API Solution Template

Provides the ability to generate an entire API Solution project including:

  • API Project
  • Unit & Integration test projects
  • Dotnet Cake Build Script
  • Semantic Versioning
  • Docker Configuration
  • Database Configuration using Entity Framework Core

The template is configured to generate a MS SQL database configuration as default, however there is an optional switch available that will enable you to create PostgreSQL database by passing an additional argument.

To create a new solution using the apisolution template simply open a terminal window and execute the command with the supplied parameters below in chosen directory.

dotnet new apisolution --name <name of your solution>  --root <your chosen root namespace>  --output <your chosen output directory>

Available arguments

  • --name Is a name switch that is used to provide your project a name for instance Cms
  • --root is a root namespace you would like to use for your project i.e. Your company name or some such.
  • --postgre optional flag to create a new solution that uses a PostgreSQL database backend
  • --force Forces content to be generated even if it would change existing files. This is required when the template chosen would override existing files in the output directory.

To create a project making use of PostgreSQL the command will be similar. However, just including the --postgre switch

dotnet new apisolution --name <name of your solution>  --root <your chosen root namespace>  
--output <your chosen output directory>  --postgre

Example solution creation using the API Template Pack

As an example we may want to develop the Diogel project for our company Threenine with so you can execute the command as follows:

dotnet new apisolution --name Diogel --root Threenine

This command will generate a full API Solution template

├── build.cake
├── Diogel.sln
├── Directory.Build.props
├── local-dev-docker-compose.yml
├── Dockerfile
├── .github
│   └── workflows
│       └── cake-build.yaml
├── .gitignore
├── GitVersion.yml
├── README.md
├── src
│   ├── Api
│   │   ├── Activities
│   │   ├── Api.csproj
│   │   ├── appsettings.Development.json
│   │   ├── appsettings.json
│   │   ├── Behaviours
│   │   ├── Exceptions
│   │   ├── Helpers
│   │   ├── Middleware
│   │   ├── Program.cs
│   │   ├── Properties
│   │   └── README.md
│   ├── Database
│   │   ├── appsettings.json
│   │   ├── DiogelContext.cs
│   │   ├── DiogelContextFactory.cs
│   │   ├── Configurations
│   │   ├── Database.csproj
│   │   └── README.md
│   ├── DTOs
│   │   ├── Dto1.cs
│   │   └── DTOs.csproj
│   └── Models
│       ├── Cmss
│       └── Models.csproj
└── tests
    ├── Integration
    │   ├── Asserts
    │   ├── Integration.csproj
    │   └── Tests
    └── Unit
        └── Unit.csproj

This will generate a full API Solution stub containing the typical project configuration for your solution. Enabling you to focus on the aspects of your project that really add value.

Enable version control

From the outset the API Solution template, is ready for you to start your development projects and you can start coding and implementing the business value required. However, there is one step that is required before getting started with your coding tasks - which is setting up your version control.

Initiating a Git repository

By convention, a vast majority of software developers predominantly make use of Git - Version Control.

The API solution makes use of Semantic Versioning and makes use of GitVersion which requires a Git Repository, so all you create a Git Repository by Changing into the root of your created directory and using:

git init

How to create a Git Repository

The API template Pack, takes an opinionated view, on defining PostgreSQL as the default database to base API’s from. We have detailed the number of reasons why we chose PostgreSQL as the default database option. As such we we included a Docker-compose script that will setup a local PostgreSQL database for you.

Opening the Solution project

You can open the Solution file in any IDE (Intergrated Development Environment) that supports Dotnet Solution files this includes some of the most preferred editors in the Dotnet Community including:

The image below is a screen shot of the Solution we created open in Rider

Solution Rider

Running Docker-compose to create development environment

All you need to do to get this up and running is to execute the command local-dev-docker-compose up -d in the root directory of your project. Alternatively, if you are using Rider you can learn How to run docker compose files in Rider

Additional Resources