protobuf-net is a mature, high-performance Protocol Buffers serialization library for .NET. It enables serialization of .NET objects to protobuf format and deserialization back, supporting both code-first (attributes) and schema-first (.proto files) approaches. The architecture consists of a core serialization engine, framework integrations (ASP.NET Core, WCF, gRPC), build-time source generators and analyzers, and extensibility mechanisms. Key entry points include the ProtoBuf.Serializer static facade, RuntimeTypeModel for advanced configuration, and ProtoContract/ProtoMember attributes for defining contracts. The library excels in performance through features like BufferPool for memory efficiency, AOT compilation to avoid reflection overhead, and sophisticated handling of object references, inheritance, and extensibility.
This is the official ASP.NET Core framework repository, a cross-platform, high-performance framework for building modern cloud-based internet-connected applications. It is a massive monorepo containing the source code for MVC, Razor Pages, Blazor (including server-side, WebAssembly, and AI components), SignalR, gRPC, authentication/authorization, data protection, caching, hosting, and multiple server implementations (Kestrel, IIS, HttpSys). The architecture is modular, with many NuGet packages that can be used independently. Key entry points include WebApplication.CreateBuilder, UseStartup, MapControllers, MapBlazorHub, and MapHub. The framework relies on the .NET runtime and the ASP.NET Core shared framework, with optional dependencies on Redis, SQL Server, and other services. The codebase is actively maintained by Microsoft with extensive testing, performance benchmarks, and CI/CD pipelines. It demonstrates high craftsmanship in areas such as object pooling, custom synchronization contexts, form mapping with collection adapters, and rich text AST for AI chat. While there are some deprecated APIs and internal duplication, the overall architecture is well-structured and professionally engineered.
This repository is the official gRPC implementation for .NET (grpc-dotnet), providing a comprehensive set of libraries for building gRPC services and clients on ASP.NET Core. It includes server-side integration via `Grpc.AspNetCore.Server` with full support for unary, server-streaming, client-streaming, and duplex streaming calls, as well as client-side libraries (`Grpc.Net.Client`, `Grpc.Net.ClientFactory`) that leverage `HttpClient` and DI. The codebase also covers gRPC-Web (both server middleware and client handler), health checks, server reflection, load balancing, retry/hedging policies, compression, interceptors, and a CLI tool (`dotnet-grpc`) for managing protobuf references. The architecture is modular, with clear separation of concerns: core abstractions in `Grpc.Core.Api`, shared utilities in `Grpc.Net.Common`, and platform-specific implementations. Extensive unit and functional tests, performance benchmarks, and interop test assets ensure correctness and performance across .NET versions and platforms.
YARP (Yet Another Reverse Proxy) is a high-performance, extensible reverse proxy toolkit for .NET, built on ASP.NET Core. It provides a library and samples for creating custom proxy servers with features including request forwarding, load balancing (random, round-robin, least-requests, power-of-two-choices), active and passive health checks, session affinity (cookie, hash, ARR, custom header), request/response transforms, and telemetry consumption. The architecture is middleware-based, with a pipeline that includes routing, load balancing, session affinity, health checks, and delegation (Http.sys). Configuration is driven by immutable records and supports dynamic reload via change tokens. YARP also includes a Kubernetes Ingress Controller module that watches Ingress, Service, Endpoint, and Secret resources to dynamically configure the proxy. The codebase demonstrates strong engineering practices: extensive unit and functional tests, pluggable policy interfaces, efficient stream copying with telemetry, and a transform builder pattern for declarative request/response modifications. It is actively maintained by Microsoft and used in production scenarios.
This repository is a .NET library (distributed as NuGet packages) that adds a second-level query cache to Entity Framework Core applications. In production, it registers a DbCommandInterceptor that intercepts every EF Core database command: SELECT queries are converted into a cache key by hashing the SQL text, parameters, and connection string; on a cache hit, the stored result set is replayed through a custom DbDataReader implementation so EF Core never touches the database; on a miss, the query executes normally and the result is serialized into a row/column format for storage. Cache invalidation is automatic — when SaveChanges/SaveChangesAsync runs, the interceptor parses the SQL to identify affected tables and evicts all cache entries that depend on them. The architecture is a clean provider pattern. The core package (EFCoreSecondLevelCacheInterceptor) defines the interceptor, cache-key generation, SQL table extraction, and the IEFCacheServiceProvider abstraction, while separate companion packages implement backends: MemoryCache, StackExchange.Redis (with custom MessagePack serialization), FusionCache, .NET HybridCache, EasyCaching.Core, and CacheManager.Core. Public entry points are the AddEFSecondLevelCache() DI extension and the Cacheable()/NotCacheable() query extensions, with fluent configuration for expiration modes (absolute/sliding/never), per-query or global policies, and lock modes for concurrency. The codebase is actively maintained (last commit 2026-09-19, zero open issues, dependabot-clean), multi-targets .NET from net462/netstandard2.0 through net10.0, and enforces strict quality gates: TreatWarningsAsErrors, SonarAnalyzer, Meziantou analyzers, and heap-allocation analyzers. Test coverage is extensive — unit tests for key generation, SQL parsing, and data-reader reconstruction, plus integration tests across providers and issue-specific repro projects. Notable craftsmanship includes a hand-written XxHash64 unsafe implementation for fast key hashing, a DbDataReader reconstruction layer that transparently replays cached rows to EF Core, and a SQL table-name extraction processor driving invalidation. Primary risks are the heavy conditional compilation across 10+ target frameworks, SQL parsing heuristics that can miss edge cases (CTEs, subqueries, quoted identifiers), and reliance on third-party cache libraries — CacheManager.Core is explicitly unmaintained upstream. Bulk operations (ExecuteUpdate/ExecuteDelete) bypass the interceptor and require manual invalidation.
Ocelot is a .NET library providing a highly configurable, middleware-based API Gateway for ASP.NET Core applications. It is not a standalone application but a framework that integrates into an ASP.NET Core host via `AddOcelot()` and `UseOcelot()`. Its architecture centers on a fixed-order middleware pipeline that processes incoming HTTP requests through stages including configuration loading, route matching, security, rate limiting, authentication, authorization, load balancing, URL rewriting, and proxying to downstream services. The pipeline is extensible through custom delegates and handlers, and supports advanced features like WebSocket proxying, response aggregation, and circuit breaking. The codebase demonstrates strong engineering practices with a clean separation of concerns across modules for Configuration, Routing, Load Balancing, Quality of Service, Rate Limiting, Caching, and WebSocket proxying. It features an extensive test suite with over a thousand unit and acceptance tests, many of which are linked to specific GitHub issues, indicating rigorous issue-driven development. The configuration system is particularly robust, supporting JSON file merging, environment-specific overrides, dynamic reloading, and fluent validation. While the core architecture is modern and well-maintained, targeting .NET 8 through 10, the codebase exhibits some technical drift. It relies on deprecated dependencies like `Microsoft.Extensions.DiagnosticAdapter` and `Newtonsoft.Json` alongside the newer `System.Text.Json`. There are known concurrency bottlenecks (e.g., a single static lock in rate limiting, blocking calls in the async configuration poller) and a reliance on reflection in unit tests that makes them brittle. Several properties are marked obsolete with planned removal in version 25.0. Despite this debt, Ocelot contains several genuinely reusable components that demonstrate non-obvious craftsmanship, such as a generic, thread-safe Circuit Breaker, a flexible Retry helper, and a clean DSL parser for claim transformations. It is an ideal choice for .NET teams requiring a robust, self-hosted, and extensible API gateway without the overhead of a commercial solution. Its primary value lies in its comprehensive feature set, extensibility, and the quality of its testing infrastructure.
The JT808Gateway is a .NET 10.0-based implementation of a gateway for the JT/T 808 protocol, commonly used in Chinese vehicle telematics systems. It handles TCP/UDP connections from vehicle terminals, processes JT808 messages (such as location reports, status updates, and commands), and provides mechanisms for sending downlink messages to devices. The gateway integrates with Apache Kafka for message queuing and decoupling, and offers a WebApi for management operations and real-time monitoring via SignalR. The architecture follows a modular design with clear separation of concerns: the core gateway handles transport and message routing, abstractions define extensibility points for custom integrations, and hosted services manage background tasks like logging and session notices. The system uses System.IO.Pipelines for high-performance I/O and employs the builder pattern for configuration. Session management is robustly implemented to track device connections by terminal ID, ensuring reliable state tracking for online/offline events. Key reusable components include the abstraction layer (enabling pluggable transports and message handlers) and the session management module (providing thread-safe session lifecycle management). The gateway also features comprehensive testing and benchmarking suites to validate performance and correctness under load. While the codebase shows signs of active maintenance with recent updates, it contains some obsolete markers indicating ongoing evolution, and the dual-mode architecture (simple vs queue-based) may introduce complexity that requires careful consideration for deployment.
BlazorBlueprint is a comprehensive Blazor UI component library inspired by shadcn/ui, providing over 112 styled components and 28 headless primitives. It targets .NET 8 across Server, WebAssembly, and Auto render modes, with full accessibility (ARIA, keyboard navigation), theming via CSS custom properties (compatible with shadcn CSS variables), and zero Tailwind/Node setup. The library is split into two layers: Primitives (headless, behavioral components with focus management, positioning, and portal services) and Components (styled, ready-to-use widgets like DataGrid, charts, forms, dialogs, and navigation). It ships with four icon libraries (5,200+ icons) and 11 chart types via Apache ECharts. The architecture emphasizes composability through cascading contexts, a consistent form-field pattern, and a utility-first approach with the ClassNames.cn helper for Tailwind class merging. The codebase demonstrates strong engineering practices: extensive use of generics, expression trees for filtering, JS interop with guarded disposal, and a localization system with 200+ string keys. However, the large API surface, heavy JS interop, and limited test coverage (only a few unit tests for DataGrid and hierarchy utilities) present maintenance risks.
BililiveRecorder is a multi-platform application for recording Bilibili (mikufans) live streams. It provides a desktop GUI (WPF), a cross-platform CLI, and a web interface (ASP.NET Core) with REST and GraphQL APIs. The core system manages room monitoring, stream capture via HTTP, danmaku (live chat) recording, and FLV file processing with a pipeline-based repair engine that fixes timestamp jumps, duplicate headers, and other stream corruption. It supports hierarchical configuration, user scripting (via embedded Jint JavaScript runtime), and webhook notifications. The application is modular: separate libraries for FLV parsing/writing (BililiveRecorder.Flv), core recording logic, toolbox utilities (fix, analyze, merge danmaku), and a web frontend with an embedded ArtPlayer-based video player. The codebase is well-structured with dependency injection, unit tests, and code generation for configuration models.
This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.
AutoFilterer is a .NET library that automatically generates LINQ expressions from Data Transfer Objects (DTOs) for filtering, sorting, and pagination on IQueryable collections. It is designed to be compatible with OpenAPI 3.0 specifications, unlike oData or GraphQL. The core architecture revolves around filter DTOs that inherit from FilterBase or its derivatives (PaginationFilterBase, OrderableFilterBase). Properties in these DTOs are decorated with attributes (e.g., StringFilterOptions, OperatorComparison, CompareTo) or use special types (StringFilter, OperatorFilter<T>, Range<T>) to define filtering rules. The library builds expression trees at runtime and applies them via the ApplyFilter extension method. It also provides a Swagger integration package (AutoFilterer.Swagger) to expose filter parameters in Swagger UI, and a source generator (AutoFilterer.Generators) to automatically create filter DTOs from entity classes. The codebase is well-structured with clear separation of concerns: abstractions (IFilter, IFilterableType), attributes, types, extensions, and a dynamic filter variant. It includes comprehensive unit tests, benchmark tests, and a sandbox application demonstrating usage with a Northwind database. The library targets netstandard2.0, netstandard2.1, and net9.0, making it broadly compatible. While the core library is mature and actively maintained, some ancillary packages (e.g., Swagger integration) use slightly outdated dependencies (Swashbuckle 5.x), and the documentation has some TODO sections. Overall, it is a solid, reusable filtering framework with high craftsmanship in expression tree manipulation.
This repository is a curated, community-maintained 'awesome list' for the Blazor framework (a Microsoft .NET web UI framework). It aggregates and categorizes hundreds of external resources including sample projects, tutorials, libraries, videos, articles, podcasts, tooling, books, and community links. The main entry point is the README.md, which provides a structured table of contents with shields.io badges (GitHub stars, last commit, license) for each listed resource. The repository also contains yearly archives (2017–2024) tracking historical resources, a Component-Bundle-Comparison.md that compares 16+ Blazor UI component libraries, and a CONTRIBUTING.md with contribution guidelines. The repository itself contains no executable application code or data pipelines; it is purely a documentation/curation project that serves as a discovery and reference hub for the Blazor ecosystem. The curation methodology follows a consistent pattern of categorization, metadata badges, and archival, making it a reusable template for other awesome lists. The repository is actively maintained with recent commits referencing .NET 11 previews in 2026, though the sheer volume of external links introduces inherent risk of link rot and staleness for less popular entries.