Implement .NET CI/CD workflow mirroring Gradle style

[Sazwanend]

To implement a .NET CI/CD workflow that mirrors Gradle style, we need to embrace the core principles Gradle brings to builds:

· Declarative tasks with explicit dependencies
· Parallel execution where possible
· Incremental builds & caching to avoid redundant work
· Multi‑project support (e.g., building multiple assemblies or test suites)
· A clear lifecycle (clean → compile → test → package → publish)

In the .NET ecosystem, we can achieve this either by scripting our pipeline declaratively (e.g., GitHub Actions, Azure DevOps) or by using a build orchestration tool like Nuke or Cake that lets us write our build logic in C# (similar to Gradle’s Groovy/Kotlin DSL).

Below I present two complementary approaches:

1. A GitHub Actions YAML pipeline that structures jobs and steps like Gradle tasks.
2. A Nuke build script that gives you full programmatic control with a Gradle‑like task model.

---

Option 1 – GitHub Actions Workflow (Declarative Gradle‑style)

The YAML below models a typical Gradle build lifecycle:

· Jobs run in parallel for different target frameworks.
· Steps are ordered like tasks (clean, restore, build, test, publish).
· Caching for NuGet packages mimics Gradle’s build cache.
· Artifacts are uploaded for later deployment.

name: .NET CI/CD (Gradle Style)

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  DOTNET_VERSION: '8.0.x'
  SOLUTION_PATH: 'MySolution.sln'

jobs:
  # ------------------------------------------------------------------
  # 1. "clean" task – optional, but we just remove old artifacts
  # ------------------------------------------------------------------
  clean:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Clean artifacts
        run: |
          if (Test-Path ./artifacts) { Remove-Item -Recurse -Force ./artifacts }
        shell: pwsh

  # ------------------------------------------------------------------
  # 2. "compile" and "test" – run in parallel for each framework
  #    (like Gradle's parallel task execution)
  # ------------------------------------------------------------------
  build-and-test:
    needs: clean
    runs-on: ubuntu-latest
    strategy:
      matrix:
        framework: [ 'net8.0', 'net6.0' ]   # multi-target
        project: [ 'src/MyApp', 'tests/MyApp.Tests' ]  # multi-module
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      # Gradle‑style cache – restore NuGet packages with cache
      - name: Cache NuGet packages
        uses: actions/cache@v4
        with:
          path: ~/.nuget/packages
          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json') }}
          restore-keys: |
            ${{ runner.os }}-nuget-

      # "restore" – equivalent to Gradle's dependency resolution
      - name: Restore dependencies
        run: dotnet restore ${{ matrix.project }}/${{ matrix.project }}.csproj

      # "compile" – build without tests
      - name: Build
        run: dotnet build ${{ matrix.project }}/${{ matrix.project }}.csproj --no-restore --configuration Release

      # "test" – run tests if the project is a test project
      - name: Test
        if: contains(matrix.project, '.Tests')
        run: dotnet test ${{ matrix.project }}/${{ matrix.project }}.csproj --no-build --configuration Release --logger trx

      # Publish test results as artifacts (like Gradle's test reports)
      - name: Upload test results
        if: always() && contains(matrix.project, '.Tests')
        uses: actions/upload-artifact@v4
        with:
          name: test-results-${{ matrix.framework }}-${{ matrix.project }}
          path: '**/TestResults/*.trx'

  # ------------------------------------------------------------------
  # 3. "assemble" / "package" – create deployable artifacts
  # ------------------------------------------------------------------
  package:
    needs: build-and-test
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup .NET
        uses: actions/setup-dotnet@v4
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }}

      - name: Restore
        run: dotnet restore ${{ env.SOLUTION_PATH }}

      - name: Build for packaging
        run: dotnet build ${{ env.SOLUTION_PATH }} --no-restore --configuration Release

      # Publish web apps or executables
      - name: Publish
        run: dotnet publish src/MyApp/MyApp.csproj --configuration Release --output ./artifacts/publish

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: app-package
          path: ./artifacts/publish

  # ------------------------------------------------------------------
  # 4. "deploy" – conditional (like Gradle's deployment tasks)
  # ------------------------------------------------------------------
  deploy:
    needs: package
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production
    steps:
      - name: Download package
        uses: actions/download-artifact@v4
        with:
          name: app-package
          path: ./deploy

      # Simulate deployment (e.g., Azure WebApp, FTP, etc.)
      - name: Deploy to Azure Web App
        uses: azure/webapps-deploy@v2
        with:
          app-name: 'my-azure-webapp'
          slot-name: 'production'
          publish-profile: ${{ secrets.AZURE_PUBLISH_PROFILE }}
          package: ./deploy

What makes this “Gradle‑style”?

· Parallel matrix jobs – like Gradle’s --parallel flag and multi‑project builds.
· Explicit task dependencies via needs.
· Caching to avoid re‑downloading packages.
· Artifact publishing – similar to Gradle’s uploadArchives.
· Conditional deployment – only on main (like Gradle tasks only run when needed).

---

Option 2 – Using Nuke (C# Build Script)

Nuke is a build automation tool written in C# that feels remarkably like Gradle. You define a Build class with targets (tasks) that have dependencies, and you can run them with a command‑line interface.

Here’s a Build.cs that mirrors the same lifecycle:

using Nuke.Common;
using Nuke.Common.IO;
using Nuke.Common.ProjectModel;
using Nuke.Common.Tools.DotNet;
using static Nuke.Common.Tools.DotNet.DotNetTasks;

class Build : NukeBuild
{
    // Entry point for the build
    public static int Main() => Execute<Build>(x => x.Compile);

    // Gradle‑style project properties
    [Parameter("Configuration to build")] 
    readonly string Configuration = "Release";

    [Solution] readonly Solution Solution; // auto‑detects .sln

    AbsolutePath ArtifactsDirectory => RootDirectory / "artifacts";

    // 1. Clean
    Target Clean => _ => _
        .Before(Restore)
        .Executes(() =>
        {
            ArtifactsDirectory.CreateOrCleanDirectory();
        });

    // 2. Restore (like Gradle's dependency resolution)
    Target Restore => _ => _
        .DependsOn(Clean)
        .Executes(() =>
        {
            DotNetRestore(s => s
                .SetProjectFile(Solution));
        });

    // 3. Compile
    Target Compile => _ => _
        .DependsOn(Restore)
        .Executes(() =>
        {
            DotNetBuild(s => s
                .SetProjectFile(Solution)
                .SetConfiguration(Configuration)
                .EnableNoRestore());
        });

    // 4. Test (parallelisable)
    Target Test => _ => _
        .DependsOn(Compile)
        .Executes(() =>
        {
            DotNetTest(s => s
                .SetProjectFile(Solution)
                .SetConfiguration(Configuration)
                .EnableNoBuild()
                .EnableNoRestore()
                .SetLogger("trx")
                .SetResultsDirectory(ArtifactsDirectory / "TestResults"));
        });

    // 5. Publish / Package
    Target Publish => _ => _
        .DependsOn(Test)
        .Executes(() =>
        {
            DotNetPublish(s => s
                .SetProject(Solution.GetProject("MyApp"))
                .SetConfiguration(Configuration)
                .SetOutput(ArtifactsDirectory / "publish"));
        });

    // 6. Deploy (conditional)
    Target Deploy => _ => _
        .DependsOn(Publish)
        .OnlyWhenStatic(() => IsServerBuild && GitRepository.IsOnMainBranch())
        .Executes(() =>
        {
            // Deploy logic here (e.g., Azure CLI)
        });
}

You then run the build with:

dotnet run --target Test      # runs test target
dotnet run --target Deploy    # runs deploy if on main

Nuke provides:

· Explicit task dependencies (.DependsOn).
· Before/After ordering (like Gradle’s mustRunAfter).
· Parallel execution (not shown, but can be enabled via .Produces / .Consumes).
· Conditional execution via .OnlyWhenStatic.
· Caching of build outputs is supported via the [Cache] attribute.

You can even use Nuke’s built‑in GitHub Actions integration to generate the YAML for you, keeping your pipeline definition in C#.

---

Which one to choose?

· GitHub Actions is great if you want a simple, declarative pipeline that lives in your repo’s .github/workflows folder and is easy for anyone to understand.
· Nuke is perfect when you need complex build logic, want to reuse C# skills, or prefer a code‑first approach (like Gradle). It also makes your build portable across CI providers.

Both approaches can mirror Gradle’s elegance – the key is to structure your pipeline around tasks with clear dependencies, parallelisation, and caching.

---

Additional Gradle‑style touches

· Incremental builds: With Nuke, you can use [Cache] attributes to skip targets when inputs haven’t changed – exactly like Gradle’s up‑to‑date checks.
· Multi‑project builds: Both approaches handle solutions with many projects; in YAML you use matrix strategies, in Nuke you iterate over Solution.AllProjects.
· Artifact repositories: You can push NuGet packages to a feed (like Gradle’s maven-publish) using DotNetPack and DotNetNuGetPush.

---

Let me know if you’d like a deeper dive into any of these aspects – I can provide more tailored examples for your specific .NET solution structure.

[gemini-code-assist]

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize the Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counterproductive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for GitHub and other Google products, sign up here.