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

Článek
10/22/2014

Aktualisiert: November 2007

In dieser exemplarischen Vorgehensweise wird beschrieben, wie ein einfaches datengebundenes Serversteuerelement erstellt wird, das eine bindungsfähige Datenquelle verfügbar macht.

Ein datengebundenes ASP.NET-Serversteuerelement verfügt über eine Benutzeroberfläche für eine Datenquelle, die eine Auflistung von Datensätzen oder Elementen darstellt. Beispiele für datengebundene Serversteuerelemente sind das DataList-Serversteuerelement und das Repeater-Serversteuerelement. Weitere Informationen über datengebundene ASP.NET-Steuerelemente finden Sie unter Übersicht über datengebundene ASP.NET-Webserversteuerelemente.

Hinweis:
Das in dieser exemplarischen Vorgehensweise beschriebene Steuerelement ist mit ASP.NET, Version 1.1, kompatibel. Weitere Informationen zum Erstellen benutzerdefinierter datengebundener Websteuerelemente für ASP.NET 2.0 finden Sie unter Entwickeln von benutzerdefinierten datengebundenen Webserversteuerelementen für ASP.NET 2.0.

Ein datengebundenes ASP.NET 1.1-Serversteuerelement kann an einen der folgenden Typen gebunden werden:

IEnumerable (z. B. ein Array-Objekt, ein ArrayList-Objekt oder ein Hashtable-Objekt).
IListSource (z. B. ein DataSet-Objekt)

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

Zu den in dieser exemplarischen Vorgehensweise erläuterten Aufgaben gehören:

Erstellen der Website zum Testen des benutzerdefinierten datengebundenen Steuerelements
Erstellen einer Klasse für das datengebundene Steuerelement. Die Klasse muss eine Eigenschaft vom Typ IListSource oder IEnumerable verfügbar machen, sodass ein Seitenentwickler den Speicherort der zu bindenden Daten angeben kann. Außerdem muss sie die DataBind-Methode und die CreateChildControls-Methode der Basisklasse überschreiben.
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. ASP.NET kompiliert Code, der zum Verzeichnis App_Code im Websitestamm hinzugefügt wird, dynamisch. Klassen in Quelldateien, die sich im Verzeichnis App_Code befinden, können daher über Seiten aufgerufen werden, ohne manuell in Assemblys kompiliert zu werden.

Hinweis:
Das Verzeichnis App_Code ist ein neues Feature, das es in ASP.NET 1.0 und 1.1 noch nicht gab. Das Verwenden des Verzeichnisses App_Code für das erste Testen des Steuerelements ist optional. Im 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.

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 zur Erstellung und Konfiguration eines virtuellen IIS-Verzeichnisses finden Sie unter Gewusst wie: Erstellen und Konfigurieren von virtuellen Verzeichnissen in IIS 5.0 und 6.0.
Erstellen Sie unter dem Stammverzeichnis der Website ein Verzeichnis mit dem Namen App_Code.

Erstellen der SimpleDataBoundControl-Klasse

Der nächste Schritt besteht darin, die Steuerelementklasse zu erstellen.

So erstellen Sie die SimpleDataBoundControl-Klasse

Erstellen Sie im Ordner App_Code, den Sie in der vorherigen Prozedur erstellt haben, je nach gewünschter Programmiersprache eine Klasse mit dem Namen SimpleDataBoundControl.cs oder SimpleDataBoundControl.vb.

Fügen Sie der Klassendatei folgenden Code hinzu:

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

Namespace Samples.ASPNet.VB.Controls
    <DefaultProperty("DataSource")> _
        Public Class SimpleDataBoundControl
        Inherits WebControl

        Private _dataSource As IEnumerable
        Private _label As Label
        Private _button As Button
        Private _table As Table

        <Category("Data"), DefaultValue(""), Description("An exposed data source: A public member of type IEnumerable to bind to such as an Array, ArrayList or Hashtable.")> _
        Public Overridable Property DataSource() As IEnumerable
            Get
                Return _dataSource
            End Get
            Set(ByVal value As IEnumerable)
                If TypeOf value Is IEnumerable OrElse value Is Nothing Then
                    _dataSource = value
                Else
                    Throw New ArgumentException()
                End If
            End Set
        End Property

        Protected Overridable Function GetDataSource() As IEnumerable
            If _dataSource Is Nothing Then
                Return Nothing
            End If

            Dim resolvedDataSource As IEnumerable
            resolvedDataSource = _dataSource

            Return resolvedDataSource

        End Function 'GetDataSource

        Protected Overridable Sub CreateMyControlHeirarchy(ByVal useViewState As Boolean)
            Dim resolvedDataSource As IEnumerable = Nothing
            If useViewState Then
                If Not (ViewState("RowCount") Is Nothing) Then
                    resolvedDataSource = New Object(Fix(ViewState("RowCount"))) {}
                Else
                    Throw New Exception("Unable to retrieve expected data from ViewState")
                End If
            Else
                resolvedDataSource = GetDataSource()
            End If

            If Not (resolvedDataSource Is Nothing) Then
                ' Create a label that will indicate form which source the data has been provided.
                Dim s As String
                If useViewState Then
                    s = "Data collection retrieved from ViewState:"
                Else
                    s = "Data collection retrieved from bound data source:"
                End If
                _label = New Label()
                Me.Controls.Add(Me._label)
                _label.Text = s

                _button = New Button()
                Me.Controls.Add(Me._button)
                _button.Text = "Test re-binding of ViewState"

                _table = New Table()
                Me.Controls.Add(Me._table)

                Dim dataItem As Object
                For Each dataItem In resolvedDataSource
                    Dim row As New TableRow()
                    _table.Rows.Add(row)
                    Dim cell As New TableCell()
                    If Not useViewState Then
                        cell.Text = dataItem.ToString()
                    End If
                    row.Cells.Add(cell)
                Next dataItem

                ViewState("RowCount") = _table.Rows.Count
            End If

        End Sub 'CreateMyControlHeirarchy

        Protected Overrides Sub CreateChildControls()
            Controls.Clear()

            If Not (ViewState("RowCount") Is Nothing) Then
                Dim useViewState As Boolean = True
                CreateMyControlHeirarchy(useViewState)
            End If

        End Sub 'CreateChildControls

        Public Overrides Sub DataBind()
            MyBase.OnDataBinding(EventArgs.Empty)

            Controls.Clear()
            ClearChildViewState()
            TrackViewState()

            Dim useViewState As Boolean = False
            CreateMyControlHeirarchy(useViewState)

            ChildControlsCreated = True
        End Sub 'DataBind

        Protected Overrides Sub RenderContents(ByVal writer As HtmlTextWriter)
            Me._label.RenderControl(writer)
            Me._table.RenderControl(writer)
            Me._button.RenderControl(writer)
        End Sub 'RenderContents
    End Class 'SimpleDataBoundControl
End Namespace

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

namespace Samples.AspNet.CS.Controls
{
    [
        DefaultProperty("DataSource")
    ]
    public class SimpleDataBoundControl : WebControl
    {
        private IEnumerable _dataSource;
        private Label _label;
        private Button _button;
        private Table _table;

        [
        Category("Data"),
        DefaultValue(""),
        Description("An exposed data source: A public member of type IEnumerable to bind to such as an Array, ArrayList or Hashtable.")
        ]
        public virtual IEnumerable DataSource
        {
            get
            {
                return _dataSource;
            }
            set
            {
                if ((value is IEnumerable) || (value == null))
                {
                    _dataSource = value;
                }
                else
                {
                    throw new ArgumentException();
                }
            }
        }

        protected virtual IEnumerable GetDataSource()
        {
            if (_dataSource == null)
            {
                return null;
            }

            IEnumerable resolvedDataSource;
            resolvedDataSource = _dataSource as IEnumerable;

            return resolvedDataSource;
        }

        protected virtual void CreateMyControlHeirarchy(bool useViewState)
        {
            IEnumerable resolvedDataSource = null;
            if (useViewState)
            {
                if (ViewState["RowCount"] != null)
                {
                    resolvedDataSource = new object[(int)ViewState["RowCount"]];
                }
                else
                {
                    throw new Exception("Unable to retrieve expected data from ViewState");
                }
            }
            else
            {
                resolvedDataSource = GetDataSource();
            }

            if (resolvedDataSource != null)
            {
                // Create a label that will indicate form which source the data has been provided.
                String s;
                if (useViewState)
                {
                    s = "Data collection retrieved from ViewState:";
                }
                else
                {
                    s = "Data collection retrieved from bound data source:";
                }
                _label = new Label();
                this.Controls.Add(this._label);
                _label.Text = s;

                _button = new Button();
                this.Controls.Add(this._button);
                _button.Text = "Test re-binding of ViewState";

                _table = new Table();
                this.Controls.Add(this._table);

                foreach (object dataItem in resolvedDataSource)
                {
                    TableRow row = new TableRow();
                    _table.Rows.Add(row);
                    TableCell cell = new TableCell();
                    if (!useViewState)
                    {
                        cell.Text = dataItem.ToString();
                    }
                    row.Cells.Add(cell);
                }

                ViewState["RowCount"] = _table.Rows.Count;
            }
        }

        protected override void CreateChildControls()
        {
            Controls.Clear();

            if (ViewState["RowCount"] != null)
            {
                bool useViewState = true;
                CreateMyControlHeirarchy(useViewState);
            }
        }

        public override void DataBind()
        {
            base.OnDataBinding(EventArgs.Empty);

            Controls.Clear();

            ClearChildViewState();

            TrackViewState();

            bool useViewState = false;
            CreateMyControlHeirarchy(useViewState);

            ChildControlsCreated = true;
        }

        protected override void RenderContents(HtmlTextWriter writer)
        {
            this._label.RenderControl(writer);
            this._table.RenderControl(writer);
            this._button.RenderControl(writer);
        }
    }
}

Codeerläuterung

Die SimpleDataBoundControl-Klasse gibt eine HTML-Tabelle wieder, die auf der in der DataSource-Eigenschaft angegebenen Datenauflistung basiert. Datengebundene ASP.NET 1.1-Webserversteuerelemente müssen eine bindungsfähige DataSource-Eigenschaft verfügbar machen, die auf einen IEnumerable-Typ oder IListSource-Typ festgelegt werden kann.

In dem Beispielcode überprüft der set-Accessor für die DataSource-Eigenschaft, ob der Wert entweder auf null oder auf ein Objekt vom Typ IEnumerable festgelegt ist. Daher kann der Seitenentwickler in diesem Beispiel an jeden IEnumerable-Typ binden, z. B. ein Array-, ArrayList- oder Hashtable-Objekt. Anfangs kann er für DataSource den Standardwert null übernehmen und die Eigenschaft im Code festlegen.

Die Metadatenattribute Category, DefaultValue und Description stellen Informationen für Entwurfstools, den ASP.NET-Seitenparser und die Common Language Runtime bereit.

Mit der CreateMyControlHeirarchy-Hilfsmethode wird die Hierarchie der untergeordneten Steuerelemente in einem gemeinsamen Codepfad erstellt. Sie wird sowohl von der überschriebenen DataBind-Methode als auch von der überschriebenen CreateChildControls-Methode aufgerufen. Die überschriebene DataBind-Methode ist erforderlich. Sie listet das Objekt in der zugeordneten Datenquelle auf und erstellt die untergeordneten Steuerelemente. Die überschriebene CreateChildControls-Methode ist erforderlich und erstellt die Hierarchie der untergeordneten Steuerelemente anhand der im Ansichtszustand gespeicherten Daten erneut.

Zur Wiedergabe überschreibt das Steuerelement die geerbte RenderContents-Methode. Dadurch kann die Wiedergabe innerhalb der Steuerelementtags erfolgen. Der Parameter, der an die RenderContents-Methode übergeben wird, ist ein Objekt vom Typ HtmlTextWriter. Dieser Typ ist eine Dienstprogrammklasse, die über Methoden für die Darstellung von Tags und anderem HTML-Markup (und Markup von HTML-Varianten) verfügt.

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

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.CS.Controls"%>

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

Hinweis:
Die @ Register-Direktive wurde in ASP.NET 2.0 gegenüber ASP.NET 1.0 und ASP.NET 1.1 nicht geändert. Wenn Sie mit der @ Register-Direktive in früheren Versionen von ASP.NET vertraut sind, werden Sie feststellen, dass das assembly-Attribut, das den Namen der Steuerelementassembly angibt, in der vorhergehenden @ Register-Direktive fehlt. Wenn das assembly-Attribut fehlt, geht ASP.NET davon aus, dass die Assembly aus Quelldateien im Verzeichnis App_Code dynamisch kompiliert wird.

Die @ Register-Direktive wurde in ASP.NET 2.0 gegenüber ASP.NET 1.0 und ASP.NET 1.1 nicht geändert. Wenn Sie mit der @ Register-Direktive in früheren Versionen von ASP.NET vertraut sind, werden Sie feststellen, dass das assembly-Attribut, das den Namen der Steuerelementassembly angibt, in der vorhergehenden @ Register-Direktive fehlt. 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.

Hinweis:
Ein Konfigurationseintrag für das Tagpräfix ist ein neues Feature in ASP.NET 2.0. In ASP.NET 1.0 und 1.1 musste die Tagpräfixzuordnung in der @ Register-Direktive jeder einzelnen Seite angegeben werden, auf der das benutzerdefinierte Steuerelement verwendet wurde.

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 (leere) 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 ein untergeordnetes Element des <controls>-Elements sein, das sich wiederum im <pages>-Abschnitt unter <system.web> befinden muss.
```
<?xml version="1.0"?>
<configuration>
  <system.web>    
   <pages>
     <controls>
       <add tagPrefix="aspSample"            namespace="Samples.AspNet.CS.Controls">       </add>
     </controls>
   </pages>
  </system.web>
</configuration>
```
```
<?xml version="1.0"?>
<configuration>
  <system.web>    
   <pages>
     <controls>
       <add tagPrefix="aspSample"            namespace="Samples.AspNet.VB.Controls">       </add>
     </controls>
   </pages>
  </system.web>
</configuration>
```
Der hervorgehobene Abschnitt zeigt einen Tagpräfixeintrag, der das Tagpräfix "aspSample" dem Namespace Samples.AspNet.CS.Controls oder Samples.AspNet.VB.Controls zuordnet.

Hinweis:
Der Tagpräfixeintrag muss ein untergeordnetes Element des <controls>-Elements sein, das sich wiederum im <pages>-Abschnitt unter <system.web> befinden muss.

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

Erstellen einer Seite zum Verwenden des benutzerdefinierten datengebundenen Steuerelements

In diesem Abschnitt der exemplarischen Vorgehensweise erstellen Sie ein Seiten-Markup, mit dem Sie das benutzerdefinierte 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 TestSimpleDataBoundControl.aspx.

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

<%@ Page Language="VB" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.VB.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)
        If Not IsPostBack Then
            Dim a As New ArrayList()
            a.Add("One")
            a.Add("Two")
            a.Add("Three")
            a.Add("Four")

            simpleDataBoundControl1.DataSource = a
            simpleDataBoundControl1.DataBind()
        End If
    End Sub 'Page_Load
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
    <title>SimpleDataBoundControl test page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <aspSample:SimpleDataBoundControl runat="server" id="simpleDataBoundControl1" BorderStyle="Solid" ></aspSample:SimpleDataBoundControl>
    </div>
    </form>
</body>
</html>

<%@ Page Language="C#" Trace="true" EnableViewState="true" %>
<%@ Register TagPrefix="aspSample" Namespace="Samples.AspNet.CS.Controls" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<script runat="server">
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            ArrayList a = new ArrayList();
            a.Add("One");
            a.Add("Two");
            a.Add("Three");
            a.Add("Four");

            simpleDataBoundControl1.DataSource = a;
            simpleDataBoundControl1.DataBind();
        }
    }
</script>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>SimpleDataBoundControl test page</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <aspSample:SimpleDataBoundControl runat="server" id="simpleDataBoundControl1" BorderStyle="Solid" ></aspSample:SimpleDataBoundControl>
    </div>
    </form>
</body>
</html>

Führen Sie die Seite TestSimpleDataBoundControl.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 TestSimpleDataBoundControl.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

Obwohl Sie das Steuerelement mithilfe des Verzeichnisses App_Code ohne Kompilieren testen können, müssen Sie das Steuerelement 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 Quelldateien enthält und das Sie weiter oben in dieser exemplarischen Vorgehensweise erstellt haben.

Dadurch wird eine Assembly mit dem Namen Samples.AspNet.CS.Controls.dll oder Samples.AspNet.VB.Controls.dll im Verzeichnis App_Code generiert.

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

vbc /t:library /out:Samples.AspNet.VB.Controls.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 das assemblyweit gültige System.Web.UI.TagPrefixAttribute-Attribut hinzufügen, um ein Standardtagpräfix vorzuschlagen, das ein visueller Designer für das Steuerelement verwenden soll. 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.CS.Controls", "aspSample")]
```
```
Imports System
Imports System.Web.UI
<Assembly: TagPrefix("Samples.AspNet.VB.Controls", "aspSample")> 
```
Das Tagpräfixattribut erstellt eine Zuordnung zwischen dem Namespace Samples.AspNet.CS.Controls bzw. Samples.AspNet.VB.Controls 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 des benutzerdefinierten Steuerelements zu testen, müssen Sie die Steuerelementassembly für die Seiten in der Website verfügbar machen.

So machen Sie die Steuerelementassembly in der Website verfügbar

Erstellen Sie unter dem Stammverzeichnis der Website das Verzeichnis Bin, falls dies noch nicht vorhanden ist.
Ziehen (verschieben) Sie die Steuerelementassembly (Samples.AspNet.CS.Controls.dll oder Samples.AspNet.VB.Controls.dll) aus dem Verzeichnis App_Code in das Verzeichnis Bin.
Verschieben Sie die Quelldatei des Steuerelements aus dem Verzeichnis App_Code in ein anderes Verzeichnis in der Website.

Wenn Sie die Quelldateien nicht aus dem Verzeichnis App_Code verschieben, 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, weil 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.

Als Nächstes 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 die Tagpräfixzuordnung in der Datei Web.config

Fügen Sie in der Datei Web.config dem <add tagPrefix=Name>-Element ein assembly-Attribut hinzu:

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

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

Das assembly-Attribut gibt den Namen der Assembly an, in der sich das Steuerelement befindet. Mit dem <add tagPrefix=Name>-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 der Assembly, die aus dem Verzeichnis App_Code dynamisch generiert wurde.

Nun können Sie das Steuerelement testen, indem Sie es auf einer Seite anzeigen.

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

Zeigen Sie die Seite TestSimpleDataBoundControl.aspx im Browser an, indem Sie den folgenden URL in die Adressleiste eingeben:
```
https://localhost/ServerControlsTest/TestSimpleDataBoundControl.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.

Nächste Schritte

Dieses einfache, benutzerdefinierte datengebundene Serversteuerelement veranschaulicht die wesentlichen Schritte zum Erstellen eines benutzerdefinierten Steuerelements, das einem Seitenentwickler eine standardmäßige Möglichkeit bietet, es an eine externe Datenquelle zu binden. Als Nächstes können Sie sich damit befassen, wie Sie mit Visual Studio anspruchsvolle benutzerdefinierte Serversteuerelemente erstellen. Hier einige Vorschläge:

Lesen Sie eine Einführung in die allgemeine Architektur der Entwicklung eines benutzerdefinierten datengebundenen Serversteuerelements. Ausführliche Informationen finden Sie unter Entwickeln von benutzerdefinierten datengebundenen Webserversteuerelementen für ASP.NET 1.1.
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 dem Thema HierarchicalDataBoundControlDesigner.
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