Eigenschaftentypen
Im folgenden Beispiel wird gezeigt, wie primitive Eigenschaften (einschließlich Enumerationseigenschaften) und Klasseneigenschaften definiert werden.
Hinweis In .NET Framework werden Wertetypen wie Boolean, Byte, Char, Double, Enum, Intnn usw. den primitiven Typen von Sprachen der Common Language Runtime zugeordnet. Weitere Informationen dazu finden Sie in der Dokumentation der verwendeten Programmiersprache.
Obwohl String ein Verweistyp ist, entspricht bei ASP.NET-Seiten die Syntax für den Zugriff auf String-Eigenschaften der von primitiven Typen. Daher wird String hier unter den primitiven Typen aufgeführt.
Der Typ von Klasseneigenschaften ist ein Verweistyp.
Primitive Eigenschaften
Im folgenden Beispiel wird die primitive Eigenschaft Number definiert.
// The private data member for the Number property.
private int number = 0;
//The description attribute contains a brief description of
//the property that is displayed
//below the property browser when the user clicks on a
//property.
//
[Description("A nonnegative integer")]
//The Number property that maps to the field number.
//
public int Number{
//The accessor methods perform other program logic
//in addition to setting or returning the property.
//
get {
if (number < 0) return 0;
return number;
}
set {
if (value < 0) number = 0;
else number = value;
}
}
[Visual Basic]
' The private data member for the Number property.
Private _number As Integer = 0
'The description attribute contains a brief description of
'the property that is displayed
'below the property browser when the user clicks on a
'property.
'
<Description("A nonnegative integer")> _
Public Property Number() As Integer
'The Number property that maps to the field number.
'
'The accessor methods perform other program logic
'in addition to setting or returning the property.
'
Get
If _number < 0 Then
Return 0
End If
Return _number
End Get
Set
If value < 0 Then
_number = 0
Else
_number = value
End If
End Set
End Property
Im folgenden Beispiel wird die ASP.NET-Syntax für das deklarative Einstellen einer primitiven Eigenschaft (keine Enumeration) gezeigt. Dabei wird die Text-Eigenschaft der Instanz eines System.Web.UI.WebControls.Button-Steuerelements festgelegt.
<asp:Button Text = "MyButton" runat = server/>
Der ASP.NET-Seitenparser konvertiert die übergebene Zeichenkette in den Typ der Eigenschaft. In diesem Beispiel ist keine Konvertierung notwendig, da die Text-Eigenschaft vom Typ String ist.
Enumerationseigenschaften
Bei Eigenschaften vom Enumerationstyp entspricht die Definitionssyntax der anderer primitiver Eigenschaftstypen. Allerdings gibt es beim Einstellen der Eigenschaft einen Unterschied in der Seitensyntax. Im folgenden Codefragment wird eine Enumeration namens Position definiert.
// The Position enumeration.
public enum Position
{
Forward = 0,
Mid = 1,
Defence = 2,
Goalee = 3,
}
[Visual Basic]
' The Position enumeration.
Public Enum Position
Forward = 0
Mid = 1
Defence = 2
Goalee = 3
End Enum
Im folgenden Codefragment wird gezeigt, wie durch das Steuerelement (SoccerPlayer) eine Eigenschaft vom Typ Position offen gelegt wird.
public class SoccerPlayer : Control
{
private Position position;
...
// PlayerPosition is an enumeration property whose
// type is the Position enumeration.
[Description("The position of the player on the field.")]
public Position PlayerPosition
{
get
{
return position;
}
set
{
position = value;
}
}
...
}
[Visual Basic]
Public Class SoccerPlayer
Inherits Control
Private _position As Position
...
' PlayerPosition is an enumeration property whose
' type is the Position enumeration.
<Description("The position of the player on the field.")> _
Public Property PlayerPosition() As Position
Get
Return _position
End Get
Set
_position = value
End Set
End Property
...
End Class
Im folgenden Beispiel wird die ASP.NET-Syntax für das deklarative Einstellen einer Enumerationseigenschaft gezeigt. Dabei wird die TextMode-Eigenschaft der Instanz eines System.Web.UI.WebControls.TextBox-Steuerelements festgelegt.
<asp:TextBox TextMode = "MultiLine" runat = server/>
Der ASP.NET-Seitenparser konvertiert die übergebene Zeichenkette in einen entsprechenden Enumerationswert, in diesem Fall TextBoxMode.MultiLine.
Wenn der Benutzer im Eigenschaftenbrowser eines visuellen Designers wie Visual Studio .NET auf Eigenschaften vom Enumerationstyp klickt, werden die entsprechenden Werte in einer Dropdownliste angezeigt.
Klasseneigenschaften
Wenn eine Klasse A über eine Eigenschaft verfügt, deren Typ die Klasse B ist, werden die Eigenschaften von B (falls vorhanden) durch Untereigenschaften von A aufgerufen.
Im folgenden Codefragment wird eine Klasse namens Address definiert, durch die vier Eigenschaften, jede vom Typ String, offen gelegt werden.
// The Address class.
public class Address {
private string street = null;
private string city = null;
private string state = null;
private string zip = null;
// The Street property.
public string Street {get{...} set{...}}
// The City property.
public string City {get{...} set{...}}
// The State property.
public string State {get{...} set{...}}
// The Zip property.
public string Zip {get{...} set{...}}
}
[Visual Basic]
' The Address class.
Public Class Address
Private _street As String = Nothing
Private _city As String = Nothing
Private _state As String = Nothing
Private _zip As String = Nothing
' The Street property.
Public Property Street() As String
Get
Return ""
End Get
Set
_street = value
End Set
End Property
' The City property.
Public Property City() As String
Get
Return ""
End Get
Set
_city = value
End Set
End Property
' The State property.
Public Property State() As String
Get
Return ""
End Get
Set
_state = value
End Set
End Property
' The Zip property.
Public Property Zip() As String
Get
Return ""
End Get
Set
_zip = value
End Set
End Property
End Class
Im folgenden Codefragment wird ein Steuerelement namens SoccerPlayer definiert, durch das eine Eigenschaft offen gelegt wird, die vom Typ der Klasse Address ist.
public class SoccerPlayer : Control
{
private Address address = new Address();
// PlayerAddress is complex property whose
// type is the class Address. Address has four
// properties, Street, City, State, and Zip. These become
// subproperties of SoccerPlayer.
public Address PlayerAddress
{
get
{
return address;
}
// Note that the set accessor is not defined.
// The get accessor provides a handle to a PlayerAddress
// instance that can be used to set a subproperty such as
// PlayerAddress.Street.
}
}
[Visual Basic]
Public Class SoccerPlayer
Inherits Control
Private address As New Address()
' PlayerAddress is complex property whose
' type is the class Address. Address has four
' properties, Street, City, State, and Zip. These become
' subproperties of SoccerPlayer.
Public ReadOnly Property PlayerAddress() As Address
Get
Return address
End Get
' Note that the set accessor is not defined.
' The get accessor provides a handle to a PlayerAddress
' instance that can be used to set a subproperty such as
' PlayerAddress.Street.
End Property
End Class
In ASP.NET gilt eine besondere Syntax für das Festlegen von Untereigenschaften. Im folgenden Beispiel werden die Untereigenschaften Font.Color und Font.Size des System.Web.UI.WebControls.Button-Steuerelements festgelegt. Durch den Bindestrich (-) wird eine Untereigenschaft gekennzeichnet.
<asp:Button Font-Color="red" Font-Size="3" runat=server/>
In einem Designer wie Visual Studio .NET kann eine Klasseneigenschaft zur Anzeige von Untereigenschaften erweitert werden.
ASP.NET ermöglicht bei Eigenschaften außerdem eine geschachtelte Syntax. Dabei können Eigenschaften als untergeordnete Elemente innerhalb eines Tags des Steuerelements deklariert werden. Um diese Syntax zu aktivieren, muss ein Steuerelement mit ParseChildrenAttribute(true) markiert sein. Weitere Informationen finden Sie unter Verwenden des ParseChildrenAttribute. System.Web.UI.WebControl wird durch ParseChildrenAttribute(true) markiert. Steuerelemente, die von WebControl abgeleitet werden, erben dessen Standardanalyselogik.
Hinweis Die im Beispiel definierten Eigenschaften bleiben im Fall von Schleifen für den Client nicht erhalten. Für die Definition von dauerhaften Eigenschaften ist die ViewState-Eigenschaft des Steuerelements zu verwenden. Weitere Informationen dazu finden Sie unter Beibehalten des Status in einem Steuerelement.