Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Dokumentationskommentare sind speziell formatierte Kommentare in der Quelle, die analysiert werden können, um Dokumentationen zum Code zu erstellen, dem sie angefügt sind. Das grundlegende Format für Dokumentationskommentare ist XML. Wenn der Kompilierungscode mit Dokumentationskommentaren erstellt wird, kann der Compiler optional eine XML-Datei ausgeben, die die Summe der Dokumentationskommentare in der Quelle darstellt. Diese XML-Datei kann dann von anderen Tools verwendet werden, um gedruckte oder Onlinedokumentationen zu erstellen.
In diesem Kapitel werden Dokumentkommentare und empfohlene XML-Tags für die Verwendung mit Dokumentkommentaren beschrieben.
Dokumentationskommentarformat
Dokumentkommentare sind spezielle Kommentare, die mit '''drei einfachen Anführungszeichen beginnen. Sie müssen dem Typ (z. B. einer Klasse, einem Delegaten oder einer Schnittstelle) oder einem Typmemm (z. B. einem Feld, einem Ereignis, einer Eigenschaft oder einer Methode) unmittelbar vorangehen, die sie dokumentieren. Ein Dokumentkommentar zu einer partiellen Methodendeklaration wird durch den Dokumentkommentar der Methode ersetzt, die den Textkörper bereitstellt, sofern vorhanden. Alle angrenzenden Dokumentkommentare werden zusammen angefügt, um einen einzelnen Dokumentkommentar zu erstellen. Wenn nach den ''' Zeichen ein Leerzeichen vorhanden ist, ist dieses Leerzeichen nicht in der Verkettung enthalten. Beispiel:
''' <remarks>
''' Class <c>Point</c> models a point in a two-dimensional plane.
''' </remarks>
Public Class Point
''' <remarks>
''' Method <c>Draw</c> renders the point.
''' </remarks>
Sub Draw()
End Sub
End Class
Dokumentationskommentare müssen nach XML wohlgeformt https://www.w3.org/TR/REC-xmlsein. Wenn der XML-Code nicht wohlgeformt ist, wird eine Warnung generiert, und die Dokumentationsdatei enthält einen Kommentar, der besagt, dass ein Fehler aufgetreten ist.
Obwohl Entwickler ihre eigenen Tags erstellen können, wird im nächsten Abschnitt ein empfohlener Satz definiert. Einige der empfohlenen Tags haben eine besondere Bedeutung:
Das
<param>-Tag wird verwendet, um Parameter zu beschreiben. Der durch ein<param>Tag angegebene Parameter muss vorhanden sein, und alle Parameter des Typelements müssen im Dokumentationskommentar beschrieben werden. Wenn eine bedingung nicht erfüllt ist, gibt der Compiler eine Warnung aus.Das
cref-Attribut kann an jedes Tag angefügt werden, um einen Verweis auf ein Codeelement bereitzustellen. Das Codeelement muss vorhanden sein; zur Kompilierungszeit ersetzt der Compiler den Namen durch die ID-Zeichenfolge, die das Element darstellt. Wenn das Codeelement nicht vorhanden ist, gibt der Compiler eine Warnung aus. Bei der Suche nach einem in einemcrefAttribut beschriebenenImportsNamen berücksichtigt der Compiler Anweisungen, die in der enthaltenden Quelldatei angezeigt werden.Der
<summary>-Tag ist dafür gedacht, dass ein Dokumentationsbetrachter zusätzliche Informationen über einen Typ oder ein Mitglied anzeigt.
Beachten Sie, dass die Dokumentationsdatei keine vollständigen Informationen zu einem Typ und zu Mitgliedern bereitstellt, nur was in den Dokumentkommentaren enthalten ist. Um weitere Informationen zu einem Typ oder Element zu erhalten, muss die Dokumentationsdatei in Verbindung mit Reflexion zum tatsächlichen Typ oder Element verwendet werden.
Recommended tags (Empfohlene Tags)
Der Dokumentationsgenerator muss jedes Tag akzeptieren und verarbeiten, das nach den Regeln von XML gültig ist. Die folgenden Tags bieten häufig verwendete Funktionen in der Benutzerdokumentation:
<c> Legt Text in einer codeähnlichen Schriftart fest
<code> Legt eine oder mehrere Zeilen Quellcode- oder Programmausgabe in einer codeähnlichen Schriftart fest.
<example> Gibt ein Beispiel an
<exception> Identifiziert die Ausnahmen, die eine Methode auslösen kann
<include> Enthält ein externes XML-Dokument
<list> Erstellt eine Liste oder Tabelle
<para> Ermöglicht das Hinzufügen der Struktur zu Text
<param> Beschreibt einen Parameter für eine Methode oder einen Konstruktor.
<paramref> Gibt an, dass ein Wort ein Parametername ist.
<permission> Dokumentiert die Sicherheitsbarrierefreiheit eines Mitglieds
<remarks> Beschreibt einen Typ
<returns> Beschreibt den Rückgabewert einer Methode.
<see> Gibt einen Link an.
<seealso> Generiert einen See Also-Eintrag.
<summary> Beschreibt ein Element eines Typs
<typeparam> Beschreibt einen Typparameter.
<value> Beschreibt eine Eigenschaft
<c>
Dieses Tag gibt an, dass ein Textfragment in einer Beschreibung eine Schriftart verwenden soll, die für einen Codeblock verwendet wird. (Verwenden Sie <code>für Zeilen tatsächlichen Code .)
Syntax:
<c>text to be set like code</c>
Beispiel:
''' <remarks>
''' Class <c>Point</c> models a point in a two-dimensional plane.
''' </remarks>
Public Class Point
End Class
<Code>
Dieses Tag gibt an, dass mindestens eine Zeile quellcode- oder Programmausgabe eine Schriftart mit fester Breite verwenden soll. (Verwenden Sie <c>für kleine Codefragmente .)
Syntax:
<code>source code or program output</code>
Beispiel:
''' <summary>
''' This method changes the point's location by the given x- and
''' y-offsets.
''' <example>
''' For example:
''' <code>
''' Dim p As Point = New Point(3,5)
''' p.Translate(-1,3)
''' </code>
''' results in <c>p</c>'s having the value (2,8).
''' </example>
''' </summary>
Public Sub Translate(x As Integer, y As Integer)
Me.x += x
Me.y += y
End Sub
<Beispiel>
Dieses Tag ermöglicht Beispielcode in einem Kommentar, um zu zeigen, wie ein Element verwendet werden kann. Ordinarily, this will be use of the tag <code> as well.
Syntax:
<example>description</example>
Beispiel:
Ein Beispiel finden Sie unter <code>.
<Ausnahme>
Dieses Tag bietet eine Möglichkeit, die Ausnahmen zu dokumentieren, die eine Methode auslösen kann.
Syntax:
<exception cref="member">description</exception>
Beispiel:
Public Module DataBaseOperations
''' <exception cref="MasterFileFormatCorruptException"></exception>
''' <exception cref="MasterFileLockedOpenException"></exception>
Public Sub ReadRecord(flag As Integer)
If Flag = 1 Then
Throw New MasterFileFormatCorruptException()
ElseIf Flag = 2 Then
Throw New MasterFileLockedOpenException()
End If
' ...
End Sub
End Module
<einschließen>
Dieses Tag wird verwendet, um Informationen aus einem externen wohlgeformten XML-Dokument einzuschließen. Ein XPath-Ausdruck wird auf das XML-Dokument angewendet, um anzugeben, welche XML aus dem Dokument eingeschlossen werden soll. Der <include> -Tag wird dann durch das ausgewählte XML aus dem externen Dokument ersetzt.
Syntax:
<include file="filename" path="xpath">
Beispiel:
Wenn der Quellcode eine Deklaration wie folgt enthielt:
''' <include file="docs.xml" path="extra/class[@name="IntList"]/*" />
und die externe Datei docs.xml den folgenden Inhalt hatte
<?xml version="1.0"?>
<extra>
<class name="IntList">
<summary>
Contains a list of integers.
</summary>
</class>
<class name="StringList">
<summary>
Contains a list of strings.
</summary>
</class>
</extra>
dann wird die gleiche Dokumentation ausgegeben, als ob der Quellcode enthalten wäre:
''' <summary>
''' Contains a list of integers.
''' </summary>
<Liste>
Dieses Tag wird verwendet, um eine Liste oder Tabelle von Elementen zu erstellen. Er kann einen <listheader> Block enthalten, um die Überschriftenzeile einer Tabelle oder Definitionsliste zu definieren. (Beim Definieren einer Tabelle muss nur ein Eintrag für den Begriff in der Überschrift angegeben werden.)
Jedes Element der Liste wird mit einem <item>-Block angegeben. Beim Erstellen einer Definitionsliste müssen sowohl Der Begriff als auch die Beschreibung angegeben werden. Für eine Tabelle, eine Aufzählung oder eine nummerierte Liste müssen jedoch nur eine Beschreibung angegeben werden.
Syntax:
<list type="bullet" | "number" | "table">
<listheader>
<term>term</term>
<description>description</description>
</listheader>
<item>
<term>term</term>
<description>description</description>
</item>
...
<item>
<term>term</term>
<description>description</description>
</item>
</list>
Beispiel:
Public Class TestClass
''' <remarks>
''' Here is an example of a bulleted list:
''' <list type="bullet">
''' <item>
''' <description>Item 1.</description>
''' </item>
''' <item>
''' <description>Item 2.</description>
''' </item>
''' </list>
''' </remarks>
Public Shared Sub Main()
End Sub
End Class
<Para>
Dieses Tag dient zur Verwendung in anderen Tags, z <remarks> . B. oder <returns>, und ermöglicht das Hinzufügen der Struktur zu Text.
Syntax:
<para>content</para>
Beispiel:
''' <summary>
''' This is the entry point of the Point class testing program.
''' <para>This program tests each method and operator, and
''' is intended to be run after any non-trvial maintenance has
''' been performed on the Point class.</para>
''' </summary>
Public Shared Sub Main()
End Sub
<Param>
Dieses Tag beschreibt einen Parameter für eine Methode, einen Konstruktor oder eine indizierte Eigenschaft.
Syntax:
<param name="name">description</param>
Beispiel:
''' <summary>
''' This method changes the point's location to the given
''' coordinates.
''' </summary>
''' <param name="x"><c>x</c> is the new x-coordinate.</param>
''' <param name="y"><c>y</c> is the new y-coordinate.</param>
Public Sub Move(x As Integer, y As Integer)
Me.x = x
Me.y = y
End Sub
<paramref>
Dieses Tag gibt an, dass ein Wort ein Parameter ist. Die Dokumentationsdatei kann bearbeitet werden, um diesen Parameter auf eine bestimmte Weise zu formatieren.
Syntax:
<paramref name="name"/>
Beispiel:
''' <summary>
''' This constructor initializes the new Point to
''' (<paramref name="x"/>,<paramref name="y"/>).
''' </summary>
''' <param name="x"><c>x</c> is the new Point's x-coordinate.</param>
''' <param name="y"><c>y</c> is the new Point's y-coordinate.</param>
Public Sub New(x As Integer, y As Integer)
Me.x = x
Me.y = y
End Sub
<Erlaubnis>
Dieses Tag dokumentiert die Sicherheitsbarrierefreiheit eines Mitglieds.
Syntax:
<permission cref="member">description</permission>
Beispiel:
''' <permission cref="System.Security.PermissionSet">Everyone can
''' access this method.</permission>
Public Shared Sub Test()
End Sub
<Bemerkungen>
Dieses Tag gibt Übersichtsinformationen zu einem Typ an. (Wird verwendet <summary> , um die Member eines Typs zu beschreiben.)
Syntax:
<remarks>description</remarks>
Beispiel:
''' <remarks>
''' Class <c>Point</c> models a point in a two-dimensional plane.
''' </remarks>
Public Class Point
End Class
<Rückgaben>
Dieses Tag beschreibt den Rückgabewert einer Methode.
Syntax:
<returns>description</returns>
Beispiel:
''' <summary>
''' Report a point's location as a string.
''' </summary>
''' <returns>
''' A string representing a point's location, in the form (x,y), without
''' any leading, training, or embedded whitespace.
''' </returns>
Public Overrides Function ToString() As String
Return "(" & x & "," & y & ")"
End Sub
<Siehe>
Mit diesem Tag kann ein Link im Text angegeben werden. (Verwenden Sie diese Eigenschaft <seealso> , um Text anzugeben, der in einem Abschnitt "Siehe auch" angezeigt werden soll.)
Syntax:
<see cref="member"/>
Beispiel:
''' <summary>
''' This method changes the point's location to the given
''' coordinates.
''' </summary>
''' <see cref="Translate"/>
Public Sub Move(x As Integer, y As Integer)
Me.x = x
Me.y = y
End Sub
''' <summary>
''' This method changes the point's location by the given x- and
''' y-offsets.
''' </summary>
''' <see cref="Move"/>
Public Sub Translate(x As Integer, y As Integer)
Me.x += x
Me.y += y
End Sub
<siehe auch>
Dieses Tag generiert einen Eintrag für den Abschnitt "Siehe auch". (Verwenden Sie <see> diese Eigenschaft, um einen Link aus Text anzugeben.)
Syntax:
<seealso cref="member"/>
Beispiel:
''' <summary>
''' This method determines whether two Points have the same location.
''' </summary>
''' <seealso cref="operator=="/>
''' <seealso cref="operator!="/>
Public Overrides Function Equals(o As Object) As Boolean
' ...
End Function
<Zusammenfassung>
Dieses Tag beschreibt ein Typmemm. (Wird <remarks> verwendet, um einen Typ selbst zu beschreiben.)
Syntax:
<summary>description</summary>
Beispiel:
''' <summary>
''' This constructor initializes the new Point to (0,0).
''' </summary>
Public Sub New()
Me.New(0,0)
End Sub
<typeparam>
Dieses Tag beschreibt einen Typparameter.
Syntax:
<typeparam name="name">description</typeparam>
Beispiel:
''' <typeparam name="T">
''' The base item type. Must implement IComparable.
''' </typeparam>
Public Class ItemManager(Of T As IComparable)
End Class
<Wert>
Dieses Tag beschreibt eine Eigenschaft.
Syntax:
<value>property description</value>
Beispiel:
''' <value>
''' Property <c>X</c> represents the point's x-coordinate.
''' </value>
Public Property X() As Integer
Get
Return _x
End Get
Set (Value As Integer)
_x = Value
End Set
End Property
ID-Zeichenfolgen
Beim Generieren der Dokumentationsdatei generiert der Compiler eine ID-Zeichenfolge für jedes Element im Quellcode, das mit einem Dokumentationskommentar markiert ist, der es eindeutig identifiziert. Diese ID-Zeichenfolge kann von externen Tools verwendet werden, um zu identifizieren, welches Element in einer kompilierten Assembly dem Dokumentkommentar entspricht.
ID-Zeichenfolgen werden wie folgt generiert:
In der Zeichenfolge wird kein Leerraum platziert.
Der erste Teil der Zeichenfolge identifiziert die Art des Mitglieds, das dokumentiert wird, durch ein einzelnes Zeichen gefolgt von einem Doppelpunkt. Die folgenden Typen von Membern werden mit dem entsprechenden Zeichen in Klammer danach definiert: Ereignisse (E), Felder (F), Methoden einschließlich Konstruktoren und Operatoren (M), Namespaces (N), Eigenschaften (P) und Typen (T). Ein Ausrufezeichen (!) gibt an, dass beim Generieren der ID-Zeichenfolge ein Fehler aufgetreten ist, und der Rest der Zeichenfolge enthält Informationen zum Fehler.
Der zweite Teil der Zeichenfolge ist der vollqualifizierte Name des Elements, beginnend mit dem globalen Namespace. Der Name des Elements, seine eingeschlossenen Typen und Namespaces werden durch Punkte getrennt. Wenn der Name des Elements selbst Punkte enthält, werden sie durch das Nummernzeichen (#) ersetzt. (Es wird davon ausgegangen, dass kein Element dieses Zeichen in seinem Namen hat.) Der Name eines Typs mit Typparametern endet mit einem Backquote (') gefolgt von einer Zahl, die die Anzahl der Typparameter für den Typ darstellt. Es ist wichtig zu beachten, dass geschachtelte Typen Zugriff auf die Typparameter der Typen haben, die sie enthalten, geschachtelte Typen implizit die Typparameter ihrer enthaltenden Typen enthalten, und diese Typen werden in diesem Fall in ihren Typparametersummen gezählt.
Bei Methoden und Eigenschaften mit Argumenten folgt die Argumentliste, eingeschlossen in Klammern. Für diejenigen, die keine Argumente haben, werden die Klammern weggelassen. Die Argumente werden durch Kommas voneinander getrennt. Die Codierung jedes Arguments ist identisch mit einer CLI-Signatur, wie folgt: Argumente werden durch ihren vollqualifizierten Namen dargestellt. Beispielsweise Integer wird , wird System.Int32String , Object wird System.String, wird System.Object, usw. Argumente, die den ByRef Modifizierer aufweisen, weisen einen '@' nach ihrem Typnamen auf. Argumente mit dem ByValOptionalParamArray Oder Modifizierer weisen keine spezielle Schreibweise auf. Argumente, die Arrays sind, werden so [lowerbound:size, ..., lowerbound:size] dargestellt, als dass die Anzahl der Kommas der Rang - 1 ist, und die unteren Grenzen und Größe jeder Dimension( falls bekannt) in dezimal dargestellt werden. Wenn keine Untergrenze oder Größe angegeben ist, wird sie weggelassen. Wenn die untere Grenze und Größe für eine bestimmte Dimension weggelassen werden, wird auch das ":" weggelassen. Arrays von Arrays werden durch ein "[]" pro Ebene dargestellt.
Beispiele für ID-Zeichenfolgen
Die folgenden Beispiele zeigen jeweils ein Fragment von VB-Code zusammen mit der ID-Zeichenfolge, die aus jedem Quellelement erzeugt wird, das einen Dokumentationskommentar haben kann:
Typen werden mit ihrem vollqualifizierten Namen dargestellt.
Enum Color
Red
Blue
Green
End Enum
Namespace Acme
Interface IProcess
End Interface
Structure ValueType
...
End Structure
Class Widget
Public Class NestedClass
End Class
Public Interface IMenuItem
End Interface
Public Delegate Sub Del(i As Integer)
Public Enum Direction
North
South
East
West
End Enum
End Class
End Namespace
"T:Color"
"T:Acme.IProcess"
"T:Acme.ValueType"
"T:Acme.Widget"
"T:Acme.Widget.NestedClass"
"T:Acme.Widget.IMenuItem"
"T:Acme.Widget.Del"
"T:Acme.Widget.Direction"
Felder werden durch ihren vollqualifizierten Namen dargestellt.
Namespace Acme
Structure ValueType
Private total As Integer
End Structure
Class Widget
Public Class NestedClass
Private value As Integer
End Class
Private message As String
Private Shared defaultColor As Color
Private Const PI As Double = 3.14159
Protected ReadOnly monthlyAverage As Double
Private array1() As Long
Private array2(,) As Widget
End Class
End Namespace
"F:Acme.ValueType.total"
"F:Acme.Widget.NestedClass.value"
"F:Acme.Widget.message"
"F:Acme.Widget.defaultColor"
"F:Acme.Widget.PI"
"F:Acme.Widget.monthlyAverage"
"F:Acme.Widget.array1"
"F:Acme.Widget.array2"
Erbauer.
Namespace Acme
Class Widget
Shared Sub New()
End Sub
Public Sub New()
End Sub
Public Sub New(s As String)
End Sub
End Class
End Namespace
"M:Acme.Widget.#cctor"
"M:Acme.Widget.#ctor"
"M:Acme.Widget.#ctor(System.String)"
Methodik.
Namespace Acme
Structure ValueType
Public Sub M(i As Integer)
End Sub
End Structure
Class Widget
Public Class NestedClass
Public Sub M(i As Integer)
End Sub
End Class
Public Shared Sub M0()
End Sub
Public Sub M1(c As Char, ByRef f As Float, _
ByRef v As ValueType)
End Sub
Public Sub M2(x1() As Short, x2(,) As Integer, _
x3()() As Long)
End Sub
Public Sub M3(x3()() As Long, x4()(,,) As Widget)
End Sub
Public Sub M4(Optional i As Integer = 1)
Public Sub M5(ParamArray args() As Object)
End Sub
End Class
End Namespace
"M:Acme.ValueType.M(System.Int32)"
"M:Acme.Widget.NestedClass.M(System.Int32)"
"M:Acme.Widget.M0"
"M:Acme.Widget.M1(System.Char,System.Single@,Acme.ValueType@)"
"M:Acme.Widget.M2(System.Int16[],System.Int32[0:,0:],System.Int64[][])"
"M:Acme.Widget.M3(System.Int64[][],Acme.Widget[0:,0:,0:][])"
"M:Acme.Widget.M4(System.Int32)"
"M:Acme.Widget.M5(System.Object[])"
Eigenschaften.
Namespace Acme
Class Widget
Public Property Width() As Integer
Get
End Get
Set (Value As Integer)
End Set
End Property
Public Default Property Item(i As Integer) As Integer
Get
End Get
Set (Value As Integer)
End Set
End Property
Public Default Property Item(s As String, _
i As Integer) As Integer
Get
End Get
Set (Value As Integer)
End Set
End Property
End Class
End Namespace
"P:Acme.Widget.Width"
"P:Acme.Widget.Item(System.Int32)"
"P:Acme.Widget.Item(System.String,System.Int32)"
Ereignisse
Namespace Acme
Class Widget
Public Event AnEvent As EventHandler
Public Event AnotherEvent()
End Class
End Namespace
"E:Acme.Widget.AnEvent"
"E:Acme.Widget.AnotherEvent"
Betriebspersonal.
Namespace Acme
Class Widget
Public Shared Operator +(x As Widget) As Widget
End Operator
Public Shared Operator +(x1 As Widget, x2 As Widget) As Widget
End Operator
End Class
End Namespace
"M:Acme.Widget.op_UnaryPlus(Acme.Widget)"
"M:Acme.Widget.op_Addition(Acme.Widget,Acme.Widget)"
Konvertierungsoperatoren weisen einen nachgestellten ~ Gefolgten vom Rückgabetyp auf.
Namespace Acme
Class Widget
Public Shared Narrowing Operator CType(x As Widget) As _
Integer
End Operator
Public Shared Widening Operator CType(x As Widget) As Long
End Operator
End Class
End Namespace
"M:Acme.Widget.op_Explicit(Acme.Widget)~System.Int32"
"M:Acme.Widget.op_Implicit(Acme.Widget)~System.Int64"
Beispiel für Dokumentationskommentare
Das folgende Beispiel zeigt den Quellcode einer Point Klasse:
Namespace Graphics
''' <remarks>
''' Class <c>Point</c> models a point in a two-dimensional
''' plane.
''' </remarks>
Public Class Point
''' <summary>
''' Instance variable <c>x</c> represents the point's x-coordinate.
''' </summary>
Private _x As Integer
''' <summary>
''' Instance variable <c>y</c> represents the point's y-coordinate.
''' </summary>
Private _y As Integer
''' <value>
''' Property <c>X</c> represents the point's x-coordinate.
''' </value>
Public Property X() As Integer
Get
Return _x
End Get
Set(Value As Integer)
_x = Value
End Set
End Property
''' <value>
''' Property <c>Y</c> represents the point's y-coordinate.
''' </value>
Public Property Y() As Integer
Get
Return _y
End Get
Set(Value As Integer)
_y = Value
End Set
End Property
''' <summary>
''' This constructor initializes the new Point to (0,0).
''' </summary>
Public Sub New()
Me.New(0, 0)
End Sub
''' <summary>
''' This constructor initializes the new Point to
''' (<paramref name="x"/>,<paramref name="y"/>).
''' </summary>
''' <param name="x"><c>x</c> is the new Point's
''' x-coordinate.</param>
''' <param name="y"><c>y</c> is the new Point's
''' y-coordinate.</param>
Public Sub New(x As Integer, y As Integer)
Me.X = x
Me.Y = y
End Sub
''' <summary>
''' This method changes the point's location to the given
''' coordinates.
''' </summary>
''' <param name="x"><c>x</c> is the new x-coordinate.</param>
''' <param name="y"><c>y</c> is the new y-coordinate.</param>
''' <see cref="Translate"/>
Public Sub Move(x As Integer, y As Integer)
Me.X = x
Me.Y = y
End Sub
''' <summary>
''' This method changes the point's location by the given x- and
''' y-offsets.
''' <example>
''' For example:
''' <code>
''' Dim p As Point = New Point(3, 5)
''' p.Translate(-1, 3)
''' </code>
''' results in <c>p</c>'s having the value (2,8).
''' </example>
''' </summary>
''' <param name="x"><c>x</c> is the relative x-offset.</param>
''' <param name="y"><c>y</c> is the relative y-offset.</param>
''' <see cref="Move"/>
Public Sub Translate(x As Integer, y As Integer)
Me.X += x
Me.Y += y
End Sub
''' <summary>
''' This method determines whether two Points have the same
''' location.
''' </summary>
''' <param name="o"><c>o</c> is the object to be compared to the
''' current object.</param>
''' <returns>
''' True if the Points have the same location and they have the
''' exact same type; otherwise, false.
''' </returns>
''' <seealso cref="Operator op_Equality"/>
''' <seealso cref="Operator op_Inequality"/>
Public Overrides Function Equals(o As Object) As Boolean
If o Is Nothing Then
Return False
End If
If o Is Me Then
Return True
End If
If Me.GetType() Is o.GetType() Then
Dim p As Point = CType(o, Point)
Return (X = p.X) AndAlso (Y = p.Y)
End If
Return False
End Function
''' <summary>
''' Report a point's location as a string.
''' </summary>
''' <returns>
''' A string representing a point's location, in the form
''' (x,y), without any leading, training, or embedded whitespace.
''' </returns>
Public Overrides Function ToString() As String
Return "(" & X & "," & Y & ")"
End Function
''' <summary>
''' This operator determines whether two Points have the
''' same location.
''' </summary>
''' <param name="p1"><c>p1</c> is the first Point to be compared.
''' </param>
''' <param name="p2"><c>p2</c> is the second Point to be compared.
''' </param>
''' <returns>
''' True if the Points have the same location and they
''' have the exact same type; otherwise, false.
''' </returns>
''' <seealso cref="Equals"/>
''' <seealso cref="op_Inequality"/>
Public Shared Operator =(p1 As Point, p2 As Point) As Boolean
If p1 Is Nothing OrElse p2 Is Nothing Then
Return False
End If
If p1.GetType() Is p2.GetType() Then
Return (p1.X = p2.X) AndAlso (p1.Y = p2.Y)
End If
Return False
End Operator
''' <summary>
''' This operator determines whether two Points have the
''' same location.
''' </summary>
''' <param name="p1"><c>p1</c> is the first Point to be comapred.
''' </param>
''' <param name="p2"><c>p2</c> is the second Point to be compared.
''' </param>
''' <returns>
''' True if the Points do not have the same location and
''' the exact same type; otherwise, false.
''' </returns>
''' <seealso cref="Equals"/>
''' <seealso cref="op_Equality"/>
Public Shared Operator <>(p1 As Point, p2 As Point) As Boolean
Return Not p1 = p2
End Operator
''' <summary>
''' This is the entry point of the Point class testing program.
''' <para>This program tests each method and operator, and
''' is intended to be run after any non-trvial maintenance has
''' been performed on the Point class.</para>
''' </summary>
Public Shared Sub Main()
' class test code goes here
End Sub
End Class
End Namespace
Dies ist die Ausgabe, die bei Angabe des Quellcodes für die Klasse Pointerstellt wird, siehe oben:
<?xml version="1.0"?>
<doc>
<assembly>
<name>Point</name>
</assembly>
<members>
<member name="T:Graphics.Point">
<remarks>Class <c>Point</c> models a point in a
two-dimensional plane. </remarks>
</member>
<member name="F:Graphics.Point.x">
<summary>Instance variable <c>x</c> represents the point's
x-coordinate.</summary>
</member>
<member name="F:Graphics.Point.y">
<summary>Instance variable <c>y</c> represents the point's
y-coordinate.</summary>
</member>
<member name="M:Graphics.Point.#ctor">
<summary>This constructor initializes the new Point to
(0,0).</summary>
</member>
<member name="M:Graphics.Point.#ctor(System.Int32,System.Int32)">
<summary>This constructor initializes the new Point to
(<paramref name="x"/>,<paramref name="y"/>).</summary>
<param><c>x</c> is the new Point's x-coordinate.</param>
<param><c>y</c> is the new Point's y-coordinate.</param>
</member>
<member name="M:Graphics.Point.Move(System.Int32,System.Int32)">
<summary>This method changes the point's location to
the given coordinates.</summary>
<param><c>x</c> is the new x-coordinate.</param>
<param><c>y</c> is the new y-coordinate.</param>
<see cref=
"M:Graphics.Point.Translate(System.Int32,System.Int32)"/>
</member>
<member name=
"M:Graphics.Point.Translate(System.Int32,System.Int32)">
<summary>This method changes the point's location by the given
x- and y-offsets.
<example>For example:
<code>
Point p = new Point(3,5);
p.Translate(-1,3);
</code>
results in <c>p</c>'s having the value (2,8).
</example>
</summary>
<param><c>x</c> is the relative x-offset.</param>
<param><c>y</c> is the relative y-offset.</param>
<see cref="M:Graphics.Point.Move(System.Int32,System.Int32)"/>
</member>
<member name="M:Graphics.Point.Equals(System.Object)">
<summary>This method determines whether two Points have the
same location.</summary>
<param><c>o</c> is the object to be compared to the current
object.</param>
<returns>True if the Points have the same location and they
have the exact same type; otherwise, false.</returns>
<seealso cref=
"M:Graphics.Point.op_Equality(Graphics.Point,Graphics.Point)"
/>
<seealso cref=
"M:Graphics.Point.op_Inequality(Graphics.Point,Graphics.Point)"
/>
</member>
<member name="M:Graphics.Point.ToString">
<summary>Report a point's location as a string.</summary>
<returns>A string representing a point's location, in the form
(x,y), without any leading, training, or embedded
whitespace.</returns>
</member>
<member name=
"M:Graphics.Point.op_Equality(Graphics.Point,Graphics.Point)">
<summary>This operator determines whether two Points have the
same location.</summary>
<param><c>p1</c> is the first Point to be compared.</param>
<param><c>p2</c> is the second Point to be compared.</param>
<returns>True if the Points have the same location and they
have the exact same type; otherwise, false.</returns>
<seealso cref="M:Graphics.Point.Equals(System.Object)"/>
<seealso cref=
"M:Graphics.Point.op_Inequality(Graphics.Point,Graphics.Point)"
/>
</member>
<member name=
"M:Graphics.Point.op_Inequality(Graphics.Point,Graphics.Point)">
<summary>This operator determines whether two Points have the
same location.</summary>
<param><c>p1</c> is the first Point to be compared.</param>
<param><c>p2</c> is the second Point to be compared.</param>
<returns>True if the Points do not have the same location and
the exact same type; otherwise, false.</returns>
<seealso cref="M:Graphics.Point.Equals(System.Object)"/>
<seealso cref=
"M:Graphics.Point.op_Equality(Graphics.Point,Graphics.Point)"
/>
</member>
<member name="M:Graphics.Point.Main">
<summary>This is the entry point of the Point class testing
program.
<para>This program tests each method and operator, and
is intended to be run after any non-trvial maintenance has
been performed on the Point class.</para>
</summary>
</member>
<member name="P:Graphics.Point.X">
<value>Property <c>X</c> represents the point's
x-coordinate.</value>
</member>
<member name="P:Graphics.Point.Y">
<value>Property <c>Y</c> represents the point's
y-coordinate.</value>
</member>
</members>
</doc>
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
Visual Basic language spec