Webserver-Steuerelement-Templates in einem Programm erzeugen

  • Artikel

Veröffentlicht: 07. Mrz 2002 | Aktualisiert: 16. Jun 2004

Dieser Artikel ist in verschiedene Abschnitte unterteilt, die zunehmend anspruchsvollere Methoden zur Erstellung von Vorlagen aufzeigen. Im ersten Abschnitt lernen Sie beispielsweise, wie Sie die einfachste Vorlage im Code erstellen, die es gibt. Nachfolgende Abschnitte bauen auf dieser einfachen Vorlage auf, indem ihre Funktionalität erweitert wird. Am Ende des Artikels werden Sie in der Lage sein, eine voll funktionsfähige Vorlage zu erzeugen, die Datenbindung enthält.

Auf dieser Seite

Einführung Einführung
Grundlagen der programmtechnischen Erstellung von Vorlagen Grundlagen der programmtechnischen Erstellung von Vorlagen
Hinzufügen unterschiedlicher Arten von Vorlagen Hinzufügen unterschiedlicher Arten von Vorlagen
Hinzufügen von Datenbindungen zu Vorlagen Hinzufügen von Datenbindungen zu Vorlagen
Programmtechnisches Erstellen von Vorlagen im "DataGrid"-Steuerelement Programmtechnisches Erstellen von Vorlagen im "DataGrid"-Steuerelement
Zusammenfassung Zusammenfassung

Anforderungen

Dieser Artikel setzt voraus, dass Sie allgemein mit der Erstellung von Web-Forms-Seiten und der Verwendung von ASP.NET-Serversteuerelementen vertraut sind. Eine weitere Anforderung besteht darin, dass Sie im Web Forms Designer mit der Erstellung von Vorlagen für die ASP.NET-Steuerelemente Repeater oder DataList zumindest experimentiert haben. Hintergrundinformationen zu Vorlagen erhalten Sie unter "Web Server Controls Templates".Schließlich wird vorausgesetzt, dass Sie eine Datenanbindung von Steuerelementen in Web Forms-Seiten durchführen können. Hintergrundinformationen zur Datenbindung erhalten Sie unter "Datenbindung in Web Forms" in der Microsoft® Visual Studio® .NET-Dokumentation.

Einführung

Die ASP.NET-Serversteuerelemente Repeater, DataList und DataGrid wurden für die Datenbindung entwickelt. Das bedeutet, dass diese Steuerelemente einen Eintrag (z.B. eine Zeile) für jedes Element in der Datenquelle erzeugen, an die sie gebunden sind. Um die Anordnung der Daten festzulegen verwenden Sie Vorlagen oder Templates. Eine Vorlage ist ein Container für andere Steuerelemente, kein Objekt mit eigener UI. Stattdessen fügen Sie der Vorlage Steuerelemente hinzu und legen die Anzeigeeigenschaften dieser Steuerelemente fest (i.d.R. über die Datenverbindung). Bei Ausführung des Steuerelements durchläuft es die Datenquelle und erstellt für jedes Datenelement einen Eintrag – eine Zusammenführung der Steuerelemente in der Vorlage mit den Informationen im Datenelement.
Das DataGrid-Steuerelement verwendet ein vordefiniertes Format, das einem Datenblatt entspricht. Jedes Datenelement erzeugt eine Zeile im Datenblatt. Bei Ausführung des Steuerelements wird jeder Eintrag als Tabellenzeile ausgegeben.
Die Steuerelemente Repeater und DataList ermöglichen Ihnen das Erzeugen einer weniger eingeschränkten Ausgabe. So kann es sich bei den Einträgen beispielsweise um Zeilen in einer Tabelle, um eine Aufzählung, um Elemente in einer durch Kommas getrennten Liste oder um ein beliebiges anderes Format handeln.

Festlegen von Vorlagen

Wenn Sie mit den Steuerelementen Repeater, DataList oder DataGrid in einer Web Forms-Seite arbeiten, ist es relativ einfach, Vorlagen zur Entwurfszeit zu erzeugen. Das DataList-Steuerelement unterstützt ein Bearbeitungsfenster mit WYSIWYG-Darstellung. Für das Repeater-Steuerelement können Sie Vorlagen in der HTML-Ansicht als spezielle Elemente erstellen, die innerhalb des Steuerelements geschachtelt sind. Im DataGrid-Steuerelement erstellen Sie mit dem Fenster Eigenschaften eine neue Vorlagenspalte.
Dies setzt jedoch voraus, dass Sie die Vorlagen zur Entwurfszeit gestalten. Aus verschiedenen Gründen wissen Sie eventuell nicht bis zur Laufzeit, welche Vorlagen Sie benötigen oder welcher Text bzw. welche Steuerelemente darin enthalten sein sollen. Für diesen Fall müssen Sie in der Lage sein, die Vorlagen vor Ort zu erzeugen. Wenn Sie einige Grundlagen der Erstellung von Klassen und der Datenbindung von Web Forms verstehen, können Sie Vorlagen im Code erstellen. Wie dies funktioniert, soll im Anschluss erläutert werden.
Anmerkung: Sie können Vorlagen auch als Web-Forms-Benutzersteuerelemente erstellen und diese dynamisch an Steuerelemente auf Ihrer Seite binden. Ausführliche Informationen finden Sie unter "Erstellen eines Benutzersteuerelements mit Vorlagen" in der .NET Framework SDK-Dokumentation.

 

Grundlagen der programmtechnischen Erstellung von Vorlagen

Zunächst wird in diesem Abschnitt veranschaulicht, wie Sie die einfachste Vorlage im Code erstellen, die es gibt. Zielsetzung dabei ist die Ausführung einer Anweisung wie die folgende:

' Visual Basic  
Repeater1.ItemTemplate = New MyTemplate()  
// C#  
Repeater1.ItemTemplate = new MyTemplate();

Sie sehen, dass dabei eine Instanz der MyTemplate-Klasse erstellt wird. Woher kommt aber die Vorlagenklasse? Sie wird von Ihnen erstellt.
Anmerkung: Die Erstellung von Vorlagen im Code ist leicht unterschiedlich für DataGrid-Steuerelemente, da dabei eine Spalte erstellt wird. Weitere Informationen darüber erhalten Sie am Ende dieses Artikels. Alle Informationen, die Sie bis dahin lesen, gelten im Wesentlichen sowohl für DataGrid-Steuerelemente als auch für DataList- und Repeater-Steuerelemente.

Eine einfache Vorlagenklasse

Eine Vorlagenklasse ist relativ simpel. Für ihre Erstellung sind mindestens folgende Schritte durchzuführen:

  • Deklarieren Sie, dass die Klasse die ITemplate-Schnittstelle des System.Web.UI-Namespace implementiert.

  • Implementieren Sie die InstantiateIn-Methode (das einzige Member der ITemplate-Schnittstelle). Diese Methode bietet eine Möglichkeit, eine Instanz von Text und Steuerelementen in den angegebenen Container einzufügen.

Anmerkung: Hintergrundinformationen zum Erstellen von Klassen in Microsoft Visual Basic® .NET finden Sie unter "Was sind Klassen?" in der Visual Studio .NET-Dokumentation. Entsprechende Informationen zu Microsoft Visual C#™ .NET finden Sie unter "class".

Der Zweck einer Vorlage besteht natürlich darin, Text und Steuerelemente für jedes Element in der Datenquelle anzeigen zu können. Dies wird in der InstantiateIn-Methode der Klasse realisiert, wo Sie die Benutzeroberfläche (UI) für die Vorlage erstellen.

Die normale Strategie für die Arbeit mit der InstantiateIn-Methode ist die Erstellung eines neuen Steuerelements, das Festlegen der gewünschten Eigenschaften und das Hinzufügen des Steuerelements zur Controls-Auflistung des übergeordneten Elements. Sie können zwar der Controls-Auflistung nicht direkt statischen Text hinzufügen, jedoch können Sie die Steuerelemente Literal oder LiteralControl erstellen, ihre Text-Eigenschaften setzen und anschließend diese Steuerelemente der übergeordneten Auflistung hinzufügen. Die InstantiateIn-Methode übergibt einen Verweis auf das übergeordnete Steuerelement (das Steuerelement Repeater, DataList oder DataGrid), wodurch dieser letzte Schritt erleichtert wird.

Das folgende Beispiel enthält eine vollständige Vorlagenklasse, die statischen Text ("Elementnummer:") und einen Zähler anzeigt. Der Zähler wird als freigegebener oder statischer Wert (je nach verwendeter Sprache) mit der Bezeichnung itemcount für die Klasse verwaltet und bei jeder Erstellung eines neuen Elements erhöht.

' Visual Basic 
Public Class MyTemplate 
   Implements ITemplate 
   Shared itemcount As Integer = 0 
   Sub InstantiateIn(ByVal container As Control) _ 
         Implements ITemplate.InstantiateIn 
      Dim lc As New Literal() 
      lc.Text = "Elementnummer: " & itemcount.ToString & " 
" 
      itemcount += 1 
      container.Controls.Add(lc) 
   End Sub 
End Class 
// C# 
private class MyTemplate : ITemplate 
{ 
   static int itemcount; 
   public void InstantiateIn(System.Web.UI.Control container) 
   { 
      Literal lc = new Literal(); 
      lc.Text = "Elementnummer: " + itemcount.ToString() + " 
"; 
      itemcount += 1; 
      container.Controls.Add(lc); 
   } 
}

Testen der Vorlagenklasse

Um die Arbeitsweise dieser Beispiel-Vorlagenklasse zu sehen, testen Sie diese mit Hilfe eines Repeater-Steuerelements. Beginnen Sie, indem Sie eine neue Web Forms-Seite erstellen und folgende Schritte ausführen:

  1. Fügen Sie ein Repeater-Steuerelement hinzu.

  2. Fügen Sie eine Datenverbindung und einen Datenadapter hinzu. Für diesen Test spielt es keine Rolle, welche Daten Sie verwenden.

  3. Erstellen Sie ein DataSet, dessen Schema der SQL-Abfrage im gerade erstellten Datenadapter entspricht. Das DataSet enthält die Daten, die Sie in Ihrem Steuerelement anzeigen.
    Tipp: Wenn Sie mit Visual Studio arbeiten, ziehen Sie einen Datenadapter auf die Seite und verwenden Sie den Assistenten, um die Verbindung zu erstellen. Klicken Sie anschließend im Menü Daten auf DataSet generieren, um ein typisiertes DataSet zu erstellen.

  4. Setzen Sie die DataSource-Eigenschaft des Repeater-Steuerelements auf das DataSet und seine DataMember-Eigenschaft auf den Namen einer Tabelle im DataSet.

Sie können nun die Vorlagenklasse erstellen. Führen Sie die folgenden Schritte aus:

  1. Kopieren Sie das vorangegangene Beispiel, und fügen Sie es in den Code für Ihre Seite ein.

    Sobald Sie den Klassencode eingefügt haben, könnte die Seite folgendermaßen aussehen (der von Ihnen eingefügte Code ist hervorgehoben):

' Visual Basic 
Public Class WebForm1 
   Inherits System.Web.UI.Page 
   ' Platz für weitere Inherits-Anweisungen 
   Private Class MyTemplate 
      Implements ITemplate 
      Dim itemcount As Integer = 0 
      Sub InstantiateIn(ByVal container As Control) _ 
      Implements ITemplate 
         Dim lc As New Literal() 
         lc.Text = "Elementnummer: " & itemcount.ToString & " 
" 
         itemcount += 1 
         container.Controls.Add(lc) 
End Sub 
   End Class 
' usw. 
// C# 
using System; 
using System.Collections; 
// Platz für weitere Namespaces 
namespace myproject 
{ 
   public class WebForm1 : System.Web.UI.Page 
   { 
   protected System.Data.SqlClient.SqlDataAdapter sqlDataAdapter1; 
   // Platz für weitere Deklarationen 
   public class MyTemplate : ITemplate 
   { 
      int itemcount; 
      public void InstantiateIn(System.Web.UI.Control container) 
   { 
      Literal lc = new Literal(); 
         lc.Text = "Elementnummer: " & itemcount.ToString & " 
" 
         itemcount += 1 
         container.Controls.Add(lc) 
      } 
      } 
// usw.

  1. Fügen Sie Code in den Page_Load-Ereignishandler ein, um eine Instanz Ihrer Vorlagenklasse zu erstellen, und weisen Sie diese der ItemTemplate-Eigenschaft des Repeater-Steuerelements zu.

  2. Füllen Sie schließlich im Page_Load-Ereignishandler das DataSet, und rufen Sie anschließend die DataBind-Methode des Repeater-Steuerelements auf, um das Beispiel fortzusetzen.

    Nach dem Hinzufügen des Codes sieht der Page_Load-Handler wie folgt aus: (Der in den Schritten 2 und 3 hinzugefügte Code ist hervorgehoben.)

' Visual Basic  
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)  
Handles MyBase.Load  
   Repeater1.ItemTemplate = New MyTemplate()  
   SqlDataAdapter1.Fill(DataSet11)  
   Repeater1.DataBind()  
End Sub  
// C#  
private void Page_Load(object sender, System.EventArgs e)  
{  
   Repeater1.ItemTemplate = New MyTemplate()  
   SqlDataAdapter1.Fill(DataSet11)  
   Repeater1.DataBind()      }

  1. Führen Sie die Seite aus.

    Eine Liste wird auf der Seite angezeigt, mit jeweils einer Zeile pro Datasource-Element.

 

Hinzufügen unterschiedlicher Arten von Vorlagen

Die oben aufgeführten Beispiele zeigen nur, wie Sie mit einer einzelnen Vorlage arbeiten, nämlich der Elementvorlage. Im nachfolgenden Abschnitt lernen Sie, wie Sie eine weiterentwickelte Version Ihrer Vorlagenklasse erstellen, die Ihnen die Definition von Headervorlagen, Footervorlagen und Vorlagen für abwechselnde Elemente (für die Steuerelemente Repeater und DataList) usw. ermöglicht.

Eine Möglichkeit ist die Erstellung einer separaten Vorlagenklasse für jede Art von Vorlage, oder eine Basis-Vorlagenklasse und abgeleitete Klassen für unterschiedliche Arten von Vorlagen. Dies ist eventuell sinnvoll, falls die einzelnen Vorlagen sehr komplex oder sehr unterschiedlich sind.

Eine alternative Methode ist die Verwendung einer einzelnen Vorlagenklasse für alle und die Angabe des zu erstellenden Vorlagentyps. Sie können an Ihre Klasse einen Wert übergeben, mit dem die Klasse den zu erstellenden Vorlagentyp ermitteln kann. Sie können sogar eine Aufzählung (ListItemType) verwenden, die bereits für Vorlagentypen in den Steuerelementen Repeater, DataList und DataGrid definiert ist.

Das nachfolgende Beispiel zeigt eine weiterentwickelte Version des oben genannten Beispiels. Der Klassencode enthält dieses Mal einen expliziten Konstruktor. Dieser akzeptiert einen einzelnen Zeichenfolgenwert, der den Vorlagentyp angibt. In der InstantiateIn-Methode verwenden Sie eine Select Case- oder switch-Anweisung (je nach Sprache), um zu ermitteln, welcher Vorlagentyp erstellt wird. Um die Vorteile der Erstellung von unterschiedlichen Vorlagentypen zu zeigen, erstellt dieses Beispiel eine Tabelle mit einer unterschiedlichen Hintergrundfarbe für Vorlagen für abwechselnde Elemente.

' Visual Basic 
Private Class MyTemplate 
   Implements ITemplate 
   Shared itemcount As Integer = 0 
    Dim TemplateType As ListItemType 
    Sub New(ByVal type As ListItemType) 
        TemplateType = type 
End Sub 
      Sub InstantiateIn(ByVal container As Control) _ 
       Implements ITemplate 
         Dim lc As New Literal() 
      Select Case TemplateType 
         Case ListItemType.Header 
                lc.Text = "<TABLE border=1><TR><TH>Elemente</TH></TR>" 
         Case ListItemType.Item 
         lc.Text = "Elementnummer: " & itemcount.ToString & "<BR>" 
               & "</TD></TR>" 
         Case ListItemType.AlternatingItem 
            lc.Text = "<TR><TD bgcolor=lightblue>Elementnummer: " _ 
               & itemcount.ToString & "</TD></TR>" 
         Case ListItemType.Footer 
            lc.Text = "</TABLE>" 
      End Select 
         container.Controls.Add(lc) 
      itemcount += 1 
   End Sub 
End Class 
// C# 
public class MyTemplate : ITemplate 
{ 
   static int itemcount = 0; 
   ListItemType templateType; 
   public MyTemplate(ListItemType type) 
   { 
      templateType = type; 
   } 
   public void InstantiateIn(System.Web.UI.Control container) 
   { 
      Literal lc = new Literal(); 
      switch( templateType ) 
   { 
         Case ListItemType.Header 
            lc.Text = "<TABLE border=1><TR><TH>Elemente</TH></TR>" 
            break; 
         Case ListItemType.Item 
         lc.Text = "Elementnummer: " & itemcount.ToString & "<BR>" 
               & "</TD></TR>" 
            break; 
         Case ListItemType.AlternatingItem 
            lc.Text = "<TR><TD bgcolor=lightblue>Elementnummer: " _ 
               & itemcount.ToString & "</TD></TR>" 
            break; 
         Case ListItemType.Footer 
            lc.Text = "</TABLE>" 
            break; 
      } 
         container.Controls.Add(lc)         itemcount += 1

Um unterschiedliche Vorlagen zu erstellen, verwenden Sie folgenden Code:

' Visual Basic  
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)  
Handles MyBase.Load  
   Repeater1.HeaderTemplate = New MyTemplate(ListItemType.Header)  
   Repeater1.ItemTemplate = New MyTemplate()  
   Repeater1.AlternatingItemTemplate = _  
      New MyTemplate(ListItemType.AlternatingItem)  
   Repeater1.FooterTemplate = New MyTemplate(ListItemType.Footer)  
   SqlDataAdapter1.Fill(DataSet11)  
   Repeater1.DataBind()  
End Sub  
// C#  
private void Page_Load(object sender, System.EventArgs e)  
{  
   Repeater1.HeaderTemplate = New MyTemplate(ListItemType.Header);  
   Repeater1.ItemTemplate = New MyTemplate(ListItemType.Item);  
   Repeater1.AlternatingItemTemplate =   
      New MyTemplate(ListItemType.AlternatingItem);  
   Repeater1.FooterTemplate = New MyTemplate(ListItemType.Footer);  
   sqlDataAdapter1.Fill(dataSet11);  
   Repeater1.DataBind();  
}

 

Hinzufügen von Datenbindungen zu Vorlagen

Die bisher definierte Vorlagenklasse zeigt nur statische Daten an. Im nachfolgenden Abschnitt werden Sie daher die bisher definierte Vorlage vervollständigen, indem Sie sie um die Funktion erweitern, Daten aus der Datenquelle des Steuerelements hinzuzufügen.

Es gibt verschiedene Methoden, um Zugriff auf Daten von der Vorlagenklasse aus zu erhalten, je nachdem, wie Sie die Klasse erstellt haben. Eine gute Methode ist die, bei der die Seitenarchitektur selbst die Datenbindung implementiert. Beim Hinzufügen von Steuerelementen zur Vorlage fügen Sie auch einen Handler für ihr DataBinding-Ereignis ein. Dieses Ereignis wird ausgelöst, nachdem das Vorlagenelement mit all seinen Steuerelementen erstellt wurde.

Anmerkung: Eventuell sind Sie der Meinung, dass Sie einfach einen Datenbindungsausdruck als Zeichenfolge bei Erstellung von Steuerelementen in der Vorlage einbetten können, wie dies beim Festlegen von Vorlagen zur Entwurfszeit der Fall ist. Dies funktioniert jedoch nicht, da die Datenbindungsausdrücke zu einem Zeitpunkt der Seitenverarbeitung in Code verwandelt werden, der vor der Erstellung Ihrer Vorlage liegt.

Im Handler für das DataBinding-Ereignis haben Sie die Gelegenheit, den Inhalt des Steuerelements zu bearbeiten. In der Regel (aber nicht immer) können Sie Daten aus einer bestimmten Quelle abrufen und diese der Text-Eigenschaft des Steuerelements zuweisen.

Anmerkung: Hintergrundinformationen zur Datenbindung auf Web Forms-Seiten finden Sie unter "Datenbindung in Web Forms" in der Visual Studio .NET-Dokumentation.

Binden eines Ereignishandlers an die Steuerelemente

Beginnen Sie, indem Sie einen Ereignishandler an die Steuerelemente binden, die Sie in der Vorlage erstellen. Der Code zur Bindung eines Steuerelements in einer Vorlage an einen Handler mit der Bezeichnung TemplateControl_DataBinding könnte (bei Verwendung eines Ausschnitts aus dem vorangegangenen Beispiel) wie folgt aussehen: (Sie fügen den Code für den Handler später hinzu.)

' Visual Basic 
      Case ListItemType.Item 
         lc.Text = "<TR><TD>" 
         AddHandler lc.DataBinding, AddressOf TemplateControl_DataBinding 
// C# 
      case ListItemType.Item: 
         lc.Text = "<TR><TD>"; 
         lc.DataBinding += new EventHandler(TemplateControl_DataBinding);            break;

Anmerkung: Ausführliche Informationen zum dynamischen Hinzufügen von Ereignishandlern finden Sie unter ""AddHandler" und "RemoveHandler"" (für Visual Basic) sowie im Ereignis-Tutorium (für Visual C#) in der Visual Studio .NET-Dokumentation.

Beachten Sie, dass sich in diesem Beispiel der Text, den Sie der Text-Eigenschaft des Literal-Steuerelements hinzufügen, von dem vorangegangenen Beispiel unterscheidet. Er enthält nur den Anfang der Tabellenzeile und -zelle für die Elementvorlage. Sie werden die Zelle und Zeile im Ereignishandler der Datenbindung vervollständigen.

Erstellen des Ereignishandlers

Nun benötigen Sie einen Ereignishandler, der bei Datenbindung des Steuerelements aufgerufen wird. Der Handler ist Teil der Vorlagenklasse. Sie erstellen ihn als übergeordnetes Element der anderen Methoden der Klasse (z.B. InstantiateIn).

Die Signatur des Handlers wird im folgenden Beispiel gezeigt. Der Name dieses Handlers muss dem Namen entsprechen, den Sie vorher beim Binden des Ereignisses verwendet haben.

' Visual Basic  
Private Sub TemplateControl_DataBinding(ByVal sender As Object, ByVal e As System.EventArgs)  
// C#  
private void TemplateControl_DataBinding(object sender, System.EventArgs e)

Beim Aufrufen der Methode wird ein Verweis auf das Steuerelement im sender-Argument übergeben, damit Sie seine Eigenschaften festlegen können. Da das sender-Argument als ein Objekt übergeben wird, müssen Sie es in den korrekten Steuerelementtyp umwandeln – in diesem Beispiel in ein Literal.

Wie erhalten Sie die Daten? Für jedes Element in einer Datenquelle erstellt das Repeater-, DataList- oder DataGrid-Steuerelement ein einziges Element (dessen Inhalt auf der Vorlage basiert). Jedes Element verfügt über eine Eigenschaft mit der Bezeichnung DataItem, die den Zugriff auf die Daten für dieses Element ermöglicht – de facto die entsprechende Datenzeile.

Wenn jedoch der Ereignishandler der Datenbindung aufgerufen wird, arbeiten Sie mit einem spezifischen Steuerelement, nicht mit dem Vorlagenelement. Sie müssen dabei die Hierarchie der Steuerelemente von Ihrem Steuerelement bis zum Vorlagenelement durchlaufen. Die beste Möglichkeit dafür ist über die NamingContainer-Eigenschaft Ihres Steuerelements. Diese gibt einen Verweis auf das Vorlagenelement zurück, in dem das Steuerelement erstellt wurde. (In einigen Fällen könnten Sie auch die Parent-Eigenschaft Ihres Steuerelements verwenden, um einen Verweis auf den Container zu erhalten. Falls jedoch Ihr Steuerelement innerhalb eines anderen Steuerelements geschachtelt ist – z.B. wenn sich das Steuerelement in einem Panel- oder einem Table-Steuerelement befindet – dann gibt die Parent-Eigenschaft keinen Verweis auf das Vorlagenelement zurück.)

Führen Sie daher folgende Schritte aus, um ein Steuerelement in einer Vorlage an spezifische Daten zu binden:

  • Rufen Sie einen Verweis auf das Vorlagenelement ab. Sie erstellen eine Variable zur Aufnahme des Verweises und weisen diese anschließend dem Wert zu, den Sie von der NamingContainer-Eigenschaft erhalten.

  • Verwenden Sie diesen Verweis, um die DataItem-Eigenschaft des Namenscontainers (des Vorlagenelements) zu erhalten.

  • Extrahieren Sie das einzelne Datenelement (z.B. die Datenspalte) aus dem DataItem-Objekt, und verwenden Sie dieses, um eine Eigenschaft des zu bindenden Steuerelements zu setzen.

Der nachfolgende Code, der auf den vorherigen Beispielen basiert, illustriert eine mögliche Vorgehensweise. Es handelt sich um einen vollständigen Datenbindungs-Ereignishandler für die Literal-Steuerelemente, die für Ihre Vorlagen erstellt werden.

Der Code erstellt eine Variable mit der Bezeichnung container vom Typ RepeaterItem (da Sie mit dem Repeater-Steuerelement gearbeitet haben) und setzt anschließend diese Variable auf die NamingContainer-Eigenschaft des Steuerelements, für das eine Datenbindung durchgeführt wird. Anschließend können Sie den Verweis verwenden, um zum DataItem des Containers zu gelangen, bei dem es sich um ein Objekt handelt. Eine einfache Methode dafür besteht darin, die Eval-Methode des DataBinder-Objekts aufzurufen (die gleiche Methode wird häufig in Datenbindungsausdrücken verwendet) und dieser anschließend einen Verweis auf das DataItem-Objekt des Containers sowie den Namen des abzurufenden Feldes zu übergeben.

Wenn Sie mehrere Steuerelementtypen in Ihren Vorlagen verwenden, müssen Sie einen unterschiedlichen Datenbindungs-Ereignishandler für jeden der Steuerelementtypen erstellen.

' Visual Basic 
Private Sub TemplateControl_DataBinding(ByVal sender As Object, ByVal e As System.EventArgs) 
   Dim lc As Literal 
   lc = CType(sender, Literal) 
   Dim container As RepeaterItem 
   container = CType(lc.NamingContainer, RepeaterItem) 
   lc.Text &= DataBinder.Eval(container.DataItem, "CategoryName") 
   lc.Text &= "</TD></TR>" 
End Sub 
// C# 
private void TemplateControl_DataBinding(object sender, System.EventArgs e) 
{ 
   Literal lc; 
   lc = (Literal) sender; 
   RepeaterItem container = (RepeaterItem) lc.NamingContainer; 
   lc.Text += DataBinder.Eval(container.DataItem, "CategoryName"); 
   lc.Text += "</TD></TR>"; 
}

 

Programmtechnisches Erstellen von Vorlagen im "DataGrid"-Steuerelement

Die oben beschriebenen Verfahren funktionieren sowohl für die Repeater- als auch die DataList-Steuerelemente. Es lassen sich auch Vorlagen programmtechnisch für das DataGrid-Steuerelement erstellen. Das Verfahren für die Erstellung der Vorlage an sich ist dasselbe. Es gibt allerdings ein paar Unterschiede bei der Verwendung der Vorlagen in einem DataGrid-Steuerelement:

  • Sie erstellen keine Elementvorlagen für das Datenblatt selbst, sondern Sie erstellen diese für eine Spalte im Datenblatt.

  • Die Vorlagen für eine DataGrid-Spalte unterscheiden sich leicht von den Vorlagen für ein Repeater- oder DataList-Steuerelement. Eine DataGrid-Spalte enthält keine abwechselnden Elemente oder Trennzeichenvorlagen. Jedoch enthält sie, wie das DataList-Steuerelement, eine EditItem-Vorlage.

Ein kurzer Rückblick: In einem DataGrid-Steuerelement sind vier Arten von Spalten möglich:

  • Gebundene Spalten – Spalten, die aus spezifischen Elementen in Ihrer Datenquelle generiert wurden.

  • Schaltflächenspalten – Spalten mit vordefinierten Schaltflächen (Bearbeiten, Aktualisieren, Abbrechen, Löschen oder Auswählen).

  • Hyperlinkspalten – Spalten, in denen jeder Eintrag ein Hyperlink auf einen URL ist, den Sie zur Entwurfszeit angeben.

  • Vorlagenspalten – Spalten, die auf einer von Ihnen festgelegten Vorlage basieren.

Wie Sie bereits erahnen, werden für den letzten Spaltentyp programmtechnisch erstellte Vorlagen verwendet. Anders formuliert: Wenn Sie die Steuerelemente einer DataGrid-Spalte zur Laufzeit ändern möchten, sollten Sie eine Vorlagenspalte verwenden und die entsprechende Vorlage vor Ort erstellen.

Das folgende Beispiel zeigt, wie Sie zwei Vorlagenspalten für ein DataGrid-Steuerelement erstellen und anschließend diese Vorlagen den Spalten zuordnen. Der erste Teil ist die Klasse für die Erstellung der Vorlagen. Sie ist fast mit dem früheren Beispiel identisch, bis auf zwei kleine Änderungen. Eine besteht darin, dass der Konstruktor der Vorlagenklasse zwei Parameter akzeptiert. Der zweite Parameter ermöglicht die Übergabe des Namens der zu erstellenden Spalte. Die zweite Änderung besteht darin, dass dieses Beispiel Code für die Erstellung einer EditItem-Vorlage enthält, wodurch ein Textbox-Steuerelement erstellt wird.

' Visual Basic 
Private Class DataGridTemplate 
   Implements ITemplate 
   Dim templateType As ListItemType 
   Dim columnName As String 
   Sub New(ByVal type As ListItemType, ByVal ColName As String) 
      templateType = type 
      columnName = ColName 
   End Sub 
   Sub InstantiateIn(ByVal container As Control) _ 
        Implements ITemplate.InstantiateIn 
      Dim lc As New Literal() 
      Select Case templateType 
         Case ListItemType.Header 
            lc.Text = "" & columnName & "" 
            container.Controls.Add(lc) 
         Case ListItemType.Item 
            lc.Text = "Element " & columnName 
            container.Controls.Add(lc) 
         Case ListItemType.EditItem 
            Dim tb As New TextBox() 
            tb.Text = "" 
            container.Controls.Add(tb) 
         Case ListItemType.Footer 
            lc.Text = "<I>Footer</I>" 
            container.Controls.Add(lc) 
      End Select 
   End Sub 
End Class 
// C# 
public class DataGridTemplate : ITemplate 
   { 
      ListItemType templateType; 
      string columnName; 
      public DataGridTemplate(ListItemType type, string colname) 
      { 
         templateType = type; 
         columnName = colname; 
      } 
      public void InstantiateIn(System.Web.UI.Control container) 
      { 
         Literal lc = new Literal(); 
         switch(templateType) 
         { 
            case ListItemType.Header: 
               lc.Text = "" + columnName + ""; 
               container.Controls.Add(lc); 
               break; 
            case ListItemType.Item: 
               lc.Text = "Element " + columnName; 
               container.Controls.Add(lc); 
               break; 
            case ListItemType.EditItem: 
               TextBox tb = new TextBox(); 
               tb.Text = ""; 
               container.Controls.Add(tb); 
               break; 
            case ListItemType.Footer: 
               lc.Text = "<I>" + columnName + "</I>"; 
               container.Controls.Add(lc); 
               break; 
         } 
      } 
   }

Das nächste Beispiel zeigt, wie Sie die Vorlagenspalten erstellen und diesen die Vorlagen zuweisen.

' Visual Basic  
Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load  
   Dim tc1 As New TemplateColumn()  
   tc1.HeaderTemplate = New _  
      DataGridTemplate(ListItemType.Header, "Column1")  
   tc1.ItemTemplate = New DataGridTemplate(ListItemType.Item, "Column1")  
   tc1.EditItemTemplate = New _  
      DataGridTemplate(ListItemType.EditItem, "Column1")  
   tc1.FooterTemplate = New _  
      DataGridTemplate(ListItemType.Footer, "Column1")  
   DataGrid1.Columns.Add(tc1)  
   Dim tc2 As New TemplateColumn()  
   tc2.HeaderTemplate = New _  
      DataGridTemplate(ListItemType.Header, "Column2")  
   tc2.ItemTemplate = New DataGridTemplate(ListItemType.Item, "Column2")  
   tc2.EditItemTemplate = New _  
      DataGridTemplate(ListItemType.EditItem, "Column2")  
   tc2.FooterTemplate = New _  
      DataGridTemplate(ListItemType.Footer, "Column2")  
   DataGrid1.Columns.Add(tc2)  
   SqlDataAdapter1.Fill(DsCategories1)  
   DataGrid1.DataBind()  
End Sub  
// C#  
private void Page_Load(object sender, System.EventArgs e)  
{  
   TemplateColumn tc1 = new TemplateColumn();  
   tc1.HeaderTemplate = new   
      DataGridTemplate(ListItemType.Header, "Column1");  
   tc1.ItemTemplate = new DataGridTemplate(ListItemType.Item, "Column1");  
   tc1.EditItemTemplate = new   
      DataGridTemplate(ListItemType.EditItem, "Column1");  
   tc1.FooterTemplate = new   
      DataGridTemplate(ListItemType.Footer, "Column1");  
   DataGrid1.Columns.Add(tc1);  
   TemplateColumn tc2 = new TemplateColumn();  
   tc2.ItemTemplate = new DataGridTemplate(ListItemType.Item, "Column2");  
   tc2.HeaderTemplate = new   
      DataGridTemplate(ListItemType.Header, "Column2");  
   tc2.EditItemTemplate = new   
      DataGridTemplate(ListItemType.EditItem, "Column2");  
   tc2.FooterTemplate = new   
      DataGridTemplate(ListItemType.Footer, "Column2");  
   DataGrid1.Columns.Add(tc2);  
   sqlDataAdapter1.Fill(dataSet11);  
   DataGrid1.DataBind();  
}

 

Zusammenfassung

Die Beispiele in diesem Artikel vermitteln trotz ihrer Einfachheit alle Grundlagen, die Sie zum Erstellen von Vorlagen im Code benötigen. Natürlich ist es wahrscheinlich, dass die Vorlagen, die Sie in Ihren eigenen Anwendungen erstellen, komplexer sind – alle Beispiele in diesem Artikel könnten problemlos zur Entwurfszeit durchgeführt werden. Nun besitzen Sie jedoch alle Werkzeuge, die Sie brauchen, um Vorlagen vor Ort zu erstellen.