Как добавить всплывающую подсказку к классам, методам, свойствам и т. Д. В C #?

Question

Не уверен, что я даже правильно называю это, но я хотел начать добавлять некоторую документацию к своим классам, методам, свойствам и т. Д. Я знаю это, вероятно, супер очевидно, но я так и не научился,Я не уверен, с чего начать.

Просто чтобы уточнить, когда вы перемещаете класс (или метод, свойство и т. Д.), В Visual Studio отображается подсказка с некоторой документацией по этому конкретному методу.

класс Microsoft.Phone.BackgroundAudio.BackgroundAudioPlayer Предоставляет фоновый доступ к функциям воспроизведения аудио, таким как воспроизведение, пауза, ускоренная перемотка вперед и назад.

Как это называется и как я могу реализовать это в моем приложении C #?

Answer 1

Вы можете использовать /// или GhostDoc

Редактировать:

В первом случае вы получите

/// <summary>
/// 
/// </summary>
class A
{
    /// <summary>
    /// 
    /// </summary>
    public A() { }

    /// <summary>
    /// 
    /// </summary>
    public int Property { get; set; }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="obj"></param>
    public void Method(object obj) { }
}

Во втором

/// <summary>
/// 
/// </summary>
class B
{

    /// <summary>
    /// Initializes a new instance of the <see cref="B"/> class.
    /// </summary>
    public B() { }

    /// <summary>
    /// Gets or sets the property.
    /// </summary>
    /// <value>
    /// The property.
    /// </value>
    public int Property { get; set; }

    /// <summary>
    /// Methods the specified obj.
    /// </summary>
    /// <param name="obj">The obj.</param>
    public void Method(object obj) { }
}

Answer 2

Чуть выше вашего класса, метода или свойства введите /// и нажмите клавишу возврата. Это создаст шаблон документации для вас.

Забыл ответить на другую часть вашего вопроса: это известно как Комментарии к XML-документации , и в MSDN имеется достаточно информации об этом.

Answer 3

То, на что вы ссылаетесь, называется XML-документацией или XML-документом.

XML-документ выполняется для класса, поля, свойства, события или метода с использованием трех косых черт (///), за которыми следует мета-информация в формате XML о классе или его члене.

VS поможет вам генерировать и форматировать эти комментарии со встроенной поддержкой IntelliSense для комментариев XML, но есть бесплатный инструмент под названием GhostDoc , который автоматически генерирует полный шаблон XML-документа, и даже «умный» достаточно в некоторых случаях, чтобы попытаться угадать базовое описание для различных элементов документации.

Вот базовый пример документации XML:

/// <summary>
/// Defines the behavior of a class following the Repository pattern for data access 
/// with basic atomic operation control.
/// </summary>
/// <typeparam name="TRest">An interface derived from IDomainObject that describes domain objects 
/// that can be retrieved or saved by this Repository.</typeparam>
public interface IRepository<TRest> : IDisposable where TRest : IDomainObject
{
    /// <summary>
    /// Begins a new unit of work to be performed atomically by the Repository.
    /// </summary>
    /// <returns>A token class representing the unit of work.</returns>
    IUnitOfWork BeginUnitOfWork();

    /// <summary>
    /// Commits all work performed under the specified unit of work.
    /// </summary>
    /// <param name="unitOfWork">The unit of work.</param>
    void CommitUnitOfWork(IUnitOfWork unitOfWork);

    /// <summary>
    /// Rolls back the specified unit of work.
    /// </summary>
    /// <param name="unitOfWork">The unit of work.</param>
    void RollBackUnitOfWork(IUnitOfWork unitOfWork);

    /// <summary>
    /// Saves the specified domain object to the data source controlled by the repository.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="domainObject">The domain object.</param>
    /// <param name="unitOfWork">The unit of work.</param>
    void Save<T>(T domainObject, IUnitOfWork unitOfWork) where T : class, TRest;

    /// <summary>
    /// Begins a Linq query for a specific object type, to be performed against the Repository's data source.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="unitOfWork">The unit of work.</param>
    /// <returns>An IQueryable representing the query to be performed.</returns>
    IQueryable<T> QueryFor<T>(IUnitOfWork unitOfWork) where T : class, TRest;

    /// <summary>
    /// Performs the specified Action using a new unit of work, with commits and rollbacks as necessary.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="func">The Action to perform. The lambda or named method must accept an IUnitOfWork as a parameter.</param>
    /// <param name="commit">if set to <c>true</c>, commit the unit of work.</param>
    void PerformInNewUnitOfWork<T>(Action<IUnitOfWork> func, bool commit = false);

    /// <summary>
    /// Performs the specified Func using a new unit of work, with commits and rollbacks as necessary.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="func">The function to evaluate. The lambda or named method must accept an IUnitOfWork as a parameter.</param>
    /// <returns>A single object of the generic type, returned by the function.</returns>
    /// <param name="commit">if set to <c>true</c>, commit the unit of work.</param>
    T PerformInNewUnitOfWork<T>(Func<IUnitOfWork, T> func, bool commit = false) where T : class, TRest;

    /// <summary>
    /// Performs the specified Func using a new unit of work, with commits and rollbacks as necessary.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="func">The Function to evaluate. The lambda or named method must accept an IUnitOfWork as a parameter.</param>
    /// <returns>An enumerable set of objects of the generic type, returned by the function.</returns>
    /// <param name="commit">if set to <c>true</c>, commit the unit of work.</param>
    IEnumerable<T> PerformInNewUnitOfWork<T>(Func<IUnitOfWork, IEnumerable<T>> func, bool commit = false) where T : class, TRest;

    /// <summary>
    /// Attaches the specified domain object to the current Unit of Work, allowing operations to be performed on it.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="domainObject">The domain object.</param>
    /// <param name="unitOfWork">The unit of work.</param>
    void Attach<T>(T domainObject, IUnitOfWork unitOfWork) where T : class, TRest;

    /// <summary>
    /// Detaches the specified domain object to the current Unit of Work.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="domainObject">The domain object.</param>
    /// <param name="unitOfWork">The unit of work.</param>
    void Detach<T>(T domainObject, IUnitOfWork unitOfWork) where T : class, TRest;

    /// <summary>
    /// Refreshes the specified collection of persistent elements with the most recent persisted data.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="elements">The list of elements to refresh.</param>
    /// <param name="unitOfWork">The Unit of Work under which to perform the operation.</param>
    void Refresh<T>(IList<T> elements, IUnitOfWork unitOfWork) where T : class, TRest;

    /// <summary>
    /// Deletes the specified domain object from the data store. 
    /// Usually performs a physical delete; logical deletes are most often done through updates.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="domainObject">The domain object to delete.</param>
    /// <param name="unitOfWork">The unit of work under which to perform the operation.</param>
    void Delete<T>(T domainObject, IUnitOfWork unitOfWork) where T : class, TRest;
}