Skip to main content

C# (.NET Core)

You can build and test a C# and .NET Core application using a Linux or Windows platform on Harness Cloud or a self-managed Kubernetes cluster build infrastructure.

This guide assumes you've created a Harness CI pipeline.

Specify architecture​

You can use a Linux or Windows platform to build and test C# (.NET Core) apps. These examples use Linux build infrastructure.

stages:
  - stage:
      name: build
      identifier: build
      type: CI
      spec:
        cloneCodebase: true
        platform:
          os: Linux
          arch: Amd64 ## Can be Amd64 or Arm64
        runtime:
          type: Cloud
          spec: {}

Install dependencies​

The .NET Core SDK and other .NET libraries are pre-installed on Harness Cloud runners. For details about all available tools and versions, go to Platforms and image specifications. You can use Run steps to install additional dependencies or run dotnet restore.

- step:
    type: Run
    identifier: dependencies
    name: Dependencies
    spec:
      shell: Sh
      command: |-
        dotnet add package Newtonsoft.json --version 12.0.1

Cache dependencies​

Add caching to your Build (CI) stage.

Cache your .NET dependencies with Cache Intelligence.

Add caching to your stage.spec:

- stage:
    spec:
      caching:
        enabled: true
        key: cache-{{ checksum "packages.lock.json" }}
        paths:
          - "~/.local/share/NuGet/cache"
      sharedPaths:
        - ~/.local/share/NuGet/cache

Build and run tests​

Add Run steps to build and run your tests.

- step:
    type: Run
    identifier: build_dotnet_app
    name: Build DotNet App
    spec:
      shell: Sh
      command: |-
        dotnet restore
        dotnet build --no-restore
        dotnet test --no-build --verbosity normal

Visualize test results​

You can view test results on the Tests tab of your pipeline executions. Test results must be in JUnit XML format.

You can use a converter to output compatible JUnit XML reports, such as NUnit to JUnit or .NET trx2JUnit.

For your pipeline to produce test reports, you need to modify the Run step that runs your tests. Make sure the command generates JUnit XML reports and add the reports specification.

- step:
    type: Run
    identifier: install_converter
    name: install converter
    spec:
      shell: Sh
      command: |-
        dotnet tool install -g trx2junit
        export PATH="$PATH:/root/.dotnet/tools"
- step:
    type: Run
    identifier: build_dotnet_app
    name: Build DotNet App
    spec:
      shell: Sh
      command: |-
        dotnet restore
        dotnet build
        dotnet test --no-build --verbosity normal
        trx2junit results.trx
      reports:
        type: JUnit
        spec:
          paths:
            - results.xml

Run tests with Test Intelligence​

Test Intelligence is available for C# (.NET Core); however, it is behind the feature flag TI_DOTNET. Contact Harness Support to enable the feature.

With this feature flag enabled, you can use Run Tests steps to run unit tests with Test Intelligence on C# codebases.

- step:
    type: RunTests
    identifier: runTestsWithIntelligence
    name: runTestsWithIntelligence
    spec:
      language: Csharp
      buildEnvironment: Core
      frameworkVersion: "6.0"
      buildTool: Dotnet
      args: --no-build --verbosity normal ## Equivalent to 'dotnet test --no-build --verbosity normal' in a Run step or shell.
      namespaces: aw,fc
      runOnlySelectedTests: true
      preCommand: |-
        dotnet tool install -g trx2junit
        export PATH="$PATH:/root/.dotnet/tools"
        dotnet restore
        dotnet build
      postCommand: trx2junit results.trx
      reports:
        type: JUnit
        spec:
          paths:
            - results.xml

Test splitting​

Harness CI supports test splitting (parallelism) for both Run and Run Tests steps.

Specify version​

The .NET SDK is pre-installed on Hosted Cloud runners. For details about all available tools and versions, go to Platforms and image specifications.

If you need a specific .NET Core SDK version that isn't already installed, you can use a Run step to install it, or you can use the setup-dotnet action in a GitHub Action step.

Install one .NET SDK version
- step:
    type: Action
    name: Install dotnet
    identifier: install_dotnet
    spec:
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: "3.1.x"

On Windows platforms, you might also need to run the setup-msbuild action.

- step:
    type: Action
    name: Install dotnet
    identifier: install_dotnet
    spec:
      uses: actions/setup-msbuild@v1
      with: ## Optional. Specify a specific version of visual Studio if you have multiple versions installed.
        vs-version: "16.4"
Install multiple .NET SDK versions
  1. Add the matrix looping strategy configuration to your stage.
strategy:
  matrix:
    dotnetVersion:
      - 7.0.x
      - 5.0.x
  1. Reference the matrix variable in your steps.
- step:
    type: Action
    name: Install dotnet
    identifier: install_dotnet
    spec:
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: <+matrix.dotnetVersion>

On Windows platforms, you might also need to run the setup-msbuild action.

- step:
    type: Action
    name: Install dotnet
    identifier: install_dotnet
    spec:
      uses: actions/setup-msbuild@v1
      with: ## Optional. Specify a specific version of visual Studio if you have multiple versions installed.
        vs-version: "16.4"

Full pipeline examples​

The following full pipeline examples are based on the partial examples above.

If you copy this example, replace the placeholder values with appropriate values for your code repo connector and repository name. Depending on your project and organization, you may also need to replace projectIdentifier and orgIdentifier.

YAML example
pipeline:
  name: default
  identifier: default
  projectIdentifier: default
  orgIdentifier: default
  properties:
    ci:
      codebase:
        connectorRef: YOUR_CODE_REPO_CONNECTOR_ID
        repoName: YOUR_REPO_NAME
        build: <+input>
  tags: {}
  stages:
    - stage:
        name: build
        identifier: build
        description: ""
        type: CI
        spec:
          cloneCodebase: true
          caching:
            enabled: true
            key: cache-{{ checksum "packages.lock.json" }}
            paths:
              - "~/.local/share/NuGet/cache"
          execution:
            steps:
              - step:
                  type: Run
                  identifier: dependencies
                  name: Dependencies
                  spec:
                    shell: Sh
                    command: |-
                      dotnet add package Newtonsoft.json --version 12.0.1
              - step:
                  type: Run
                  identifier: install_converter
                  name: install converter
                  spec:
                    shell: Sh
                    command: |-
                      dotnet tool install -g trx2junit
                      export PATH="$PATH:/root/.dotnet/tools"
              - step:
                  type: Run
                  identifier: build_dotnet_app
                  name: Build DotNet App
                  spec:
                    shell: Sh
                    command: |-
                      dotnet restore
                      dotnet build
                      dotnet test --no-build --verbosity normal
                      trx2junit results.trx
                    reports:
                      type: JUnit
                      spec:
                        paths:
                          - results.xml
          platform:
            os: Linux
            arch: Amd64
          runtime:
            type: Cloud
            spec: {}
          sharedPaths:
            - ~/.local/share/NuGet/cache

Next steps​

Now that you have created a pipeline that builds and tests a C# (.NET Core) app, you could: