Exemplarische Vorgehensweise: Erstellen eines benutzerdefinierten datengebundenen ASP.NET-Websteuerelements für ASP.NET 2.0

Článek
10/22/2014

Aktualisiert: November 2007

In dieser exemplarischen Vorgehensweise wird beschrieben, wie ein einfaches datengebundenes Webserversteuerelement in ASP.NET, Version 2.0, erstellt wird. ASP.NET 2.0 verfügt über ein Datenquellenmodell, das es Ihnen ermöglicht, datengebundene Steuerelemente an Datenquellensteuerelemente zu binden und so häufige Datenvorgänge wie Paging, Sortieren und Löschen aus dem datengebundenen Steuerelement zu verschieben. Dieses Datenmodell bietet Seitenentwicklern ein flexibleres datengebundenes Steuerelement und bessere Wiederverwendungsmöglichkeiten. Außerdem unterstützt das ASP.NET 2.0-Datenquellenmodell die direkte Bindung an ein Datenauflistungsobjekt. Weitere Informationen über die Entwicklung benutzerdefinierter datengebundener Steuerelemente für das ASP.NET 2.0-Datenmodell finden Sie unter Entwickeln von benutzerdefinierten datengebundenen Webserversteuerelementen für ASP.NET 2.0.

In dieser exemplarischen Vorgehensweise erstellen Sie ein datengebundenes Steuerelement, das an ein Datenquellensteuerelement oder ein anderes Objekt, das die IEnumerable-Schnittfläche implementiert, gebunden werden kann.

In dieser exemplarischen Vorgehensweise werden u. a. die folgenden Aufgaben veranschaulicht:

Erstellen einer Website, um das benutzerdefinierte datengebundene Steuerelement mit dynamischer Kompilierung zu testen
Erstellen einer datengebundenen Steuerelementklasse, die die Basisklasse DataBoundControl erweitert. Diese Klasse zeigt eine Tabellenspalte an, die die gebundenen Daten darstellt. Im Folgenden finden Sie eine Übersicht darüber, was die datengebundene Steuerelementklasse bereitstellen muss:
- Eine Überschreibung der PerformSelect-Methode der Basisklasse des datengebundenen Steuerelements. Innerhalb dieser Methode werden Aufgaben ausgeführt, um den Datenabruf zu initiieren.
- Eine Methode mit einem einzelnen Parameter vom Typ IEnumerable, um die zurückgegebenen Daten zu empfangen. Jede erforderliche Datenverarbeitung wird innerhalb dieser Methode ausgeführt. Als letzter Schritt wird die PerformDataBinding-Methode aufgerufen, um die Datenbindung zu initiieren.
- Eine Überschreibung der PerformDataBinding-Methode. Innerhalb dieser Methode werden die abgerufenen Daten aufgelistet, und es werden untergeordnete Steuerelemente zur Darstellung der Daten hinzugefügt.
Registrieren des Steuerelements in der Datei Web.config
Testen des Steuerelements auf einer ASP.NET-Webseite
Kompilieren des Steuerelements, um es als Binärcode zu verteilen
Testen des kompilierten, benutzerdefinierten datengebundenen Serversteuerelements

Erstellen einer Website zum Testen des Steuerelements

Sie können die dynamische Kompilierung von ASP.NET verwenden, um das Steuerelement auf einer Seite zu testen, ohne es in eine Assembly zu kompilieren. Code im Verzeichnis App_Code unter dem Stammverzeichnis einer ASP.NET-Website wird von ASP.NET dynamisch kompiliert. Klassen in Quelldateien, die im Verzeichnis App_Code liegen, müssen also nicht erst manuell in Assemblys kompiliert werden – der Zugriff von Seiten auf diese Klassen ist auch so möglich.

Hinweis:
Das Verzeichnis App_Code ist in ASP.NET 1.0 und 1.1 nicht verfügbar. Das Verwenden des Verzeichnisses App_Code für das erste Testen des Steuerelements ist optional. Im nächsten Abschnitt, "Kompilieren des Steuerelements in eine Assembly", werden Sie sehen, dass die wesentlichen Schritte zum Erstellen eines Serversteuerelements die gleichen sind wie in früheren Versionen von ASP.NET.

So erstellen Sie eine Website zum Testen benutzerdefinierter datengebundener Steuerelemente

Erstellen Sie eine Website mit dem Namen ServerControlsTest.

Sie können die Site in IIS als virtuelles Verzeichnis mit dem Namen ServerControlsTest erstellen. Ausführliche Informationen zum Erstellen und Konfigurieren eines virtuellen IIS-Verzeichnisses finden Sie unter Gewusst wie: Erstellen und Konfigurieren von virtuellen Verzeichnissen in IIS 5.0 und 6.0.
Erstellen Sie direkt unter dem Stammverzeichnis der Website (dem Webanwendungsstamm) ein Verzeichnis mit dem Namen App_Code.

Erstellen der SimpleDataBoundColumn-Klasse

In diesem Abschnitt erstellen Sie die datengebundene Steuerelementklasse, die die DataBoundControl-Klasse erweitert. Die gebundenen Daten werden vom neuen Steuerelement in einer einspaltigen Tabelle angezeigt.

So erstellen Sie die SimpleDataBoundColumn-Klasse

Erstellen Sie im Ordner App_Code eine Klasse mit dem Namen SimpleDataBoundColumn.cs oder SimpleDataBoundColumn.vb.

Fügen Sie der Klassendatei folgenden Code hinzu:

Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.Security.Permissions
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls

Namespace Samples.AspNet.Controls.VB

    <AspNetHostingPermission(SecurityAction.Demand, _
        Level:=AspNetHostingPermissionLevel.Minimal), _
        AspNetHostingPermission(SecurityAction.InheritanceDemand, _
        Level:=AspNetHostingPermissionLevel.Minimal)> _
    Public Class SimpleDataBoundColumn
        Inherits DataBoundControl

        Public Property DataTextField() As String
            Get
                Dim o As Object = ViewState("DataTextField")
                If o Is Nothing Then
                    Return String.Empty
                Else
                    Return CStr(o)
                End If
            End Get
            Set(ByVal value As String)
                ViewState("DataTextField") = value
                If (Initialized) Then
                    OnDataPropertyChanged()
                End If
            End Set
        End Property

        Protected Overrides Sub PerformSelect()
            ' Call OnDataBinding here if bound to a data source using the
            ' DataSource property (instead of a DataSourceID), because the
            ' databinding statement is evaluated before the call to GetData.       
            If Not IsBoundUsingDataSourceID Then
                OnDataBinding(EventArgs.Empty)
            End If

            ' The GetData method retrieves the DataSourceView object from  
            ' the IDataSource associated with the data-bound control.            
            GetData().Select(CreateDataSourceSelectArguments(), _
                AddressOf OnDataSourceViewSelectCallback)

            ' The PerformDataBinding method has completed.
            RequiresDataBinding = False
            MarkAsDataBound()

            ' Raise the DataBound event.
            OnDataBound(EventArgs.Empty)

        End Sub

        Private Sub OnDataSourceViewSelectCallback(ByVal retrievedData As IEnumerable)
            ' Call OnDataBinding only if it has not already been 
            ' called in the PerformSelect method.
            If IsBoundUsingDataSourceID Then
                OnDataBinding(EventArgs.Empty)
            End If
            ' The PerformDataBinding method binds the data in the  
            ' retrievedData collection to elements of the data-bound control.
            PerformDataBinding(retrievedData)

        End Sub

        Protected Overrides Sub PerformDataBinding(ByVal retrievedData As IEnumerable)
            MyBase.PerformDataBinding(retrievedData)

            ' Verify data exists.
            If Not (retrievedData Is Nothing) Then
                Dim tbl As New Table()
                Dim row As TableRow
                Dim cell As TableCell
                Dim dataStr As String = String.Empty

                Dim dataItem As Object
                For Each dataItem In retrievedData
                    ' If the DataTextField was specified get the data
                    ' from that field, otherwise get the data from the first field. 
                    If DataTextField.Length > 0 Then
                        dataStr = DataBinder.GetPropertyValue(dataItem, DataTextField, Nothing)
                    Else
                        Dim props As PropertyDescriptorCollection = TypeDescriptor.GetProperties(dataItem)
                        If props.Count >= 1 Then
                            If Nothing <> props(0).GetValue(dataItem) Then
                                dataStr = props(0).GetValue(dataItem).ToString()
                            End If
                        End If
                    End If

                    row = New TableRow()
                    tbl.Rows.Add(row)
                    cell = New TableCell()
                    cell.Text = dataStr
                    row.Cells.Add(cell)
                Next dataItem

                Controls.Add(tbl)
            End If

        End Sub
    End Class
End Namespace

using System;
using System.Collections;
using System.ComponentModel;
using System.Security.Permissions;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace Samples.AspNet.Controls.CS
{
    [AspNetHostingPermission(SecurityAction.Demand,
       Level = AspNetHostingPermissionLevel.Minimal)]
    [AspNetHostingPermission(SecurityAction.InheritanceDemand,
        Level = AspNetHostingPermissionLevel.Minimal)]
    public class SimpleDataBoundColumn : DataBoundControl
    {
        public string DataTextField
        {
            get
            {
                object o = ViewState["DataTextField"];
                return ((o == null) ? string.Empty : (string)o);
            }
            set
            {
                ViewState["DataTextField"] = value;
                if (Initialized)
                {
                    OnDataPropertyChanged();
                }
            }
        }

        protected override void PerformSelect()
        {
            // Call OnDataBinding here if bound to a data source using the
            // DataSource property (instead of a DataSourceID), because the
            // databinding statement is evaluated before the call to GetData.       
            if (!IsBoundUsingDataSourceID)
            {
                this.OnDataBinding(EventArgs.Empty);
            }

            // The GetData method retrieves the DataSourceView object from  
            // the IDataSource associated with the data-bound control.            
            GetData().Select(CreateDataSourceSelectArguments(),
                this.OnDataSourceViewSelectCallback);

            // The PerformDataBinding method has completed.
            RequiresDataBinding = false;
            MarkAsDataBound();

            // Raise the DataBound event.
            OnDataBound(EventArgs.Empty);
        }

        private void OnDataSourceViewSelectCallback(IEnumerable retrievedData)
        {
            // Call OnDataBinding only if it has not already been 
            // called in the PerformSelect method.
            if (IsBoundUsingDataSourceID)
            {
                OnDataBinding(EventArgs.Empty);
            }
            // The PerformDataBinding method binds the data in the  
            // retrievedData collection to elements of the data-bound control.
            PerformDataBinding(retrievedData);
        }

        protected override void PerformDataBinding(IEnumerable retrievedData)
        {
            base.PerformDataBinding(retrievedData);

            // Verify data exists.
            if (retrievedData != null)
            {
                Table tbl = new Table();
                TableRow row;
                TableCell cell;
                string dataStr = String.Empty;

                foreach (object dataItem in retrievedData)
                {
                    // If the DataTextField was specified get the data
                    // from that field, otherwise get the data from the first field. 
                    if (DataTextField.Length > 0)
                    {
                        dataStr = DataBinder.GetPropertyValue(dataItem,
                            DataTextField, null);
                    }
                    else
                    {
                        PropertyDescriptorCollection props =
                                TypeDescriptor.GetProperties(dataItem);
                        if (props.Count >= 1)
                        {
                            if (null != props[0].GetValue(dataItem))
                            {
                                dataStr = props[0].GetValue(dataItem).ToString();
                            }
                        }
                    }

                    row = new TableRow();
                    tbl.Rows.Add(row);
                    cell = new TableCell();
                    cell.Text = dataStr;
                    row.Cells.Add(cell);
                }

                this.Controls.Add(tbl); 
            }
        }
    }
}

Codeerläuterung

Die SimpleDataBoundColumn-Klasse wird von der DataBoundControl-Datenbindungsbasisklasse abgeleitet. Durch Ableiten von dieser Basisklasse werden die verfügbar gemachten Datenbindungseigenschaften DataSourceID, DataSource und DataMember bereitgestellt. Diese verfügbar gemachten Eigenschaften ermöglichen es einem Seitenentwickler, die Datenquelle und einen bestimmten Datenmember für die Bindung an dieses benutzerdefinierte Steuerelement anzugeben.

Um zu veranschaulichen, wie weitere benutzerdefinierte Datenbindungseigenschaften hinzugefügt werden, wurde der SimpleDataBoundColumn-Klasse eine DataTextField-Eigenschaft hinzugefügt. Wenn der Seitenentwickler die DataTextField-Eigenschaft festlegt, wird der neue Wert im Ansichtszustand gespeichert. Außerdem wird die OnDataPropertyChanged-Methode aufgerufen, wenn das Steuerelement bereits initialisiert wurde. Dadurch wird das datengebundene Steuerelement gezwungen, die Daten erneut zu binden, um die neue Einstellung für die Datenbindungseigenschaft verwenden zu können.

Die überschriebene DataBind-Methode ist erforderlich und enthält Logik, mit der das Objekt in der zugeordneten Datenquelle aufgelistet wird und die untergeordneten Steuerelemente erstellt werden. Die folgenden Aufgaben für datengebundene ASP.NET 2.0-Steuerelemente müssen innerhalb der überschriebenen DataBind-Methode ausgeführt werden, wie in der SimpleDataBoundColumn-Klasse gezeigt:

Die IsBoundUsingDataSourceID-Eigenschaft wird auf den Wert false überprüft, um zu bestimmen, ob die Datenquelle in der DataSource-Eigenschaft angegeben ist.
Wenn die zu bindenden Daten in der DataSource-Eigenschaft angegeben sind, wird die OnDataBinding-Methode aufgerufen, um den in der DataSource-Eigenschaft angegebenen Datenmember zu binden.
Die GetData-Methode wird aufgerufen, um das DataSourceView-Objekt abzurufen, das dem datengebundenen Steuerelement zugeordnet ist.
Die Select-Methode des abgerufenen DataSourceView-Objekts wird aufgerufen, um den Datenabruf zu initiieren, und die OnDataSourceViewSelectCallback-Rückrufmethode zum Behandeln der abgerufenen Daten wird angegeben.
Um die Beendigung der Aufgaben für den Datenabruf der PerformSelect-Methode anzugeben, wird die RequiresDataBinding-Eigenschaft auf false festgelegt und anschließend die MarkAsDataBound-Methode aufgerufen.
Das OnDataBound-Ereignis wird ausgelöst.

Die OnDataSourceViewSelectCallback-Rückrufmethode empfängt die abgerufenen Daten. Diese Rückrufmethode muss einen einzelnen Parameter vom Typ IEnumerable akzeptieren. Wenn das benutzerdefinierte Steuerelement eine Verarbeitung der Daten erfordert, sollte sie innerhalb dieser Rückrufmethode erfolgen. Dieses benutzerdefinierte Steuerelement verwendet die Daten unverändert. Deshalb tritt in diesem Beispiel keine zusätzliche Datenverarbeitung auf. Als letzter Schritt wird die PerformDataBinding-Methode aufgerufen, um den Datenbindungsprozess zu starten.

In der überschriebenen PerformDataBinding-Methode werden alle untergeordneten Steuerelemente zur Darstellung der Daten erstellt. Die Datenauflistung wird aufgelistet, und für jedes Datenelement wird ein neues TableCell-Objekt erstellt. Wenn die DataTextField-Eigenschaft festgelegt ist, wird mit ihr bestimmt, welches Datenfeld an die Text-Eigenschaft der Zelle gebunden wird. Andernfalls wird das erste Feld verwendet.

Der Controls-Auflistung des benutzerdefinierten SimpleDataBoundColumn-Steuerelements wird das übergeordnete Table-Steuerelement hinzugefügt. Jedes Steuerelement, das der Controls-Auflistung des Steuerelements hinzugefügt wird, wird automatisch wiedergegeben, während die geerbte Render-Methode ausgeführt wird.

Weitere Informationen über die erforderlichen Implementierungsschritte für ein datengebundenes Webserversteuerelement finden Sie unter Entwickeln von benutzerdefinierten datengebundenen Webserversteuerelementen für ASP.NET 2.0.

Erstellen eines Tagpräfixes

Ein Tagpräfix ist das Präfix, z. B. "asp" in <asp:Table />, das vor dem Typnamen des Steuerelements angezeigt wird, wenn das Steuerelement in einer Seite deklarativ erstellt wird. Damit ein Steuerelement in einer Seite deklarativ verwendet werden kann, benötigt ASP.NET ein Tagpräfix, das dem Namespace des Steuerelements zugeordnet ist. Der Entwickler einer Seite kann eine Tagpräfix/Namespace-Zuordnung bereitstellen, indem er auf jeder Seite, die das benutzerdefinierte Steuerelement verwendet, eine @ Register-Direktive hinzufügt, wie in folgendem Beispiel gezeigt:

<%@ Register TagPrefix="aspSample" 
    Namespace="Samples.AspNet.Controls.CS"%>

<%@ Register TagPrefix="aspSample" 
    Namespace="Samples.AspNet.Controls.VB"%>

Hinweis:
Es gibt kein assembly-Attribut in der @ Register-Direktive, das den Namen der Steuerelementassembly angibt. Wenn das assembly-Attribut fehlt, geht ASP.NET davon aus, dass die Assembly aus Quelldateien im Verzeichnis App_Code dynamisch kompiliert wird.

Als Alternative zur Verwendung der @ Register-Direktive auf jeder ASPX-Seite kann der Seitenentwickler in der Datei Web.config die Tagpräfix- und Namespace-Zuordnung angeben. Dies ist nützlich, wenn das benutzerdefinierte Steuerelement in mehreren Seiten einer Webanwendung verwendet wird. Die folgende Prozedur beschreibt, wie die Tagpräfixzuordnung in der Datei Web.config angegeben wird.

So fügen Sie in der Datei Web.config eine Tagpräfixzuordnung hinzu

Erstellen Sie im Stammordner der Website eine Datei mit dem Namen Web.config, falls diese noch nicht vorhanden ist.
Falls Sie eine neue Web.config-Datei erstellt haben, kopieren Sie das folgende XML-Markup in die Datei, und speichern Sie sie anschließend. Falls die Datei Web.config in der Site bereits vorhanden war, fügen Sie das folgende hervorgehobene Element hinzu.

Hinweis:

Der Tagpräfixeintrag muss dem controls-Abschnitt untergeordnet sein, der sich unter dem pages-Abschnitt befindet, welcher wiederum system.web untergeordnet sein muss.
```
<?xml version="1.0"?>
<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.CS" />
      </controls>
    </pages>
  </system.web>
</configuration>
```
```
<?xml version="1.0"?>
<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.VB" />
      </controls>
    </pages>
  </system.web>
</configuration>
```
Der hervorgehobene Abschnitt zeigt einen Tagpräfixeintrag, der das Tagpräfix "aspSample" dem Namespace Samples.AspNet.Controls.CS oder Samples.AspNet.Controls.VB zuordnet.

Hinweis:
Der Tagpräfixeintrag muss dem controls-Abschnitt untergeordnet sein, der sich unter dem pages-Abschnitt befindet, welcher wiederum system.web untergeordnet sein muss.

Nachdem Sie in der Konfigurationsdatei eine Tagpräfixzuordnung angegeben haben, können Sie das SimpleDataBoundColumn-Steuerelement deklarativ (als <aspSample:SimpleDataBoundColumn />) in jeder Seite Ihrer Website verwenden.

Hinweis:
In ASP.NET 1.0 und 1.1 wird die Tagpräfixzuordnung in der @ Register-Direktive jeder einzelnen Seite angegeben, auf der das benutzerdefinierte Steuerelement verwendet wurde.

Erstellen einer Seite zum Verwenden des benutzerdefinierten datengebundenen Steuerelements

In diesem Abschnitt der exemplarischen Vorgehensweise erstellen Sie Seiten-Markup, mit dem Sie das benutzerdefinierte datengebundene Steuerelement testen können.

So erstellen Sie eine Seite, die das benutzerdefinierte datengebundene Steuerelement verwendet

Erstellen Sie in der Website eine Datei mit dem Namen TestSimpleDataBoundColumn.aspx.

Kopieren Sie das folgende Markup in die Datei TestSimpleDataBoundColumn.aspx, und speichern Sie die Datei.

<%@ Page Language="VB" Trace="true"%>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.Controls.VB" %>
<%@ Import Namespace="System.Data" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<script runat="server">
         Function CreateDataSource() As ICollection 

         ' Create sample data for the DataList control.
         Dim dt As DataTable = New DataTable()
         dim dr As DataRow

         ' Define the columns of the table.
         dt.Columns.Add(New DataColumn("IntegerValue", GetType(Int32)))
         dt.Columns.Add(New DataColumn("StringValue", GetType(String)))
         dt.Columns.Add(New DataColumn("CurrencyValue", GetType(Double)))
         dt.Columns.Add(New DataColumn("ImageValue", GetType(String)))

         ' Populate the table with sample values.
         Dim i As Integer

         For i = 0 To 8 

            dr = dt.NewRow()

            dr(0) = i
            dr(1) = "Description for item " & i.ToString()
            dr(2) = 1.23 * (i + 1)
            dr(3) = "Image" & i.ToString() & ".jpg"

            dt.Rows.Add(dr)

         Next i

         Dim dv As DataView = New DataView(dt)
         Return dv

      End Function

      Sub Page_Load(sender As Object, e As EventArgs) 

         ' Load sample data only once, when the page is first loaded.
         If Not IsPostBack Then 

            simpleDataBoundColumn1.DataSource = CreateDataSource()
            simpleDataBoundColumn1.DataBind()

         End If

      End Sub

</script>

<head runat="server">
    <title>SimpleDataBoundColumn test page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <aspSample:SimpleDataBoundColumn runat="server" id="simpleDataBoundColumn1" DataTextField="CurrencyValue" BorderStyle="Solid"></aspSample:SimpleDataBoundColumn>
    </div>
    </form>
</body>
</html>

<%@ Page Language="C#" Trace="true"%>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.Controls.CS" %>
<%@ Import Namespace="System.Data" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<script runat="server">

      ICollection CreateDataSource() 
      {
         DataTable dt = new DataTable();
         DataRow dr;

         dt.Columns.Add(new DataColumn("IntegerValue", typeof(Int32)));
         dt.Columns.Add(new DataColumn("StringValue", typeof(string)));
         dt.Columns.Add(new DataColumn("CurrencyValue", typeof(double)));

         for (int i = 0; i < 9; i++) 
         {
            dr = dt.NewRow();

            dr[0] = i;
            dr[1] = "Item " + i.ToString();
            dr[2] = 1.23 * (i + 1);

            dt.Rows.Add(dr);
         }

         DataView dv = new DataView(dt);
         return dv;
      }

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            simpleDataBoundColumn1.DataSource = CreateDataSource();
            simpleDataBoundColumn1.DataBind();
        }
    }
</script>

<head runat="server">
    <title>SimpleDataBoundColumn test page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <aspSample:SimpleDataBoundColumn runat="server" id="simpleDataBoundColumn1" DataTextField="CurrencyValue" BorderStyle="Solid"></aspSample:SimpleDataBoundColumn>
    </div>
    </form>
</body>
</html>

Führen Sie die Seite SimpleDataBoundColumnTest.aspx aus.
Nehmen Sie einige Änderungen am Quellcode des benutzerdefinierten Steuerelements vor. Schreiben Sie zum Beispiel eine zusätzliche Zeichenfolge, indem Sie am Ende der RenderContents-Methode diese Codezeile hinzufügen:
```
writer.Write("<br />Testing how the App_Code directory works.");
```
```
writer.Write("<br />Testing how the App_Code directory works.")
```
Aktualisieren Sie die Seite SimpleDataBoundColumnTest.aspx im Browser.

Sie werden sehen, dass die am Steuerelement vorgenommenen Änderungen in der Seite widergespiegelt werden, obwohl Sie das Steuerelement nicht kompiliert haben.

Kompilieren des Steuerelements in eine Assembly

Das Verzeichnis App_Code ermöglicht Ihnen das Testen des Steuerelements, ohne es zu kompilieren. Sie müssen das Steuerelement jedoch kompilieren, wenn Sie es als Objektcode an andere Entwickler verteilen möchten. Außerdem können Sie ein Steuerelement erst dann der Toolbox eines visuellen Designers hinzufügen, wenn es in eine Assembly kompiliert wurde.

So kompilieren Sie das Steuerelement in eine Assembly

Legen Sie die Windows-Umgebungsvariable PATH auf Ihrem Computers so fest, dass Sie den Pfad zur .NET Framework-Installation beinhaltet. Führen Sie dazu folgende Schritte aus:
1. Klicken Sie in Windows mit der rechten Maustaste auf Arbeitsplatz. Klicken Sie im Kontextmenü auf Eigenschaften, dann auf die Registerkarte Erweitert und anschließend auf die Schaltfläche Umgebungsvariablen.
2. Doppelklicken Sie in der Liste Systemvariablen auf die Path-Variable.
3. Geben Sie im Textfeld Variablenwert hinter den im Textfeld vorhandenen Werten ein Semikolon (;) und anschließend den Pfad der .NET Framework-Installation ein. .NET Framework wird normalerweise im Windows-Installationsverzeichnis unter \Microsoft.NET\Framework\Versionsnummer installiert.
4. Klicken Sie jeweils auf OK, um die Dialogfelder zu schließen.

Führen Sie den folgenden Befehl aus dem Verzeichnis App_Code heraus aus, das die im vorherigen Verfahren dieser exemplarischen Vorgehensweise erstellten Quelldateien enthält. Dadurch wird eine Assembly mit dem Namen Samples.AspNet.Controls.CS.dll oder Samples.AspNet.Controls.VB.dll im selben Verzeichnis App_Code generiert.

csc /t:library /out:Samples.AspNet.Controls.CS.dll /r:System.dll /r:System.Web.dll *.cs

vbc /t:library /out:Samples.AspNet.Controls.VB.dll /r:System.dll /r:System.Web.dll *.vb

Aufgrund der /t:library-Compileroption erstellt der Compiler eine Bibliothek anstelle einer ausführbaren Assembly. Die /out-Option stellt einen Namen für die Assembly bereit, und die /r-Option listet die Assemblys auf, die mit der Assembly verknüpft sind.

Hinweis:
Um das Beispiel in sich abgeschlossen zu halten, wird in dieser exemplarischen Vorgehensweise eine Assembly mit nur einem Steuerelement erstellt. Im Allgemeinen empfehlen die .NET Framework-Entwurfsrichtlinien, keine Assemblys zu erstellen, die nur wenige Klassen enthalten. Um die Bereitstellung zu erleichtern, sollten Sie so wenige Assemblys wie möglich erstellen.

Verwenden von TagPrefixAttribute, um eine Tagpräfix-Namespace-Zuordnung bereitzustellen

Weiter oben wurde beschrieben, wie ein Seitenentwickler ein Tagpräfix auf der Seite oder in der Datei Web.config angeben kann. Wenn Sie ein Steuerelement kompilieren, können Sie auf Wunsch ein Standardtagpräfix vorschlagen, das ein visueller Designer für das Steuerelement verwenden soll, indem Sie das assemblyweit gültige System.Web.UI.TagPrefixAttribute-Attribut hinzufügen. Das TagPrefixAttribute-Attribut ist hilfreich, da es einem visuellen Designer ein Tagpräfix bereitstellt, falls in der Datei Web.config oder in einer @ Register-Direktive auf der Seite keine Tagpräfixzuordnung vorhanden ist. Das Tagpräfix wird mit der Seite registriert, wenn in der Toolbox erstmals auf das Steuerelement doppelgeklickt wird oder das Steuerelement erstmals von der Toolbox auf die Seite gezogen wird.

Wenn Sie sich entscheiden, das TagPrefixAttribute-Attribut zu verwenden, können Sie es in einer getrennten Datei angeben, die mit dem Steuerelement kompiliert wird. Die Datei hat konventionsgemäß den Namen AssemblyInfo.Spracherweiterung, z. B. AssemblyInfo.cs oder AssemblyInfo.vb. Im folgenden Verfahren wird beschrieben, wie Sie die TagPrefixAttribute-Metadaten angeben.

Hinweis:
Wenn Sie in der Assembly des Steuerelements das TagPrefixAttribute nicht angeben und der Seitenentwickler weder in der Seite noch in der Datei Web.config die Tagpräfix-Namespace-Zuordnung angibt, erstellt der visuelle Designer möglicherweise ein Standardtagpräfix. So erstellt Visual Studio 2005 beispielsweise ein eigenes Tag (wie cc1) für das Steuerelement, sobald das Steuerelement aus der Toolbox gezogen wird.

Wenn Sie in der Assembly des Steuerelements das TagPrefixAttribute nicht angeben und der Seitenentwickler weder in der Seite noch in der Datei Web.config die Tagpräfix-Namespace-Zuordnung angibt, erstellt der visuelle Designer möglicherweise ein Standardtagpräfix. So erstellt Visual Studio 2005 beispielsweise ein eigenes Tag (wie cc1) für das Steuerelement, sobald das Steuerelement aus der Toolbox gezogen wird.

So fügen Sie mit TagPrefixAttribute eine Tagpräfix-Zuordnung hinzu

Erstellen Sie im Quellcodeverzeichnis eine Datei mit dem Namen AssemblyInfo.cs bzw. AssemblyInfo.vb, und fügen Sie der Datei den folgenden Code hinzu:
```
using System;
using System.Web.UI;
[assembly: TagPrefix("Samples.AspNet.Controls.CS", "aspSample")]
```
```
Imports System
Imports System.Web.UI
<Assembly: TagPrefix("Samples.AspNet.Controls.VB", "aspSample")> 
```
Das Tagpräfixattribut erstellt eine Zuordnung zwischen dem Namespace Samples.AspNet.Controls.CS bzw. Samples.AspNet.Controls.VB und dem Präfix aspSample.
Kompilieren Sie erneut alle Quelldateien mit dem Kompilierungsbefehl, den Sie bereits zuvor (mit oder ohne der eingebetteten Ressource) verwendet haben.

Verwenden des kompilierten, benutzerdefinierten datengebundenen Serversteuerelements auf einer ASP.NET-Seite

Um die kompilierte Version Ihres benutzerdefinierten Steuerelements zu testen, müssen Sie den Seiten in der Website den Zugriff auf die Steuerelementassembly ermöglichen.

So machen Sie der Website die Steuerelementassembly zugänglich

Erstellen Sie unter dem Stammverzeichnis der Website das Verzeichnis Bin.
Ziehen Sie die Steuerelementassembly (Samples.AspNet.Controls.CS.dll oder Samples.AspNet.Controls.VB.dll) aus dem Verzeichnis App_Code in das Verzeichnis Bin.
Löschen Sie die Quelldatei des Steuerelements aus dem Verzeichnis App_Code.

Wenn Sie die Quelldateien nicht löschen, ist der Steuerelementtyp sowohl in der kompilierten Assembly als auch in der von ASP.NET dynamisch generierten Assembly vorhanden. Dadurch entsteht beim Laden des Steuerelements ein mehrdeutiger Verweis, und alle Seiten, auf denen das Steuerelement verwendet wird, generieren einen Compilerfehler.

Die in dieser exemplarischen Vorgehensweise erstellte Assembly wird als private Assembly bezeichnet, da sie im Verzeichnis Bin einer ASP.NET-Website platziert werden muss, damit das Steuerelement auf den Seiten der Website verwendet werden kann. Von anderen Anwendungen aus kann nicht auf die Assembly zugegriffen werden, außer Sie fügen diesen Anwendungen eine Kopie der Assembly hinzu. Wenn Sie Steuerelemente für freigegebene Webhostinganwendungen erstellen, packen Sie die Steuerelemente i. d. R. in einer privaten Assembly zusammen. Wenn Sie jedoch Steuerelemente für die Verwendung in einer dedizierten Hostingumgebung erstellen oder wenn Sie eine Gruppe von Steuerelementen erstellen, die ein Internetanbieter allen seinen Kunden bereitstellt, müssen Sie die Steuerelemente i. d. R. in einer freigegebenen Assembly (mit starkem Namen) zusammenpacken, die im globalen Assemblycache installiert wird. Weitere Informationen finden Sie unter Arbeiten mit Assemblys und dem globalen Assemblychache.

Danach müssen Sie die Tagpräfixzuordnung ändern, die Sie in der Datei Web.config erstellt haben, um den Namen der Steuerelementassembly anzugeben.

So ändern Sie in der Datei Web.config die Tagpräfixzuordnung

Fügen Sie in der Datei Web.config dem addtagPrefix-Element ein assembly-Attribut hinzu:

<controls>
  <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.CS" assembly="Samples.AspNet.Controls.CS" />
</controls>

<controls>
  <add tagPrefix="aspSample" namespace="Samples.AspNet.Controls.VB" assembly="Samples.AspNet.Controls.VB" />
</controls>

Das assembly-Attribut gibt den Namen der Assembly an, in der sich das Steuerelement befindet. Mit dem addtagPrefix-Element wird ein Tagpräfix einer Kombination aus Namespace und Assembly zugeordnet. Wenn ASP.NET die Assembly aus den Quelldateien im Verzeichnis App_Code dynamisch generiert, wird kein Assemblyattribut benötigt. Wenn das Assemblyattribut nicht verwendet wird, lädt ASP.NET den Steuerelementtyp aus den Assemblys, die aus dem Verzeichnis App_Code dynamisch generiert werden.

So zeigen Sie die Seite an, die das benutzerdefinierte Steuerelement verwendet

Zeigen Sie die Seite SimpleDataBoundColumnTest.aspx im Browser an, indem Sie die folgende URL in die Adressleiste eingeben:
```
https://localhost/ServerControlsTest/SimpleDataBoundColumnTest.aspx
```

Wenn Sie das Steuerelement in einem visuellen Designer verwenden, z. B. Visual Studio 2005, können Sie das Steuerelement der Toolbox hinzufügen, es von der Toolbox auf die Entwurfsoberfläche ziehen und im Eigenschaftenbrowser auf die Eigenschaften und Ereignisse des Steuerelements zugreifen. In Visual Studio 2005 verfügt das Steuerelement in der Quellansicht des Seitendesigners und im Code-Editor außerdem über vollständige IntelliSense-Unterstützung. Dazu gehören sowohl die Anweisungsvervollständigung in einem script-Block als auch die Unterstützung für den Eigenschaftenbrowser, wenn ein Seitenentwickler auf das Tag des Steuerelements klickt.

Hinweis:
In vielen visuellen Designern können Sie der Toolbox des Designers benutzerdefinierte Steuerelemente hinzufügen. Ausführliche Informationen finden Sie in der Dokumentation zu Ihrem Designer.

Nächste Schritte

Dieses einfache, benutzerdefinierte datengebundene Serversteuerelement veranschaulicht die wesentlichen Schritte zum Erstellen eines benutzerdefinierten Steuerelements, das einem Seitenentwickler eine standardmäßige, effiziente und flexible Möglichkeit bietet, es an eine externe Datenquelle zu binden. Als Nächstes können Sie sich mit dem in Visual Studio verfügbaren Framework befassen, mit dem Sie anspruchsvolle benutzerdefinierte Serversteuerelemente erstellen können. Sie können sich u. a. folgendermaßen weiter mit dem Thema befassen:

Lesen Sie eine Einführung in die allgemeine Architektur und die Implementierungsschritte, die bei der Entwicklung eines benutzerdefinierten datengebundenen Serversteuerelements ausgeführt werden müssen. Ausführliche Informationen finden Sie unter Entwickeln von benutzerdefinierten datengebundenen Webserversteuerelementen für ASP.NET 2.0.
Beschäftigen Sie sich mit den vorhandenen Klassen datengebundener Serversteuerelemente, die Sie erweitern und anpassen können. Eine Übersicht über die verfügbaren datengebundenen Webserversteuerelemente finden Sie unter Übersicht über datengebundene ASP.NET-Webserversteuerelemente. Informationen über die Klassen datengebundener Webserversteuerelemente finden Sie unter den folgenden Themen: GridView, DetailsView, FormView, Repeater und DataList.
Erfahren Sie mehr über Themen wie Wiedergabe, Definieren von Eigenschaften, Beibehalten des Zustands und Implementieren von zusammengesetzten benutzerdefinierten Steuerelementen. Ausführliche Informationen finden Sie unter Entwickeln von benutzerdefinierten ASP.NET-Serversteuerelementen, Beispiel für den Vergleich zwischen Steuerelementzustand und Ansichtszustand und Benutzerdefinierte Zustandsverwaltung für Serversteuerelemente.
Erfahren Sie mehr über die Metadatenattribute, die Sie auf das benutzerdefinierte datengebundene Serversteuerelement und seine Member anwenden können, um Informationen für Entwurfstools bereitzustellen. Ausführliche Informationen finden Sie unter Metadatenattribute für benutzerdefinierte Serversteuerelemente.
Erstellen Sie einen Steuerelement-Designer zum Hinzufügen von Entwurfszeitfeatures, Vorlagen oder Formaten. Ein Beispiel eines Designers für benutzerdefinierte datengebundene Steuerelemente finden Sie unter HierarchicalDataBoundControlDesigner und Exemplarische Vorgehensweise: Erstellen eines einfachen Steuerelement-Designers für ein Webserver-Steuerelement. Eine Übersicht über die ASP.NET-Steuerelement-Designer finden Sie unter Übersicht über ASP.NET-Steuerelement-Designer.
Arbeiten Sie mit einem Beispiel eines benutzerdefinierten datengebundenen Steuerelement-Designers. Ausführliche Informationen finden Sie unter den Erläuterungen zur HierarchicalDataBoundControlDesigner-Klasse.
Lesen Sie eine Anweisung zur Definition geeigneter Entwurfszeitattribute, um ein benutzerdefiniertes Serversteuerelement in der Visual Studio-Toolbox verfügbar zu machen. Ausführliche Informationen finden Sie unter Gewusst wie: Verwenden von benutzerdefinierten ASP.NET-Serversteuerelementen in Visual Studio.

Siehe auch

Sdílet prostřednictvím