# Sep

> Use Sep for high-performance separated-value parsing and writing in .NET, including delimiter inference, explicit parser/writer options, and low-allocation row/column workflows. USE FOR: delimited data needs are performance-sensitive and allocation-aware; project needs explicit control over separator inference, escaping, trimming, and header behavior;. DO NOT USE FOR: unrelated stacks; generic ta…

- **Type:** Skill
- **Install:** `agentstack add skill-managedcode-dotnet-skills-sep`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [managedcode](https://agentstack.voostack.com/s/managedcode)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [managedcode](https://github.com/managedcode)
- **Source:** https://github.com/managedcode/dotnet-skills/tree/main/catalog/Libraries/Sep/skills/sep
- **Website:** https://skills.managed-code.com

## Install

```sh
agentstack add skill-managedcode-dotnet-skills-sep
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Sep for .NET separated values

## Trigger On

- delimited data needs are performance-sensitive and allocation-aware
- project needs explicit control over separator inference, escaping, trimming, and header behavior
- reading/writing large or long-lived file pipelines in ML, ETL, or analytics workloads
- startup/perf tests require AOT/trimming-friendly CSV/TSV processing

## Install

- NuGet:
  - `dotnet add package Sep`
  - `dotnet add package Sep --version `
- XML package reference:
  - ``
- Verify baseline support by checking the package page:
  - [NuGet: Sep](https://www.nuget.org/packages/Sep/)
- Source:
  - [GitHub: nietras/Sep](https://github.com/nietras/Sep)

## Workflow

```mermaid
flowchart LR
  A[Input source: file/text/stream] --> B[Sep.Reader or Sep.New(...).Reader]
  B --> C[SepReaderOptions]
  C --> D[Rows -> Cols -> Span/Parse]
  D --> E[Transform and validate]
  E --> F[SepWriter via SepWriterOptions]
  F --> G[To file/text output]
```

1. Decide schema shape
   - header present or no header
   - separator known (`;`, `,`, tab, custom) or infer from first row
   - row/column quoting rules
2. Build reader with `Sep.Reader(...)` and explicit options only where needed:
   - `Sep.Reader()` for inferred separator from header-like first row
   - `Sep.New(',').Reader(...)` for explicit separator mode
   - `Sep.Reader(o => o with { HasHeader = false })` if header is absent
3. Read rows and map columns as `ReadOnlySpan` first, convert only when needed.
4. For output, use `reader.Spec.Writer()` when you need the same separator/culture as input.
5. Control writer behavior with `Sep.Writer(...)` and `SepWriterOptions` (`WriteHeader`, `Escape`, `DisableColCountCheck`).
6. Add async only where it brings value and your runtime is C# 13 / .NET 9+ for `await foreach` over async reader rows.
7. Use `ParallelEnumerate` for CPU-heavy transformations only after benchmarking single-threaded baseline.

### Install and read patterns

```csharp
using var reader = Sep.Reader(o => o with
{
    HasHeader = true,
    Unescape = true,
    Trim = SepTrim.Both
}).FromText(data);

foreach (var row in reader)
{
    var id = row["Id"].Parse();
    var name = row[1].ToString();
    // process row
}
```

### Write patterns

```csharp
using var reader = Sep.Reader().FromFile("input.csv");
using var writer = reader.Spec.Writer().ToFile("output.csv");

foreach (var row in reader)
{
    using var writeRow = writer.NewRow(row);
    writeRow["Amount"].Format(row["Amount"].Parse() * 1.2);
}
```

### Async reading and writing

```csharp
var text = "A;B\n1;hello\n";

using var reader = await Sep.Reader().FromTextAsync(text);
await using var writer = reader.Spec.Writer().ToText();

await foreach (var row in reader)
{
    await using var writeRow = writer.NewRow(row);
    var normalized = row["B"].ToString().ToUpperInvariant();
    writeRow["B"].Set(normalized);
}
```

### Common configuration patterns

- Header-driven read
  - default `HasHeader = true`
  - query by name: `row["ColName"]`
- Headerless pipelines
  - `HasHeader = false`
  - use index-based access: `row[0]`, `row[1]`
- Round-trip output
  - start writer with `reader.Spec.Writer()` to preserve inference and formatting contract
- Speed-first processing
  - keep default buffer + culture unless profiling proves a need to tune

## Best practices

- Parse to primitive types with `Parse` in hot paths to avoid extra allocations.
- Keep `ToString`/format conversions at the edge (presentational layers), not in inner loops.
- Prefer `Unescape`, `Trim`, and `DisableQuotesParsing` settings deliberately and test with realistic samples.
- For large transforms, isolate heavy CPU work after enumeration and then apply `ParallelEnumerate` where appropriate.

## Limitations to check before production

- `SepReader.Row` and `SepWriter.Row` are `ref struct`s:
  - avoid patterns that store rows beyond immediate scope
  - materialize if you truly need random async/LINQ-style buffering
- `SepReader` row iteration is row-by-row by design; it is intentionally not the same as a classic collection model.

## Deliver

- installation and usage guide that is ready to copy into a .NET repo
- practical reader/writer configuration patterns
- clear notes on defaults, tradeoffs, and constraints

## Validate

- `dotnet add package Sep` installs correctly and project compiles
- one file-read sample and one file-write sample execute successfully
- header/no-header and explicit-separator cases are covered
- at least one validation sample for quoting/unescaping or async path exists if required by task

## Load References

- [references/overview.md](references/overview.md) - official links and practical decision notes.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [managedcode](https://github.com/managedcode)
- **Source:** [managedcode/dotnet-skills](https://github.com/managedcode/dotnet-skills)
- **License:** MIT
- **Homepage:** https://skills.managed-code.com

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-managedcode-dotnet-skills-sep
- Seller: https://agentstack.voostack.com/s/managedcode
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.