Skip to main content

Esta versão do GitHub Enterprise Server será descontinuada em 2024-06-29. Nenhum lançamento de patch será feito, mesmo para questões críticas de segurança. Para obter melhor desempenho, segurança aprimorada e novos recursos, atualize para a última versão do GitHub Enterprise Server. Para obter ajuda com a atualização, entre em contato com o suporte do GitHub Enterprise.

Criar e testar .NET

Você pode criar um fluxo de trabalho de integração contínua (CI) para criar e testar o seu projeto .NET.

Observação: no momento, não há suporte para os executores hospedados no GitHub no GitHub Enterprise Server. Você pode ver mais informações sobre o suporte futuro planejado no GitHub public roadmap.

Introdução

Este guia mostra como criar, testar e publicar um pacote no .NET.

Executores hospedados em GitHub têm um cache de ferramentas com software pré-instalado que inclui o SDK do .NET Core. Para ver a lista completa de programas de software atualizados e as versões pré-instaladas do SDK do .NET Core, confira Programas de software instalados nos executores hospedados no GitHub.

Pré-requisitos

Você já deve estar familiarizado com a sintaxe YAML e como é usado com GitHub Actions. Para obter mais informações, confira "Sintaxe de fluxo de trabalho para o GitHub Actions".

Recomendamos que você tenha um entendimento básico do .NET Core SDK. Para obter mais informações, confira Introdução ao .NET.

Usando um fluxo de trabalho inicial em .NET

Para experimentar uma introdução rápida, adicione um fluxo de trabalho inicial ao diretório .github/workflows do repositório.

O GitHub fornece um fluxo de trabalho inicial para .NET que deve funcionar para a maioria dos projetos .NET. As seções subsequentes deste guia fornecem exemplos de como você pode personalizar esse fluxo de trabalho inicial.

  1. No sua instância do GitHub Enterprise Server, navegue até a página principal do repositório.

  2. No nome do repositório, clique em Ações.

    Captura de tela das guias do repositório "github/docs". A guia "Ações" está realçada com um contorno laranja.

  3. Se você já tiver um fluxo de trabalho no repositório, clique em Novo fluxo de trabalho.

  4. A página "Escolher um fluxo de trabalho" mostra uma seleção de fluxos de trabalho iniciais recomendados. Pesquise por "dotnet".

  5. No fluxo de trabalho ".NET", clique em Configurar.

    Se não encontrar o fluxo de trabalho inicial ".NET", copie o seguinte código de fluxo de trabalho para um novo arquivo chamado dotnet.yml no diretório .github/workflows do seu repositório.

    YAML
    name: .NET
    
    on:
      push:
        branches: [ "main" ]
      pull_request:
        branches: [ "main" ]
    
    jobs:
      build:
        runs-on: ubuntu-latest
    
        steps:
        - uses: actions/checkout@v4
        - name: Setup .NET
          uses: actions/setup-dotnet@v3
          with:
            dotnet-version: 6.0.x
        - name: Restore dependencies
          run: dotnet restore
        - name: Build
          run: dotnet build --no-restore
        - name: Test
          run: dotnet test --no-build --verbosity normal
    
  6. Edite o fluxo de trabalho conforme necessário. Por exemplo, altere a versão do .NET.

  7. Clique em Confirmar alterações.

Especificando uma versão do .NET

Para usar uma versão pré-instalada do SDK do .NET Core em um executor hospedado no GitHub, use a ação setup-dotnet. Essa ação localiza uma versão específica do .NET no cache de ferramentas em cada executor e adiciona os binários necessários a PATH. Estas alterações persistirão para o resto do trabalho.

A ação setup-dotnet é a maneira recomendada de usar o .NET com o GitHub Actions, pois garante um comportamento consistente entre diferentes executores e diferentes versões do .NET. Se você estiver usando um executor auto-hospedado, precisará instalar o .NET e adicioná-lo a PATH. Para obter mais informações, confira a ação setup-dotnet.

Usar múltiplas versões do .NET

name: dotnet package

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        dotnet-version: [ '3.1.x', '6.0.x' ]

    steps:
      - uses: actions/checkout@v4
      - name: Setup dotnet ${{ matrix.dotnet-version }}
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ matrix.dotnet-version }}
      # You can test your matrix by printing the current dotnet version
      - name: Display dotnet version
        run: dotnet --version

Usar uma versão específica do .NET

Você pode configurar seu trabalho para usar uma versão específica do .NET, como 6.0.22. Como alternativa, você pode usar a sintaxe da versão semântica para obter a última versão secundária. Este exemplo usa a versão mais recente do .NET 6.

    - name: Setup .NET 6.x
      uses: actions/setup-dotnet@v3
      with:
        # Semantic version range syntax or exact version of a dotnet version
        dotnet-version: '6.x'

Instalar dependências

Os executores hospedados em GitHub têm o gerenciador do pacote NuGet instalado. Você pode usar o dotnet CLI para instalar dependências do registro do pacote NuGet antes de criar e testar seu código. Por exemplo, o YAML abaixo instala o pacote Newtonsoft.

steps:
- uses: actions/checkout@v4
- name: Setup dotnet
  uses: actions/setup-dotnet@v3
  with:
    dotnet-version: '6.0.x'
- name: Install dependencies
  run: dotnet add package Newtonsoft.Json --version 12.0.1

Memorizar dependências

Você pode armazenar em cache dependências do NuGet para fluxos de trabalho futuros usando a entrada opcional cache. Por exemplo, o YAML abaixo armazena em cache a pasta NuGet global-packages e, em seguida, instala o pacote Newtonsoft. Uma segunda entrada opcional, cache-dependency-path, pode ser usada para especificar o caminho para um arquivo de dependência: packages.lock.json.

Para obter mais informações, confira "Memorizar dependências para acelerar os fluxos de trabalho".

steps:
- uses: actions/checkout@v4
- name: Setup dotnet
  uses: actions/setup-dotnet@v3
  with:
    dotnet-version: '6.x'
    cache: true
- name: Install dependencies
  run: dotnet add package Newtonsoft.Json --version 12.0.1

Observação: conforme o número de dependências, pode ser mais rápido usar o cache de dependência. Os projetos com muitas dependências grandes devem ver um aumento no desempenho conforme reduz o tempo necessário para fazer o download. Os projetos com menos dependências podem não ver um aumento significativo no desempenho e até mesmo ver um ligeiro diminuir devido à forma como o NuGet instala dependências armazenadas em cache. O desempenho varia de projeto para projeto.

Criar e testar seu código

Você pode usar os mesmos comandos usados localmente para criar e testar seu código. Este exemplo demonstra como usar dotnet build e dotnet test em um trabalho:

steps:
- uses: actions/checkout@v4
- name: Setup dotnet
  uses: actions/setup-dotnet@v3
  with:
    dotnet-version: '6.0.x'
- name: Install dependencies
  run: dotnet restore
- name: Build
  run: dotnet build
- name: Test with the dotnet CLI
  run: dotnet test

Empacotar dados do fluxo de trabalho como artefatos

Após a conclusão de um fluxo de trabalho, você poderá fazer o upload dos artefatos resultantes para análise. Por exemplo, é possível que você precise salvar os arquivos de registro, os despejos de núcleo, os resultados de teste ou capturas de tela. O exemplo a seguir demonstra como você pode usar a ação upload-artifact para carregar os resultados do teste.

Para obter mais informações, confira "Armazenar dados do fluxo de trabalho como artefatos".

name: dotnet package

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      matrix:
        dotnet-version: [ '3.1.x', '6.0.x' ]

      steps:
        - uses: actions/checkout@v4
        - name: Setup dotnet
          uses: actions/setup-dotnet@v3
          with:
            dotnet-version: ${{ matrix.dotnet-version }}
        - name: Install dependencies
          run: dotnet restore
        - name: Test with dotnet
          run: dotnet test --logger trx --results-directory "TestResults-${{ matrix.dotnet-version }}"
        - name: Upload dotnet test results
          uses: actions/upload-artifact@v3
          with:
            name: dotnet-results-${{ matrix.dotnet-version }}
            path: TestResults-${{ matrix.dotnet-version }}
          # Use always() to always run this step to publish test results when there are test failures
          if: ${{ always() }}

Publicar nos registros do pacote

É possível configurar o seu fluxo de trabalho para publicar o pacote .NET em um pacote de registro quando o CI teste é aprovado. Você pode usar segredos do repositório para armazenar quaisquer tokens ou credenciais necessárias para publicar seu binário. O exemplo a seguir cria e publica um pacote no GitHub Packages usando dotnet core cli.

name: Upload dotnet package

on:
  release:
    types: [created]

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v3
        with:
          dotnet-version: '6.0.x' # SDK Version to use.
          source-url: https://nuget.pkg.github.com/<owner>/index.json
        env:
          NUGET_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
      - run: dotnet build --configuration Release <my project>
      - name: Create the package
        run: dotnet pack --configuration Release <my project>
      - name: Publish the package to GPR
        run: dotnet nuget push <my project>/bin/Release/*.nupkg