Spectre.Console

https://spectreconsole.net
Admin
Spectre.Console is a .NET library for creating beautiful console applications with rich text output,...
Tokens:282,126
Snippets:3,475
Trust Score:8
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install Spectre.Console and run a quick styled text, table, and status spinner example

Source: https://spectreconsole.net/console

Install the Spectre.Console package via the .NET CLI, then run this C# example that writes styled markup, renders a table, and shows a status spinner for 2.5 seconds before printing 'Done!'.

```bash
dotnet add package Spectre.Console
```

```csharp
{
    // Styled text with markup
    AnsiConsole.MarkupLine("[bold blue]Welcome[/] to [green]Spectre.Console[/]!");
  
    // A simple table
    var table = new Table()
        .AddColumn("Feature")
        .AddColumn("Description")
        .AddRow("[green]Markup[/]", "Rich text with colors and styles")
        .AddRow("[blue]Tables[/]", "Structured data display")
        .AddRow("[yellow]Progress[/]", "Spinners and progress bars");
    AnsiConsole.Write(table);
  
    // Status spinner for work
    AnsiConsole.Status()
        .Start("Processing...", ctx =>
        {
            Thread.Sleep(2500);
        });
  
    AnsiConsole.MarkupLine("[green]Done![/]");
}
```

--------------------------------

### Set Application Name and Add Examples with SetApplicationName and AddExample

Source: https://spectreconsole.net/cli/how-to/customizing-help-text-and-usage

Configures the application name, version, and usage examples for the help output. The resulting help text shows the custom name and the examples as displayed.

```csharp
var app = new CommandApp<DeployCommand>();
  
app.Configure(config =>
{
    // Set application name (overrides default exe/dll name)
    config.SetApplicationName("myapp");
  
    // Set version shown in --version output
    config.SetApplicationVersion("1.2.0");
  
    // Add examples shown in top-level help
    config.AddExample("production");
    config.AddExample("staging", "--force");
    config.AddExample("dev", "--dry-run", "--verbose");
});
  
return await app.RunAsync(args);
```

```text
USAGE:
    myapp <environment> [OPTIONS]
  
EXAMPLES:
    myapp production
    myapp staging --force
    myapp dev --dry-run --verbose
```

--------------------------------

### Return Value from Live Display with Start<T>()

Source: https://spectreconsole.net/console/live/live-display

Returns a result from the live display context using the generic Start<T>() method. The example accumulates a total, updates the display target with progress, and returns the total after completion. The returned value is then written to the console.

```csharp
var result = AnsiConsole.Live(new Text("Processing..."))
    .Start(ctx =>
    {
        int total = 0;
  
        for (int i = 1; i <= 10; i++)
        {
            total += i;
            ctx.UpdateTarget(new Text($"Processing: {i}/10 (Total: {total})"));
            Thread.Sleep(300);
        }
  
        ctx.UpdateTarget(new Text("[green]Complete![/]"));
        Thread.Sleep(500);
  
        return total;
    });
  
AnsiConsole.WriteLine($"Final result: {result}");
```

--------------------------------

### Start(Action<LiveDisplayContext> action)

Source: https://spectreconsole.net/console/live/live-display

Starts the live display with a synchronous action.

```APIDOC
## LiveDisplay.Start(Action<LiveDisplayContext> action)

### Description
Starts the live display.

### Method
Start

### Parameters
- `action` (Action<LiveDisplayContext>) - Required - The action to execute.

```

--------------------------------

### Start<T>(Func<LiveDisplayContext, T> func)

Source: https://spectreconsole.net/console/live/live-display

Starts the live display with a synchronous function that returns a result.

```APIDOC
## LiveDisplay.Start<T>(Func<LiveDisplayContext, T> func)

### Description
Starts the live display.

### Method
Start<T>

### Parameters
- `func` (Func<LiveDisplayContext, T>) - Required - The action to execute.

### Returns
- The result.

```

--------------------------------

### Explain command examples

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

Examples of using the explain command with various options to show all commands, a specific command, parameter details, or hidden items.

```text
myapp cli explain                    # Show all commands
myapp cli explain add                # Show specific command
myapp cli explain --detailed         # Show parameter details
myapp cli explain --hidden           # Include hidden items
```

--------------------------------

### Complete SelectionPrompt example with search and styling

Source: https://spectreconsole.net/console/prompts/selection-prompt

Complete example combining search, pagination, wrap-around, custom styling, and complex objects. Uses `EnableSearch()`, `WrapAround()`, `HighlightStyle`, and `UseConverter()`; sets `SearchHighlightStyle` after building the prompt and displays the result in a panel.

```csharp
var projects = new[]
{
    new Project { Name = "E-Commerce Platform", Status = "Active", Priority = "High" },
    new Project { Name = "Mobile App Redesign", Status = "Active", Priority = "Medium" },
    new Project { Name = "API Gateway", Status = "Planning", Priority = "High" },
    new Project { Name = "Customer Portal", Status = "Active", Priority = "Low" },
    new Project { Name = "Analytics Dashboard", Status = "Completed", Priority = "Medium" },
    new Project { Name = "Payment Integration", Status = "Active", Priority = "High" },
    new Project { Name = "User Authentication", Status = "Completed", Priority = "High" },
    new Project { Name = "Email Service", Status = "Planning", Priority = "Low" }
};
  
var prompt = new SelectionPrompt<Project>()
    .Title("Select a [green]project[/] to view details")
    .PageSize(6)
    .MoreChoicesText("[grey](Move up and down to see more projects)[/]")
    .EnableSearch()
    .SearchPlaceholderText("Type to search projects...")
    .WrapAround()
    .HighlightStyle(new Style(Color.Cyan1, decoration: Decoration.Bold))
    .UseConverter(p => $"[bold]{p.Name}[/] - {p.Status} [{GetPriorityColor(p.Priority)}]{p.Priority}[/]")
    .AddChoices(projects);
  
prompt.SearchHighlightStyle = new Style(Color.Yellow, decoration: Decoration.Underline);
  
var selected = AnsiConsole.Prompt(prompt);
  
AnsiConsole.WriteLine();
AnsiConsole.Write(new Panel($"[bold]{selected.Name}[/]\nStatus: {selected.Status}\nPriority: {selected.Priority}")
    .Header("Project Details")
    .BorderColor(Color.Cyan1));
```

--------------------------------

### TreeGuide.Ascii output example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Example output of a tree using the TreeGuide.Ascii style, showing ASCII characters for branches and continuations.

```text
Root
|-- Child 1
|   |-- Grandchild 1.1
|   `-- Grandchild 1.2
`-- Child 2
    |-- Grandchild 2.1
    `-- Grandchild 2.2
```

--------------------------------

### AddExample

Source: https://spectreconsole.net/cli/reference/api/Spectre.Console.Cli.Unsafe.IUnsafeBranchConfigurator

Adds an example of how to use the branch.

```APIDOC
## AddExample

### Description
Adds an example of how to use the branch.

### Method
AddExample

### Signature
`public void AddExample(string[] args)`

### Parameters
- **args** (string[]) - Required - The example arguments.
```

--------------------------------

### Remaining.Raw Example Command

Source: https://spectreconsole.net/cli/reference/command-context

Example command line showing arguments after the '--' delimiter. These are available in the Remaining.Raw property.

```text
myapp --verbose -- arg1 arg2 --not-parsed
```

--------------------------------

### Start a live progress display with AnsiConsole.Progress().StartAsync

Source: https://spectreconsole.net/console/explanation/understanding-rendering-model

Starts a live progress display that updates in place. The background refresh re-renders the content every 100ms by default; the loop increments the task until it finishes.

```csharp
await AnsiConsole.Progress()
    .StartAsync(async ctx =>
    {
        var task = ctx.AddTask("Processing");
        while (!task.IsFinished)
        {
            task.Increment(1);
            await Task.Delay(50);
        }
    });
```

--------------------------------

### Guide(Tree, TreeGuide)

Source: https://spectreconsole.net/console/reference/api/Spectre.Console.TreeExtensions

Extension method that sets the tree guide line appearance for a Tree instance.

```APIDOC
## Guide(Tree, TreeGuide)

### Description
Sets the tree guide line appearance for a Tree instance.

### Method
Guide

### Signature
`public static Tree Guide(Tree tree, TreeGuide guide)`

### Parameters
- **tree** (Tree) - The tree.
- **guide** (TreeGuide) - The tree guide lines to use.

### Returns
The same instance so that multiple calls can be chained.
```

--------------------------------

### TreeGuide.Line output example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Example output of a tree using the TreeGuide.Line style, which uses standard Unicode line-drawing characters.

```text
Root
├── Child 1
│   ├── Grandchild 1.1
│   └── Grandchild 1.2
└── Child 2
    ├── Grandchild 2.1
    └── Grandchild 2.2
```

--------------------------------

### Style the Tree with Markup and Guide

Source: https://spectreconsole.net/console/how-to/displaying-hierarchical-data

Demonstrates styling the tree: use markup for colored nodes, call Guide(TreeGuide.BoldLine) to change the line style, and Style(Style.Parse("dim")) to set the overall style.

```csharp
var tree = new Tree("[yellow]MyProject[/]")
    .Guide(TreeGuide.BoldLine)
    .Style(Style.Parse("dim"));
  
var src = tree.AddNode("[blue]src[/]");
src.AddNode("[grey]Program.cs[/]");
src.AddNode("[grey]Startup.cs[/]");
  
var controllers = src.AddNode("[blue]Controllers[/]");
controllers.AddNode("[grey]HomeController.cs[/]");
controllers.AddNode("[grey]ApiController.cs[/]");
  
var tests = tree.AddNode("[green]tests[/]");
tests.AddNode("[grey]UnitTests.cs[/]");
  
AnsiConsole.Write(tree);
```

--------------------------------

### Record()

Source: https://spectreconsole.net/console/reference/api/Spectre.Console.AnsiConsole

Starts recording the console output.

```APIDOC
## Record()

### Description
Starts recording the console output.

### Method
Record

```

--------------------------------

### Localize calendar with Culture property

Source: https://spectreconsole.net/console/widgets/calendar

Set the Culture property to control week start day, day names, and month formatting. The example shows en-US (Sunday start) and fr-FR (Monday start) cultures.

```csharp
AnsiConsole.MarkupLine("[yellow]US culture (Sunday start):[/]");
var usCulture = new Calendar(2025, 11)
{
    Culture = new CultureInfo("en-US")
};
usCulture.AddCalendarEvent(2025, 11, 15);
AnsiConsole.Write(usCulture);
  
AnsiConsole.WriteLine();
AnsiConsole.MarkupLine("[yellow]French culture (Monday start):[/]");
var frenchCulture = new Calendar(2025, 11)
{
    Culture = new CultureInfo("fr-FR")
};
frenchCulture.AddCalendarEvent(2025, 11, 15);
AnsiConsole.Write(frenchCulture);
```

--------------------------------

### ICommandConfigurator.WithExample(string[] args)

Source: https://spectreconsole.net/cli/reference/api/Spectre.Console.Cli.ICommandConfigurator

Adds an example of how to use the command.

```APIDOC
## ICommandConfigurator.WithExample(string[] args)

### Description
Adds an example of how to use the command.

### Method
WithExample

### Signature
`public ICommandConfigurator WithExample(string[] args)`

### Parameters
- **args** (string[]) - The example arguments.

### Returns
- **ICommandConfigurator** - The same `ICommandConfigurator` instance so that multiple calls can be chained.

```

--------------------------------

### Replace Content with ctx.UpdateTarget()

Source: https://spectreconsole.net/console/how-to/live-rendering-and-dynamic-updates

Use ctx.UpdateTarget() to swap the entire display. The example starts with a panel showing 'Starting...', then updates it to 'Processing...' and finally 'Complete!'.

```csharp
AnsiConsole.Live(new Panel("Starting..."))
    .Start(ctx =>
    {
        Thread.Sleep(1000);
        ctx.UpdateTarget(new Panel("[yellow]Processing...[/]"));
        Thread.Sleep(1000);
        ctx.UpdateTarget(new Panel("[green]Complete![/]"));
        Thread.Sleep(500);
    });
```

--------------------------------

### Run the app with different greeting styles

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Example commands showing the output for each greeting style using the --style option.

```bash
dotnet run -- Alice
# Hello, Alice!
  
dotnet run -- Alice --style Formal
# Good day, Alice.
  
dotnet run -- Alice --style Enthusiastic
# Hey there, Alice! Great to see you!
```

--------------------------------

### Run the application with sample arguments

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Runs the application with and without the --formal flag, showing the expected output for each case.

```bash
dotnet run -- Alice
# Hello, Alice!
  
dotnet run -- Alice --formal
# Good day, Alice.
```

--------------------------------

### Ask for Confirmation with AnsiConsole.Confirm()

Source: https://spectreconsole.net/console/how-to/prompting-for-user-input

Use AnsiConsole.Confirm() to get a yes/no answer. The method returns a boolean; the example shows branching on the result to display a message.

```csharp
if (AnsiConsole.Confirm("Continue with installation?"))
{
    AnsiConsole.MarkupLine("[green]Installing...[/]");
}
```

--------------------------------

### Using AnsiConsole.Status() with Spinner.Known.Dots

Source: https://spectreconsole.net/console/reference/spinner-reference

Shows how to start a status display with a built-in spinner. The Spinner.Known.Dots spinner is used, and the status runs for 3 seconds via Task.Delay. This is the primary usage example for the Status API.

```csharp
await AnsiConsole.Status()
    .Spinner(Spinner.Known.Dots)
    .StartAsync("Thinking...", async ctx =>
    {
        await Task.Delay(3000);
    });
```

--------------------------------

### Wire up the command app

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Sets up the command app with GreetCommand as the default command and runs it with the provided arguments.

```csharp
using Spectre.Console.Cli;
  
var app = new CommandApp<GreetCommand>();
return app.Run(args);
```

--------------------------------

### Inspect Text Dimensions with Length and Lines

Source: https://spectreconsole.net/console/widgets/text

Use the Length and Lines properties to get the character count and number of lines of a Text widget. The example creates single-line and multi-line Text instances, then displays their dimensions in a table.

```csharp
var singleLine = new Text("Hello, World!");
var multiLine = new Text("Line 1\nLine 2\nLine 3");
  
var table = new Table()
    .AddColumn("Text")
    .AddColumn("Length")
    .AddColumn("Lines");
  
table.AddRow(
    new Text("\"Hello, World!\""),
    new Text(singleLine.Length.ToString()),
    new Text(singleLine.Lines.ToString())
);
  
table.AddRow(
    new Text("\"Line 1\\nLine 2\\nLine 3\""),
    new Text(multiLine.Length.ToString()),
    new Text(multiLine.Lines.ToString())
);
  
AnsiConsole.Write(table);
```

--------------------------------

### Create a basic Panel

Source: https://spectreconsole.net/console/widgets/panel

Creates a basic Panel with the text "Hello, World!" and writes it to the console. Use this as the simplest way to display content inside a bordered box.

```csharp
var panel = new Panel("Hello, World!");
AnsiConsole.Write(panel);
```

--------------------------------

### Select a spinner animation with Spinner.Known.Star

Source: https://spectreconsole.net/console/live/status

Use this snippet to display a status with a specific spinner animation. The example selects the 'Star' spinner and starts a status that shows 'Loading resources...' for 2 seconds before printing a success message.

```csharp
AnsiConsole.Status()
    .Spinner(Spinner.Known.Star)
    .Start("Loading resources...", ctx =>
    {
        Thread.Sleep(2000);
        AnsiConsole.MarkupLine("[green]Resources loaded![/]");
    });
```

--------------------------------

### Strip Markup for Plain Text with Markup.Remove()

Source: https://spectreconsole.net/console/how-to/escaping-markup

Use Markup.Remove() to get plain text without markup tags, useful for logging or file output. The example shows removing markup from a styled string and then displaying both the styled and plain versions.

```csharp
var styled = "[bold red]Error:[/] Connection to [blue]database[/] failed";
  
// Remove all markup tags for plain text
var plain = Markup.Remove(styled);
  
AnsiConsole.MarkupLine("[dim]Styled output:[/]");
AnsiConsole.MarkupLine(styled);
  
AnsiConsole.MarkupLine("[dim]Plain text for logs:[/]");
AnsiConsole.WriteLine(plain);
```

--------------------------------

### Auto Clear Live Display with AutoClear(true)

Source: https://spectreconsole.net/console/live/live-display

Removes the live display from the console when the context completes. The example creates a table with a status column, starts a live display with AutoClear(true), and updates the table rows in a loop. After the context finishes, the display is cleared and a message is written.

```csharp
var spinner = new Table()
    .AddColumn("Status")
    .AddRow("[blue]Processing...[/]");
  
AnsiConsole.Live(spinner)
    .AutoClear(true)
    .Start(ctx =>
    {
        for (int i = 1; i <= 5; i++)
        {
            spinner.Rows.Clear();
            spinner.AddRow($"[blue]Processing step {i}/5...[/]");
            ctx.Refresh();
            Thread.Sleep(800);
        }
    });
  
AnsiConsole.WriteLine("Display cleared - task complete!");
```

--------------------------------

### Create and render a tree with TreeGuide.Line

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Creates a tree with the Line guide, adds child and grandchild nodes, and writes it to the console with AnsiConsole.Write.

```csharp
var tree = new Tree("Root");
tree.Guide(TreeGuide.Line);
  
var node1 = tree.AddNode("Child 1");
node1.AddNode("Grandchild 1.1");
node1.AddNode("Grandchild 1.2");
  
tree.AddNode("Child 2");
  
AnsiConsole.Write(tree);
```

--------------------------------

### Implement GreetCommand with factory and settings

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

The GreetCommand uses the factory to get a greeting service and writes the result to the console. Its Settings class defines the name argument and the --style option with a default of Casual.

```csharp
public class GreetCommand : Command<GreetCommand.Settings>
{
    private readonly IGreetingFactory _greetingFactory;
    private readonly IAnsiConsole _console;
  
    public GreetCommand(IGreetingFactory greetingFactory, IAnsiConsole console)
    {
        _greetingFactory = greetingFactory;
        _console = console;
    }
  
    public class Settings : CommandSettings
    {
        [CommandArgument(0, "<name>")]
        [Description("The name to greet")]
        public string Name { get; init; } = string.Empty;
  
        [CommandOption("-s|--style")]
        [Description("The greeting style to use (Casual, Formal, or Enthusiastic)")]
        [DefaultValue(GreetingStyle.Casual)]
        public GreetingStyle Style { get; init; }
    }
  
    protected override int Execute(CommandContext context, Settings settings, CancellationToken cancellation)
    {
        var service = _greetingFactory.Create();
        var greeting = service.GetGreeting(settings.Name);
        _console.WriteLine(greeting);
        return 0;
    }
}
```

--------------------------------

### Build Welcome Screen with FigletText

Source: https://spectreconsole.net/console/widgets/figlet

Builds a welcome screen by combining figlet text for the app name with regular text for the version.

```csharp
var appName = new FigletText("MyApp")
{
    Color = Color.Blue,
    Justification = Justify.Center
};
  
var version = new Text("Version 1.0.0", new Style(Color.Grey))
{
    Justification = Justify.Center
};
  
AnsiConsole.Write(appName);
AnsiConsole.Write(version);
AnsiConsole.WriteLine();
```

--------------------------------

### DescriptionAttribute example

Source: https://spectreconsole.net/cli/reference/attribute-and-parameter-reference

Example of applying DescriptionAttribute to a command option property to set its help text.

```csharp
[Description("The output file path")]
[CommandOption("-o|--output")]
public string? Output { get; set; }
```

--------------------------------

### Install Spectre.Console.Cli.Testing package

Source: https://spectreconsole.net/cli/how-to/testing-command-line-applications

Install the Spectre.Console.Cli.Testing package to use CommandAppTester for testing CLI applications.

```bash
dotnet add package Spectre.Console.Cli.Testing
```

--------------------------------

### Async Live Display with StartAsync()

Source: https://spectreconsole.net/console/live/live-display

Uses StartAsync() for asynchronous work within the live display context. The example creates a table with operation and status columns, then iterates through a list of operations, updating the status row to 'Complete' after a delay. Requires an async context and uses Task.Delay to simulate work.

```csharp
var status = new Table()
    .AddColumn("Operation")
    .AddColumn("Status");
  
await AnsiConsole.Live(status)
    .StartAsync(async ctx =>
    {
        var operations = new[]
        {
            "Fetching data",
            "Processing records",
            "Updating database",
            "Generating report",
            "Sending notifications"
        };
  
        foreach (var operation in operations)
        {
            status.AddRow(operation, "[yellow]In Progress[/]");
            ctx.Refresh();
  
            await Task.Delay(1000);
  
            status.Rows.Update(status.Rows.Count - 1, 1, new Text("[green]Complete[/]"));
            ctx.Refresh();
        }
    });
```

--------------------------------

### Install Spectre.Console.ImageSharp package

Source: https://spectreconsole.net/console/widgets/canvas-image

Install the Spectre.Console.ImageSharp package, which is required for CanvasImage and is not included in the default Spectre.Console package.

```bash
dotnet add package Spectre.Console.ImageSharp
```

--------------------------------

### TypeConverterAttribute example

Source: https://spectreconsole.net/cli/reference/attribute-and-parameter-reference

Example of applying TypeConverterAttribute to an enum type definition. See Type Converters for implementation details.

```csharp
[TypeConverter(typeof(LogLevelConverter))]
public enum LogLevel { Debug, Info, Warning, Error }
```

--------------------------------

### Complete build output display

Source: https://spectreconsole.net/console/tutorials/getting-started-building-rich-console-app

Combines all previous examples into a complete build-output display with success, warning, error, and documentation link lines.

```csharp
var fileName = "Authentication.cs";
var dependency = "Newtonsoft.Json";
  
AnsiConsole.MarkupLine("[green]✓ Build completed successfully[/]");
AnsiConsole.MarkupLineInterpolated($"[#FFA500]⚠[/] [yellow]3 warnings[/] in {fileName}");
AnsiConsole.MarkupLineInterpolated($"[bold red]✗ Error:[/] Missing dependency '{dependency}'");
AnsiConsole.MarkupLine("  → See: [link=https://docs.example.com/dependencies]documentation[/]");
```

--------------------------------

### StartAsync(Func<LiveDisplayContext, Task> func)

Source: https://spectreconsole.net/console/live/live-display

Starts the live display asynchronously with an async action.

```APIDOC
## LiveDisplay.StartAsync(Func<LiveDisplayContext, Task> func)

### Description
Starts the live display.

### Method
StartAsync

### Parameters
- `func` (Func<LiveDisplayContext, Task>) - Required - The action to execute.

### Returns
- The result.

```

--------------------------------

### TreeGuide.DoubleLine output example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Example output of a tree using the TreeGuide.DoubleLine style, which uses double-line Unicode box-drawing characters.

```text
Root
╠══ Child 1
║   ╠══ Grandchild 1.1
║   ╚══ Grandchild 1.2
╚══ Child 2
    ╠══ Grandchild 2.1
    ╚══ Grandchild 2.2
```

--------------------------------

### Configure DI container and pass registrar to CommandApp

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Sets up the ServiceCollection, registers the greeting service, creates a TypeRegistrar, and runs the app with CommandApp.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Spectre.Console.Cli;
  
var services = new ServiceCollection();
services.AddSingleton<IGreetingService, GreetingService>();
  
var registrar = new TypeRegistrar(services);
var app = new CommandApp<GreetCommand>(registrar);
return app.Run(args);
```

--------------------------------

### Complete Custom Object Example with MultiSelectionPrompt<CloudService>

Source: https://spectreconsole.net/console/prompts/multi-selection-prompt

Complete example using a custom CloudService record type with display conversion, pre-selection via Select(), and Required() to enforce at least one selection. After the prompt, the selected services are processed to display details and compute estimated hourly and monthly costs.

```csharp
var services = new[]
{
    new CloudService("compute", "EC2 Instances", 0.10m),
    new CloudService("storage", "S3 Storage", 0.023m),
    new CloudService("database", "RDS Database", 0.17m),
    new CloudService("cache", "ElastiCache", 0.05m),
    new CloudService("cdn", "CloudFront CDN", 0.085m),
    new CloudService("lambda", "Lambda Functions", 0.0000002m)
};
  
var selected = AnsiConsole.Prompt(
    new MultiSelectionPrompt<CloudService>()
        .Title("Select [green]cloud services[/] to provision:")
        .UseConverter(service => $"{service.Name} (${service.HourlyRate:F3}/hr)")
        .Required()
        .AddChoices(services)
        .Select(services[0])); // Pre-select EC2
  
AnsiConsole.WriteLine();
AnsiConsole.Write(new Rule("[yellow]Selected Services[/]"));
  
var totalCost = 0m;
foreach (var service in selected)
{
    AnsiConsole.MarkupLine($"[blue]{service.Name}[/] ({service.Id})");
    AnsiConsole.MarkupLine($"  Rate: [green]${service.HourlyRate:F4}/hour[/]");
    totalCost += service.HourlyRate;
}
  
AnsiConsole.WriteLine();
AnsiConsole.MarkupLine($"[bold]Estimated hourly cost: [green]${totalCost:F4}[/][/]");
AnsiConsole.MarkupLine($"[dim]Monthly estimate (730 hours): ${totalCost * 730:F2}[/]");
```

--------------------------------

### TreeGuide.BoldLine output example

Source: https://spectreconsole.net/console/reference/tree-guide-reference

Example output of a tree using the TreeGuide.BoldLine style, which uses bold Unicode box-drawing characters.

```text
Root
┣━━ Child 1
┃   ┣━━ Grandchild 1.1
┃   ┗━━ Grandchild 1.2
┗━━ Child 2
    ┣━━ Grandchild 2.1
    ┗━━ Grandchild 2.2
```

--------------------------------

### DefaultValueAttribute example

Source: https://spectreconsole.net/cli/reference/attribute-and-parameter-reference

Example of applying DefaultValueAttribute to command options. Default values appear in help output when ShowOptionDefaultValues is enabled in settings.

```csharp
[DefaultValue(10)]
[CommandOption("-c|--count")]
public int Count { get; set; }
  
[DefaultValue("output.txt")]
[CommandOption("-o|--output")]
public string Output { get; set; }
```

--------------------------------

### Run the application

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Runs the application with a file path and shows the expected output.

```bash
dotnet run -- myfile.txt
# Starting to process: myfile.txt
# Processing step 1...
# Processing step 2...
# Processing step 3...
# Processing complete!
```

--------------------------------

### Remaining.Parsed Example Command

Source: https://spectreconsole.net/cli/reference/command-context

Example command line showing an undefined option. The Remaining.Parsed property would contain the key-value pair for 'unknown-option'.

```text
myapp --known-option value --unknown-option foo
```

--------------------------------

### Version command output

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

Example output from the version command, displaying library versions.

```text
Spectre.Console.Cli version 1.0.0
Spectre.Console version 1.0.0
```

--------------------------------

### Run with different log levels

Source: https://spectreconsole.net/cli/tutorials/logging-in-cli-apps

Shows example command-line invocations and their expected log output for different --logLevel values.

```bash
dotnet run -- myfile.txt
# info: Processing step 1...
  
dotnet run -- myfile.txt --logLevel Debug
# dbug: Detailed step 1 information
# info: Processing step 1...
  
dotnet run -- myfile.txt --logLevel Warning
# warn: This is a warning message
```

--------------------------------

### Register keyed services and run the app

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Registers keyed singleton greeting services for each style and the scoped factory, then creates the CommandApp with a TypeRegistrar and runs it.

```csharp
using Microsoft.Extensions.DependencyInjection;
using Spectre.Console.Cli;
  
var services = new ServiceCollection();
  
// Register keyed greeting services - each style gets its own implementation
services.AddKeyedSingleton<IGreetingService, CasualGreetingService>(GreetingStyle.Casual);
services.AddKeyedSingleton<IGreetingService, FormalGreetingService>(GreetingStyle.Formal);
services.AddKeyedSingleton<IGreetingService, EnthusiasticGreetingService>(GreetingStyle.Enthusiastic);
  
// Register the factory that resolves the appropriate service based on settings
services.AddScoped<IGreetingFactory, GreetingFactory>();
  
var registrar = new TypeRegistrar(services);
var app = new CommandApp<GreetCommand>(registrar);
return app.Run(args);
```

--------------------------------

### Get a Result with a Spinner

Source: https://spectreconsole.net/console/how-to/running-tasks-with-async-spinner

Gets a result from an async operation while showing a spinner. Call `.Spinner()` on a `Task<T>` to await the result and display the spinner animation.

```csharp
var result = await FetchDataAsync().Spinner(Spinner.Known.Star);
AnsiConsole.MarkupLine($"[green]Got result: {result}[/]");
```

--------------------------------

### Show built-in help

Source: https://spectreconsole.net/cli/tutorials/quick-start-your-first-cli-app

Displays the automatically generated help for the application. The help shows usage, the required <name> argument, and the optional --count flag with its description.

```bash
dotnet run -- --help
```

--------------------------------

### XmlDoc command output format

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

Example XML output from the xmldoc command, showing the structure with command metadata, parameters, and examples. Hidden commands are excluded.

```xml
<?xml version="1.0" encoding="utf-8"?>
<Model>
  <Command Name="add" ClrType="AddCommand" Settings="AddSettings">
    <Description>Add a new item</Description>
    <Parameters>
      <Argument Name="name" Position="0" Required="true" Kind="Scalar" />
      <Option Short="v" Long="verbose" Required="false" Kind="Flag" />
    </Parameters>
    <Examples>
      <Example>add item --verbose</Example>
    </Examples>
  </Command>
</Model>
```

--------------------------------

### Displaying a Configuration File with JsonText in a Panel

Source: https://spectreconsole.net/console/widgets/json

Displays a configuration file with colors for structure and wraps it in a panel with a green header. The example sets MemberColor to yellow, StringColor to white, NumberColor to aqua, and BooleanColor to lime, then writes the panel.

```csharp
var json = """
{
    "database": {
        "host": "localhost",
        "port": 5432,
        "name": "myapp_db",
        "ssl": true
    },
    "cache": {
        "enabled": true,
        "ttl": 3600,
        "provider": "redis"
    },
    "logging": {
        "level": "info",
        "output": "console"
    }
}
""";
  
var jsonText = new JsonText(json)
    .MemberColor(Color.Yellow)
    .StringColor(Color.White)
    .NumberColor(Color.Aqua)
    .BooleanColor(Color.Lime);
  
var panel = new Panel(jsonText)
    .Header("[green]app.config.json[/]")
    .BorderColor(Color.Green);
  
AnsiConsole.Write(panel);
```

--------------------------------

### Return a value from progress with Start()

Source: https://spectreconsole.net/console/live/progress

Shows how to return a value from a progress operation. The Start() callback increments a task and returns a count, which is then used after completion to display the result.

```csharp
var result = AnsiConsole.Progress()
    .Start(ctx =>
    {
        var task = ctx.AddTask("Processing items", maxValue: 100);
        int processedCount = 0;
  
        while (!ctx.IsFinished)
        {
            task.Increment(1);
            processedCount++;
            Thread.Sleep(20);
        }
  
        return processedCount;
    });
  
AnsiConsole.MarkupLine($"[green]Processed {result} items[/]");
```

--------------------------------

### Run hierarchical commands and show help

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Shows the expected output when running the 'add package', 'add reference', and 'add --help' commands. The help command lists 'package' and 'reference' as subcommands.

```bash
dotnet run -- add package Newtonsoft.Json
# Added package Newtonsoft.Json
  
dotnet run -- add reference ../MyLib/MyLib.csproj
# Added reference to ../MyLib/MyLib.csproj
  
dotnet run -- add --help
# Shows 'package' and 'reference' as subcommands
```

--------------------------------

### CommandSettings base class example with Validate()

Source: https://spectreconsole.net/cli/reference/attribute-and-parameter-reference

Example of a settings class inheriting from CommandSettings and overriding the Validate() method to add custom validation. The method returns ValidationResult.Error or ValidationResult.Success.

```csharp
public class MySettings : CommandSettings
{
    [CommandArgument(0, "<path>")]
    public string Path { get; set; }
  
    public override ValidationResult Validate()
    {
        if (!File.Exists(Path))
            return ValidationResult.Error("File not found");
        return ValidationResult.Success();
    }
}
```

--------------------------------

### Proportional sizing with Ratio()

Source: https://spectreconsole.net/console/widgets/layout

Distributes space proportionally using Ratio(): left and right get 1/4 each, center gets 2/4 (half). Use this when sections should scale relative to each other.

```csharp
var layout = new Layout("Root")
    .SplitColumns(
        new Layout("Left").Ratio(1),
        new Layout("Center").Ratio(2),
        new Layout("Right").Ratio(1));
  
layout["Left"].Update(new Panel("1/4 width").BorderColor(Color.Blue));
layout["Center"].Update(new Panel("2/4 width (half)").BorderColor(Color.Green));
layout["Right"].Update(new Panel("1/4 width").BorderColor(Color.Yellow));
  
AnsiConsole.Write(layout);
```

--------------------------------

### Create a new console project

Source: https://spectreconsole.net/console/tutorials/getting-started-building-rich-console-app

Creates a new console application named MySpectreApp and navigates into its directory.

```bash
dotnet new console -n MySpectreApp
cd MySpectreApp
```

--------------------------------

### Run the app with dotnet run

Source: https://spectreconsole.net/cli/tutorials/dependency-injection-in-cli-apps

Runs the application with the argument 'Alice' and shows the expected output.

```bash
dotnet run -- Alice
# Hello, Alice!
```

--------------------------------

### Register commands with metadata and show help output

Source: https://spectreconsole.net/cli/how-to/configuring-commandapp-and-commands

Registers commands with descriptions, aliases, and examples using AddCommand<T> and chained methods. The output shows the resulting help text with aliases in parentheses.

```csharp
var app = new CommandApp();
  
app.Configure(config =>
{
    // Set application identity for help output
    config.SetApplicationName("myapp");
    config.SetApplicationVersion("1.0.0");
  
    // Add commands with descriptions, aliases, and examples
    config.AddCommand<AddCommand>("add")
        .WithDescription("Add a new item")
        .WithAlias("a")
        .WithExample("add", "todo.txt")
        .WithExample("add", "notes.md", "--force");
  
    config.AddCommand<RemoveCommand>("remove")
        .WithDescription("Remove an item")
        .WithAlias("rm")
        .WithAlias("delete")
        .WithExample("remove", "old-file.txt");
  
    config.AddCommand<ListCommand>("list")
        .WithDescription("List all items")
        .WithAlias("ls");
  
#if DEBUG
    // Development-only settings
    config.PropagateExceptions();
    config.ValidateExamples();
#endif
});
  
return await app.RunAsync(args);
```

```text
USAGE:
    myapp [COMMAND] [OPTIONS]
  
COMMANDS:
    add (a)              Add a new item
    remove (rm, delete)  Remove an item
    list (ls)            List all items
```

--------------------------------

### IHasCulture.Culture

Source: https://spectreconsole.net/console/reference/api/Spectre.Console.IHasCulture

Gets or sets the culture.

```APIDOC
## IHasCulture.Culture

### Description
Gets or sets the culture.

### Property
`Culture` : CultureInfo

### Remarks
This property is part of the IHasCulture interface.
```

--------------------------------

### Run add and list commands with output

Source: https://spectreconsole.net/cli/tutorials/building-a-multi-command-cli-tool

Shows the expected output when running the add and list commands. The add command prints the added package name; the list command prints a placeholder list.

```bash
dotnet run -- add Newtonsoft.Json
# Added package Newtonsoft.Json
  
dotnet run -- list
# Packages:
#   (none yet)
```

--------------------------------

### Padding Example

Source: https://spectreconsole.net/console/widgets/panel

Shows two panels with different padding: minimal (0,0) and spacious (4,2). Both are written to the console to demonstrate the effect.

```csharp
var minimal = new Panel("Minimal padding")
    .Padding(0, 0);
  
var spacious = new Panel("Extra padding")
    .Padding(4, 2);
  
AnsiConsole.Write(minimal);
AnsiConsole.Write(spacious);
```

--------------------------------

### Basic live display with AnsiConsole.Live

Source: https://spectreconsole.net/console/live/live-display

Creates a live display with a Table and updates it inside the Start context. Call ctx.Refresh() after each modification to push changes to the console.

```csharp
var table = new Table();
table.AddColumn("Status");
table.AddRow("Starting...");
  
AnsiConsole.Live(table)
    .Start(ctx =>
    {
        Thread.Sleep(1000);
        table.AddRow("Processing...");
        ctx.Refresh();
  
        Thread.Sleep(1000);
        table.AddRow("Complete!");
        ctx.Refresh();
  
        Thread.Sleep(1000);
    });
```

--------------------------------

### Explain command access

Source: https://spectreconsole.net/cli/reference/built-in-command-behaviors

Shows how to invoke the explain command with an optional command path.

```text
myapp cli explain
myapp cli explain <command>
```
Tokens:
Raw