浅析如何在Nancy中生成API文档

public class ProductsModule : NancyModule
{
    public ProductsModule() : base("/products")
    {
        Get("/", _ =>
        {
            return Response.AsText("product list");
        }, null, "GetProductList");

        Get("/{productid}", _ =>
        {
            return Response.AsText(_.productid as string);
        }, null, "GetProductByProductId");

        Post("/", _ =>
        {
            return Response.AsText("Add product");
        }, null, "AddProduct");

        //省略部分..
    }
}

public class DocMudule : NancyModule
{
    private IRouteCacheProvider _routeCacheProvider;

    public DocMudule(IRouteCacheProvider routeCacheProvider) : base("/docs")
    {
        this._routeCacheProvider = routeCacheProvider;

        Get("/", _ =>
        {
            var routeDescriptionList = _routeCacheProvider
                                         .GetCache()
                                         .SelectMany(x => x.Value)
                                         .Select(x => x.Item2)
                                         .Where(x => !string.IsNullOrWhiteSpace(x.Name))
                                         .ToList();

            return Response.AsJson(routeDescriptionList);
        });
    }
}

public interface IRouteCache : IDictionaryint, RouteDescription>>>, ICollectionint, RouteDescription>>>>, IEnumerableint, RouteDescription>>>>, IEnumerable
{
    bool IsEmpty();
}

public sealed class RouteDescription
{
    
    public RouteDescription(string name, string method, string path, Funcbool> condition);

    //The name of the route
    public string Name { get; set; }
    
    //The condition that has to be fulfilled inorder for the route to be a valid match.
    public Funcbool> Condition { get; }
    
    //The description of what the route is for.
    public string Description { get; set; }
    
    //Gets or sets the metadata information for a route.
    public RouteMetadata Metadata { get; set; }
    
    //Gets the method of the route.
    public string Method { get; }
    
    //Gets the path that the route will be invoked for.
    public string Path { get; }
    
    //Gets or set the segments, for the route, that was returned by the Nancy.Routing.IRouteSegmentExtractor.
    public IEnumerablestring> Segments { get; set; }
}

public class RouteMetadata
{
    //Creates a new instance of the Nancy.Routing.RouteMetadata class.
    public RouteMetadata(IDictionaryobject> metadata);

    //Gets the raw metadata System.Collections.Generic.IDictionary`2.
    public IDictionaryobject> Raw { get; }

    //Gets a boolean that indicates if the specific type of metadata is stored.
    public bool Has();
    
    //Retrieves metadata of the provided type.
    public TMetadata Retrieve();
}

public class CustomRouteMetadata
{
    // group by the module
    public string Group { get; set; }
    
    // description of the api
    public string Description { get; set; }
    
    // path of the api
    public string Path { get; set; }
    
    // http method of the api
    public string Method { get; set; }
    
    // name of the api
    public string Name { get; set; }
    
    // segments of the api
    public IEnumerablestring> Segments { get; set; }
}

public class ProductsMetadataModule : MetadataModule
{
    public ProductsMetadataModule()
    {            
        Describe["GetProductList"] = desc =>
        {                
            var dic = new DictionaryType, object>
            {
                {
                    typeof(CustomRouteMetadata),
                    new CustomRouteMetadata
                    {
                        Group = "Products",
                        Description = "Get All Products from Database",
                        Path = desc.Path,
                        Method = desc.Method,
                        Name = desc.Name,
                        Segments = desc.Segments
                    }
                }
            };
            return new RouteMetadata(dic);
        };

        Describe["GetProductByProductId"] = desc =>
        {
            var dic = new DictionaryType, object>
            {
                {
                    typeof(CustomRouteMetadata),
                    new CustomRouteMetadata
                    {
                        Group = "Products",
                        Description = "Get a Product by product id",
                        Path = desc.Path,
                        Method = desc.Method,
                        Name = desc.Name,
                        Segments = desc.Segments
                    }
                }
            };
            return new RouteMetadata(dic);              
        };

        //省略部分...
    }
}

public class ProductsMetadataModule : MetadataModule
{
    public ProductsMetadataModule()
    {
        Describe["GetProductList"] = desc =>
        {
            return new CustomRouteMetadata
            {
                Group = "Products",
                Description = "Get All Products from Database",
                Path = desc.Path,
                Method = desc.Method,
                Name = desc.Name,
                Segments = desc.Segments
            };
        };

        Describe["GetProductByProductId"] = desc =>
        {
            return new CustomRouteMetadata
            {
                Group = "Products",
                Description = "Get a Product by product id",
                Path = desc.Path,
                Method = desc.Method,
                Name = desc.Name,
                Segments = desc.Segments
            };
        };

        //省略部分..
    }
}

 var routeDescriptionList = _routeCacheProvider
                            .GetCache()
                            //.RetrieveMetadata()                                            
                            .RetrieveMetadata()
                            .Where(x => x != null);

public class DefaultRouteCacheProvider : IRouteCacheProvider, IDiagnosticsProvider
{
    /// 

    /// The route cache factory
    /// 
    protected readonly Func RouteCacheFactory;

    /// 

    /// Initializes a new instance of the DefaultRouteCacheProvider class.
    /// 
    /// 
 name="routeCacheFactory">
    public DefaultRouteCacheProvider(Func routeCacheFactory)
    {
        this.RouteCacheFactory = routeCacheFactory;
    }

    /// 

    /// Gets an instance of the route cache.
    /// 
    /// An  cref="IRouteCache"/> instance.
    public IRouteCache GetCache()
    {
        return this.RouteCacheFactory();
    }
    
    //省略部分..
}

public RouteCache(
    INancyModuleCatalog moduleCatalog,
    INancyContextFactory contextFactory,
    IRouteSegmentExtractor routeSegmentExtractor,
    IRouteDescriptionProvider routeDescriptionProvider,
    ICultureService cultureService,
    IEnumerable routeMetadataProviders)
{
    this.routeSegmentExtractor = routeSegmentExtractor;
    this.routeDescriptionProvider = routeDescriptionProvider;
    this.routeMetadataProviders = routeMetadataProviders;

    var request = new Request("GET", "/", "http");

    using (var context = contextFactory.Create(request))
    {
        this.BuildCache(moduleCatalog.GetAllModules(context));
    }
}

private void BuildCache(IEnumerable modules)
{
    foreach (var module in modules)
    {
        var moduleType = module.GetType();

        var routes =
            module.Routes.Select(r => r.Description).ToArray();

        foreach (var routeDescription in routes)
        {
            routeDescription.Description = this.routeDescriptionProvider.GetDescription(module, routeDescription.Path);
            routeDescription.Segments = this.routeSegmentExtractor.Extract(routeDescription.Path).ToArray();
            routeDescription.Metadata = this.GetRouteMetadata(module, routeDescription);
        }

        this.AddRoutesToCache(routes, moduleType);
    }
}

private RouteMetadata GetRouteMetadata(INancyModule module, RouteDescription routeDescription)
{
    var data = new Dictionaryobject>();

    foreach (var provider in this.routeMetadataProviders)
    {
        var type = provider.GetMetadataType(module, routeDescription);
        var metadata = provider.GetMetadata(module, routeDescription);

        if (type != null && metadata != null)
        {
            data.Add(type, metadata);
        }
    }

    return new RouteMetadata(data);
}

public abstract class RouteMetadataProvider : IRouteMetadataProvider
{
    public Type GetMetadataType(INancyModule module, RouteDescription routeDescription)
    {
        return typeof(TMetadata);
    }

    public object GetMetadata(INancyModule module, RouteDescription routeDescription)
    {
        return this.GetRouteMetadata(module, routeDescription);
    }

    protected abstract TMetadata GetRouteMetadata(INancyModule module, RouteDescription routeDescription);
}

public abstract class MetadataModule : IMetadataModule where TMetadata : class
{
    private readonly IDictionarystring, Func> metadata;

    protected MetadataModule()
    {
        this.metadata = new Dictionarystring, Func>();
    }

    // Gets  for describing routes.
    public RouteMetadataBuilder Describe
    {
        get { return new RouteMetadataBuilder(this); }
    }

    // Returns metadata for the given RouteDescription.
    public object GetMetadata(RouteDescription description)
    {
        if (this.metadata.ContainsKey(description.Name))
        {
            return this.metadata[description.Name].Invoke(description);
        }

        return null;
    }

    // Helper class for configuring a route metadata handler in a module.
    public class RouteMetadataBuilder
    {
        private readonly MetadataModule parentModule;

        public RouteMetadataBuilder(MetadataModule metadataModule)
        {
            this.parentModule = metadataModule;
        }

        // Describes metadata for a route with the specified name.
        public Functhis[string name]
        {
            set { this.AddRouteMetadata(name, value); }
        }

        protected void AddRouteMetadata(string name, Func value)
        {
            this.parentModule.metadata.Add(name, value);
        }
    }
    
    //省略部分..
}