SauceControl.InheritDoc 0.1.0

This MSBuild Task takes a different approach from other documentation post-processing tools. By integrating with MSBuild, it has access to the exact arguments passed to the compiler, including assembly references and the output assembly and XML documentation file paths. As it processes inheritdoc elements, it is able to more accurately resolve base types whether they come from the target framework, referenced NuGet packages, or project references. This more accurate resolution of references means it can be more clever about mapping documentation from base types and members to yours. For example, it can identify when you change the name of a method parameter from the base type’s definition and update the documentation accordingly.

How it Works

The InheritDoc Task inserts itself between the CoreCompile and CopyFilesToOutputDirectory steps in the MSBuild process, making a backup copy of the documentation file output from the compiler and then processing it to replace inheritdoc tags. The output of InheritDoc is then used for the remainder of your build process. The XML documentation in your output (bin) folder will be the processed version. If you have further steps, such as building a NuGet package, the updated XML file will used in place of the original, meaning inheritdoc Just Works™.

This enhances the new support for inheritdoc in Roslyn (available starting in the VS 16.4 preview builds), making it available to all downstream consumers of your documentation. When using tools such as DocFX, you will no longer be subject to limitations around inheritdoc tag usage because the documentation will already have those tags replaced with the upstream docs.

How to Use It

1. Add some inheritdoc tags to your XML documentation comments.

   This tool’s handling of inheritdoc tags is based on the draft design document used for the new prototype Roslyn support, which is in turn based on the inheritdoc support in Sandcastle Help File Builder (SHFB).

2. Add the SauceControl.InheritDoc NuGet package reference to your project.

   This is a design-time only dependency; it will not be deployed with or referenced by your compiled app/library.

3. There is no 3.

   Once the package reference is added to your project, the XML docs will be processed automatically with each build.

<PropertyGroup Condition="'$(Configuration)'=='Debug'">
    <InheritDocEnabled>false</InheritDocEnabled>
</PropertyGroup>

Some Examples

Consider the following C#

/// <summary>Interface IX</summary>
public interface IX
{
    /// <summary>Method X</summary>
    void X();
}

/// <inheritdoc />
public interface IY : IX
{
    /// <summary>Method Y</summary>
    void Y();
}

/// <summary>Class A</summary>
public class A : IY
{
    void IX.X() { }

    /// <inheritdoc />
    public virtual void Y() { }

    /// <summary>Method M</summary>
    /// <typeparam name="T">TypeParam T</typeparam>
    /// <param name="t">Param t</param>
    /// <returns>Return value <paramref name="t" /> of type <typeparamref name="T" /></returns>
    public virtual void M<T>(T t) { }

    /// <summary>Overloaded Method O</summary>
    /// <param name="s">Param s</param>
    /// <param name="t">Param t</param>
    /// <param name="u">Param u</param>
    public static void O(string[] s, string t, string u) { }

    /// <inheritdoc cref="O(string[], string, string)" />
    public static void O(string[] s) { }
}

/// <inheritdoc />
public class B : A
{
    /// <inheritdoc />
    public override void Y() { }

    /// <inheritdoc />
    public override void M<TValue>(TValue value) { }
}

Once processed, the output XML documentation will look like this (results abbreviated and comments added manually to highlight features)

<member name="T:IX">
    <summary>Interface IX</summary>
</member>
<member name="M:IX.X">
    <summary>Method X</summary>
</member>
<member name="T:IY">
    <summary>Interface IX</summary> 
</member>
<member name="M:IY.Y">
    <summary>Method Y</summary>
</member>
<member name="T:A">
    <summary>Class A</summary>
</member>
<member name="M:A.Y">
    <summary>Method Y</summary> 
</member>
<member name="M:A.M``1(``0)">
    <summary>Method M</summary>
    <typeparam name="T">TypeParam T</typeparam>
    <param name="t">Param t</param>
    <returns>Return value <paramref name="t" /> of type <typeparamref name="T" /></returns>
</member>
<member name="M:A.O(System.String[],System.String,System.String)">
    <summary>Overloaded Method O</summary>
    <param name="s">Param s</param>
    <param name="t">Param t</param>
    <param name="u">Param u</param>
</member>
<member name="M:A.O(System.String[])"> 
    <summary>Overloaded Method O</summary> 
    <param name="s">Param s</param>
    
</member>
<member name="T:B">
    <summary>Class A</summary> 
</member>
<member name="M:B.Y">
    <summary>Method Y</summary> 
</member>
<member name="M:B.M``1(``0)">
    <summary>Method M</summary> 
    <typeparam name="TValue">TypeParam T</typeparam> 
    <param name="value">Param t</param> 
    <returns>Return value <paramref name="value" /> of type <typeparamref name="TValue" /></returns> 
</member>
<member name="M:A.IX#X"> 
    <summary>Method X</summary>
</member>