dotnet-run-file
Scannednpx machina-cli add skill NikiforovAll/claude-code-rules/dotnet-run-file --openclaw.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:
- Create a
.csfile with your code (top-level statements supported) - Add directives at the top if needed (packages, SDK, properties)
- 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:
- Ask what they want to accomplish
- Determine if stdin one-liner or file-based is better
- For simple tasks → use stdin pattern
- For complex tasks → create a
.csfile - Add necessary directives based on requirements
- 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
- Step 1: Create a .cs file (with optional directives) containing your code
- Step 2: Run: dotnet run filename.cs, or pipe code via stdin with dotnet run -
- 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