Use .NET CLI with JFrog CLI

Run .NET CLI commands with Artifactory integration for dependency resolution and build information collection.

This topic covers the following tasks:

• Configure .NET for Artifactory (jf dotnet-config)
• Run .NET CLI commands (jf dotnet)

When to Use

Use jf dotnet if your .NET project uses the .NET SDK CLI (dotnet restore, dotnet build) for builds. For projects using the NuGet CLI directly, use jf nuget instead.

Prerequisites

• A .NET project must exist in the current directory (a .csproj or .sln file). If you don't have one yet, create one with dotnet new.
• JFrog CLI server configured. See jf config add — note the server ID you use, as it is required by jf dotnet-config.
• Authentication: A valid Artifactory access token is required. If your token is a reference token (non-JWT), you must also supply a username when configuring the server — NuGet uses basic authentication and requires both a username and password/token. Re-run jf config add and provide a username if you see Value cannot be null or empty string. (Parameter 'username') errors.
• Run jf dotnet-config in the project directory before the first build.

Configuration: jf dotnet-config

Generate .NET configuration for resolving packages through Artifactory. Run this once per project before your first build.

To configure .NET for Artifactory:

1. From your project directory (containing a .csproj or .sln), run jf dotnet-config with --server-id-resolve and --repo-resolve (see Non-Interactive Configuration).
2. Confirm .jfrog/projects/dotnet.yaml was created (see How to Verify).

Synopsis

jf dotnet-config [options]

Aliases: dotnetc

Configuration Options

Configuration Examples

View Help

jf dotnet-config --help

Non-Interactive Configuration

Configure .NET with non-interactive flags:

jf dotnet-config --server-id-resolve=<server-id> --repo-resolve=<repo-name>

Where:

• <server-id>: The server ID configured using jf config add
• <repo-name>: The name of the NuGet repository in Artifactory

For example:

jf dotnet-config --server-id-resolve=my-server --repo-resolve=nuget-virtual

Why Run Config First?

You must run jf dotnet-config before jf dotnet restore. The config creates .jfrog/projects/dotnet.yaml for NuGet package resolution through Artifactory. Without it, jf dotnet does not know where to fetch packages.

👍

Shortcut

: In CI/CD, pass all flags non-interactively so the config step is fully automated and reproducible.

Configuration Notes

• Run once per project: Re-run when changing the resolution repository.
• NuGet V2: Use --nuget-v2=true only if your Artifactory NuGet repository is configured for the V2 protocol. Most modern setups use V3.
• Alternative: For NuGet-only projects (not using .NET SDK), use jf nuget instead.

Expected Output

$ jf dotnet-config --server-id-resolve=my-server --repo-resolve=nuget-virtual
[Info] dotnet build config successfully created.

How to Verify

After running, confirm the configuration exists:

cat .jfrog/projects/dotnet.yaml

The file should contain:

version: 1
type: dotnet
resolver:
    repo: <repo-name>
    serverId: <server-id>

Where <repo-name> and <server-id> match the values you passed to jf dotnet-config.

Build: jf dotnet

Run .NET CLI commands with Artifactory integration for dependency resolution and build information collection.

To run .NET CLI with Artifactory integration:

1. Run jf dotnet-config in the project directory if you have not already (see Configuration).
2. From the project root, run jf dotnet with the .NET subcommand (for example, restore, build), adding --build-name and --build-number when you want build-info (see Build Examples).

Synopsis

jf dotnet <dotnet-arguments> [options]

Aliases: none

Arguments

Build Options

Build Examples

📘

Note

Run these commands from the root of your .NET project directory (where your .csproj or .sln file lives), and only after running jf dotnet-config in that directory.

Restore and Build

jf dotnet restore
jf dotnet build

On success, restore ends with:

Restore succeeded.

And build ends with:

Build succeeded.

Build with Build Information

jf dotnet restore --build-name=<build-name> --build-number=<build-number>
jf dotnet build --build-name=<build-name> --build-number=<build-number>

Where:

• <build-name> is a name for the build (for example, my-dotnet-app)
• <build-number> is a number or identifier for the build run (for example, 1)

For example:

jf dotnet restore --build-name=my-dotnet-app --build-number=1
jf dotnet build --build-name=my-dotnet-app --build-number=1

Publish Build Info

After restoring and building with --build-name and --build-number, publish the collected build info to Artifactory:

jf rt build-publish <build-name> <build-number>

For example:

jf rt build-publish my-dotnet-app 1

👍

Tip

jf rt bp is a shorthand alias for jf rt build-publish.

Important Notes

• dotnet vs nuget: jf dotnet wraps the .NET CLI (which includes NuGet functionality). Use jf dotnet for .NET SDK-style projects and jf nuget for traditional NuGet-only projects.
• .NET commands: All standard .NET CLI commands work (restore, build, publish, test, pack, and others).
• Build-info: Use --build-name and --build-number, then publish with jf rt build-publish.

CI/CD Example (GitHub Actions)

# .github/workflows/build.yml
steps:
  - uses: actions/checkout@v4
  - name: Setup JFrog CLI
    uses: jfrog/setup-jfrog-cli@v4
    env:
      JF_URL: ${{ vars.JF_URL }}
      JF_ACCESS_TOKEN: ${{ secrets.JF_ACCESS_TOKEN }}
  - name: Setup .NET
    uses: actions/setup-dotnet@v4
    with:
      dotnet-version: '8.0.x'
  - name: Configure .NET
    run: jf dotnet-config --server-id-resolve=setup-jfrog-cli-server --repo-resolve=nuget-virtual
  - name: Restore packages
    run: jf dotnet restore --build-name=my-dotnet-app --build-number=${{ github.run_number }}
  - name: Build
    run: jf dotnet build
  - name: Publish build info
    run: jf rt build-publish my-dotnet-app ${{ github.run_number }}

Troubleshooting

Enable debug logging: export JFROG_CLI_LOG_LEVEL=DEBUG

Related Topics

• Build Tools Overview — Capabilities matrix and tool reference
• Native Mode — Supported packages with Native Mode