Documenting DotNet core API’s with swagger
This is the first post in a series of post about developing an API using ASP.net Core. The intention of this series of blog posts is basically walk through of all the steps required to develop a fully functioning API, it may be a brave attempt, as this going to be somewhat of blow by blow and step by step account which will hopefully provide others with insights of an average software development project.
The Project
This is an actual new development project, for my company threenine.co.uk, and is an extension of our Free and Open Source WordPress plugin Stop Web Crawlers – an easy way to block referer spammers .
Can’t wait to see it in action ?
Check out the code on GitHub
The intention is to develop an API to enabling the updating of Referer spam list for our 500+ user base. It is an experimental prototype at this stage.
Developing API for other developers and integrators to use , you will need to ensure that you supply clear and easy to understand documentation. Documenting or describing your REST API’s doesn’t have to a boring chore , in fact using a framework like swagger makes it really easy.
Swagger
Swagger is an Open Source API Specification Framework, enabling interactive documentation and SDK generation over your Existing REST API.
In this guide I will provide a working example of how to use swagger to start documenting an API. I’ll be starting a brand new development project.
We’ll start off creating a standard DotNet Core Web API project using one of the quick start templates , Create a .net core web application on ubuntu in 5 minutes , as you might guess I am using ubuntu as my primary development workstation, but the general process of creating a project is the same regardless of operating system.
After creating the project give it a quick test to ensure that all is working as expected.
|
1 2 3 |
dotnet restore dotnet build dotnet run |
We can now browse to the api http://localhost:5000/api/values
Our new very simple API is working!
Swashbuckle.AspNetCore
Swashbuckle combines ApiExplorer and Swagger/swagger-ui to provide a rich discovery, documentation and playground experience to your API consumers. It also contains an embedded version of swagger-ui which it will automatically serve up once Swashbuckle is installed. This means you can complement your API with a slick discovery UI to assist consumers with their integration efforts. Best of all, it requires minimal coding and maintenance, allowing you to focus on building an awesome API!
Swashbuckle.AspNetCore is a release of this library specifically for .net Core API – Check out the GitHub Repository
Add a Reference to the Swashbuckle.AspNetCore library. I do this in Visual Studio Code by adding the Nuget Package Manager extension and then making use of the Command Pallette (
Nuget Package Manager : Add Package and Search swashbuckle.AspNetCore
Once complete we can update our StartUp.cs class with the following code.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Swashbuckle.AspNetCore; using Swashbuckle.AspNetCore.Swagger; namespace api { public class Startup { public Startup(IHostingEnvironment env) { var builder = new ConfigurationBuilder() .SetBasePath(env.ContentRootPath) .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true) .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) .AddEnvironmentVariables(); Configuration = builder.Build(); } public IConfigurationRoot Configuration { get; } // This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "My API", Version = "v1" }); }); } // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) { loggerFactory.AddConsole(Configuration.GetSection("Logging")); loggerFactory.AddDebug(); app.UseMvc(); app.UseSwagger(); app.UseSwaggerUI(c => { c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1"); }); } } } |
We can now build and start our API again
|
1 2 3 |
dotnet restore dotnet build dotnet run |
If we now navigate our browser to http://localhost:5000/swagger we’ll now see the Swagger Ui which is handy for testing your methods and checking their correct responses without needing tools like Postman etc.
Customization
The above example is obviously far too simple for most documentation purposes, and most organisations and projects will require further customization. This is where the real power of Swashbuckle comes in.
Add Developer Details
The first step we’ll take in customizing the details available regarding our API, is to provide further details about who developed the API and some contact details.
In our StartUp.cs we’ll update the ConfigureServices method to include some additional basic contact details
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "Stop Web Crawlers Update API", Version = "v1" , Description = "Stop Web Crawlers Update API to enable the update of Referer Spammer Lists", TermsOfService = "None", Contact = new Contact { Name = "threenine.co.uk", Email ="support@threenine.co.uk", Url ="https://threenine.co.uk"} }); } ); } |
After this is complete and we restart our project and navigate to the swagger page, our API documentation will now display the general contact information.
Include XML Comment Descriptions
It is usually a good idea to enhance the generated documentation with human-friendly descriptions, usually derived from annotations via XML Comments on Controllers and Models. We can configure SwashBuckle to incorporate those comments into the Swagger JSON:
Using VS Code we will need to add some additional lines to our .csproj file.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <Project Sdk="Microsoft.NET.Sdk.Web"> <PropertyGroup> <TargetFramework>netcoreapp1.1</TargetFramework> </PropertyGroup> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'"> <DocumentationFile>bin\Debug\netcoreapp1.1\SWCapi.xml</DocumentationFile> </PropertyGroup> <ItemGroup> <Folder Include="wwwroot\" /> </ItemGroup> <ItemGroup> <PackageReference Include="Microsoft.AspNetCore" Version="1.0.3" /> <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="1.0.2" /> <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="1.0.1" /> <PackageReference Include="Swashbuckle.AspNetCore" Version="1.0.0-rc3" /> </ItemGroup> </Project> |
Essentially we are going to Create an XML file which will store our comments which will be stored in our bin folder.
We’ update our StartUp.cs with some additional information about the developers and contact details for support.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new Info { Title = "Stop Web Crawlers Update API", Version = "v1" , Description = "Stop Web Crawlers Update API to enable the update of Referer Spammer Lists", TermsOfService = "None", Contact = new Contact { Name = "threenine.co.uk", Email ="support@threenine.co.uk", Url ="https://threenine.co.uk"} }); var filePath = Path.Combine(PlatformServices.Default.Application.ApplicationBasePath, "SWCapi.xml"); c.IncludeXmlComments(filePath); } ); } |
We can annotate our controller with some additional XML Comments to provide further detail as to what our API delivers. In this example I have just decorated the simple controller with some example documentation for illustrative purposes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
[Route("api/[controller]")] public class ValuesController : Controller { /// <summary> /// Returns a collection of values /// </summary> [HttpGet("[action]")] public IEnumerable Get() { return new string[] { "value1", "value2" }; } /// <summary> /// Returns an item from a collection of values based on ID /// </summary> [HttpGet("[action] {id}")] public string Get(int id) { return "value"; } |
When we review our swagger documentation we’ll now see our additional comments appear.
There may be occasion when you would like to provide further information as to the inner workings of the API. This can be achieved by using the additional Remarks
This content can be further enhanced with some additional text or even adding additional JSON or XML for further details.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
/// <summary> /// Returns a collection of values /// </summary> ///<remarks> /// This is a remark to add additional information about this method /// GET /get /// { /// "value1", /// "value2" /// } ///</remarks> [HttpGet("[action]")] public IEnumerable<string> Get() { return new string[] { "value1", "value2" }; } |
This information will now be displayed as follows
Gary Woodfine
A unique background as business owner, marketing, software development and business development ensures that he can offer the optimum business consultancy services across a wide spectrum of business challenges.
Latest posts by Gary Woodfine (see all)
- C# Tuples - June 11, 2017
- C#Local Functions - May 21, 2017
- Using AutoMapper in Domain Objects with DotNet Core - April 24, 2017