> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# Documentation Comment C# documentation comments are specially formatted comments containing XML elements, placed immediately preceding user-defined types (classes, interfaces, structs, records, delegates) or members (methods, properties, fields, events). The C# compiler parses these comments during compilation to extract the XML elements and generate a structured XML file representing the API surface. ## Syntax Documentation comments are denoted by either triple forward slashes (`///`) for single-line constructs or a forward slash followed by two asterisks (`/** ... */`) for multi-line block constructs. ```csharp theme={"dark"} ///

/// Single-line documentation comment syntax. ///

/** *

* Multi-line block documentation comment syntax. *

*/ ``` ## Core XML Elements The compiler recognizes specific XML tags to categorize the metadata of the documented code element. * `

`: Provides a concise, high-level description of the type or member. * ``: Specifies supplementary, detailed information that expands upon the `

`. * ``: Describes a specific method or delegate parameter. The `name` attribute must match the parameter signature exactly. * ``: Describes a generic type parameter. * ``: Describes the return value of a method. * ``: Describes the value represented by a property. * ``: Identifies an exception that the method or property can throw. The `cref` attribute creates a compiler-verified cross-reference to the exception type. * ``: Creates an inline hyperlink to another code element within the documentation text. * ``: Creates a cross-reference link, typically placed in a "See Also" section at the end of the documentation. * ``: Contains a code example demonstrating the element. Often used in conjunction with the `

` tag.

## Structural Example

The following code block demonstrates the application of documentation comments to a generic method, utilizing multiple XML elements to map the method's signature and behavior.

```csharp theme={"dark"}
/// 
/// Parses a string representation of a value into its generic type equivalent.
/// 
/// The target type to parse the string into. Must implement .
/// The string containing the data to parse.
/// An instance of  representing the parsed value.
/// Thrown when  is null.
/// Thrown when  is not in the correct format.
public T ParseValue(string input) where T : IParsable
{
    if (input == null)
    {
        throw new ArgumentNullException(nameof(input));
    }
    
    return T.Parse(input, CultureInfo.InvariantCulture);
}
```

## Compiler Configuration

To instruct the C# compiler to extract these comments and emit the XML file, the `GenerateDocumentationFile` property must be enabled in the project's `.csproj` file.

```xml theme={"dark"}

  true

```

When enabled, the compiler validates the XML syntax and verifies all `cref` (code reference) and `name` attributes against the actual code elements. If a referenced parameter or type does not exist, the compiler generates a warning (e.g., `CS1572` or `CS1574`).


  Tired of Poor C# Skills? Fix That With Deep Grasping!

  
    Learn More