C#6.0语言规范(十九) 文档注释

C＃为程序员提供了一种机制，可以使用包含XML文本的特殊注释语法来记录他们的代码。在源代码文件中，具有特定形式的注释可用于指示工具从这些注释和它们之前的源代码元素生成XML。使用这种语法的注释称为文档注释。它们必须紧接在用户定义的类型（例如类，委托或接口）或成员（例如字段，事件，属性或方法）之前。XML生成工具称为文档生成器。（这个生成器可以是，但不一定是C＃编译器本身。）文档生成器生成的输出称为文档文件。文档文件用作a的输入文档查看器 ; 用于生成类型信息及其相关文档的某种视觉显示的工具。

此规范建议在文档注释中使用一组标记，但不需要使用这些标记，并且如果需要，可以使用其他标记，只要遵循格式良好的XML的规则。

介绍

具有特殊形式的注释可用于指示工具从这些注释和它们之前的源代码元素生成XML。这样的注释是以三个斜杠（///）开头的单行注释，或以斜杠和两个星（/**）开头的分隔注释。它们必须紧接在用户定义的类型（例如类，委托或接口）或它们注释的成员（例如字段，事件，属性或方法）之前。属性部分（属性规范）被视为声明的一部分，因此文档注释必须位于应用于类型或成员的属性之前。

句法：

single_line_doc_comment
    : '///' input_character*
    ;

delimited_doc_comment
    : '/**' delimited_comment_section* asterisk+ '/'
    ;

在single_line_doc_comment中，如果在与当前single_line_doc_comment相邻的每个single_line_doc_comment上的字符后面有空白字符，那么该空白字符不包含在XML输出中。///

在分隔文档注释中，如果第二行上的第一个非空白字符是星号，并且在分隔文档中的每一行的开头重复相同的可选空格字符和星号字符的模式注释，然后重复模式的字符不包含在XML输出中。该模式可以包括星号字符之后以及之前的空格字符。

例：

/// <summary>Class <c>Point</c> models a point in a two-dimensional
/// plane.</summary>
///
public class Point 
{
    /// <summary>method <c>draw</c> renders the point.</summary>
    void draw() {...}
}

文档注释中的文本必须根据XML规则（http://www.w3.org/TR/REC-xml）很好地形成。如果XML格式不正确，则会生成警告，文档文件将包含一条注释，说明遇到了错误。

虽然开发人员可以自由创建自己的标记集，但推荐标记中定义了推荐集。一些推荐的标签具有特殊含义：

• 该<param>标签是用来描述参数。如果使用此类标记，则文档生成器必须验证指定的参数是否存在，以及文档注释中是否描述了所有参数。如果此类验证失败，则文档生成器会发出警告。
• 该cref属性可以附加到任何标记以提供对代码元素的引用。文档生成器必须验证此代码元素是否存在。如果验证失败，文档生成器会发出警告。在查找cref属性中描述的名称时，文档生成器必须根据using源代码中出现的语句来遵循名称空间可见性。对于通用的代码元素，不能使用普通的通用语法（即“ List<T>”），因为它会生成无效的XML。可以使用大括号代替括号（即“ List{T}”），或者可以使用XML转义语法（即“ List<T>”）。
• 该<summary>标记旨在供文档查看器用于显示有关类型或成员的其他信息。
• 该<include>标签包括从外部XML文件的信息。

请注意，文档文件不提供有关类型和成员的完整信息（例如，它不包含任何类型信息）。要获取有关类型或成员的此类信息，必须将文档文件与实际类型或成员的反射结合使用。

常用标签

文档生成器必须接受并处理根据XML规则有效的任何标记。以下标记提供用户文档中常用的功能。（当然，其他标签也是可能的。）

标签	部分	目的
<c>	<c>	以类似代码的字体设置文本
<code>	<code>	设置一行或多行源代码或程序输出
<example>	<example>	表示一个例子
<exception>	<exception>	标识方法可以抛出的异常
<include>	<include>	包含来自外部文件的XML
<list>	<list>	创建列表或表
<para>	<para>	允许添加到文本的结构
<param>	<param>	描述方法或构造函数的参数
<paramref>	<paramref>	确定单词是参数名称
<permission>	<permission>	记录成员的安全可访问性
<remark>	<remark>	描述有关类型的其他信息
<returns>	<returns>	描述方法的返回值
<see>	<see>	指定链接
<seealso>	<seealso>	生成另请参阅条目
<summary>	<summary>	描述类型或类型的成员
<value>	<value>	描述一处房产
<typeparam>		描述泛型类型参数
<typeparamref>		确定单词是类型参数名称

<c>

此标记提供了一种机制，用于指示描述中的文本片段应设置为特殊字体，例如用于代码块的字体。对于实际代码行，请使用<code>（<code>）。

句法：

<c>text</c>

例：

/// <summary>Class <c>Point</c> models a point in a two-dimensional
/// plane.</summary>

public class Point 
{
    // ...
}

<code>

此标记用于以某种特殊字体设置一行或多行源代码或程序输出。对于叙述中的小代码片段，请使用<c>（<c>）。

句法：

<code>source code or program output</code>

例：

/// <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>

public void Translate(int xor, int yor) {
    X += xor;
    Y += yor;
}

<example>

此标记允许注释中的示例代码，以指定如何使用方法或其他库成员。通常，这也涉及使用tag <code>（<code>）。

句法：

<example>description</example>

例：

有关示例，请参阅<code>（<code>）。

<exception>

此标记提供了一种记录方法可以抛出的异常的方法。

句法：

<exception cref="member">description</exception>

• member是会员的名字。文档生成器检查给定成员是否存在，并转换member为文档文件中的规范元素名称。
• description 是对抛出异常的情况的描述。

例：

public class DataBaseOperations
{
    /// <exception cref="MasterFileFormatCorruptException"></exception>
    /// <exception cref="MasterFileLockedOpenException"></exception>
    public static void ReadRecord(int flag) {
        if (flag == 1)
            throw new MasterFileFormatCorruptException();
        else if (flag == 2)
            throw new MasterFileLockedOpenException();
        // ...
    } 
}

<include>

此标记允许包含源代码文件外部的XML文档的信息。外部文件必须是格式良好的XML文档，并且XPath表达式应用于该文档以指定要包含的文档中的XML。该<include>标签，然后用从外部文件所选择的XML替换。

句法：

<include file="filename" path="xpath" />

• filename是外部XML文件的文件名。文件名相对于包含include标记的文件进行解释。
• xpath 是一个XPath表达式，用于选择外部XML文件中的某些XML。

例：

如果源代码包含如下声明：

/// <include file="docs.xml" path='extradoc/class[@name="IntList"]/*' />
public class IntList { ... }

外部文件“docs.xml”具有以下内容：

<?xml version="1.0"?>
<extradoc>
  <class name="IntList">
     <summary>
        Contains a list of integers.
     </summary>
  </class>
  <class name="StringList">
     <summary>
        Contains a list of integers.
     </summary>
  </class>
</extradoc>

然后输出相同的文档，就好像源代码包含：

/// <summary>
///    Contains a list of integers.
/// </summary>
public class IntList { ... }

<list>

此标记用于创建项目列表或表。它可能包含一个<listheader>块来定义表或定义列表的标题行。（定义表时，只term需要提供标题中的条目。）

列表中的每个项目都使用<item>块指定。当创建一个定义列表，无论是term和description必须指定。但是，对于表，项目符号列表或编号列表，只description需要指定。

句法：

<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>

• term是定义的术语，其定义是description。
• description是子弹或编号列表中的项目，或者是a的定义term。

例：

public class MyClass
{
    /// <summary>Here is an example of a bulleted list:
    /// <list type="bullet">
    /// <item>
    /// <description>Item 1.</description>
    /// </item>
    /// <item>
    /// <description>Item 2.</description>
    /// </item>
    /// </list>
    /// </summary>
    public static void Main () {
        // ...
    }
}

<para>

此标记用于其他标记内，例如<summary>（<remark>）或<returns>（<returns>），并允许将结构添加到文本中。

句法：

<para>content</para>

content该段落的文本在哪里。

例：

/// <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-trivial maintenance has
/// been performed on the Point class.</para></summary>
public static void Main() {
    // ...
}

<param>

此标记用于描述方法，构造函数或索引器的参数。

句法：

<param name="name">description</param>

• name 是参数的名称。
• description 是参数的描述。

例：

/// <summary>This method changes the point's location to
///    the given coordinates.</summary>
/// <param name="xor">the new x-coordinate.</param>
/// <param name="yor">the new y-coordinate.</param>
public void Move(int xor, int yor) {
    X = xor;
    Y = yor;
}

<paramref>

此标记用于指示单词是参数。可以处理文档文件以便以某种不同的方式格式化此参数。

句法：

<paramref name="name"/>

其中name是参数的名称。

例：

/// <summary>This constructor initializes the new Point to
///    (<paramref name="xor"/>,<paramref name="yor"/>).</summary>
/// <param name="xor">the new Point's x-coordinate.</param>
/// <param name="yor">the new Point's y-coordinate.</param>

public Point(int xor, int yor) {
    X = xor;
    Y = yor;
}

<permission>

此标记允许记录成员的安全可访问性。

句法：

<permission cref="member">description</permission>

• member是会员的名字。文档生成器检查给定的代码元素是否存在，并将成员转换为文档文件中的规范元素名称。
• description 是对成员的访问权限的描述。

例：

/// <permission cref="System.Security.PermissionSet">Everyone can
/// access this method.</permission>

public static void Test() {
    // ...
}

<remark>

此标记用于指定有关类型的额外信息。（使用<summary>（<summary>）来描述类型本身和类型的成员。）

句法：

<remark>description</remark>

description评论的文字在哪里。

例：

/// <summary>Class <c>Point</c> models a point in a 
/// two-dimensional plane.</summary>
/// <remark>Uses polar coordinates</remark>
public class Point 
{
    // ...
}

<returns>

此标记用于描述方法的返回值。

句法：

<returns>description</returns>

其中description是返回值的描述。

例：

/// <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, trailing, or embedded whitespace.</returns>
public override string ToString() {
    return "(" + X + "," + Y + ")";
}

<see>

此标记允许在文本中指定链接。使用<seealso>（<seealso>）指示要在“另请参阅”部分中显示的文本。

句法：

<see cref="member"/>

其中member是成员的名称。文档生成器检查给定的代码元素是否存在，并将成员更改为生成的文档文件中的元素名称。

例：

/// <summary>This method changes the point's location to
///    the given coordinates.</summary>
/// <see cref="Translate"/>
public void Move(int xor, int yor) {
    X = xor;
    Y = yor;
}

/// <summary>This method changes the point's location by
///    the given x- and y-offsets.
/// </summary>
/// <see cref="Move"/>
public void Translate(int xor, int yor) {
    X += xor;
    Y += yor;
}

<seealso>

此标记允许为“另请参阅”部分生成条目。使用<see>（<see>）从文本中指定链接。

句法：

<seealso cref="member"/>

其中member是成员的名称。文档生成器检查给定的代码元素是否存在，并将成员更改为生成的文档文件中的元素名称。

例：

/// <summary>This method determines whether two Points have the same
///    location.</summary>
/// <seealso cref="operator=="/>
/// <seealso cref="operator!="/>
public override bool Equals(object o) {
    // ...
}

<summary>

此标记可用于描述类型或类型的成员。使用<remark>（<remark>）来描述类型本身。

句法：

<summary>description</summary>

description是类型或成员的摘要。

例：

/// <summary>This constructor initializes the new Point to (0,0).</summary>
public Point() : this(0,0) {
}

<value>

此标记允许描述属性。

句法：

<value>property description</value>

property description是该物业的描述。

例：

/// <value>Property <c>X</c> represents the point's x-coordinate.</value>
public int X
{
    get { return x; }
    set { x = value; }
}

<typeparam>

此标记用于描述类，结构，接口，委托或方法的泛型类型参数。

句法：

<typeparam name="name">description</typeparam>

其中name是type参数的名称，description是其描述。

例：

/// <summary>A generic list class.</summary>
/// <typeparam name="T">The type stored by the list.</typeparam>
public class MyList<T> {
    ...
}

<typeparamref>

此标记用于指示单词是类型参数。可以处理文档文件以某种不同的方式格式化此类型参数。

句法：

<typeparamref name="name"/>

name参数的名称。

例：

/// <summary>This method fetches data and returns a list of <typeparamref name="T"/>.</summary>
/// <param name="query">query to execute</param>
public List<T> FetchData<T>(string query) {
    ...
}

处理文档文件

文档生成器为源代码中的每个元素生成一个ID字符串，该元素标记有文档注释。此ID字符串唯一标识源元素。文档查看器可以使用ID字符串来标识文档适用的相应元数据/反射项。

文档文件不是源代码的分层表示; 相反，它是一个平面列表，每个元素都有一个生成的ID字符串。

ID字符串格式

文档生成器在生成ID字符串时遵循以下规则：

• 字符串中没有放置空格。

• 字符串的第一部分通过单个字符后跟冒号来标识要记录的成员类型。定义了以下类型的成员：

  字符	描述
  和	事件
  F	领域
  中号	方法（包括构造函数，析构函数和运算符）
  ñ	命名空间
  P	属性（包括指数）
  Ť	类型（例如类，委托，枚举，接口和结构）
  !	错误字符串; 字符串的其余部分提供有关错误的信息。例如，文档生成器为无法解析的链接生成错误信息。

• 字符串的第二部分是元素的完全限定名称，从名称空间的根开始。元素的名称，其封闭类型和命名空间由句点分隔。如果项目的名称本身具有句点，则它们将替换为#(U+0023)字符。（假设没有元素在其名称中包含此字符。）

• 对于带参数的方法和属性，参数列表如下，括在括号中。对于那些没有参数的人，省略了括号。参数用逗号分隔。每个参数的编码与CLI签名相同，如下所示：
  • 参数由其文档名称表示，该名称基于其完全限定名称，修改如下：
    • 表示泛型类型的参数具有附加的“'”字符，后跟类型参数的数量
    • 具有outor ref修饰符的参数具有@以下类型名称。通过值或通过的参数params没有特殊符号。
    • 作为数组的参数表示为[lowerbound:size, ... , lowerbound:size]逗号的数量小于1，并且每个维度的下限和大小（如果已知）以十进制表示。如果未指定下限或大小，则省略它。如果省略特定尺寸的下限和尺寸，则也省略“ :”。锯齿状数组[]每个级别用一个“ ” 表示。
    • 具有除void之外的指针类型的参数使用*以下类型名称表示。void指针使用类型名称表示System.Void。
    • 引用类型上定义的泛型类型参数的参数使用“`”字符后跟类型参数的从零开始的索引进行编码。
    • 使用方法中定义的泛型类型参数的参数使用双重反引号“`”而不是用于类型的“`”。
    • 引用构造泛型类型的参数使用泛型类型进行编码，后跟“{”，后跟逗号分隔的类型参数列表，后跟“}”。

ID字符串示例

以下示例显示了C＃代码的一个片段，以及从能够具有文档注释的每个源元素生成的ID字符串：

• 类型使用其完全限定名称表示，并使用通用信息进行扩充：

enum Color { Red, Blue, Green }

namespace Acme
{
    interface IProcess {...}

    struct ValueType {...}

    class Widget: IProcess
    {
        public class NestedClass {...}
        public interface IMenuItem {...}
        public delegate void Del(int i);
        public enum Direction { North, South, East, West }
    }

    class MyList<T>
    {
        class Helper<U,V> {...}
    }
}

"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"
"T:Acme.MyList`1"
"T:Acme.MyList`1.Helper`2"

字段由其完全限定名称表示：

namespace Acme
{
    struct ValueType
    {
        private int total;
    }

    class Widget: IProcess
    {
        public class NestedClass
        {
            private int value;
        }

        private string message;
        private static Color defaultColor;
        private const double PI = 3.14159;
        protected readonly double monthlyAverage;
        private long[] array1;
        private Widget[,] array2;
        private unsafe int *pCount;
        private unsafe float **ppValues;
    }
}

"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"
"F:Acme.Widget.pCount"
"F:Acme.Widget.ppValues"

构造函数。

namespace Acme
{
    class Widget: IProcess
    {
        static Widget() {...}
        public Widget() {...}
        public Widget(string s) {...}
    }
}

"M:Acme.Widget.#cctor"
"M:Acme.Widget.#ctor"
"M:Acme.Widget.#ctor(System.String)"

析构函数

namespace Acme
{
    class Widget: IProcess
    {
        ~Widget() {...}
    }
}

"M:Acme.Widget.Finalize"

方法。

namespace Acme
{
    struct ValueType
    {
        public void M(int i) {...}
    }

    class Widget: IProcess
    {
        public class NestedClass
        {
            public void M(int i) {...}
        }

        public static void M0() {...}
        public void M1(char c, out float f, ref ValueType v) {...}
        public void M2(short[] x1, int[,] x2, long[][] x3) {...}
        public void M3(long[][] x3, Widget[][,,] x4) {...}
        public unsafe void M4(char *pc, Color **pf) {...}
        public unsafe void M5(void *pv, double *[][,] pd) {...}
        public void M6(int i, params object[] args) {...}
    }

    class MyList<T>
    {
        public void Test(T t) { }
    }

    class UseList
    {
        public void Process(MyList<int> list) { }
        public MyList<T> GetValues<T>(T inputValue) { return null; }
    }
}

"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.Char*,Color**)"
"M:Acme.Widget.M5(System.Void*,System.Double*[0:,0:][])"
"M:Acme.Widget.M6(System.Int32,System.Object[])"
"M:Acme.MyList`1.Test(`0)"
"M:Acme.UseList.Process(Acme.MyList{System.Int32})"
"M:Acme.UseList.GetValues``(``0)"

属性和索引器。

namespace Acme
{
    class Widget: IProcess
    {
        public int Width { get {...} set {...} }
        public int this[int i] { get {...} set {...} }
        public int this[string s, int i] { get {...} set {...} }
    }
}

"P:Acme.Widget.Width"
"P:Acme.Widget.Item(System.Int32)"
"P:Acme.Widget.Item(System.String,System.Int32)"

事件

namespace Acme
{
    class Widget: IProcess
    {
        public event Del AnEvent;
    }
}

"E:Acme.Widget.AnEvent"

一元运算符。

namespace Acme
{
    class Widget: IProcess
    {
        public static Widget operator+(Widget x) {...}
    }
}

"M:Acme.Widget.op_UnaryPlus(Acme.Widget)"

全套使用一元运算符函数名称如下：op_UnaryPlus，op_UnaryNegation，op_LogicalNot，op_OnesComplement，op_Increment，op_Decrement，op_True，和op_False。

二元运算符。

namespace Acme
{
    class Widget: IProcess
    {
        public static Widget operator+(Widget x1, Widget x2) {...}
    }
}

"M:Acme.Widget.op_Addition(Acme.Widget,Acme.Widget)"

一套完整的用于二元运算符函数名称如下：op_Addition，op_Subtraction，op_Multiply，op_Division，op_Modulus，op_BitwiseAnd，op_BitwiseOr，op_ExclusiveOr，op_LeftShift，op_RightShift，op_Equality，op_Inequality，op_LessThan，op_LessThanOrEqual，op_GreaterThan，和op_GreaterThanOrEqual。

转换运算符~后跟返回类型后跟“ ”。

namespace Acme
{
    class Widget: IProcess
    {
        public static explicit operator int(Widget x) {...}
        public static implicit operator long(Widget x) {...}
    }
}

"M:Acme.Widget.op_Explicit(Acme.Widget)~System.Int32"
"M:Acme.Widget.op_Implicit(Acme.Widget)~System.Int64"

一个例子

C＃源代码

以下示例显示了Point类的源代码：

namespace Graphics
{

/// <summary>Class <c>Point</c> models a point in a two-dimensional plane.
/// </summary>
public class Point 
{

    /// <summary>Instance variable <c>x</c> represents the point's
    ///    x-coordinate.</summary>
    private int x;

    /// <summary>Instance variable <c>y</c> represents the point's
    ///    y-coordinate.</summary>
    private int y;

    /// <value>Property <c>X</c> represents the point's x-coordinate.</value>
    public int X
    {
        get { return x; }
        set { x = value; }
    }

    /// <value>Property <c>Y</c> represents the point's y-coordinate.</value>
    public int Y
    {
        get { return y; }
        set { y = value; }
    }

    /// <summary>This constructor initializes the new Point to
    ///    (0,0).</summary>
    public Point() : this(0,0) {}

    /// <summary>This constructor initializes the new Point to
    ///    (<paramref name="xor"/>,<paramref name="yor"/>).</summary>
    /// <param><c>xor</c> is the new Point's x-coordinate.</param>
    /// <param><c>yor</c> is the new Point's y-coordinate.</param>
    public Point(int xor, int yor) {
        X = xor;
        Y = yor;
    }

    /// <summary>This method changes the point's location to
    ///    the given coordinates.</summary>
    /// <param><c>xor</c> is the new x-coordinate.</param>
    /// <param><c>yor</c> is the new y-coordinate.</param>
    /// <see cref="Translate"/>
    public void Move(int xor, int yor) {
        X = xor;
        Y = yor;
    }

    /// <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>xor</c> is the relative x-offset.</param>
    /// <param><c>yor</c> is the relative y-offset.</param>
    /// <see cref="Move"/>
    public void Translate(int xor, int yor) {
        X += xor;
        Y += yor;
    }

    /// <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="operator=="/>
    /// <seealso cref="operator!="/>
    public override bool Equals(object o) {
        if (o == null) {
            return false;
        }

        if (this == o) {
            return true;
        }

        if (GetType() == o.GetType()) {
            Point p = (Point)o;
            return (X == p.X) && (Y == p.Y);
        }
        return false;
    }

    /// <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 override string ToString() {
        return "(" + X + "," + Y + ")";
    }

    /// <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="Equals"/>
    /// <seealso cref="operator!="/>
    public static bool operator==(Point p1, Point p2) {
        if ((object)p1 == null || (object)p2 == null) {
            return false;
        }

        if (p1.GetType() == p2.GetType()) {
            return (p1.X == p2.X) && (p1.Y == p2.Y);
        }

        return false;
    }

    /// <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="Equals"/>
    /// <seealso cref="operator=="/>
    public static bool operator!=(Point p1, Point p2) {
        return !(p1 == p2);
    }

    /// <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-trivial maintenance has
    /// been performed on the Point class.</para></summary>
    public static void Main() {
        // class test code goes here
    }
}
}

产生的XML

以下是给定类的源代码时由一个文档生成器生成的输出Point，如上所示：

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Point</name>
    </assembly>
    <members>
        <member name="T:Graphics.Point">
            <summary>Class <c>Point</c> models a point in a two-dimensional
            plane.
            </summary>
        </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="xor"/>,<paramref name="yor"/>).</summary>
            <param><c>xor</c> is the new Point's x-coordinate.</param>
            <param><c>yor</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>xor</c> is the new x-coordinate.</param>
            <param><c>yor</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>xor</c> is the relative x-offset.</param>
            <param><c>yor</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-trivial 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>