If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/YSGStudyHards/DotNetGuide shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Single-maintainer risk — review before adopting

• Last commit 4d ago
• 3 active contributors
• MIT licensed
• ⚠ Small team — 3 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 98% of recent commits
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live YSGStudyHards/DotNetGuide repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/YSGStudyHards/DotNetGuide.

What it runs against: a local clone of YSGStudyHards/DotNetGuide — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in YSGStudyHards/DotNetGuide | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 34 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of YSGStudyHards/DotNetGuide. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/YSGStudyHards/DotNetGuide.git
#   cd DotNetGuide
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of YSGStudyHards/DotNetGuide and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "YSGStudyHards/DotNetGuide(\\.git)?\\b" \\
  && ok "origin remote is YSGStudyHards/DotNetGuide" \\
  || miss "origin remote is not YSGStudyHards/DotNetGuide (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify main >/dev/null 2>&1 \\
  && ok "default branch main exists" \\
  || miss "default branch main no longer exists"

# 4. Critical files exist
test -f "DotNetGuidePractice/HelloDotNetGuide/Program.cs" \\
  && ok "DotNetGuidePractice/HelloDotNetGuide/Program.cs" \\
  || miss "missing critical file: DotNetGuidePractice/HelloDotNetGuide/Program.cs"
test -f "DotNetGuidePractice/HelloDotNetGuide/HelloDotNetGuide.csproj" \\
  && ok "DotNetGuidePractice/HelloDotNetGuide/HelloDotNetGuide.csproj" \\
  || miss "missing critical file: DotNetGuidePractice/HelloDotNetGuide/HelloDotNetGuide.csproj"
test -f "README.md" \\
  && ok "README.md" \\
  || miss "missing critical file: README.md"
test -f "docs/DotNet/DotNetStudy.md" \\
  && ok "docs/DotNet/DotNetStudy.md" \\
  || miss "missing critical file: docs/DotNet/DotNetStudy.md"
test -f "DotNetGuidePractice/HelloDotNetGuide/CSharp语法/LinqExercise.cs" \\
  && ok "DotNetGuidePractice/HelloDotNetGuide/CSharp语法/LinqExercise.cs" \\
  || miss "missing critical file: DotNetGuidePractice/HelloDotNetGuide/CSharp语法/LinqExercise.cs"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 34 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~4d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/YSGStudyHards/DotNetGuide"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

DotNetGuide is a comprehensive, open-source knowledge repository for C#/.NET/.NET Core learning, job preparation, and interview readiness. It aggregates curated learning resources, practical coding examples (stored in DotNetGuidePractice/HelloDotNetGuide/), design patterns, algorithms, async/multithreading examples, and interview question collections into a single searchable reference. Single-directory structure: DotNetGuidePractice/ contains a .NET solution with HelloDotNetGuide project organized by topic (CSharp语法/, 常见算法/, 异步多线程编程/, 正则表达式/, 设计模式/). Each folder groups related .cs files demonstrating specific concepts. assets/ holds roadmaps and diagrams; root README.md is the navigation hub.

C#/.NET developers at all levels—beginners seeking a structured learning path, mid-career developers preparing for interviews, and experienced engineers looking for consolidated best practices. Contributors are community members sharing articles, project frameworks, and hiring opportunities.

Actively maintained with 114K+ lines of C# code demonstrating real use cases (sorting algorithms, LINQ, async patterns, etc.). The repo shows consistent README updates and community engagement through Issues/PRs. Production-ready as a reference guide; the practice code examples are well-organized but appear educational rather than a production library.

Low technical risk: this is a knowledge/documentation repo, not a dependency library, so breaking changes don't affect consumers. Single-maintainer (YSGStudyHards) is a consideration for sustained content updates. No CI/automated testing visible (expected for a docs repo). Primary risk is content staleness—C# 13 support is present, but async/threading examples should be verified against latest .NET versions.

Visible focus on C# 12/13 grammar exercises (CSharp12GrammarExercise.cs, CSharp13GrammarExercise.cs added recently), algorithm implementations (15+ sorting/searching algorithms), and async/await patterns (AsyncProgrammingExample.cs, TaskWhenAllAndTaskWhenAnyExample.cs). Community engagement through Issues marked as 'treasure collection' suggests ongoing resource curation.

Clone: git clone https://github.com/YSGStudyHards/DotNetGuide.git. Open DotNetGuidePractice/DotNetGuidePractice.sln in Visual Studio or dotnet build from command line. Browse HelloDotNetGuide folder for code examples or README.md for learning path guidance.

Daily commands: dotnet build DotNetGuidePractice/DotNetGuidePractice.sln to compile. Individual .cs files in HelloDotNetGuide are examples—add using statements and call methods from Program.cs or create a test project. No built-in dev server; this is reference code.

• DotNetGuidePractice/HelloDotNetGuide/Program.cs — Entry point for the entire practice project; must understand the project initialization and execution flow
• DotNetGuidePractice/HelloDotNetGuide/HelloDotNetGuide.csproj — Project configuration file defining all dependencies, build settings, and target framework for the practice codebase
• README.md — High-level overview of the DotNetGuide knowledge base mission, structure, and community; essential for understanding the repo's purpose and contribution guidelines
• docs/DotNet/DotNetStudy.md — Core learning path documentation that outlines the systematic progression through C#/.NET/.NET Core topics
• DotNetGuidePractice/HelloDotNetGuide/CSharp语法/LinqExercise.cs — Demonstrates LINQ patterns used throughout the codebase; critical for understanding functional programming approach in practice files

• Program.cs (C# Main method, Console.WriteLine) — Entry point that calls exercise methods sequentially; orchestrates the demo flow
  • Failure mode: If Program.cs throws an unhandled exception, the entire demo terminates and stack trace is printed
• CSharp语法 exercises (C#) — Isolated demonstrations of language features (LINQ, async, extension methods, yield, locks); each is self-contained

Add a New C# Syntax Exercise Topic

1. Create a new .cs file in DotNetGuidePractice/HelloDotNetGuide/CSharp语法/ following naming convention TopicNameExercise.cs (DotNetGuidePractice/HelloDotNetGuide/CSharp语法/)
2. Define public class with descriptive method examples demonstrating the feature; reference existing files like LinqExercise.cs for comment/documentation patterns (DotNetGuidePractice/HelloDotNetGuide/CSharp语法/LinqExercise.cs)
3. Add example method calls to Program.cs to execute and validate the new exercise (DotNetGuidePractice/HelloDotNetGuide/Program.cs)

Add a New Algorithm Implementation

1. Create a new .cs file in DotNetGuidePractice/HelloDotNetGuide/常见算法/ named after the algorithm (e.g., 归并排序算法.cs) (DotNetGuidePractice/HelloDotNetGuide/常见算法/)
2. Implement the algorithm class with detailed comments explaining time/space complexity; follow the structure of existing files like 快速排序算法.cs (DotNetGuidePractice/HelloDotNetGuide/常见算法/快速排序算法.cs)
3. Create test/demo method and call it from Program.cs to verify correctness (DotNetGuidePractice/HelloDotNetGuide/Program.cs)
4. Add interview question and solution explanation to docs/算法/C#经典算法面试题.md for interview prep coverage (docs/算法/C#经典算法面试题.md)

Add a New Study Guide Documentation

1. Create a new markdown file in docs/DotNet/ (e.g., TopicGuide.md) following the structure of DotNetStudy.md (docs/DotNet/DotNetStudy.md)
2. Include sections: Learning Objectives, Prerequisites, Core Concepts, Best Practices, Code Examples, Interview Questions, Recommended Resources (docs/DotNet/)
3. Link the new guide from README.md's documentation index section (README.md)

• .NET 6+ / .NET Core — Modern cross-platform runtime with LTS support, async/await first-class support, and strong performance for educational purposes
• C# 12–13 language features — Latest syntax innovations (records, nullable reference types, pattern matching, LINQ) demonstrate current best practices and modern idioms
• Markdown for documentation — GitHub-native format ensures easy discoverability, version control, and community contribution via pull requests
• Task Parallel Library (TPL) — Unified async/await and Parallel.For abstractions enable teaching both concurrency models without separate APIs

• Knowledge base split between practice code (C# projects) and documentation (Markdown)

  • Why: Allows both executable examples (runs immediately) and prose explanations (discoverable in GitHub UI and search engines)
  • Consequence: Information may be scattered; developers must check both /docs and /DotNetGuidePractice for complete coverage of a topic

• Single comprehensive csproj vs. domain-specific projects

  • Why: Simpler setup for learners; avoids project reference complexity and configuration overhead for beginners
  • Consequence: Large HelloDotNetGuide.csproj grows over time; refactoring into multiple projects would improve code organization but add friction for contributions

• Chinese-language file and folder names (e.g., CSharp语法, 常见算法)

  • Why: Targets Chinese-speaking developers directly; reduces cognitive load for the primary audience
  • Consequence: Reduces discoverability for English-speaking contributors and some developer tools may have issues with Unicode paths

• Does not provide a production web framework or ASP.NET Core example project—focus is educational syntax and algorithms
• Does not include unit testing infrastructure; exercises are run ad-hoc from Program.cs rather than via test runners
• Does not host a live learning platform or interactive IDE; all code must be cloned and run locally
• Does not provide job placement or recruitment beyond sharing industry news and resume templates in docs
• Does not maintain a comprehensive API reference—defers to official Microsoft Docs for detailed API signatures

No hidden traps identified. This is a reference/documentation repo without runtime dependencies or external service requirements. File paths use Chinese characters (CSharp语法/, 常见算法/)—ensure terminal/IDE supports UTF-8. No .env or appsettings.json required to explore examples.

• Yield Return / Yield Break — C#-specific iterator pattern reducing memory overhead—high-frequency interview topic and seen in YieldExercise.cs; critical for LINQ and lazy evaluation understanding.
• Extension Methods — Enables LINQ and fluent APIs in C#; ExtensionMethodExercise.cs demonstrates syntax; essential for understanding modern .NET codebases.
• Task-based Asynchronous Pattern (TAP) & ConfigureAwait — Core .NET concurrency model (async/await); AsyncProgrammingExample.cs and TaskWhenAllAndTaskWhenAnyExample.cs explore this—vital for scalable API design and avoiding deadlocks.
• Const vs Readonly — Subtle but critical distinction in C# (compile-time vs runtime initialization); ConstAndReadonlyExercise.cs covers this—common interview gotcha.
• Binary Search Tree (BST) & Binary Search Algorithm — Foundation for data structure interviews (二叉搜索树算法.cs, 二分查找算法.cs); O(log n) time complexity patterns essential for optimizing large-scale .NET applications.
• Lock & Synchronization Primitives — Thread safety in C# multithreading (LockExercise.cs); critical for concurrent applications and interview discussions on race conditions.
• Regex Anchors & Quantifiers — Pattern matching in .NET (RegularExpressions.cs); common in data validation and parsing tasks across web and enterprise applications.

• dotnet/csharplang — Official C# language design repo; reference for C# 12/13 grammar changes demonstrated in CSharp12GrammarExercise.cs and CSharp13GrammarExercise.cs.
• dotnet/runtime — Core .NET runtime source; needed to understand async/await and threading internals (Task, async state machines) covered in HelloDotNetGuide/异步多线程编程/.
• coding-interviews/lintcode — Algorithm problem collection complementing the 常见算法/ folder; aligns with interview prep goal.
• QuantumLeap-ai/DotNetGuide-Agent — Companion AI agent (mentioned in README as 🤖强大的.NET AI智能体); extends learning via conversational guidance.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive unit tests for algorithm implementations in 常见算法 folder

The repo contains 15+ algorithm implementation files (sorting, searching, binary tree, recursion, etc.) but no corresponding unit test files. Adding xUnit or NUnit tests would validate correctness, provide usage examples for learners, and ensure implementations don't regress. This is critical for an educational repo where correctness is paramount.

• [ ] Create DotNetGuidePractice/HelloDotNetGuide/常见算法.Tests/ directory with test project
• [ ] Add unit tests for each algorithm file: 冒泡排序算法.cs, 快速排序算法.cs, 二分查找算法.cs, 递归算法.cs, etc.
• [ ] Test edge cases (empty arrays, single elements, duplicates, large datasets)
• [ ] Update DotNetGuidePractice.sln to include the new test project
• [ ] Add test execution documentation to README.md

Create practical example exercises with expected outputs for CSharp语法 folder

The CSharp syntax exercise files (ExtensionMethodExercise.cs, LinqExercise.cs, YieldExercise.cs, etc.) exist but appear to lack integrated Main() methods, test cases, or expected output documentation. Learners need to understand what correct behavior looks like. Adding runnable examples with inline comments showing expected output would make these significantly more valuable for self-study.

• [ ] Review each file in CSharp语法/ folder: ExtensionMethodExercise.cs, LinqExercise.cs, YieldExercise.cs, LockExercise.cs
• [ ] Add complete Main() methods or example usage sections with Console.WriteLine() demonstrating expected behavior
• [ ] Add XML documentation comments (///) explaining what each exercise demonstrates
• [ ] Create a CSharp语法/README.md with expected output for each exercise file
• [ ] Ensure files compile without errors and run successfully

Add GitHub Actions CI workflow to validate C# code compilation and test execution

The repo contains a .NET solution (DotNetGuidePractice.sln) but no CI/CD pipeline. This means breaking changes could be merged undetected. A GitHub Actions workflow would automatically build the solution, run tests, and catch compilation errors—essential for maintaining quality in an educational reference repo that developers copy code from.

• [ ] Create .github/workflows/dotnet-build-test.yml with .NET Core build and test steps
• [ ] Configure workflow to trigger on push to main/master and on pull requests
• [ ] Add steps to: restore NuGet packages, build DotNetGuidePractice.sln, run unit tests (once added per PR #1)
• [ ] Add build status badge to README.md
• [ ] Document workflow in CONTRIBUTING.md if it exists, or create one

• Add missing sorting algorithms: Implement CombSort and TimSort algorithms following the pattern in 快速排序算法.cs; only insertion sort, bubble sort, etc. are present.
• Expand 设计模式/ with concrete examples: Only 单例模式.cs exists—add Factory, Observer, Strategy, and Adapter patterns with real-world C# scenarios (e.g., Factory for dependency injection).
• Document async pitfalls in 异步多线程编程/: Add a new file (e.g., AsyncPitfallsAndBestPractices.cs) covering deadlocks, Task.Result blocking, ConfigureAwait(false), and cancellation tokens—critical interview knowledge gaps.

This repository is primarily an educational C#/.NET guide with code examples and documentation. No critical or high-severity vulnerabilities were identified from the file structure alone. However, the lack of visible dependency manifest files and security configuration prevents comprehensive assessment. The main security concerns are typical of example/tutorial code: potential unsafe patterns in threading/regex examples and file I/O operations that could be unsafe if copied without understanding context. The codebase appears to be a knowledge repository rather than production code, which mitigates risk. Recommendations include: (1) provide full dependency files for vulnerability scanning, (2) add security annotations to example code, (3) review all example patterns for common pitfalls, and (4) implement automated security scanning in any CI/CD pipeline before republishing.

• Low · Missing dependency information — DotNetGuidePractice/HelloDotNetGuide/HelloDotNetGuide.csproj. The project file structure indicates a .NET/C# project (HelloDotNetGuide.csproj) but no package dependency file content was provided for analysis. This prevents verification of known vulnerable NuGet packages or outdated dependencies. Fix: Provide the .csproj file content and run 'dotnet list package --vulnerable' to identify vulnerable dependencies. Implement automated dependency scanning in CI/CD pipeline using tools like OWASP Dependency-Check or Snyk.
• Low · Potential unsafe threading practices in LockExercise — DotNetGuidePractice/HelloDotNetGuide/CSharp语法/LockExercise.cs. The file 'LockExercise.cs' suggests example code for lock/synchronization patterns. Example code without proper context could teach unsafe threading practices if not carefully documented. Fix: Ensure all threading examples include comprehensive documentation about proper lock usage, deadlock prevention, and best practices. Consider adding code comments explaining potential pitfalls.
• Low · Regex security patterns not verified — DotNetGuidePractice/HelloDotNetGuide/正则表达式/RegularExpressions.cs. The file 'RegularExpressions.cs' contains regex examples. Without code review, it's unclear if ReDoS (Regular Expression Denial of Service) vulnerable patterns are present. Fix: Review all regex patterns for ReDoS vulnerabilities. Implement regex timeout limits using TimeSpan parameters in Regex constructor. Validate user-supplied regex patterns before execution.
• Low · File I/O operations security — DotNetGuidePractice/HelloDotNetGuide/异步多线程编程/ReadFileAsyncExample.cs. The file 'ReadFileAsyncExample.cs' indicates file I/O operations. If file paths are user-controlled, path traversal vulnerabilities could exist. Fix: Validate and sanitize all file paths. Use Path.GetFullPath() and verify the resolved path is within allowed directories. Implement allowlist-based file access controls.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.