Inheriting comments from an interface in an implementing class?

Question

Suppose I have this interface

public interface IFoo
{
    ///
    /// Foo method
    ///
    void Foo();

    ///
    /// Bar method
    ///
    void Bar();

    ///
    /// Situation normal
    ///
    void Snafu();
}

And this class

public class Foo : IFoo
{
    public void Foo() { ... }
    public void Bar() { ... }
    public void Snafu() { ... }
}

Is there a way, or is there a tool that can let me automatically put in the comments of each member in a base class or interface?

Because I hate re-writing the same comments for each derived sub-class!

user_73025 · Answer

Use /// if you want inheritance. Avoid GhostDoc or anything like that.

I agree it is annoying that comments are not inherited. It would be a fairly simple add-in to create if someone had the time (i wish i did).

That said, in our code base we put XML comments on the interfaces only and add extra implementation comments to the class. This works for us as our classes are private/internal and only the interface is public. Any time we use the objects via the interfaces we have full comments display in intellisence.

GhostDoc is good start and has made the process easier to write comments. It is especially useful keeping comments up-to-date when you add/remove parameters, re-run GhostDoc and it will update the description.

user_12725 · Answer

GhostDoc does exactly that. For methods which aren't inherited, it tries to create a description out of the name.

FlingThing() becomes "Flings the Thing"

user_5775048 · Answer

I would say to directly use the

///   --> For methods inheritance

And

///   --> For directly class inheritance

You have to put this comments just on the previous line of your class/method

This will get the info of your comments for example from an interface that you have documented like :

    /// 
    /// This method is awesome!
    /// 
    /// The awesome parameter of the month!.
    /// A  that is also awesome...
    AwesomeObject CreateAwesome(WhateverObject awesomeParam);

user_710069 · Answer

Well, there is a kind of native solution, I found for .NET Core 2.2

The idea is to use tag.

You can add true your .csproj a file.

You might have an interface:

namespace YourNamespace
{
    /// 
    /// Represents interface for a type.
    /// 
    public interface IType
    {
        /// 
        /// Executes an action in read access mode.
        /// 
        void ExecuteAction();
    }
}

And something that inherits from it:

using System;

namespace YourNamespace
{
    /// 
    /// A type inherited from  interface.
    /// 
    public class InheritedType : IType
    {
        /// 
        public void ExecuteAction() => Console.WriteLine("Action is executed.");
    }
}

Ok, it is a bit scary, but it does add the expected elements to the YourNamespace.xml.

If you build Debug configuration, you can swap Release for Debug in the file attribute of include tag.

To find a correct member's name to reference just open generated Documentation.xml file.

I also assume that this approach requires a project or solution to be build at least twice (first time to create an initial XML file, and the second time to copy elements from it to itself).

The bright side is that Visual Studio validates copied elements, so it is much easier to keep documentation and code in sync with interface/base class, etc (for example names of arguments, names of type parameters, etc).

At my project, I have ended up with both (for DocFX) and (For publishing NuGet packages and for validation at Visual Studio):

        /// 
        /// 
        public void ExecuteReadOperation(Action action) => action();

user_6859121 · Answer

End the question:
This feature has been added at VS2019 v16.4.

https://developercommunity.visualstudio.com/t/608809#T-N875117

It works on the interfeace and abstruct class overrideable members

Inheriting comments from an interface in an implementing class?

10 Answers