Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Os comentários da documentação são comentários formatados especialmente na origem que podem ser analisados para produzir documentação sobre o código ao qual estão anexados. O formato básico para comentários de documentação é XML. Quando o código de compilação com comentários de documentação, o compilador pode, opcionalmente, emitir um arquivo XML que representa a soma total dos comentários da documentação na origem. Esse arquivo XML pode ser usado por outras ferramentas para produzir documentação impressa ou online.
Este capítulo descreve comentários de documentos e marcas XML recomendadas para usar com comentários de documento.
Formato de comentário da documentação
Comentários de documento são comentários especiais que começam com '''três aspas simples. Eles devem preceder imediatamente o tipo (como uma classe, delegado ou interface) ou membro do tipo (como um campo, evento, propriedade ou método) que eles documentam. Um comentário de documento sobre uma declaração de método parcial será substituído pelo comentário do documento sobre o método que fornece seu corpo, se houver um. Todos os comentários de documentos adjacentes são acrescentados para produzir um único comentário de documento. Se houver um caractere de espaço em branco seguindo os ''' caracteres, esse caractere de espaço em branco não será incluído na concatenação. Por exemplo:
''' <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
Os comentários da documentação devem ser XML bem formados de acordo https://www.w3.org/TR/REC-xmlcom . Se o XML não estiver bem formado, um aviso será gerado e o arquivo de documentação conterá um comentário informando que um erro foi encontrado.
Embora os desenvolvedores sejam livres para criar seu próprio conjunto de marcas, um conjunto recomendado é definido na próxima seção. Algumas das etiquetas recomendadas têm significados especiais.
A marca
<param>é usada para descrever parâmetros. O parâmetro especificado por uma<param>marca deve existir e todos os parâmetros do membro do tipo devem ser descritos no comentário da documentação. Se qualquer uma das condições não for verdadeira, o compilador emitirá um aviso.O atributo
crefpode ser anexado a qualquer tag para fornecer uma referência a um elemento de código. O elemento de código deve existir; em tempo de compilação, o compilador substitui o nome pela cadeia de caracteres de ID que representa o membro. Se o elemento de código não existir, o compilador emitirá um aviso. Ao procurar um nome descrito em umcrefatributo, o compilador respeitaImportsas instruções que aparecem no arquivo de origem que contém.A
<summary>tag deve ser usada por um visualizador de documentação para exibir informações adicionais sobre um tipo ou membro.
Observe que o arquivo de documentação não fornece informações completas sobre um tipo e membros, apenas o que está contido nos comentários do documento. Para obter mais informações sobre um tipo ou membro, o arquivo de documentação deve ser usado em conjunto com a reflexão sobre o tipo ou membro real.
Marcações recomendadas
O gerador de documentação deve aceitar e processar qualquer tag válida de acordo com as regras de XML. As marcas a seguir fornecem funcionalidades comumente usadas na documentação do usuário:
<c> Define o texto em uma fonte semelhante a um código
<code> Define uma ou mais linhas de código-fonte ou saída de programa em uma fonte semelhante a um código
<example> Indica um exemplo
<exception> Identifica as exceções que um método pode gerar
<include> Inclui um documento XML externo
<list> Cria uma lista ou tabela
<para> Permite que a estrutura seja adicionada ao texto
<param> Descreve um parâmetro para um método ou construtor
<paramref> Identifica que uma palavra é um nome de parâmetro
<permission> Documenta a acessibilidade de segurança de um membro
<remarks> Descreve um tipo
<returns> Descreve o valor retornado de um método
<see> Especifica um link
<seealso> Gera uma entrada Ver Também
<summary> Descreve um membro de um tipo
<typeparam> Descreve um parâmetro de tipo
<value> Descreve uma propriedade
<c>
Essa marca especifica que um fragmento de texto em uma descrição deve usar uma fonte como a usada para um bloco de código. (Para linhas de código real, use <code>.)
Sintaxe:
<c>text to be set like code</c>
Exemplo:
''' <remarks>
''' Class <c>Point</c> models a point in a two-dimensional plane.
''' </remarks>
Public Class Point
End Class
<código>
Essa marca especifica que uma ou mais linhas de código-fonte ou saída do programa devem usar uma fonte de largura fixa. (Para fragmentos de código pequenos, use <c>.)
Sintaxe:
<code>source code or program output</code>
Exemplo:
''' <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
<exemplo>
Essa marca permite que o código de exemplo em um comentário mostre como um elemento pode ser usado. Normalmente, isso envolverá o uso da marca <code> também.
Sintaxe:
<example>description</example>
Exemplo:
Para ver um exemplo, consulte <code>.
<exceção>
Essa tag fornece uma maneira de documentar as exceções que um método pode gerar.
Sintaxe:
<exception cref="member">description</exception>
Exemplo:
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
<incluir>
Essa marca é usada para incluir informações de um documento XML bem formado externo. Uma expressão XPath é aplicada ao documento XML para especificar qual XML deve ser incluído no documento. A <include> tag é então substituída pelo XML selecionado do documento externo.
Sintaxe:
<include file="filename" path="xpath">
Exemplo:
Se o código-fonte contiver uma declaração como a seguinte:
''' <include file="docs.xml" path="extra/class[@name="IntList"]/*" />
e o arquivo externo docs.xml tinha o conteúdo a seguir
<?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>
Em seguida, a mesma documentação é gerada como se o código-fonte contivesse:
''' <summary>
''' Contains a list of integers.
''' </summary>
<lista>
Essa tag é usada para criar uma lista ou tabela de itens. Ele pode conter um <listheader> bloco para definir a linha de título de uma tabela ou lista de definição. (Ao definir uma tabela, apenas uma entrada para o termo no título precisa ser fornecida.)
Cada item na lista é especificado com um bloco <item>. Ao criar uma lista de definição, o termo e a descrição devem ser especificados. No entanto, para uma tabela, lista com marcadores ou lista numerada, apenas a descrição precisa ser especificada.
Sintaxe:
<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>
Exemplo:
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>
Essa marca é para uso dentro de outras marcas, como <remarks> ou <returns>, e permite que a estrutura seja adicionada ao texto.
Sintaxe:
<para>content</para>
Exemplo:
''' <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>
Essa marca descreve um parâmetro para um método, construtor ou propriedade indexada.
Sintaxe:
<param name="name">description</param>
Exemplo:
''' <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>
Essa marca indica que uma palavra é um parâmetro. O arquivo de documentação pode ser processado para formatar esse parâmetro de alguma maneira distinta.
Sintaxe:
<paramref name="name"/>
Exemplo:
''' <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
<permissão>
Essa marca documenta a acessibilidade de segurança de um membro
Sintaxe:
<permission cref="member">description</permission>
Exemplo:
''' <permission cref="System.Security.PermissionSet">Everyone can
''' access this method.</permission>
Public Shared Sub Test()
End Sub
<Observações>
Essa marca especifica informações de visão geral sobre um tipo. (Use <summary> para descrever os membros de um tipo.)
Sintaxe:
<remarks>description</remarks>
Exemplo:
''' <remarks>
''' Class <c>Point</c> models a point in a two-dimensional plane.
''' </remarks>
Public Class Point
End Class
<retornos>
Essa marca descreve o valor retornado de um método.
Sintaxe:
<returns>description</returns>
Exemplo:
''' <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
<consultar>
Essa tag permite que um link seja especificado no texto. (Use <seealso> para indicar o texto que será exibido em uma seção Ver Também.)
Sintaxe:
<see cref="member"/>
Exemplo:
''' <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
<veja também>
Essa marca gera uma entrada para a seção Consulte Também. (Use <see> para especificar um link de dentro do texto.)
Sintaxe:
<seealso cref="member"/>
Exemplo:
''' <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
<resumo>
Essa marca descreve um membro do tipo. (Use <remarks> para descrever um tipo em si.)
Sintaxe:
<summary>description</summary>
Exemplo:
''' <summary>
''' This constructor initializes the new Point to (0,0).
''' </summary>
Public Sub New()
Me.New(0,0)
End Sub
<typeparam>
Essa marca descreve um parâmetro de tipo.
Sintaxe:
<typeparam name="name">description</typeparam>
Exemplo:
''' <typeparam name="T">
''' The base item type. Must implement IComparable.
''' </typeparam>
Public Class ItemManager(Of T As IComparable)
End Class
<valor>
Essa marca descreve uma propriedade.
Sintaxe:
<value>property description</value>
Exemplo:
''' <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
Cadeias de caracteres de ID
Ao gerar o arquivo de documentação, o compilador gera uma cadeia de caracteres de ID para cada elemento no código-fonte marcado com um comentário de documentação que o identifica exclusivamente. Essa cadeia de caracteres de ID pode ser usada por ferramentas externas para identificar qual elemento em um assembly compilado corresponde ao comentário do documento.
As cadeias de caracteres de ID são geradas da seguinte maneira:
Nenhum espaço em branco é colocado na cadeia de caracteres.
A primeira parte da cadeia de caracteres identifica o tipo de membro que está sendo documentado, por meio de um único caractere seguido por dois-pontos. Os seguintes tipos de membros são definidos, com o caractere correspondente em parênteses após ele: eventos (E), campos (F), métodos que incluem construtores e operadores (M), namespaces (N), propriedades (P) e tipos (T). Um ponto de exclamação (!) indica que ocorreu um erro ao gerar a cadeia de caracteres de ID e o restante da cadeia de caracteres fornece informações sobre o erro.
A segunda parte da cadeia de caracteres é o nome totalmente qualificado do elemento, começando no namespace global. O nome do elemento, seus tipos de delimitamento e namespace são separados por períodos. Se o nome do item em si tiver períodos, eles serão substituídos pelo sinal de libra (#). (Supõe-se que nenhum elemento tenha esse caractere em seu nome.) O nome de um tipo com parâmetros de tipo termina com um backquote (') seguido por um número que representa o número de parâmetros de tipo no tipo. É importante lembrar que, como os tipos aninhados têm acesso aos parâmetros de tipo dos tipos que os contêm, os tipos aninhados contêm implicitamente os parâmetros de tipo de seus tipos de contenção e esses tipos são contados em seus totais de parâmetro de tipo nesse caso.
Para métodos e propriedades com argumentos, a lista de argumentos segue, entre parênteses. Para aqueles sem argumentos, os parênteses são omitidos. Os argumentos são separados por vírgulas. A codificação de cada argumento é a mesma que uma assinatura da CLI, da seguinte maneira: os argumentos são representados pelo nome totalmente qualificado. Por exemplo, Integer torna-se System.Int32, String torna-se System.String, Object torna-se System.Objecte assim por diante. Os argumentos que têm o ByRef modificador têm um '@' seguindo seu nome de tipo. Os argumentos que têm o ByValOptional modificador ou ParamArray o modificador não têm notação especial. Os argumentos que são matrizes são representados como [lowerbound:size, ..., lowerbound:size] onde o número de vírgulas é a classificação - 1, e os limites inferiores e o tamanho de cada dimensão, se conhecido, são representados em decimal. Se um limite inferior ou tamanho não for especificado, ele será omitido. Se o limite inferior e o tamanho de uma determinada dimensão forem omitidos, o ':' também será omitido. Matrizes de matrizes são representadas por um "[]" por nível.
Exemplos de cadeia de caracteres de ID
Os exemplos a seguir mostram cada um um fragmento de código VB, juntamente com a cadeia de caracteres de ID produzida de cada elemento de origem capaz de ter um comentário de documentação:
Os tipos são representados usando seu nome totalmente qualificado.
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"
Os campos são representados pelo nome totalmente qualificado.
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"
Construtores.
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)"
Métodos.
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[])"
Propriedades.
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)"
Eventos
Namespace Acme
Class Widget
Public Event AnEvent As EventHandler
Public Event AnotherEvent()
End Class
End Namespace
"E:Acme.Widget.AnEvent"
"E:Acme.Widget.AnotherEvent"
Operadores.
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)"
Os operadores de conversão têm uma trilha ~ seguida pelo tipo de retorno.
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"
Exemplo de comentários de documentação
O exemplo a seguir mostra o código-fonte de uma Point classe:
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
Aqui está a saída produzida quando dado o código-fonte da classe Point, mostrado acima:
<?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>
Colaborar conosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
Visual Basic language spec