Skip to content
CAI
Software that uses CAICheck a score

MarsonShine/Books

41.2

Weak · 8 November 2026

19.4k

lines of production code

C#

with C, C++, Java

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This repository is a comprehensive educational collection of code examples and documentation for systems programming and software engineering. It provides practical implementations across C++, C\#, Java, and TypeScript, covering topics such as language features, concurrency, design patterns, and performance optimization. The system also includes resources for distributed systems design, Kubernetes configurations, and low-level network programming.

How it got here

2018–2019 — multi-language concurrency and design pattern examples

34 changes.

This period focused on expanding a comprehensive collection of educational code samples across C\#, Java, and TypeScript, with a heavy emphasis on concurrency patterns, modern language features, and design patterns. The work involved creating detailed implementations for topics such as async/await, reactive extensions, thread safety, and various structural and behavioral design patterns. Additionally, the documentation site was migrated from Jekyll to MkDocs to improve navigation and deployment workflows.

2020–2021 — High-performance .NET and systems programming examples

40 changes.

This period focused on expanding a comprehensive collection of code samples demonstrating high-performance .NET techniques, including memory optimization, concurrency, and dynamic code generation. It also added educational materials for C\# 9.0 features, C++ fundamentals, and Go design patterns to support broader language learning.

2022–2023 — comprehensive programming examples

33 changes.

This period focused on populating the repository with extensive educational code examples across multiple languages and domains. It added C++ exercises covering core language features, object-oriented design, and memory management, alongside C\# demonstrations for functional programming, diagnostics, and .NET 8 capabilities. The work also expanded into systems programming with Unix and Linux networking examples, shell scripting, and Kubernetes configurations.

2024–2026 — Data structures and compiler front-end samples

11 changes.

This period focused on expanding the codebase with comprehensive sample implementations for functional data structures, including immutable stacks, deques, and graph algorithms. It also introduced a compiler front-end with lexer and parser components, alongside documentation enhancements for Rx.NET and C\# 14 features.

Features

Add C\# 9.0 record type usage examples

The documentation now includes a new code example demonstrating C\# 9.0 record features, specifically illustrating value-based equality, immutability, and the \with\ expression for creating modified copies of records.

docs · high confidence

Add C\# metrics demonstration code

The MetricDemo location now includes a set of C\# source files (Program.cs through Program5.cs) that serve as practical examples for using the System.Diagnostics.Metrics API. These demos illustrate how to create and record data using counters, histograms, and observable gauges, including scenarios with attributes and multiple measurement values.

CSharpGuide/diagnostics/MetricDemo · high confidence

Add DynamicLoadExtension project for IL generation performance testing

A new DynamicLoadExtension project has been added to the solution, containing the core Extension class, a Templates helper for IL generation scenarios, and a Program entry point. The Extension.DoWork method currently returns true with its actual computation logic commented out, allowing users to measure the overhead of function calls in performance benchmarks.

WHPerformanceDotNet/src/DynamicLoadExtension · high confidence

Add Rx and TPL Dataflow interoperation examples

The 07Interoperate cookbook now includes code samples demonstrating how to integrate Reactive Extensions (Rx) with .NET concurrency patterns. This includes wrapping asynchronous operations into Rx observables using methods like FromAsync and StartAsync, converting TPL Dataflow blocks (BufferBlock, ActionBlock) into observable streams, and bridging the two paradigms for combined reactive and dataflow processing.

ConcurrencyInCSharpCookbook/07Interoperate · high confidence

Add TPL Dataflow concurrency cookbook

Introduces a new example demonstrating TPL Dataflow patterns, including linking blocks, handling exceptions with PropagateCompletion, dynamically disconnecting links, limiting flow with BoundedCapacity, parallel processing via MaxDegreeOfParallelism, and creating custom encapsulated blocks.

ConcurrencyInCSharpCookbook/04DataFlow · high confidence

Add chapter 3 deque sample and update finger tree text

This change introduces a new sample implementation of a Deque (double-ended queue) data structure in Chapter 3. It adds the \IDeque\<T\>\ interface, the \Deque\<T\>\ class utilizing a finger-tree-based internal representation with \IMini\ records (\One\, \Two\, \Three\, \Four\), and extension methods for bulk operations. A \Program.cs\ file demonstrates usage by pushing and popping elements from both ends of the deque. The solution file \chapter 3.sln\ is also added to support building this new sample project.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 3 · high confidence

Add chapter 6 source code for combinations, permutations, and deques

The chapter 6 sample project now includes implementations for generating combinations (lexicographic and recursive), permutations (lexicographic, Fisher-Yates, Changes, and Johnson-Trotter algorithms), and a persistent deque data structure, along with helper extension methods for combining, permuting, and formatting collections.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 6 · high confidence

Add lock-free concurrency primitives and thread-safe patterns

Introduces new concurrency utilities in the LockFreeWithInterlocked module: an AsyncLock class using SemaphoreSlim for asynchronous locking, a generic LockFreeStack\<T\> implementing a lock-free push/pop algorithm via Interlocked.CompareExchange, and a pattern for replacing thread-safe collections with volatile reference swaps for high-performance updates. Additionally, the sample program demonstrates thread-safe random number generation using ThreadLocal\<Random\> to avoid contention during parallel operations.

WHPerformanceDotNet/src/LockFreeWithInterlocked · high confidence

Add memory-mapped file usage guide with safe type conversion

Introduces a new C\# guide demonstrating memory-mapped file operations, including creating views, overlaying structs, and handling endianness. The example code includes a safe, generic type-conversion helper to replace unsafe casts and addresses a previous issue with incorrect boolean conversion logic.

CSharpGuide/memory-mapped-files · high confidence

Added .NET 6 startup filter and middleware demonstration

The demo application now includes a custom IStartupFilter and corresponding middleware to illustrate the ASP.NET Core startup pipeline. The DemoIStartupFilter injects the DemoMiddleware into the request pipeline, while the middleware itself demonstrates manual management of the IServiceProvidersFeature to ensure request services are available, providing a concrete example of how startup filters and middleware interact during application initialization.

CSharpGuide/Net6WebDemo · high confidence

Added .NET 8 feature demonstration project

The CSharpGuide/net8-guide location now includes a new .NET 8 demonstration project that showcases several new platform capabilities. This includes collection expressions with custom \CollectionBuilder\ support for interfaces, performance improvements via \FrozenDictionary\, \SearchValues\, and \XxHash\, as well as updates to \System.Text.Json\ serialization (supporting \init\/\required\ keywords and source generation), \TimeProvider\ for time management, and cryptographic support for SHA-3.

CSharpGuide/net8-guide · high confidence

Added APUE source code examples for Unix system programming

Added a comprehensive set of C source code examples covering core Unix system programming concepts. The new files demonstrate file and directory operations (ls, demo1), process control and execution (demo2, 15-17), signal handling and masking (10-2, 10-5, 10-22, 10-24), POSIX threads and synchronization (11-14, 11-15, 12-5, 12-6c, 12-8, 12-9), I/O operations including non-blocking I/O and memory-mapped I/O (14-1, 14-24, 14-27), inter-process communication via pipes and shared memory (15-5, 15-6, 15-7, 15-33), and network socket programming for both connected and connectionless protocols (16-10, 16-16, 16-17, 16-19, 16-20).

APUE/src · high confidence

Added AsyncLocal best-practice and memory-leak demonstration code

The CSharpGuide/asynclocal location now includes a C\# solution and project containing demo code that illustrates correct usage of AsyncLocal\<T\> to avoid common pitfalls. The code demonstrates how direct assignment to AsyncLocal can cause execution-context copy-on-write issues and memory leaks (via DisposableThing and ChunkyObject), and shows the recommended pattern of wrapping the value in StrongBox (via DisposableThing2 and SafeChunkyObject) to mitigate those problems.

CSharpGuide/asynclocal · high confidence

Added C\# 10 language feature examples

Added a new set of demonstration files in the C\# 10.0 guide location illustrating key C\# 10 features, including global using directives, lambda expression improvements with explicit return types, custom interpolated string handlers for logging, record struct definitions, and extended property patterns in pattern matching.

CSharpGuide/LanguageVersions/10.0, CSharpGuide/LanguageVersions/7.0 · high confidence

Added C\# 4.0 dynamic vs reflection performance benchmark

A new example file demonstrates the performance difference between using the C\# 4.0 \dynamic\ keyword (DLR) and traditional reflection for method invocation. The code includes a benchmark loop that measures the execution time of both approaches, providing users with concrete data on the overhead associated with each technique.

CSharpGuide/LanguageVersions/4.0 · high confidence

Added C\# 7 deconstruction and pattern matching examples

This change introduces new demonstration code for C\# 7 features within the Chapter 12 project. It adds \DeconstructionExtensions.cs\ to show how to define custom deconstruction methods for \DateTime\ via extension methods, and \PatnerMatching.cs\ to illustrate constant, type, and \var\ pattern matching in \switch\ statements and \if\ conditions. The \Program.cs\ entry point is updated to exercise these capabilities, including tuple deconstruction for a \Point\ class and generic type checking.

_CSharpInDepth/Chapter12\_Deconstruction\PatnerMatching · high confidence

Added C\# 7.2 ref struct and readonly ref examples

Added demonstration code for C\# 7.2 features, specifically \ref struct\ and \ref readonly\. The new \ReadonlyAndRefStructs.cs\ file illustrates the use of \readonly struct\ for immutability, \ref readonly\ returns to prevent copying, and the \in\ parameter modifier for efficient pass-by-reference. The \Spans.cs\ file provides a concrete example of using \Span\<T\>\ and \ReadOnlySpan\<T\>\ for memory-efficient string manipulation without heap allocations.

CSharpGuide/LanguageVersions/7.2 · high confidence

Added C\# 8 concise syntax and Span\<T\> performance examples

The CSharpInDepth project now includes new chapters demonstrating C\# 8 features, specifically concise code patterns and high-performance memory management. The Chapter14\_ConciseCode project illustrates numeric literal improvements, such as using underscores as digit separators for better readability in integers, decimals, and hex/binary literals. Additionally, the Chapter13\_HighPerformancePassByReference project and updated documentation explain how to use Span\<T\> and stackalloc to optimize memory access and reduce allocations compared to traditional array-based approaches.

CSharpInDepth · high confidence

Added C\# 8 reference-type performance examples

This location introduces a new set of code samples demonstrating C\# 8 high-performance patterns, specifically focusing on \ref\ locals, \ref\ returns, \in\ parameters, and \ref readonly\ modifiers. The new files illustrate how to avoid value copying for large structs, create zero-copy read-only views of arrays, and utilize \Span\<T\>\ with \stackalloc\ to reduce heap allocations compared to traditional unsafe code or standard array usage.

_CSharpInDepth/Chapter13\HighPerformancePassByReference · high confidence

Added C\# 8.0 feature examples

Added code examples demonstrating C\# 8.0 features including async streams, default interface methods, nullable reference types, ranges and indexes, and switch expressions.

CSharpGuide/LanguageVersions/8.0 · high confidence

Added C\# 8.0 nullable reference type demo

A new demo file (practice\_demo.cs) has been added to the C\# 8.0 language guide section to illustrate the use of nullable reference types. The code demonstrates how to handle potential null values in constructor parameters using the null-conditional operator (?) combined with the null-forgiving operator (!) to suppress compiler warnings when passing nullable values to non-nullable parameters.

CSharpGuide/LanguageVersions/8.0/demo · high confidence

Added C\# 9.0 pattern matching and minimal API examples

This location now includes demonstration code for C\# 9.0 features, specifically adding \PatternMatcheDemo.cs\ to illustrate property patterns and record types, alongside a new \openapi\ subdirectory containing a minimal API project setup for ASP.NET Core.

CSharpGuide/LanguageVersions/9.0 · high confidence

Added C\# exception handling trap example

A new C\# console application has been added to demonstrate a common pitfall in exception handling involving the execution order of \catch\ filters (\when\ clauses) and \finally\ blocks. The example illustrates how code within a \when\ condition can execute even when an exception is thrown, potentially leading to unexpected behavior such as running with elevated privileges before the exception is handled.

CSharpGuide/exceptionhandle · high confidence

Added C\# generics patterns for non-generic to generic method invocation

Added new C\# code examples in the \CSharpGuide/generics\ directory demonstrating how to handle scenarios where non-generic code needs to invoke generic methods. The changes introduce \IPolicy\ and specific policy types (\LifePolicy\, \HomePolicy\, \AutoPolicy\), along with generic validators (\IPolicyValidator\<T\>\). Two implementation strategies are provided: \GenericInheritance.cs\ shows using a generic base class to bridge non-generic interfaces, while \GenericComposition.cs\ demonstrates a bridge class using composition. The \NoneGenericCallGeneric.cs\ file illustrates how to resolve these validators dynamically at runtime using reflection (\MakeGenericType\) within a service provider, offering alternatives to hard-coded switch statements.

CSharpGuide/generics · high confidence

Added C\# implementation of Bridge, Chain of Responsibility, Decorator, Proxy, and Visitor design patterns

The DesignPattern project now includes concrete C\# implementations for five classic design patterns. The Bridge pattern separates handset brands from software functions; the Chain of Responsibility handles hierarchical request approvals; the Decorator pattern dynamically adds responsibilities to person objects; the Proxy pattern provides a surrogate for giving gifts; and the Visitor pattern defines operations on person elements. These files serve as educational examples of these structural and behavioral patterns.

DesignPattern, DesignPattern/DesignPattern · high confidence

Added C\# performance optimization examples for strings, serialization, and memory management

This change introduces a new \CSharpGuide/performance\ project containing code samples that demonstrate high-performance patterns in .NET. It includes \ArrayChunkOfStruct.cs\ to illustrate efficient struct array access using \ref\ returns and \MemoryMarshal.GetArrayDataReference\ (available in .NET 5+), \SerializationPerformance.cs\ as a placeholder for \System.Text.Json\ serialization best practices, and \ZeroingMemoryAllocatedByStackalloc.cs\ to address stack-allocated memory zeroing behavior. Additionally, it adds a \strings\ sub-project with \Strings.cs\, which provides optimized implementations for query string manipulation and Base64 encoding using \Span\<T\>\, \ArrayBufferWriter\, and \Base64\ APIs to minimize memory allocations.

CSharpGuide/performance · high confidence

Added C\# serialization examples using System.Text.Json

Added new C\# code examples demonstrating how to use System.Text.Json for reading and writing JSON data. The changes include an interface and class for writing JSON via Utf8JsonWriter, and a utility class showing how to parse JSON documents, handle comments, and calculate statistics from JSON arrays.

CSharpGuide/serializes · high confidence

Added C\# source generator demos and test suite

This change introduces a collection of C\# source generator examples within the MySourceGenerator project, including basic implementations like AugmentingGenerator and CustomGenerator, as well as more advanced incremental generators for creating enum extension methods (EnumToGenerator) and processing XML files (FileTransformGenerator, MyXmlGenerator). It also adds supporting infrastructure such as EquatableArray for incremental caching, MSBuild property visibility configuration via MyGenerator.props, and a corresponding test project (SourceGeneratorTests) to verify generator execution.

CSharpGuide/SourceGeneratorDemo/MySourceGenerator · high confidence

Added C++ OOP examples for inheritance, polymorphism, and text querying

The CPPPrimer/src/15-oop directory now includes a set of C++ header and source files demonstrating object-oriented principles. These files define a class hierarchy for book pricing (Quote, Disc\_Quote, Bulk\_quote) with virtual functions and copy/move semantics, a query system (Query, TextQuery, QueryResult) for searching text content, and a Basket class for managing items. The changes also include a demonstration of inheritance and derived class copy/move operations, as well as a final class example.

CPPPrimer/src/15-oop · high confidence

Added C++ Primer introductory examples and exercises

Added a set of C++ source files in the \CPPPrimer/src/01\ directory that serve as introductory examples and exercises for the C++ Primer book. These include basic I/O programs (e.g., \iomain.cpp\, \main.cpp\), control flow demonstrations using \for\ and \while\ loops (e.g., \1-4-2-for.cpp\, \1-4-while.cpp\, \1-4-4-if.cpp\), a bookstore transaction example (\1-6-bookstore.cpp\), and various exercise solutions in the \exams/\ subdirectory (e.g., \1-3.cpp\ through \1-12.cpp\). The collection also includes files illustrating common pitfalls, such as incorrect \cout\ usage (\1-6.cpp\) and comment nesting rules (\1-7.cpp\, \1-8.cpp\).

CPPPrimer/src/01 · high confidence

Added C++ associative container examples and word-transform demo

Added source files demonstrating C++ \std::map\ and \std::set\ usage, including basic operations, iteration, insertion, and deletion. Included a word-transform utility that reads translation rules from a file and applies them to input text, along with supporting test data files (\rule.txt\, \content.txt\) and exercise solutions for word counting and family name mapping.

CPPPrimer/src/11-associate-container · high confidence

Added C++ class implementation exercises and examples

Added a collection of C++ source files and headers in the 07-class directory that demonstrate core object-oriented concepts. These include the Sales\_data class with constructors, member functions, and friend functions for input/output operations, as well as the Screen class illustrating inline member definitions, mutable data members, and type aliases. The changes also introduce examples of literal types, constexpr constructors, and static data members, providing practical implementations for class design and usage.

CPPPrimer/src/07-class · high confidence

Added C++ demonstration files for type conversion and byte inspection

Added three new C++ source files to the CSAPP/cpps directory: hellowrold.cpp, which prints a greeting message using standard streams; showbytes.cpp, which provides utility functions to display the byte representation of integers, floats, and pointers; and typeconvert.cpp, which demonstrates signed-to-unsigned short type conversion.

CSAPP/cpps · high confidence

Added C++ examples for function objects, type conversion, and function matching

Added source files in the \CPPPrimer/src/14-operators-converter\ directory demonstrating C++ function objects (functors like \absInt\ and \PrintString\), type conversion operators (including ambiguity issues in \SmallInt\), and function matching/dispatch using \std::function\, lambdas, and function pointers.

CPPPrimer/src/14-operators-converter · high confidence

Added C++ expression exercises covering type sizes, casting, and overflow

The CPPPrimer/src/04/exams directory now includes four new example programs demonstrating core C++ expression concepts. 4-6.cpp provides a utility to check if a number is even, 4-7.cpp illustrates integer overflow scenarios, 4-28.cpp prints the memory size of various built-in and fixed-width types, and 4-36.cpp demonstrates explicit type casting using static\_cast.

CPPPrimer/src/04 · high confidence

Added C++ function concept examples and exercises

Added a set of C++ source files in the \CPPPrimer/src/06-function\ directory that demonstrate core function concepts, including local static variables, constant references, function overloading, inline/constexpr functions, function pointers, and recursion. The addition also includes a separate compilation example (\head/\) showing header declarations and implementation separation, along with exercise solutions covering array references and return types.

CPPPrimer/src/06-function · high confidence

Added C++ generic algorithm examples and exercises

Added a set of C++ source files in the generic-algorithm directory demonstrating standard library algorithms. These include examples for copy and replace operations, sorting and deduplication, lambda expressions with capture and mutability, iterator usage (including reverse iterators), partitioning, and stream iterators for file and console I/O.

CPPPrimer/src/10-generic-algorithm · high confidence

Added C++ generic template exercises

Added a set of C++ source files in the \CPPPrimer/src/16-generic-template/exams\ directory that demonstrate generic programming and template features. These include a generic \find\ utility (\exam\_template.h\), a \Blob\ smart-pointer-based container with iterator support (\16-12.h\, \16-24.cpp\), a parameterized \Screen\ class (\16-14.h\), a custom \unique\_ptr\ implementation (\16-28.cpp\), and examples of template specialization and variadic templates for debugging and error reporting (\16-48.cpp\, \16-56.cpp\, \16-62.cpp\, \16-63.cpp\).

CPPPrimer/src/16-generic-template/exams · high confidence

Added C++ operator override and copy control examples

Added a set of C++ source files in the \CPPPrimer/src/13-operator-override\ directory demonstrating copy control, operator overloading, and memory management. The changes include implementations of \HasPtr\ with custom reference counting and move semantics, a \Message\ and \Folder\ class hierarchy with copy/move assignment and swap operations, a \StrVec\ container with manual memory management, and various exercise files illustrating value semantics, move constructors, and reference binding.

CPPPrimer/src/13-operator-override · high confidence

Added C++ string and container exercise solutions

Added a set of C++ source files in the \CPPPrimer/src/09-collection\ directory that demonstrate standard library usage. These examples cover string construction from C-style pointers, iterator-based container conversions (list to vector), string search operations (finding numeric and alphabetic characters), string replacement logic, and parsing date strings with multiple format support.

CPPPrimer/src/09-collection · high confidence

Added C++ string and vector exercises

Added a set of C++ source files in the Chapter 3 directory demonstrating string and vector operations, including reading input, iterating over characters, modifying strings, initializing vectors, and comparing arrays.

CPPPrimer/src/03 · high confidence

Added C/C++ examples for Linux network programming patterns

The TCPIP/example directory now includes a suite of C and C++ source files demonstrating various Linux networking and concurrency techniques. These examples cover I/O multiplexing using epoll and poll, asynchronous signal handling via pipefd, zero-copy data transfer using splice, and shared memory-based multi-process architectures. Additionally, the collection provides implementations of high-performance timer structures (sorted linked list, time wheel, and min-heap) and synchronization primitives (mutexes, semaphores, and condition variables) to support robust server-side logic.

TCPIP/example · high confidence

Added CSAPP Chapter 3 example code for examining assembly output

Added C source files (main.c, mstore.c) and the corresponding assembly listing (mstore.s) for Chapter 3, providing concrete examples to view and analyze the generated assembly code for a multiplication and store operation.

CSAPP/exam · high confidence

Added Chapter 2 C++ Primer source examples

Added a set of C++ source files in the Chapter 2 directory demonstrating basic built-in types, variables, scope, type conversions, pointers, references, const correctness, typedef/using aliases, auto type deduction, and decltype. The examples also include a custom Sales\_data struct usage and illustrate pointer-to-pointer indirection and string literal concatenation.

CPPPrimer/src/02 · high confidence

Added Chapter 2 exercise solutions covering C++ types, pointers, and scope

Added a set of new C++ source files in the Chapter 2 exercises directory (CPPPrimer/src/02/exams) that demonstrate core language concepts. These examples cover basic built-in types and character literals, signed/unsigned arithmetic behavior, variable scope and shadowing (including global vs. local variables), pointer operations (dereferencing, assignment, and type safety), references, const correctness, auto type deduction, decltype, and custom struct definitions.

CPPPrimer/src/02/exams · high confidence

Added ConcurrencyInCSharpCookbook solution with multiple project references

The ConcurrencyInCSharpCookbook.sln file was added, defining a Visual Studio solution that includes ten distinct C\# projects: ThreadBasic, 03ParallerBasic, 04DataFlow, 05ReactiveExtensions, 06UnitTest, 07Interoperate, 08Collections, 09Cancellation, 11Sync, 12Schedule, and 13PracticalSkills. This solution file enables building and managing these concurrency-related examples together in Visual Studio 15.

ConcurrencyInCSharpCookbook · high confidence

Added ETL demo application with ETW event tracing

The EtlDemo project now includes a functional demonstration of Event Tracing for Windows (ETW) in .NET. It introduces an Events class that defines and emits specific trace events (ProcessingStart, ProcessingFinish, FoundPrime, and Error) using the System.Diagnostics.Tracing namespace. A BaseListener abstract class and its ConsoleListener implementation are provided to subscribe to these events, filter them by source name and keywords, and output the received data to the console. The Program.cs entry point exercises this flow by emitting a prime number event and displaying the trace output.

WHPerformanceDotNet/src/EtlDemo · high confidence

Added EventSource and DiagnosticSource demonstration code

The EventSourceDemo location now includes a complete set of C\# source files demonstrating .NET diagnostics patterns. This includes multiple EventSource implementations (ActivityIdEventSource, ParallelActivityIdEventSource, CustomEventSource, AdvancedCustomizedEventSource, MyLoggingEventSource, and OptimizedEventSource) showcasing event writing, keywords, tasks, opcodes, and optimized unsafe writes. It also provides a ConsoleWriterEventListener for capturing and displaying these events, helper classes for event constants, and a DiagnosticSourceQuickStart demonstrating how to subscribe to and listen for DiagnosticListener events. The Program.cs entry point ties these components together to run the demonstrations.

CSharpGuide/diagnostics/EventSourceDemo · high confidence

Added FileReadingPooledValueTaskSource implementation

Added a new \FileReadingPooledValueTaskSource\ class that implements \IValueTaskSource\<string\>\. This component provides a custom underlying source for ValueTasks, handling state management, continuation scheduling via \SynchronizationContext\ or \TaskScheduler\, and result retrieval, serving as a building block for high-performance asynchronous file reading operations.

CSharpGuide/valuetask · high confidence

Added Full GC Notification Demo Application

A new console application has been added to demonstrate the .NET GC notification mechanism. It registers for full garbage collection notifications, spawns a background thread to monitor GC approach and completion events, and simulates memory pressure by allocating arrays until an OutOfMemoryException occurs, allowing users to observe how the system handles GC warnings and completions.

WHPerformanceDotNet/src/FullGCNotification · high confidence

Added Go design pattern implementations

The DesignPattern/DesignPatternGo directory now includes a comprehensive set of Go code examples demonstrating various software design patterns. This addition covers the Abstract Factory, Adapter, Command, Decorator, Function Options, Mediator, Memento, Observer, Prototype, Proxy, Singleton, State, Strategy, and Visitor patterns, providing reference implementations for these architectural concepts.

DesignPattern/DesignPatternGo · high confidence

Added IO exercise examples for stream state handling and file processing

New example files were added to the IO chapter to demonstrate C++ input/output operations. The first example illustrates reading from standard input while monitoring and clearing stream state flags. The second example demonstrates reading sales data from an input file, combining records with matching ISBNs, and writing the aggregated results to an output file.

CPPPrimer/src/08-io · high confidence

Added Java code examples for Effective Java principles

Added a collection of Java source files in the \src/\ directory demonstrating key concepts from Effective Java, including the Builder pattern, static factory methods, composition over inheritance (ForwardingSet, InstrumentedHashSet), and thread-safe observer patterns (MyObservableSet).

EffectiveJava · high confidence

Added Java concurrency and design pattern examples

Added example code for Java concurrency and design patterns, including a forwarding set implementation, an observable set with thread-safe observer notification, a sleeping task using an executor service, and a thread joining exercise.

repository · high confidence

Added Java enumerated type examples and utility classes

This change introduces a collection of educational examples in the \ThinkingInJava/src/enumerated\ package demonstrating Java enumerated types. It includes \AlarmPoints\ and \OzWitch\ for basic enum definitions, \CharacterCategory\ for enums with custom methods and state, and \PostOffice\ for implementing the strategy pattern using enums. It also covers \EnumMaps\ and \EnumSets\ for collection usage, \SpaceShip\ for overriding \toString\, and \SecurityCategory\ for nested enums. Additionally, utility classes \Enums\, \Generator\, \CollectionData\, and \Print\ are added to the \net.mindview.util\ package to support these examples.

ThinkingInJava/src/enumerated · high confidence

Added Java project scaffolding with Hello World example

A new Java project structure has been added to the repository, including a README.md describing the setup for 'Java 编程思想' (Thinking in Java) in VSCode and a Hello.java file that prints 'Hello World' to the console.

ThinkingInJava · high confidence

Added Kubernetes Job, CronJob, and StatefulSet configuration examples

This update introduces new example files for Kubernetes batch workloads and stateful applications. In the Job&CronJob directory, it adds YAML manifests for parallel and standard batch jobs (calculating Pi) along with a shell script and template for creating multiple jobs, demonstrating parallelism, completions, and backoff limits. In the StatefulSet directory, it provides configurations for a MySQL cluster (including headless services and ConfigMaps) and an Nginx StatefulSet with persistent volume claim templates, illustrating stable network identities and storage for stateful workloads.

Kubernetes · high confidence

Added Reactive Extensions (Rx) concurrency examples and VS Code configuration

This location introduces a new Reactive Extensions (Rx) demonstration project, including VS Code launch and build tasks for the .NET Core console app. The code provides examples of converting standard and non-standard .NET events into Observable streams, using operators like Throttle and Sample to limit event flow, Window and Buffer to group events, and ObserveOn to manage execution contexts. It also demonstrates handling timeouts and exceptions within reactive pipelines.

ConcurrencyInCSharpCookbook/05ReactiveExtensions · high confidence

Added Roslyn SDK demonstration projects for syntax and semantic analysis

The CSharpGuide/roslySdkDemo location now includes a new solution containing three demo projects: HelloSyntaxTree, which parses C\# source code and traverses the syntax tree to inspect nodes like usings and method signatures; SemanticQuickStart, which demonstrates building a compilation and using the semantic model to resolve symbols and query type information; and SyntaxWalker, which implements a custom CSharpSyntaxWalker to collect specific syntax nodes such as using directives. These additions provide practical examples for working with the Roslyn compiler platform.

CSharpGuide/roslySdkDemo · high confidence

Added Roslyn-based code analyzer and code fix for C\# type naming

This change introduces a new Roslyn diagnostic analyzer and its corresponding code fix provider within the SampleCodeAnalyzer project. The analyzer detects C\# type names that contain lowercase letters and suggests a fix to rename them to uppercase. The implementation includes the core analyzer logic, a code fix provider that utilizes the Roslyn Renamer to update all references, localized resource strings for the diagnostic messages, and a comprehensive test suite with verifiers for both C\# and Visual Basic to validate the analyzer and code fix behavior.

WHPerformanceDotNet/src/SampleCodeAnalyzer · high confidence

Added Rx-based timeout wrapper and service interface for unit testing

The 06UnitTest project now includes an IHttpService interface that exposes an IObservable\<string\> for fetching URLs, and a MyTimeoutClass that wraps this service to enforce a 1-second timeout on the observable stream using System.Reactive. A basic unit test scaffold (UnitTest1) is also present to support future testing of this timeout behavior.

ConcurrencyInCSharpCookbook/06UnitTest · high confidence

Added SIMD vectorization demo for .NET 8

This change introduces a new C\# demonstration project (\simd-vector-demo\) showcasing hardware-accelerated SIMD operations. It includes an \Extensions\ class providing a generic \Sum\ method that utilizes \Vector\<T\>\ for parallel summation when hardware acceleration is available, and a \VectorOperator\ class implementing low-level byte vector operations such as ASCII validation, widening/narrowing, and element searching using \Vector128\, \Vector256\, and \Vector512\ intrinsics. The project is configured for .NET 8 and includes a \Program.cs\ file demonstrating various vector manipulations like shuffling, conditional selection, and saturation packing.

CSharpGuide/simd-vector-demo · high confidence

Added Sales\_data and Sales\_item library headers

New header files (Sales\_data.h and Sales\_item.h) have been added to the libs directory, providing C++ classes for managing sales transactions. These headers define structs/classes with members for book numbers, units sold, and revenue, along with overloaded operators for input/output, addition, and comparison, as well as utility functions for reading and printing sales data.

CPPPrimer/src/libs · high confidence

Added TypeScript library examples for type system fundamentals

The \ts/lib\ directory now includes a collection of TypeScript source files and their corresponding declaration files demonstrating core language features. These additions cover type assertions, the \any\ type, global declarations (including jQuery and custom interfaces), basic data types (boolean, number, string, void), function signatures (including overloads, default parameters, and rest parameters), interfaces, and union types. This provides a reference implementation for these specific TypeScript concepts.

ts/lib · high confidence

Added TypeScript source files and declaration files for language feature examples

This change introduces a collection of new TypeScript source files and declaration files under ts/src and ts/types to demonstrate various TypeScript language features. The additions include examples for type assertions, advanced types (generics, interfaces, classes, enums, tuples), basic types (any, union, function overloads), and module declarations (including global extensions and CommonJS/ES6 export patterns). These files serve as educational examples or documentation for TypeScript syntax and type system capabilities.

ts/src · high confidence

Added VS Code debugging configurations and C\# source files for Chapters 3, 6, and 10

This change introduces the necessary project structure and source code for three chapters of the C\# In Depth series. It adds VS Code \launch.json\ and \tasks.json\ files to enable .NET Core debugging and building for Chapter 3 (Generics), Chapter 6 (Iterators), and Chapter 10 (Extension Methods). The source files include \AdvancedGeneric.cs\, \Pair.cs\, and \ReflectorGeneric.cs\ for generics; \IteratorWorkflow.cs\ for iterator behavior; and \EnumerableUtil.cs\ and \StreamUtil.cs\ for extension method implementations.

_CSharpInDepth/Chapter06, CSharpInDepth/Chapter10\_Extension, CSharpInDepth/Chapter\_3\Generic · high confidence

Added annotation-based use case tracking and database constraint definitions

New files introduce a \UseCase\ annotation for marking methods with IDs and descriptions, along with a \UseCaseTracker\ utility that scans classes via reflection to verify that all expected use cases are implemented. Additionally, a set of annotations (\DBTable\, \SQLString\, \Constraints\) is added to the \database\ subpackage to define table names, field types, and database constraints (primary key, nullability, uniqueness) on Java classes and fields.

ThinkingInJava/src/annotations · high confidence

Added async concurrency and state-machine implementation examples

The C\# async guide now includes two new code examples demonstrating asynchronous patterns. The first illustrates the behavioral differences between AsyncLocal and ThreadLocal storage when values are modified across concurrent async tasks. The second provides a manual implementation of the async state machine for a lazy-initialization scenario, showing how the compiler transforms an async method into a stateful class with explicit continuation handling.

CSharpGuide/async · high confidence

Added cancellation examples and VS Code debugging configuration

This change introduces a new C\# cookbook section for concurrency cancellation, providing code examples for cancelling async methods, parallel loops (via ParallelOptions), PLINQ, and Reactive Extensions (Rx). It also includes a helper class for shared cancellation tokens, a polling-based cancellation pattern, and timeout handling. Additionally, VS Code launch and task configurations are added to enable building and debugging the .NET Core console application.

ConcurrencyInCSharpCookbook/09Cancellation · high confidence

Added chapter 10 example for first-order binary term unification

The repository now includes a C\# LINQ script (chapter10.linq) demonstrating first-order binary term unification. This example implements the core data structures (BinTerm, Hole, Symbol, Constant) and the unification algorithm, including Robinson's occurs-check, to solve a specific unification problem involving generic types and function signatures.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 10 · high confidence

Added collection metric demonstration with EventCounters and Prometheus export

The CollectionMetricDemo location now includes concrete examples for collecting and exporting metrics. It introduces EventCounter sources (CocurrentRequestEventCounterSource, ConditionalEventCounterSource, MinimalEventCounterSource) that track request rates, processing times, working set memory, and lock contention, along with a SimpleEventListener to print these counters to the console. Additionally, it provides MeterListenerProgram and PromethusProgram to demonstrate .NET Metrics API usage, including a Prometheus HTTP exporter listening on localhost:9184 for scraping.

CSharpGuide/diagnostics/CollectionMetricDemo · high confidence

Added concurrency collection examples and async queue support

This update introduces new code examples for various thread-safe and immutable collections in C\#, including BlockingCollection (for blocking queues, stacks, and bags), ConcurrentDictionary, ImmutableList, ImmutableSet, ImmutableStack, and ImmutableQueue. It also adds an AsyncQueue implementation using BufferBlock for asynchronous producer-consumer scenarios and updates the main program to demonstrate these collections, including the use of Nito.AsyncEx for running async code synchronously.

ConcurrencyInCSharpCookbook/08Collections · high confidence

Added concurrency demonstration examples

Added a set of Java source files in the concurrency package that demonstrate core threading concepts, including basic thread creation, executor services (cached thread pools), Callable tasks with results, thread joining and interruption, uncaught exception handling, and thread priorities.

ThinkingInJava/src/concurrency · high confidence

Added concurrency exercise examples for thread management

Added new Java source files in the excs/concurrency directory demonstrating basic threading concepts, including creating threads with Runnable tasks (E01\_Runable, E02\_Fibonacci), using ExecutorService with cached thread pools (E03\_Runnable2, E06\_SleepingTask2), and configuring daemon threads (E08\_MoreBasicThreads).

ThinkingInJava/src/excs · high confidence

Added concurrency scheduling examples for parallel execution and dataflow synchronization

The 12Schedule cookbook section now includes code examples demonstrating how to control task execution using the Task Scheduler. This includes limiting the total degree of parallelism in nested Parallel.ForEach loops via ConcurrentExclusiveSchedulerPair, and synchronizing dataflow blocks (TransformBlock and ActionBlock) by associating them with the current synchronization context. The examples also illustrate the usage of ConcurrentScheduler and ExclusiveScheduler for managing concurrent versus exclusive task execution.

ConcurrencyInCSharpCookbook/12Schedule · high confidence

Added concurrency synchronization and throttling examples

The 11Sync directory now includes sample implementations for managing concurrent access and limiting throughput. It introduces blocking synchronization primitives via BlockLock (using C\# lock) and BlockSemaphore (using ManualResetEventSlim and AutoResetEvent), as well as asynchronous alternatives in AsyncLock (SemaphoreSlim) and AsyncSemaphore (AsyncManualResetEvent). Additionally, Throttling.cs provides patterns for limiting parallelism using Dataflow, PLINQ, Parallel.ForEach, and SemaphoreSlim for HTTP requests.

ConcurrencyInCSharpCookbook/11Sync · high confidence

Added concurrency utility patterns and examples

Added new code examples in the 13PracticalSkills section demonstrating practical concurrency patterns: AsyncDataBind for binding asynchronous tasks to UI properties, AsyncLazy for thread-safe asynchronous lazy initialization with retry and execution context options, InitializeShareResources for initializing shared resources using Lazy and AsyncLazy, ParameterStatusInConcurrent for passing state across asynchronous contexts using AsyncLocal, and RxLazyGetValue for deferred evaluation in Reactive Extensions.

ConcurrencyInCSharpCookbook/13PracticalSkills · high confidence

Added distributed tracing demo applications

New demo applications have been added to showcase distributed tracing capabilities. The console-based DistributedTraceDemo demonstrates manual activity creation, tagging, and event logging using OpenTelemetry. The web-based DistributedTraceWebDemo is an ASP.NET Core Razor Pages application configured with OpenTelemetry to automatically instrument ASP.NET Core requests and export traces to the console, providing a complete example of web request tracing.

CSharpGuide/diagnostics/DistributedTraceDemo, CSharpGuide/diagnostics/DistributedTraceWebDemo, CSharpGuide/diagnostics/DistributedTraceWebDemo/wwwroot · high confidence

Added dynamic memory management and smart pointer examples

The dynamic memory allocation chapter now includes a comprehensive set of C++ source files demonstrating manual memory management and smart pointer usage. These additions cover dynamic arrays with \std::unique\_ptr\ and \std::allocator\, safe string handling via \StrBlob\ and \WeakStrBlob\ classes using \std::shared\_ptr\, and a text query system (\TextQuery\) that utilizes smart pointers for managing word-to-line mappings.

CPPPrimer/src/12-dynamic-allocate-momery · high confidence

Added example for handling exceptions in async void methods

The ThreadBasic cookbook now includes a new example demonstrating how to handle exceptions in async void methods. It introduces an ICommand interface and a MyAsyncCommand implementation to show the risks of async void, and uses the Nito.AsyncEx library's AsyncContext in Program.cs to safely capture and handle exceptions that would otherwise be unhandled in a standard async void context.

ConcurrencyInCSharpCookbook/ThreadBasic · high confidence

Added generic object creation performance benchmarks and optimization utilities

Added a new benchmark suite and supporting implementation classes to the GenericOptimization module to compare the performance of different object instantiation strategies. The changes introduce a \GenericConstraintBenchmark\ class that measures the overhead of direct constructors, generic constraints (\where T : new()\), delegates, \Activator.CreateInstance\, expression trees (\FastActivator\), and dynamic IL emission (\FastActivator\<T\>\). Supporting files include \DynamicModuleLambdaCompiler\ for generating factory delegates via IL, \FastActivator\ for expression-tree-based activation, and \NodeFactory\ as a baseline generic constraint implementation, allowing users to evaluate and select the most efficient object creation method for their scenarios.

WHPerformanceDotNet/src/GenericOptimization · high confidence

Added high-performance I/O and threading examples

Added Program.cs to the HighPerformanceIOProgram project, demonstrating asynchronous file reading using FileStream with a TaskCompletionSource, and comparing thread-safety strategies for concurrent list updates via locking versus local buffering.

WHPerformanceDotNet/src/HighPerformanceIOProgram · high confidence

Added lexer, parser, and symbol table components for expression translation

The dragonbook/src area now includes a complete set of source files for a simple compiler front-end. This adds a lexer (Lexer.java, Num.java, Rel.java, Token.java, Word.java, Tag.java) that handles tokenization including comments and reserved words, a parser (Parser.java) that processes arithmetic expressions, a symbol table environment (Env.java, Symbol.java) for scope management, and a main entry point (Postfix.java) that translates infix expressions to postfix notation.

dragonbook/src · high confidence

Added memory allocation optimization examples using Span, ref returns, and object pooling

The MomeryAllocation module now includes demonstration code for several .NET memory optimization techniques. It introduces \Span\<T\>\ usage to avoid memory allocations when working with managed arrays, stack-allocated memory, and unmanaged memory. It also provides examples of using \ref\ returns to avoid value copying of structs and prevent boxing, alongside a \HybirdCache\ implementation that uses \WeakReference\ to manage object lifecycles and reduce memory pressure. Additionally, a \PoolManager\ is added to demonstrate object pooling for reusing instances, and an \AvoidFinalize\ class illustrates proper disposal patterns to prevent finalizer overhead.

WHPerformanceDotNet/src/MomeryAllocation · high confidence

Added parallel programming examples for C\# concurrency

This location introduces a new sample demonstrating basic parallel development in C\#. The code and documentation cover using Parallel.Invoke for independent method execution, Parallel.ForEach and PLINQ (AsParallel) for data aggregation, and Task creation with AttachedToParent options for parent-child task hierarchies. It also illustrates waiting for tasks using Task.WaitAll and handling cancellation via CancellationToken.

ConcurrencyInCSharpCookbook/03ParallerBasic · high confidence

Added performance benchmarking examples for dynamic code generation

Added new sample projects in the DynamicGenerateCode and DynamicGenerateExecutor directories that demonstrate and benchmark the performance overhead of reflection versus dynamically generated delegates. The DynamicGenerateExecutor project uses System.Reflection.Emit to create optimized delegates for object instantiation and method invocation, comparing their execution time against direct calls and standard reflection (Activator.CreateInstance and MethodInfo.Invoke) to illustrate the efficiency gains of runtime code generation.

WHPerformanceDotNet/src/DynamicGenerateCode, WHPerformanceDotNet/src/DynamicGenerateExecutor · high confidence

Added pretty-printing implementation for document structures and expression trees

The chapter 9 source file now includes a complete implementation of a pretty-printing system. This adds a \Doc\ class hierarchy (including \TextDoc\, \GroupDoc\, \IndentDoc\, \OptBreakDoc\, and \ConcatDoc\) with logic to determine if content fits within a specified width and to format output with appropriate line breaks and indentation. It also defines an expression tree structure (\Expr\, \Id\, \Add\, \Mult\, \Member\, \Call\, etc.) and a visitor interface (\IExprVisitor\) to support traversing these expressions, alongside example usage demonstrating the pretty-printer's behavior at different widths.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 9 · high confidence

Added producer-consumer threading demo using System.Threading.Channels

A new C\# example file (ThreadChannelDemo.cs) has been added to the threads guide, demonstrating the producer-consumer pattern via the System.Threading.Channels API. The demo includes methods for unbounded channel usage, single-producer/single-consumer scenarios, and multiple-producer/single-consumer scenarios, illustrating how to coordinate async data flow between threads.

CSharpGuide/threads · high confidence

Added ref foreach benchmarking sample for C\# 7.3

A new benchmarking project has been added to demonstrate performance differences between standard foreach loops, for loops, LINQ, and ref foreach iterations on lists, arrays, and custom wrappers. This sample allows users to evaluate the impact of using ref foreach with spans in C\# 7.3 environments.

CSharpGuide/LanguageVersions/7.3 · high confidence

Added sample code for .NET async and parallel programming patterns

New demonstration files have been added to the WHPerformanceDotNet project to illustrate asynchronous and parallel execution techniques. The AsyncProgram module shows how to manage multiple tasks, handle cancellation via CancellationToken, and track completion using Interlocked operations. The Parallel module demonstrates Parallel.For and Parallel.ForEach loops, including the use of Partitioner for optimized data partitioning and loop state control for early termination.

WHPerformanceDotNet/src/AsyncProgram · high confidence

Added shell script examples and usage documentation

This change introduces a collection of new Bash shell scripts and documentation files to the ShellScript directory. The new content includes basic usage examples (such as 'Hello World' and input handling), network service detection scripts, date calculation utilities, and various loop and conditional logic demonstrations (including case statements, while/for loops, and parameter shifting). It also adds reference documentation covering Bash features like aliases, variable manipulation, and debugging techniques.

ShellScript · high confidence

Added source code for chapters 11 and 12

New LINQ script files have been added to the repository: chapter 11 contains the implementation of binary term anti-unification (including the \AntiUnification\ class, \Hole\, \Symbol\, and \Constant\ types), and chapter 12 contains helper functions for mapping and binding operations on \Lazy\<T\>\, \Nullable\<T\>\, \Task\<T\>\, and \IEnumerable\<T\>\ types.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 11, Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 12 · high confidence

Added source code for graph coloring and Sudoku solving

The chapter 8 source file now includes a complete LINQPad script demonstrating immutable graph structures, graph coloring algorithms, and a backtracking solver for Sudoku puzzles using constraint reduction.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 8 · high confidence

Added unsafe class usage example

A new C\# project has been added to demonstrate unsafe memory operations. The solution includes a \MagicalBox\ struct that uses \fixed\ buffers and \System.Runtime.CompilerServices.Unsafe\ methods to write and read primitive values directly to memory, bypassing standard bounds checking.

CSharpGuide/unsafeclass-useage · high confidence

Automated documentation preparation hook for MkDocs

A new Python hook (\hooks/prepare\_docs.py\) has been added to automate the preparation of documentation for MkDocs. This script aggregates markdown files from the \docs\ directory and other relevant project root directories, resolving placeholder links and handling symlinks, then copies them into a generated \\_mkdocs\_docs\ directory. It also includes logic to extract or generate titles for documentation pages, ensuring a consistent structure for the generated site.

hooks · high confidence

C\# 10.0 language features and nullable reference types enabled

The CSharpGuide project now targets C\# 10.0 and enables nullable reference types and strict mode, allowing the codebase to utilize modern language features such as pattern matching in the 'is' operator and 'when' clauses in switch/catch statements.

CSharpGuide · high confidence

C\# 14 language guide introduces extension members and operators

This entry adds a new C\# 14 sample project that demonstrates the new \extension\ syntax. The \Extensions.cs\ file defines instance extensions (such as \IsEmpty\ and \AddIfNotNull\ on \List\<T\>\, and \IsNullOrEmpty2\ on \string\) and a static extension operator (\+\) for concatenating lists. The \User.cs\ class showcases property implementations using the \field\ keyword, while \Program.cs\ exercises these new capabilities.

CSharpGuide/LanguageVersions/14.0 · high confidence

Demonstration of C\# 11 required member initialization

Added a sample program illustrating the C\# 11 'required' modifier for properties. The code shows that instantiating a class with required properties fails if those properties are not set, even when a parameterless constructor is available, and demonstrates the use of the \[SetsRequiredMembers\] attribute to satisfy requirements within a parameterized constructor.

CSharpGuide/LanguageVersions/11.0 · high confidence

This update introduces a suite of immutable data structures and helper utilities for the Chapter 2 sample code. It adds an immutable stack (IImStack/ImStack) with support for covariance, a Hughes list (HList) for efficient concatenation, and an immutable queue (IImQueue/ImQueue) built on two stacks. It also includes extension methods for formatting and list manipulation, a generic UndoRedo state manager, and a mutable UndoRedoQueue that leverages the immutable queue for history tracking. The chapter solution and entry point are updated to demonstrate these components.

Fabulous-Adventures-In-Data-Structures/sourcecode/chapter 2 · high confidence

Initial commit of CSAPP C++ study materials and Visual Studio projects

This change introduces the initial structure for the CSAPP C++ study materials, including a Visual Studio solution file and multiple project configurations (03opcode, 05opcode, 07opcode, 09opcode, algor, mathlib). It adds source code files demonstrating various computer systems concepts such as function pointers, vector operations, linking, and signal handling, along with corresponding header files and build configurations.

CSAPP/cpps/csapp · high confidence

Initial solution structure and NuGet configuration for performance samples

The repository now includes the main solution file (\writehighperformancedotnetcode.sln\) and a \NuGet.Config\ that configures package sources to include \nuget.org\, the Roslyn feed, and the Roslyn Analyzers feed. The solution defines multiple project references covering performance topics such as async programming, garbage collection, high-performance I/O, lock-free concurrency, memory allocation, parallel processing, generic optimization, TPL Dataflow, dynamic loading, and ETL demos, alongside a new Sample Code Analyzer project.

WHPerformanceDotNet/src · high confidence

Introduces cryptographic random number generation and statistical distribution utilities

Adds a new \BetterRandom\ class that uses \System.Security.Cryptography.RandomNumberGenerator\ for cryptographically secure random integers and doubles, replacing the previous reliance on the standard \Random\ class for core generation. Introduces a set of interfaces (\IDistribution\, \IDiscreteDistribution\) and implementations for statistical distributions, including \Normal\ (using the Box-Muller transform) and \StandardDiscreteUniform\. Also provides extension methods in \Extensions.cs\ to generate ASCII histograms for both continuous and discrete distributions, aiding in the visualization of random data.

CSharpGuide/random · high confidence

Introduces functional programming primitives and extension methods

The MarsonShine.Functional library now provides a suite of immutable data structures and functional utilities for C\# developers. This includes Option, Either, Exceptional, and Validation types to handle nulls, errors, and validation logic without exceptions, alongside extension methods for IEnumerable, Task, and Func to support functional patterns like currying, composition, and monadic chaining (Map/Bind).

FunctionalCSharp/src/MarsonShine.Functional · high confidence

Introduction of a generic object pooling system

The GCPool library now provides a generic object pooling mechanism designed to reduce garbage collection pressure by reusing objects. This includes a \PoolManager\ that manages pools of objects implementing the new \IPoolableObject\ interface, allowing applications to acquire and return pooled instances (such as the provided \MyPoolObject\ example) to recycle memory.

WHPerformanceDotNet/src/GCPool · high confidence

New AsyncInCSharp sample project with comprehensive async/await examples and documentation

Added a new C\# sample project (AsyncInCSharp) containing multiple sub-projects and documentation that demonstrate various aspects of asynchronous programming in .NET. The project includes examples of custom awaitables (ExampleAwaitable), TAP (Task-based Asynchronous Pattern) usage, exception handling in async methods, cancellation tokens, custom combinators with timeouts, and performance comparisons between sync and async code. It also provides detailed documentation on async compiler transformations, ASP.NET async patterns, UI application considerations, and exception handling best practices.

AsyncInCSharp · high confidence

New async lifecycle patterns and VS Code debugging support for the 10OOP cookbook

This change introduces a set of new C\# classes and interfaces in the 10OOP project to demonstrate advanced asynchronous object lifecycle patterns, including async constructors (\AsyncConstructorClass\), async initialization (\IAsyncInitialize\, \AsyncInitialization\), async disposal with cancellation tokens (\DisposedAsync\), and an async completion pattern using \TaskCompletionSource\ (\IAsyncCompletion\, \MyClassCompletion\). It also adds an \AsyncHelper\ utility to simplify the usage of resources implementing \IAsyncCompletion\ via a \using\-like syntax, and provides VS Code configuration files (\launch.json\, \tasks.json\) to enable debugging and building the .NET Core console application.

ConcurrencyInCSharpCookbook/10OOP · high confidence

New design pattern implementations and documentation in DesignPatternCore

This update adds several new design pattern implementations and their corresponding documentation to the DesignPatternCore library. Specifically, it introduces the Bridge pattern (with HandsetBrand and HandsetSoft abstractions), the Builder pattern (using a computer assembly example), the Chain of Responsibility pattern (for request handling by managers), the Decorator pattern (for clothing/persona decoration), the Facade pattern (simplifying stock and investment operations), the Abstract Factory and Factory patterns (for file conversion to PDF), the Memento pattern (for state snapshotting), the Observer pattern (with subject/observer interfaces and event-based updates), the Property/Prototype pattern (for deep/shallow cloning of resumes), the Proxy pattern (for gift-giving delegation), and the Specification pattern (for filtering mobile devices). These additions provide reusable, documented examples for common software design structures.

DesignPattern/DesignPatternCore · high confidence

New diagnostics demo solution with multiple project templates

A new solution file, diagnostics-demo.sln, has been added to the CSharpGuide/diagnostics directory. This solution groups five distinct demo projects: EventSourceDemo, MetricDemo, CollectionMetricDemo, DistributedTraceDemo, and DistributedTraceWebDemo. These projects serve as practical examples for implementing diagnostics features such as event sourcing, metrics collection, and distributed tracing within the C\# guide.

CSharpGuide/diagnostics · high confidence

New functional programming demo project with C\# examples

Added a new C\# demo solution (Demo.sln) containing a comprehensive set of examples illustrating functional programming concepts. The project includes implementations of immutable data structures (e.g., AccountState, List), Either/Option monads, function composition, and middleware patterns. It also features domain-specific examples such as a functional MakeTransfer controller, event-sourced account logic, and database query abstractions using Dapper, alongside exercises and non-functional counterparts for comparison.

FunctionalCSharp/src/Demo · high confidence

New system design interview guides added for distributed systems and web infrastructure

Added comprehensive design interview guides for eight distributed system topics: Unique ID Generation (Snowflake), Consistent Hashing, Key/Value Stores, News Feed Systems, Notification Systems, Rate Limiters, Search Autocomplete (Trie), and URL Shorteners. Also added a Web Crawler design guide. These markdown files provide high-level architecture, component breakdowns, and deep-dive algorithmic details (e.g., token bucket, CAP theorem, trie optimization) to help users prepare for system design interviews.

SystemDesignInterview · high confidence

Rx.NET documentation and diagrams added

The RxNet module now includes a comprehensive set of documentation files covering key types, sequence creation, filtering, transformation, aggregation, partitioning, combination, scheduling, timing, error handling, and publishing operators. The update also adds four appendix documents explaining the limitations of classic IO streams, disposable patterns, usage guidelines, and the algebraic underpinnings of Rx. Additionally, SVG marble diagrams for Chapter 2 have been added to visualize input/output and on/off states.

RxNet · high confidence

Source generator demos now include enum extension generation and property notification

The SourceGeneratorGuide demo project has been expanded to demonstrate additional source generation capabilities. It now includes an \EnumExtensionsAttribute\ that generates fast \ToStringFast\ extension methods for enums (such as \Direction\, \Color\, and \RoleEnum\), and an \AutoNotifyAttribute\ that generates \INotifyPropertyChanged\ boilerplate for partial class properties. The demo also features a basic augmenting generator that adds a \GeneratedMethod\ to \UserClass\ and a partial method hook in \Program\ to illustrate how generated code integrates with user-defined classes.

CSharpGuide/SourceGeneratorDemo/SourceGeneratorGuide · high confidence

Behavioural changes

1 commit (0 fixes) modifying CPPPrimer/src

A change to existing behaviour in CPPPrimer/src — 1 commit, 2 files.

CPPPrimer/src · medium confidence · unverified

Migrate site from Jekyll to MkDocs

The documentation site has been rebuilt using MkDocs with the Material theme, replacing the previous Jekyll-based setup. This change introduces a new navigation structure organized by topic (e.g., C\# Async, Clean Architecture, DDIA), adds support for dark/light mode toggling, and configures automatic deployment to GitHub Pages via a new workflow. Users will now access the content through a MkDocs-generated static site with improved search and navigation features.

(repo-wide) · high confidence

Optimized IL generation for dynamic method invocation

The DynamicLoadExecutor now uses more efficient IL instructions when generating delegates for calling methods on dynamically loaded assemblies. Specifically, the code generation for method calls has been optimized by removing unnecessary local variable storage and switching from virtual method calls (Callvirt) to direct method calls (Call), which reduces overhead during execution.

WHPerformanceDotNet/src/DynamicLoadExecutor · high confidence

Fixes

Added C++ generic template examples and fixes

Added several new C++ source files demonstrating generic programming concepts, including template type inference, function pointers, higher-order functions, perfect forwarding (std::forward), variadic templates, and explicit template instantiation control. The commit also includes fixes for template type inference and member template definitions within the provided examples.

CPPPrimer/src/16-generic-template · medium confidence

Dependencies

Initial project structure and dependency configuration for C\# and .NET samples

This change introduces the foundational project structure for a collection of C\# and .NET educational and demonstration projects. It adds numerous \.csproj\ files across directories such as \AsyncInCSharp\, \CSharpGuide\, \ConcurrencyInCSharpCookbook\, and \WHPerformanceDotNet\, establishing target frameworks ranging from \netcoreapp2.0\ to \net10.0\ and configuring language features like nullable reference types and implicit usings. It also defines specific package dependencies for key areas, including \System.Data.SqlClient\ for data access, \OpenTelemetry\ components for distributed tracing and metrics, \Microsoft.CodeAnalysis\ packages for source generator and Roslyn SDK demonstrations, and \Nito.AsyncEx\ and \System.Reactive\ for concurrency and reactive programming examples.

(dependencies) · high confidence

Housekeeping

Added placeholder text files to TPLDataflow directory

Added several new text files (0001.txt, 0001\_1.txt, 0002.txt, 00022.txt) to the WHPerformanceDotNet/src/TPLDataflow directory. These files contain repetitive, non-functional placeholder text and do not represent any product feature or behavioral change.

WHPerformanceDotNet/src/TPLDataflow · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 40 → 41 (+1.7)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 56 → 58 (+2.0)
  • Architecture 100 → 74 (-25.9)
  • Maturity 41 → 61 (+20.3)
  • Readiness 33 → 33 (+0.0)
  • Security 34 → 32 (-1.7)
  • Accessibility 80 → 80 (+0.0)
  • Performance 72 → 71 (-0.9)

Resolved (593)

  • CommentedOutCode (docs/AsyncInCSharp/AwaitWhatActuallyToDo/WhereAwaitCanNotBeUsed.cs)
  • CommentedOutCode (docs/CSharpGuide/LanguageVersions/8.0/DefaultInterfaceMethod.cs)
  • CommentedOutCode (docs/CSharpGuide/LanguageVersions/8.0/DefaultInterfaceMethod.cs)
  • CommentedOutCode (docs/CSharpGuide/Net6WebDemo/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/SourceGeneratorDemo/MySourceGenerator/AugmentingGenerator.cs)
  • CommentedOutCode (docs/CSharpGuide/SourceGeneratorDemo/MySourceGenerator/Enums/EnumToGenerator.cs)
  • CommentedOutCode (docs/CSharpGuide/SourceGeneratorDemo/MySourceGenerator/Enums2/EnumToGenerator.cs)
  • CommentedOutCode (docs/CSharpGuide/SourceGeneratorDemo/MySourceGenerator/MyXmlGenerator.cs)
  • CommentedOutCode (docs/CSharpGuide/SourceGeneratorDemo/MySourceGenerator/MyXmlGenerator.cs)
  • CommentedOutCode (docs/CSharpGuide/SourceGeneratorDemo/SourceGeneratorGuide/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/asynclocal/asynclocal/Program.cs)
  • CommentedOutCode (docs/CSharpGuide/diagnostics/EventSourceDemo/Program.cs)
  • …and 573 more

New (78)

  • Documentation: no build, run or usage example (ConcurrencyInCSharpCookbook/08Collections/README.md)
  • End-of-life runtime: .NET net5.0 (CSharpInDepth/Chapter12_Deconstruction_PatnerMatching/Chapter12_Deconstruction_PatnerMatching.csproj)
  • End-of-life runtime: .NET net5.0 (CSharpInDepth/Chapter13_HighPerformancePassByReference/Chapter13_HighPerformancePassByReference.csproj)
  • End-of-life runtime: .NET net5.0 (CSharpInDepth/Chapter14_ConciseCode/Chapter14_ConciseCode.csproj)
  • End-of-life runtime: .NET net6.0 (CSharpGuide/Net6WebDemo/Net6WebDemo.csproj)
  • End-of-life runtime: .NET net6.0 (FunctionalCSharp/src/Demo/Demo.csproj)
  • End-of-life runtime: .NET net6.0 (FunctionalCSharp/src/MarsonShine.Functional/MarsonShine.Functional.csproj)
  • End-of-life runtime: .NET net6.0 (FunctionalCSharp/src/Marsonshine.Functional.Data/Marsonshine.Functional.Data.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/LanguageVersions/11.0/csharp11/csharp11.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/LanguageVersions/7.3/RefForeach/RefForeach.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/SourceGeneratorDemo/SourceGeneratorTests/SourceGeneratorTests.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/asynclocal/asynclocal/asynclocal.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/diagnostics/CollectionMetricDemo/CollectionMetricDemo.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/diagnostics/DistributedTraceDemo/DistributedTraceDemo.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/diagnostics/DistributedTraceWebDemo/DistributedTraceWebDemo.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/diagnostics/EventSourceDemo/EventSourceDemo.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/diagnostics/MetricDemo/MetricDemo.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/performance/strings/strings.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/roslySdkDemo/HelloSyntaxTree/HelloSyntaxTree.csproj)
  • End-of-life runtime: .NET net7.0 (CSharpGuide/roslySdkDemo/SemanticQuickStart/SemanticQuickStart.csproj)
  • …and 58 more

API surface

  • Unchanged — 2 HTTP endpoints

Architecture

  • Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

Added bounded contexts (1)

  • CSharpGuide

Removed bounded contexts (1)

  • docs

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

MarsonShine/Books was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 1ccbbeefebffb728557d33dda0faaa2bfd7938d0 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.