Get the FREE Ultimate OpenClaw Setup Guide →

dotnet-run-file

Scanned
npx machina-cli add skill NikiforovAll/claude-code-rules/dotnet-run-file --openclaw
Files (1)
SKILL.md
2.8 KB

.NET Run Files

Run C# code directly without creating project files using .NET 10's dotnet run file.cs feature.

When to Use This Skill

Use this skill when the user wants to:

  • Execute C# code quickly without creating a project
  • Write one-liner scripts via stdin (ideal for Claude Code)
  • Learn about run file directives (#:package, #:sdk, #:property)
  • Create executable shell scripts in C#
  • Convert a run file to a full project

Guide

For detailed examples and directives reference, load references/guide.md.

Quick Reference

Basic Execution

# Run a .cs file
dotnet run app.cs

# Run from stdin
echo 'Console.WriteLine("Hello");' | dotnet run -

# Multi-line via heredoc
dotnet run - << 'EOF'
var now = DateTime.Now;
Console.WriteLine($"Time: {now}");
EOF

Directives

#:package Humanizer@*            // NuGet package (version required, wildcards ok)
#:sdk Microsoft.NET.Sdk.Web       // SDK selection
#:property LangVersion preview    // MSBuild property
#:project ../src/MyLib            // Project reference

Convert to Project

dotnet project convert app.cs

Core Operations

1. Run a C# File

Steps:

  1. Create a .cs file with your code (top-level statements supported)
  2. Add directives at the top if needed (packages, SDK, properties)
  3. Execute: dotnet run filename.cs

Example:

// hello.cs
Console.WriteLine("Hello from .NET!");
dotnet run hello.cs

2. Execute via Stdin

Purpose: Run C# code without creating files - ideal for quick scripts and AI-assisted workflows.

Patterns:

# Simple one-liner
echo 'Console.WriteLine(Math.PI);' | dotnet run -

# With package
dotnet run - << 'EOF'
#:package Humanizer@*
using Humanizer;
Console.WriteLine(TimeSpan.FromMinutes(90).Humanize());
EOF

# Heredoc for multi-line
dotnet run - << 'EOF'
using System.Text.Json;

var obj = new { Name = "Test", Value = 42 };
Console.WriteLine(JsonSerializer.Serialize(obj));
EOF

Interactive Flow

When user asks to run C# code without specifics:

  1. Ask what they want to accomplish
  2. Determine if stdin one-liner or file-based is better
  3. For simple tasks → use stdin pattern
  4. For complex tasks → create a .cs file
  5. Add necessary directives based on requirements
  6. Execute and show results

Claude Code Integration Tips

For AI-assisted workflows:

  • Prefer stdin for quick calculations, data transformations, API calls
  • Use heredoc syntax for multi-line code
  • Output JSON for easy parsing: dotnet run script.cs | jq .

Source

git clone https://github.com/NikiforovAll/claude-code-rules/blob/main/plugins/handbook-dotnet/skills/dotnet-run-file/SKILL.mdView on GitHub

Overview

dotnet-run-file lets you execute C# code without creating project files using dotNET 10's dotnet run file.cs. It supports running scripts via stdin and run file directives like #:package, #:sdk, and #:property. This makes prototyping, quick automation, and converting run files to full projects simple and fast.

How This Skill Works

The approach leverages dotnet run to execute a standalone .cs file. You can place run directives at the top to manage packages, SDKs, and MSBuild properties, and you can feed code via stdin or heredoc for scripting. For longer-term use, a run file can later be converted into a conventional project with dotnet project convert.

When to Use It

  • Execute C# code quickly without creating a project
  • Write one-liner scripts via stdin for quick tasks or AI workflows
  • Learn about run file directives like #:package, #:sdk, and #:property
  • Create executable shell scripts in C#
  • Convert a run file to a full Visual Studio or CLI project

Quick Start

  1. Step 1: Create a .cs file (with optional directives) containing your code
  2. Step 2: Run: dotnet run filename.cs, or pipe code via stdin with dotnet run -
  3. Step 3: Inspect output and, if needed, convert to a project with dotnet project convert

Best Practices

  • Place run-file directives at the very top of the file before code
  • Use stdin or heredoc for multi-line scripts to keep files compact
  • Specify necessary directives (package, SDK, properties) prior to execution
  • Start with small, testable code before adding packages or complex logic
  • When projects grow, use dotnet project convert to generate a standard project

Example Use Cases

  • Simple hello script: create hello.cs with Console.WriteLine("Hello from .NET!"); then dotnet run hello.cs
  • One-liner via stdin: echo 'Console.WriteLine(Math.PI);' | dotnet run -
  • Heredoc with a package: dotnet run - << 'EOF' #:package Humanizer@* using Humanizer; Console.WriteLine(TimeSpan.FromMinutes(90).Humanize()); EOF
  • Multi-line script that serializes an object: use System.Text.Json to emit JSON from a small anonymous object
  • Convert to a project: dotnet project convert app.cs to generate a full .csproj-based project

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers