Skip to content
cccskills
FreePublished on GitHub

dotnet-enumerable

Write and optimize C#/.NET enumerables, iterators, and LINQ usage. USE FOR: choosing IEnumerable<T>/IReadOnlyCollection<T>/IReadOnlyList<T>/ICollection<T>/IList<T>/IAsyncEnumerable<T> for params/returns; foreach codegen and value-type vs reference-type enumerator performance (List<T>, arrays, Span<T>, ImmutableArray<T>, ArraySegment<T>); avoiding boxed enumerator allocations; Count() vs Any() vs Count property complexity traps; First()/Single()(OrDefault) cost and predicate-overload collapsing; ToList()/ToArray() allocation cost vs lazy evaluation; returning Enumerable.Empty<T>()/yield break instead of null; writing yield-based iterators, lazy validation, coroutines, behavior trees; writing async iterators with await foreach/yield return, EnumeratorCancellation/WithCancellation token propagation, ConfigureAwait; handling enumerables via reflection/Roslyn (NetFabric.Reflection/CodeAnalysis). DO NOT USE FOR: SIMD/vectorized span math (dotnet-simd); generic math over numeric types (dotnet-generic-math).

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36 stars(GitHub 36 + cccskills 0)

Run score Not tested

See how to install

Files included (7)

  • SKILL.md6.2 KB
  • references/async-enumeration.md3.6 KB
  • references/custom-iterators.md6.3 KB
  • references/enumerable-interfaces.md5.2 KB
  • references/iteration-performance.md7.5 KB
  • references/linq-patterns.md4.5 KB
  • references/tooling.md3.8 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

.NET Enumerables & Iteration Performance

Core namespaces: System.Collections.Generic (IEnumerable<T>, IReadOnlyList<T>, ...), System.Linq.

Interface Cheat Sheet

InterfaceAdds over parentCost profile
IEnumerable<T>GetEnumerator()sequential-only; Count() is O(n), Any() is O(1)
IReadOnlyCollection<T>CountO(1) count without enumerating
IReadOnlyList<T>this[int]random access; for + indexer avoids enumerator allocation
ICollection<T> / IList<T>mutation (Add, this[int] set, ...)backwards-compatible mutable counterparts, don't derive from the IReadOnly* pair
IAsyncEnumerable<T>GetAsyncEnumerator()async pull stream, use with await foreach

Expose the most-capable interface a return type can honestly provide; consume the least-capable interface an algorithm needs. Never return null for "empty" — use Enumerable.Empty<T>() or yield break. Details: references/enumerable-interfaces.md. Writing async iterators: references/custom-iterators.md. Consuming them — cancellation (WithCancellation/[EnumeratorCancellation]), ConfigureAwait: references/async-enumeration.md.

Performance Quick Rules

RuleWhy
Prefer Any() over Count() == 0Any() calls MoveNext() once — O(1); Count() enumerates fully unless the source implements ICollection
Don't cast arrays/List<T> to IEnumerable<T> in hot pathstheir value-type enumerators get boxed to reference types — heap allocation + virtual MoveNext()/Current calls
Reuse LINQ query variables instead of .ToList() mid-pipelinekeeps lazy evaluation; ToList()/ToArray() force an allocation + full copy
Use First(predicate) / Count(predicate) overloadsone enumerator instead of Where(predicate).First()
Avoid Single()/SingleOrDefault() in production hot pathsit enumerates to the end even on the first match, just to prove uniqueness
Use CollectionsMarshal.AsSpan(list) for hot-path List<T> iterationrandom-access span over the internal array, bypassing List<T>.Enumerator — matches array/Span<T> speed; never resize the list while the span is alive
Prefer foreach over for when iterating a field/property/method-returned array or spanforeach caches the reference into a local once, enabling reliable bounds-check elimination; for re-reads the field/property each iteration

Full benchmark data for arrays/Span<T>/List<T>/ImmutableArray<T>/ArraySegment<T>: references/iteration-performance.md. Count/Any/First/Single/ToList complexity: references/linq-patterns.md.

Quick Pattern: yield for Lazy Sequences

public static IEnumerable<int> Range(int start, int count)
{
    if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
    return GetEnumerable(start, count);   // validate eagerly, iterate lazily

    static IEnumerable<int> GetEnumerable(int start, int count)
    {
        var end = start + count;
        for (var value = start; value < end; value++)
            yield return value;
    }
}

Splitting eager validation from the yield-based local function avoids the surprise of an exception only surfacing on the first MoveNext() call. Details, yield break, and enumerable-vs-enumerator return choice: references/custom-iterators.md.

Reference Files

FileLoad When
references/enumerable-interfaces.mdChoosing which collection interface to expose/consume; IEnumerable/IEnumerator, IReadOnlyCollection<T>/IReadOnlyList<T>, ICollection<T>/IList<T>, IAsyncEnumerable<T> semantics
references/iteration-performance.mdforeach codegen, value-type vs reference-type enumerators, array/Span<T>/List<T>/ImmutableArray<T>/ArraySegment<T> iteration benchmarks, bounds-check elimination, CollectionsMarshal.AsSpan
references/linq-patterns.mdCount()/Any(), First()/Single()(OrDefault), ToList()/ToArray() cost, query composition & lazy evaluation, null vs Enumerable.Empty<T>(), IQueryable, why LINQ operators don't apply to IAsyncEnumerable<T>
references/custom-iterators.mdWriting yield-based iterators (sync and async), lazy-evaluation pitfalls, enumerable vs enumerator return types, coroutines, behavior trees
references/async-enumeration.mdConsuming IAsyncEnumerable<T> with await foreach, foreach vs await foreach diagnostics, cancellation ([EnumeratorCancellation], WithCancellation), ConfigureAwait on async streams, IAsyncEnumerable<T> vs Task<IReadOnlyList<T>>
references/tooling.mdDetecting/handling enumerables via reflection (NetFabric.Reflection) or Roslyn (NetFabric.CodeAnalysis), expression-tree foreach generation, testing enumerables

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

3d-rotation-theory

Free

Abstract math for 3D rotation representations and conversions. USE FOR: understanding axis-angle representation; Euler angles (yaw/pitch/roll, convention choices); rotation matrices (SO(3)); quaternion-based rotation; converting between representations; identifying and avoiding gimbal lock; composing rotations; half-angle formula; right-hand rule. DO NOT USE FOR: quaternion arithmetic details (use quaternion-algebra); slerp/lerp interpolation (use interpolation-on-manifolds); coordinate system definitions (use coordinate-system-conversions).

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36Updated Aug 10, 2026

agent-graph-orchestration

Free

Design and scaffold multi-agent squads/swarms using the graph orchestration pattern (nodes = agents, edges = dependencies/data flow). USE FOR: designing a coordination topology for a multi-agent squad (sequential pipeline, parallel fan-out/aggregation, branching, feedback loop, cyclic); building an orchestrator agent that delegates to specialist agents; setting up an adversarial/tribunal code or document review with independent reviewers; scaffolding a squad's agent files for a target coding-agent harness (e.g. Copilot CLI or Claude Code custom agents). DO NOT USE FOR: authoring a single agent's frontmatter/prompt body (use copilot-cli-custom-agents, claude-code-custom-agents, or the target harness's own skill); SKILL.md authoring (use create-skill); ad-hoc multi-agent chat with no explicit topology.

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36Updated Aug 10, 2026

agent-harness-logs

Free

Find, inspect, query, redact, and troubleshoot logs, transcripts, sessions, and OpenTelemetry data from coding-agent harnesses on Windows, macOS, Linux, and WSL. USE FOR: GitHub Copilot in VS Code; Copilot CLI; Claude Code; OpenAI Codex; Gemini CLI; OpenCode; Cursor, Windsurf, Kiro, or other VS Code-family editors; locating log files; diagnosing tool or model failures; correlating turns, subagents, and tool calls; querying JSONL, plaintext, or SQLite without spending model tokens; preparing sanitized diagnostics. DO NOT USE FOR: application logs unrelated to coding agents; uploading raw logs; treating unstable transcript schemas as public APIs.

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36Updated Aug 10, 2026

agents-md

Free

Author and maintain AGENTS.md files — the open, tool-agnostic format for giving coding agents project context. Use when: creating AGENTS.md; writing an agent instructions file; root or nested AGENTS.md for monorepos; migrating CLAUDE.md, AGENT.md, .cursor/rules, or copilot-instructions.md to AGENTS.md; greenfield project setup before code exists; brownfield onboarding for an existing codebase; documenting build/test/lint commands, code style, PR/commit conventions, and security considerations for agents; AGENTS.md discovery and precedence rules. Works for any language, framework, or project size. DO NOT USE FOR: authoring SKILL.md skill files (use create-skill); APM package/plugin authoring (use apm-producer); language-specific style rules (use language skills e.g. csharp-best-practices).

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36Updated Aug 10, 2026

angles-and-circular-arithmetic

Free

Abstract math for angle measurement, unit systems, and circular arithmetic. USE FOR: implementing angle types; converting between degrees/radians/gradians/revolutions; reducing angles to canonical range [0, Full); computing reference angles and quadrants; implementing safe modular arithmetic with negative inputs; angle addition and subtraction; classifying angles by sign and size. DO NOT USE FOR: trigonometric functions (use trigonometric-functions); coordinate conversions (use coordinate-system-conversions); interpolation (use interpolation-on-manifolds).

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36Updated Aug 10, 2026

claude-code-custom-agents

Free

Create and maintain Claude Code custom subagents (.claude/agents/*.md files). USE FOR: authoring project (.claude/agents/) or user (~/.claude/agents/) subagent files; frontmatter fields (name, description, tools, disallowedTools, model, permissionMode, maxTurns, skills, mcpServers, hooks, memory, background, effort, isolation, color, initialPrompt); writing descriptions that drive automatic delegation and 'use proactively' phrasing; invoking subagents via natural language, @-mention, session-wide --agent, or the Agent tool; restricting which subagent types a coordinator can spawn with Agent(name1, name2); nested subagents and depth limits; built-in subagents (Explore, Plan, general-purpose, claude); troubleshooting a subagent that won't load or isn't invoked. DO NOT USE FOR: GitHub Copilot CLI custom agents (use copilot-cli-custom-agents); agent teams/teammates (a different, session-spanning feature); MCP server authoring; SKILL.md authoring (use create-skill).

The English summary is being prepared. Showing the original description.

NetFabric/NetFabric.Numerics36Updated Aug 10, 2026

See all skills by NetFabric

Report a problem with this skill