Continuous Integration in C#

Introduction

Continuous Integration (CI) is a development practice where developers merge their code changes into a shared repository several times a day. Each integration is verified by an automated build and test process to detect integration errors as quickly as possible. In this tutorial, we will explore how to set up CI pipelines for C# projects using popular tools like GitHub Actions, Azure DevOps, and Jenkins.

Concept

The primary goal of CI is to ensure that the codebase remains stable and functional throughout the development lifecycle. By automating the build and test processes, developers can catch issues early, reducing the time and effort required to fix bugs later in the project.

Key Components of CI

1. Version Control System (VCS): A system like Git is used to manage changes to the codebase.
2. Build Tool: Tools like MSBuild or Cake are used to compile the source code.
3. Test Framework: Frameworks like NUnit, xUnit, or MSTest are used to run automated tests.
4. CI/CD Server: Platforms like GitHub Actions, Azure DevOps, and Jenkins automate the build and test processes.

Examples

Setting Up CI with GitHub Actions

GitHub Actions is a powerful automation tool that allows you to automate your software workflow. Here’s how you can set up a basic CI pipeline for a C# project using GitHub Actions.

1. Create a Workflow File:

   Create a new file named .github/workflows/ci.yml in the root of your repository.

1name: C# CI
2 
3 on:
4   push:
5     branches: [ main ]
6   pull_request:
7     branches: [ main ]
8 
9 jobs:
10   build:
11 
12     runs-on: ubuntu-latest
13 
14     steps:
15     - uses: actions/checkout@v2
16     - name: Setup .NET
17       uses: actions/setup-dotnet@v1
18       with:
19         dotnet-version: '6.0.x'
20     - name: Build
21       run: dotnet build --configuration Release --no-restore
22     - name: Test
23       run: dotnet test

2. Commit and Push the Workflow File:

   Add the .github/workflows/ci.yml file to your repository and commit it.

git add .github/workflows/ci.yml
 git commit -m "Add GitHub Actions CI workflow"
 git push origin main

3. Observe the Workflow Execution:

   After pushing the changes, navigate to the "Actions" tab in your GitHub repository to see the workflow running.

Setting Up CI with Azure DevOps

Azure DevOps is another robust platform for setting up continuous integration pipelines. Here’s how you can set it up for a C# project.

1. Create a New Pipeline:

   • Go to your Azure DevOps project.
   • Navigate to "Pipelines" and click on "New pipeline".
   • Select the source repository (e.g., GitHub).
   • Choose the branch you want to build (e.g., main).

2. Configure the Pipeline:

   Azure DevOps will provide a YAML template for your C# project. You can customize it as needed.

1trigger:
2   branches:
3     include:
4       - main
5 
6 pool:
7   vmImage: 'ubuntu-latest'
8 
9 steps:
10 - task: UseDotNet@2
11   inputs:
12     packageType: 'sdk'
13     version: '6.0.x'
14     installationPath: $(Agent.ToolsDirectory)/dotnet
15 
16 - script: dotnet build --configuration Release
17   displayName: 'Build'
18 
19 - script: dotnet test
20   displayName: 'Test'

3. Save and Run the Pipeline:

   Save the pipeline configuration and run it to see the CI process in action.

Setting Up CI with Jenkins

Jenkins is a widely used open-source automation server that can be configured for continuous integration.

1. Install Jenkins Plugins:

   • Install the "Git Plugin" and "MSBuild Plugin".

2. Create a New Job:

   • Go to your Jenkins dashboard.
   • Click on "New Item".
   • Enter a name for the job and select "Freestyle project".
   • Configure the source code management to use Git and specify the repository URL.

3. Configure Build Steps:

   • Add build steps to execute MSBuild and run tests.

1stage('Build') {
2     steps {
3         bat 'msbuild /p:Configuration=Release'
4     }
5 }
6 
7 stage('Test') {
8     steps {
9         bat 'vstest.console.exe ***Tests.dll'
10     }
11 }

4. Save and Run the Job:

   Save the job configuration and run it to see the CI process in action.

What's Next?

After setting up continuous integration, you can explore continuous deployment (CD) to automate the release of your application. This will allow you to deploy your code changes automatically to staging or production environments once they pass all tests.

For more information on continuous deployment in C#, check out our next tutorial: Continuous Deployment in C#.