dodyg/practical-aspnetcore

This system is a comprehensive library of sample applications and code snippets for the ASP.NET Core framework. It demonstrates a wide range of features including Blazor (Server, WebAssembly, SSR), gRPC, MVC, Razor Pages, and minimal APIs. The collection covers core infrastructure such as dependency injection, configuration, caching, and routing, alongside advanced topics like localization, authentication, and background services. It serves as a practical reference for developers to understand and implement modern .NET web development patterns.

121 changes.

This period was defined by a massive expansion of the sample library, introducing dozens of new projects covering Blazor, gRPC, endpoint routing, and configuration patterns. The work focused on modernizing existing samples to target .NET 6 and 10, while adding comprehensive build and debugging configurations to support local development.

143 changes.

This period was dominated by the migration of existing samples to the .NET 6 minimal hosting model and the introduction of numerous new sample projects. The work focused on demonstrating modern ASP.NET Core features, including gRPC-Web, Blazor Server localization, and advanced JSON DOM manipulation, while also updating legacy samples to align with the new architectural patterns.

85 changes.

This period is defined by the extensive addition of new sample projects across the codebase, covering a wide array of ASP.NET Core and .NET features. The work focuses on demonstrating modern development patterns, including minimal APIs, Blazor, OpenTelemetry, and various middleware implementations. It also includes updates to existing samples to reflect newer .NET versions and framework capabilities.

A new ASP.NET Core MVC application was added to demonstrate API versioning. The project includes a controller that exposes endpoints for version 1 and version 2 of the API, allowing users to see how API versioning is implemented in a web application.

projects/mvc/api-versioning · high confidence

A new sample project demonstrates ASP.NET Core 10's built-in Server-Sent Events (SSE) support via \Results.ServerSentEvents()\. The sample includes a C\# endpoint that streams an \IAsyncEnumerable\<string\>\ to clients using the \text/event-stream\ header, along with an HTML/JavaScript client that connects to the SSE endpoint. The project is configured with a solution file and a README explaining the features, such as automatic flush management and proper cancellation token handling.

projects/sse · high confidence

Introduces a new \projects/net10\ directory containing sample applications for .NET 10, including minimal API examples for Server-Sent Events, OpenAPI documentation, form validation, and memory pool eviction. The update also adds a \global.json\ file to pin the SDK version to 10.0.100 and includes VS Code settings and build scripts to support the new project structure.

projects/net10 · high confidence

The authentication project area was updated to include five distinct samples demonstrating modern ASP.NET Core authentication patterns. These include simplified JWT bearer and cookie authentication, mixed scheme authorization, a Web API template using .NET 10's built-in OpenAPI 3.1 support with Scalar UI, and a full Identity API implementation backed by Entity Framework Core. The update also adds build scripts and a consolidated readme to organize these examples.

projects/authentication · high confidence

A new sample project (open-api-12) demonstrates support for the HTTP QUERY method and OpenAPI 3.2 in .NET 11. The sample uses the Scalar UI to expose the API reference and includes a global.json pinning the SDK to version 11.0.100-preview.6.

projects/net11 · high confidence

A new ASP.NET Core application has been added to demonstrate request-based localization. The app configures supported cultures (en-US, en-GB) and uses resource files to display localized strings based on the request's UI culture, allowing users to switch between US and British English to see how culture and UI culture affect formatting and resource lookup.

projects/localization/localization-3 · medium confidence

A new sample project (json-15) was added to demonstrate parsing a JSON array using System.Text.Json.Nodes and querying it with LINQ to find a specific node. The project includes Program.cs, which parses a JSON string containing an array of objects and uses LINQ to find a non-binary person with exactly three favorite numbers, and a README explaining the example.

projects/json/json-15 · medium confidence

A new example project (json-10) demonstrates how to control JSON serialization behavior in .NET 6 using the System.Text.Json library. The example shows how to configure JsonSerializerOptions for camelCase naming and null/default value handling, and illustrates the use of JsonIgnoreCondition attributes (WhenWritingNull, WhenWritingDefault, Always, Never) to control property serialization.

projects/json/json-10 · medium confidence

The mvc-localization-6 sample now targets .NET 6, providing a working MVC application that demonstrates localization using .resx files for English and French. The application configures request localization to support fr-FR and en-US cultures, with French set as the default, and exposes localized strings (Hello, Goodbye, Yes, No) in the Home view.

projects/mvc/localization/mvc-localization-6 · medium confidence

A new sample application has been added to demonstrate MVC routing in .NET 6. The project configures a web application with controller-based routing, mapping the root URL and a default controller/action pattern, and includes a home controller that renders a simple HTML page with navigation links.

projects/mvc/routing/routing-1, projects/mvc/tag-helper/tag-helper-1 · medium confidence

The routing-7 project now includes a complete, runnable MVC application using the .NET 6 minimal API style (WebApplication.CreateBuilder). It demonstrates attribute routing with \[Route\] and \[HttpGet\] attributes on a HomeController, serving HTML content for index and about pages. VS Code launch and task configurations are added to support debugging and building the project.

projects/mvc/routing/routing-7 · medium confidence

The directory now contains a new .NET 6 MVC application using the minimal hosting model (WebApplication.CreateBuilder). The entry point (Program.cs) configures controllers and maps routes, including a home controller with index and about pages. VS Code launch and task configurations are added to support debugging and building the project.

projects/mvc/routing/routing-6 · high confidence

A new sample project has been added to the repository, demonstrating the use of the System.Text.Json library in a .NET 6 Web API application. The sample includes a Person model and a root endpoint that serializes an object to JSON, accompanied by a README explaining the usage of JsonSerializer.SerializeAsync.

projects/json/json, projects/json/json-3 · high confidence

A new sample project has been added to demonstrate serializing complex object graphs using System.Text.Json. The sample shows how to configure JsonSerializerOptions for pretty-printing, camelCase naming, and ignoring nulls, specifically highlighting the serialization of a Dictionary\<string, object\> to generate flexible JSON structures.

projects/json/json-5 · high confidence

A new sample project has been added to demonstrate configuring System.Text.Json serialization options, including handling null values, applying camelCase naming policies, and formatting output for readability.

projects/json/json-2 · medium confidence

A new WebSockets sample application has been added to the web-sockets-3 project, implementing a basic echo and broadcast server using the .NET 6 minimal API and WebSockets middleware. The app manages client connections via a ConnectionManager and includes a simple HTML/JS client for testing. This aligns with the project's upgrade to .NET 6.

projects/web-sockets/web-sockets-3 · high confidence

A new benchmark project has been added to compare two approaches for converting CamelCase strings to snake\_case: a manual implementation based on Newtonsoft.Json and a LINQ-based approach. The project includes a Program.cs file containing the benchmark runner and the string conversion logic, along with a README.md file explaining the purpose and instructions for running the benchmarks using dotnet.

projects/json/json-8 · high confidence

A new sample project (caching-2) demonstrates memory caching with file-based expiration in .NET 6. The application uses IMemoryCache to store a greeting message and configures the cache entry to expire when cache-file.txt is modified, allowing users to see how cache invalidation works in a web context.

projects/caching/caching-2 · high confidence

A new sample project is added that demonstrates enabling MVC with the default controller route in .NET 6. The project includes a minimal WebApplication setup with controller-based routing and a sample HomeController, along with VS Code launch and task configurations to support local development and debugging.

projects/endpoint-routing/new-routing-3 · high confidence

A new .NET 6 sample project has been added to demonstrate endpoint routing. The project includes a Program.cs that uses the modern WebApplication builder, configures controllers with attribute routing, and employs a middleware to generate URLs via LinkGenerator. VS Code launch and task configurations have been added to support debugging and building the project.

projects/endpoint-routing/endpoint-routing-6 · high confidence

Added a new README.md file documenting 11 ASP.NET Core features, including Server Addresses, Request, Connection, Custom, Request Culture, Session (with and without Redis), Maximum Request Body Size, and IHttpResponseBodyFeature. Included build scripts (build.bat and build.sh) to compile each feature project.

projects/features · high confidence

A new .NET 6 web application is introduced in the localization-2 project, featuring request-based culture switching between English (en-US) and French (fr-FR). The app configures ASP.NET Core's localization services to read from resource files (Common.en-US.resx and Common.fr-FR.resx) and allows users to toggle the display language via query string parameters.

projects/localization/localization-2, projects/localization/localization-5, projects/localization/localization-6 · high confidence

A new .NET 6 minimal API application has been added to the i-application-lifetime project. This application demonstrates handling application lifetime events (starting, stopping, and stopped) using the IHostApplicationLifetime service, and responds with a 'Hello world' message.

projects/i-application-lifetime · high confidence

A new .NET 6 project has been added to the file-provider directory, demonstrating how to serve static files and enable directory browsing in a minimal API application. The example includes a Program.cs that configures static file serving and a directory browser at /browse, along with sample wwwroot assets (CSS, HTML, and text files) to illustrate the feature.

projects/file-provider/serve-static-files-6 · high confidence

A new minimal API endpoint has been added to the features-request-culture project, implementing a request localization feature that reads the current culture from the request and returns the English name of that culture in the HTTP response.

projects/features/features-request-culture · medium confidence

A new .NET 6 minimal API project has been added that demonstrates custom Tag Helpers. The sample includes an AlertTagHelper that renders Bootstrap alert classes based on context, along with Danger and Warning tag helpers that set the alert type. The view uses these helpers to display different alert styles, illustrating data passing from parent to child tags.

projects/mvc/tag-helper/tag-helper-5 · high confidence

A new sample application has been added to demonstrate the \GetEncodedUrl\ extension method from \Microsoft.AspNetCore.Http.Extensions\. The app serves an HTML page that displays the fully escaped URL for various test paths, such as those with query parameters and special characters. The project has been upgraded to target .NET 6.

projects/uri-helper/uri-helper-get-encoded-url · high confidence

A new sample project has been added to demonstrate the consolidated IHttpResponseBodyFeature in .NET 6. The sample shows how to write directly to the HTTP response body using the new interface, which replaces the previous separate features for body, file transfer, and buffering. A README file is also included to explain the feature's purpose.

projects/features/features-http-body-response · medium confidence

A new sample application has been added to the utils folder, demonstrating how to use FileExtensionContentTypeProvider to resolve MIME types for file extensions. The project is built on .NET 6 and includes a minimal API endpoint that displays MIME mappings for .pdf, .doc, .docx, and .json files.

projects/utils/media-type-names-2 · high confidence

A new sample project (json-7) demonstrates serializing objects to JSON with a custom naming policy that converts property names to snake\_case. The implementation includes a \SnakeCaseNamingPolicy\ and a \StringUtils\ helper to perform the case conversion, allowing users to see how to configure \JsonSerializerOptions\ in .NET 6.

projects/json/json-7 · high confidence

A new sample project for .NET 6 demonstrates manual JSON serialization using the \System.Text.Json\ API. The sample creates a web application that constructs a JSON payload containing various data types (strings, numbers, booleans, dates, objects, and arrays) and writes it directly to the HTTP response stream using \Utf8JsonWriter\.

projects/json/json-6 · high confidence

A new sample project (json-12) demonstrates how to parse and access number, string, and array values from a JSON string using the System.Text.Json.Nodes API. The sample includes a minimal web application that reads JSON data and writes the parsed values to the HTTP response.

projects/json/json-12 · high confidence

A new sample project has been added that demonstrates serving static files using the minimal API approach in .NET 6. The application configures the static file middleware and serves content from the wwwroot directory, including an HTML page and CSS styles.

projects/file-provider/serve-static-files-1 · high confidence

Added three new sample projects (json-23, json-24, json-25) demonstrating advanced System.Text.Json customization in .NET 7. json-23 shows how to ignore negative values during serialization, json-24 demonstrates writing integer values as strings, and json-25 illustrates adding an extra timestamp property to the serialized output.

projects/json/json-23, projects/json/json-24, projects/json/json-25 · high confidence

New example projects (caching-1 and caching-3) demonstrate in-memory caching in .NET 8. caching-1 shows basic cache set/get, while caching-3 adds console logging and registers a post-eviction callback to log when cache entries expire.

projects/caching/caching-3 · high confidence

A new sample project for endpoint routing is introduced, demonstrating how to attach metadata to inline middleware using \IEndpointConventionBuilder.WithMetadata\. The project targets .NET Core 3.1 and includes VS Code configuration files (\.vscode/launch.json\ and \.vscode/tasks.json\) to enable debugging and task execution for the \new-routing-3\ project.

projects/endpoint-routing/new-routing-15 · medium confidence

Added .vscode/launch.json and .vscode/tasks.json files to enable debugging and building the new-routing-14 sample project in Visual Studio Code. The launch configuration targets the netcoreapp3.1 build output, allowing developers to run and debug the application directly from the IDE.

projects/endpoint-routing/new-routing-14 · high confidence

Developers can now launch and debug the MVC routing example directly from VS Code using the new .NET Core launch and task configurations. The project includes a minimal ASP.NET Core 6 application with a HomeController that demonstrates attribute-based routing for the Home and About pages.

projects/mvc/routing/routing-4 · high confidence

A new 'version' project has been added to the repository, providing a minimal ASP.NET Core application that displays detailed runtime information. The app uses the modern WebApplication API to serve an HTML page showing the .NET Environment.Version, RuntimeInformation.FrameworkDescription, CoreCLR and CoreFX build hashes, and OS/architecture details. The project includes a README explaining its purpose as a system information demo.

projects/version · high confidence

A new Program.cs file introduces two nested middleware endpoints: /hello and /hello/world. The /hello endpoint returns an HTML page with links to both /hello and /hello/world. The /hello/world endpoint writes the current request path and path base to the response. This adds new functionality for testing or demonstrating middleware behavior.

projects/middleware/middleware-5 · medium confidence

A new ASP.NET Core 6 application has been added to the parameter-transformer project. It demonstrates how to configure a custom IOutboundParameterTransformer to automatically convert PascalCase controller and action names into kebab-case URLs (e.g., AboutUs becomes about-us). The sample includes a HomeController and a GetThisOffersNowController to show the transformation in action.

projects/endpoint-routing/parameter-transformer · high confidence

A new sample application has been added to demonstrate the UriHelper.GetEncodedPathAndQuery method. The project targets ASP.NET Core 6 and provides a web interface that displays the encoded path and query string for various test URLs, including those with special characters and fragments.

projects/uri-helper/uri-helper-get-encoded-path-and-query · high confidence

The projects/net9 directory now includes sample projects demonstrating ASP.NET Core 9 features. The 'open-api-3' sample shows how to use the built-in OpenAPI document generator, while 'open-api-4' demonstrates using NSwag UI to visualize the generated OpenAPI document. Additionally, the 'typed-results-2' sample illustrates the use of \TypedResults.InternalServerError\ for returning HTTP 500 status codes. These samples require .NET SDK 9.0.100.

projects/net9 · high confidence

A new basic sample demonstrating ASP.NET Core Identity with Entity Framework Core and SQLite has been added. This sample provides a complete authentication flow, allowing users to register, sign in, sign out, and access restricted areas. The implementation includes account controllers for login and registration, a home controller, and views for the login, registration, and email confirmation processes.

projects/security/authentication-with-identity · high confidence

A new sample project is introduced that demonstrates how to retrieve endpoint metadata from MVC controller action methods using a custom middleware. The implementation includes a GreeterMiddleware that extracts a custom MessageAttribute from the current endpoint and stores it in the HTTP context, allowing the HomeController to display metadata-driven content. This serves as a practical example of leveraging the Endpoint routing system in ASP.NET Core.

projects/endpoint-routing/new-routing-13 · high confidence

Added a new ASP.NET Core MVC application that demonstrates how to use the Accept-Language HTTP header to determine the request culture. The sample configures the application to support French (fr-FR) and English (en-US) by relying exclusively on the AcceptLanguageHeaderRequestCultureProvider. It includes a global resource file (Global.en.resx and Global.fr.resx) containing localized strings for 'Hello', 'Goodbye', 'Yes', and 'No', and a view that uses jQuery AJAX calls with the Accept-Language header to display translated messages.

projects/mvc/localization/mvc-localization-8 · high confidence

A new SignalR sample was added to the project, including a server-side ChatHub that broadcasts messages to all connected clients, and a corresponding client application that connects to the hub, sends messages, and displays them in a list. The client also serves static files, including the SignalR JavaScript client library from node\_modules.

projects/signalr/signalr-1/Client · high confidence

Added new example projects for ASP.NET Core exception handling. The single-handler example demonstrates implementing \IExceptionHandler\ to catch unhandled exceptions, while the multi-handler example shows how to register multiple \IExceptionHandler\ implementations, where the order of registration determines the exception handling chain.

projects/exception-handler-middleware · high confidence

A new RouteDebugger middleware has been introduced to the web application, which automatically appends an 'X-ASPNETC-ROUTE' header to every HTTP response. This header contains detailed information about the matched route, including the endpoint name, route pattern, allowed HTTP methods, and route data values, aiding in the debugging of routing behavior.

projects/route-debugger-web · high confidence

A new OpenTelemetry example project has been added that demonstrates how to record custom events on an existing ASP.NET Core span. The application configures OpenTelemetry tracing with console export and, on the root path, adds two custom events to the current activity to capture trace and span identifiers. A solution file and VS Code color theme settings are also included to support the new project.

projects/open-telemetry/open-telemetry-2 · high confidence

A new Blazor Server application sample has been added to the project. The sample demonstrates the minimal setup for a Razor component app, including the necessary service registrations for Razor Pages and Server-side Blazor, along with the standard middleware pipeline for HTTPS redirection, static files, and Blazor hub routing.

projects/blazor-ss/HelloWorld · high confidence

A new Blazor Server sample demonstrating JavaScript integration has been added to the JsIntegration folder. The sample includes a minimal Program.cs that configures Razor Pages and Server-Side Blazor, and a README explaining that it shows how to access JavaScript functions available at the windows global scope.

projects/blazor-ss/JsIntegration · medium confidence

A new Index.razor page was added to the Blazor Server JS integration sample, demonstrating JavaScript interop calls (console.log, alert, confirm) using IJSRuntime. The page includes a button to trigger a confirm dialog and logs messages on initial render.

projects/blazor-ss/JsIntegration/Components/Pages · high confidence

A new Blazor Server application is introduced that fetches and displays RSS feed items from a remote XML source. The app uses server-side rendering to load news items via the Microsoft.SyndicationFeed library, rendering each item's description as unescaped HTML using MarkupString. The project includes a minimal Razor layout, a service layer for fetching data, and a static HTML host page that bootstraps the Blazor server circuit.

projects/blazor-ss/RssReader · high confidence

The Blazor Server application structure is introduced with new Razor components: App.razor defines the root router with 404 handling, Index.razor provides the main page content, and \_Imports.razor adds standard namespace imports for the Blazor Server project.

projects/blazor-ss/HelloWorld/Components · high confidence

The project now includes a complete Blazor Server application that demonstrates localization using Portable Object (PO) files. Users can switch between English, French, and Polish by selecting language links, with translations loaded from separate PO files organized in the Resources directory. The implementation uses a custom ILocalizationFileLocationProvider to load multiple PO files per culture, supporting both simple string translations and plural forms.

projects/blazor-ss/Localization-3 · high confidence

Introduces a new Blazor Server application (ChatR) that demonstrates hosting a SignalR Hub alongside Blazor Server-Side components. The sample includes a NotificationHub for real-time broadcasting, a NotificationService client for managing SignalR connections, and a Program entry point configuring the ASP.NET Core pipeline with Razor Pages, static files, and the Blazor server-side endpoint.

projects/blazor-ss/ChatR · high confidence

A new Blazor Server application has been added to demonstrate how to use layout and nested layouts with Razor Component apps. The project includes a minimal WebApplication setup with Server-side Blazor, Razor Pages, and static file support, along with documentation explaining the layout usage.

projects/blazor-ss/Layout · high confidence

A new sample project for Blazor Server-side rendering is introduced, demonstrating how to implement localization using global resources. The update adds Razor components and pages that display translatable text (Hello, Goodbye, Yes, No) and provide links to switch between English and French. The backend configures supported cultures (fr-FR, en, fr) and uses a cookie-based request culture provider to persist the user's language preference across requests.

projects/blazor-ss/Localization · high confidence

A new Blazor Server sample has been added to demonstrate the behavior of Singleton, Scoped, and Transient dependency injection lifetimes. The sample includes the necessary Razor components, services, and a UI that allows users to interact with each lifetime type and observe how state is shared or isolated across browser tabs and page reloads.

projects/blazor-ss/DependencyInjection · high confidence

A new Blazor Server sample was added to demonstrate how to manage communication between components located in different hierarchy levels. The implementation uses a scoped AppState service to facilitate event-based communication, ensuring that state is isolated per user session. The sample includes the AppState class, a Notification component that subscribes to state changes, and UI components (Index, Child) that trigger notifications, all wired together in Program.cs with the appropriate service registration.

projects/blazor-ss/ComponentEvents · high confidence

A new Blazor Server application is introduced that demonstrates localization using Portable Object (PO) files via the OrchardCore.Localization.Core package. The sample includes an Index page that renders localized strings and plural forms, a Switch page that handles language switching via cookies, and corresponding PO resource files for English and French. The setup configures request localization with French as the default culture and supports English and French, enabling users to switch languages on the page.

projects/blazor-ss/Localization-2 · high confidence

The Blazor Server section now includes a comprehensive set of sample applications, including a ChatR hub, dependency injection examples, localization with PO files, RTL/LTR support, and a RenderTreeBuilder example. A README.md file documents these samples, and new build scripts (build.bat and build.sh) have been added to compile each sample project.

projects/blazor-ss · high confidence

Added a collection of Blazor WebAssembly sample components under the \projects/blazor-wasm\ directory. These samples demonstrate various Blazor features including routing, layout, event callbacks, two-way data binding, cascading parameters, and component parameter passing. Each sample is a self-contained Blazor WebAssembly application with its own entry point, pages, and supporting files.

projects/blazor-wasm · high confidence

Added new Razor components to support nested layouts in the Blazor application. This includes a top-level layout (TopLayout) with header, navigation, and footer, along with two nested layout components (NestedLayout, NestedLayout2) that wrap content with distinct styling. Corresponding pages (Index, PageUsingNestedLayout, PageUsingNestedLayout2) are introduced to demonstrate the layout hierarchy, enabling users to navigate between home, nested, and deeply nested page views.

projects/blazor-ss/Layout/Components/Pages · high confidence

A new Blazor Server sample named ComponentEvents-2 has been added to demonstrate cross-component and cross-page communication using the Blazor.EventAggregator library. The sample includes an AppState model, an Index page and Child component that publish events, and a Notification component that subscribes to and displays them, all wired up via dependency injection in Program.cs.

projects/blazor-ss/ComponentEvents-2 · high confidence

A new sample project has been added to demonstrate how to build a Blazor server-side component programmatically using the RenderTreeBuilder API instead of Razor syntax. The project includes a ListNames component that renders an unordered list of names and a nested Separator component, wired up in Program.cs to render via the server-side Blazor pipeline.

projects/blazor-ss/RenderTreeBuilder · high confidence

A new sample project (corewcf-1) has been added to demonstrate a simple request/response flow using CoreWCF. The sample includes a server that hosts a basic HTTP SOAP service and a client that consumes it, illustrating the integration of CoreWCF with .NET 6.

projects/corewcf · high confidence

Added a comprehensive set of sample applications and documentation for the Datastar hypermedia framework using .NET 10 and the Pico CSS framework. The update includes a new README.md at the root of the datastar directory, along with multiple sample projects such as backend-patch-signals, data-attr, data-bind, data-class, data-computed, data-effect, data-ignore, data-indicator, and others. Each sample demonstrates specific Datastar features like server-sent events, signal patching, attribute binding, and conditional rendering, providing developers with practical examples of how to integrate Datastar into .NET 10 applications.

projects/datastar · high confidence

This change introduces a comprehensive set of ELSA workflow engine samples for .NET 8, including activities such as Composite, For, ForEach, Fork, If, ReadLine, Sequence, SetName, SetVariable, and While, as well as workflows demonstrating runtime inputs, custom properties, and result returns. The addition includes build scripts (build.bat, build.sh) and a global.json to standardize the .NET 8 SDK version across the samples.

projects/elsa · high confidence

A new MVC example project has been added that demonstrates how to return a file stream to the browser. The project includes a HomeController with an Index action that displays a download link, and a Hegel action that reads a PDF file from the wwwroot directory and returns it as a FileStreamResult, allowing users to download the file directly.

projects/mvc/result-filestream · high confidence

The MVC localization sample now includes French language support, with new resource files (Global.fr.resx) providing French translations for UI strings like 'Hello' and 'Goodbye'. Additionally, VS Code launch and task configuration files have been added to facilitate debugging and building the project within the VS Code environment.

projects/mvc/localization/mvc-localization-4 · high confidence

A new utility project has been added to the \projects/utils/http-status-codes\ directory. It provides a web application that displays a side-by-side comparison of HTTP status codes from \Microsoft.AspNetCore.Http.StatusCodes\ and \System.Net.HttpStatusCode\, helping developers understand the differences between the two approaches in ASP.NET Core.

projects/utils/http-status-codes · high confidence

A new sample project (new-routing-22) has been added that demonstrates configuring Kestrel to enforce HTTP/2 for all endpoints. The application is configured to run exclusively over HTTPS, requiring users to access the endpoint via the HTTPS URL (https://localhost:5001/) rather than HTTP.

projects/endpoint-routing/new-routing-22 · high confidence

A new 'hello-world' sample project has been added to the RazorSlices directory, providing a minimal example of how to use the Razor-based template engine without MVC, Razor Pages, or Blazor. The sample includes a C\# entry point that maps a root route to render a Razor slice, along with the necessary view files (\_ViewImports.cshtml, Index.cshtml) and configuration files to demonstrate the simplest integration.

projects/razor-slices · high confidence

The Hydro framework samples have been added to the project, providing a comprehensive set of examples for developers. These include samples for component nesting and data flow (component-1, component-2), component lifecycle hooks (component-3), global and child-to-parent event handling (event-global, event-child-parent), event subject filtering (event-global-subject), and cookie management (cookies). Each sample demonstrates specific Hydro capabilities such as dispatching global events, subscribing to events, and managing component state.

projects/hydro · medium confidence

A new example project demonstrates how to read configuration from an INI file using the .NET Options pattern. The application loads settings from a settings.ini file, supporting nested and hierarchical properties (e.g., \privacy:individual:sharedkey\), and exposes the parsed values via a web endpoint.

projects/configurations/configuration-ini-options · high confidence

A new example project demonstrates loading settings from an INI file. The application reads key-value pairs from a 'settings.ini' file and exposes them via a simple HTTP endpoint, allowing users to see how configuration values are parsed and served.

projects/configurations/configuration-ini · high confidence

Users can now run the ImagerSharp application directly via the new Program.cs entry point, which configures ImageSharp for image processing and serves a static HTML page demonstrating image resizing via query parameters. The addition of launchSettings.json enables convenient local development and debugging of the web service.

projects/image-sharp · high confidence

Added a new sample project at projects/json/json-18 that demonstrates creating and serializing JSON documents using the System.Text.Json.Nodes API. The example illustrates both verbose and terse approaches to constructing a JsonObject, providing a practical reference for users working with the JSON DOM.

projects/json/json-18 · high confidence

A new sample project (json-22) demonstrates how to use the System.Text.Json API to parse a JSON array, insert new items at the beginning and end of the array, and serialize the updated structure back to a string.

projects/json/json-22 · high confidence

A new sample project at projects/json/json-20 demonstrates how to parse a JSON array into a writable DOM using System.Text.Json.Nodes.JsonNode.Parse, then modify individual properties (e.g., names) and write the updated document to the HTTP response.

projects/json/json-20 · medium confidence

A new sample project (json-17) was added that demonstrates using the System.Text.Json API to parse a JSON array and use LINQ to find a specific node. The example shows how to parse a JSON array of objects, iterate through them, and identify a specific entry (finding the person with a specific favorite number) using LINQ queries on the JsonNode structure.

projects/json/json-17 · high confidence

The json-11 project now includes a custom JSON converter that serializes and deserializes DateTime values using the JavaScript date ticks format (e.g., /Date(1234567890)/). This allows the application to handle date formats commonly used by JavaScript libraries and legacy APIs, as demonstrated by the sample person.json and the associated Program.cs implementation.

projects/json/json-11 · high confidence

A new sample project (json-13) was added to demonstrate parsing and accessing JSON objects using the \System.Text.Json\ API. The sample shows how to parse a JSON string into a \JsonNode\, extract specific values like name and age, and iterate over object properties using \JsonObject\. This provides a concrete example of handling JSON data in a .NET application.

projects/json/json-13 · high confidence

Introduces new MVC and Razor Pages implementations for the guestbook feature. The MVC implementation includes an EntryController with actions for Index, Edit, Create, and Like, alongside corresponding Razor views for Create, Edit, and Index. The Razor Pages implementation provides Create, Edit, and Index pages with their corresponding code-behind files, enabling users to view, create, edit, and like guestbook entries through both architectural patterns.

projects/razor-pages/razor-pages-mvc · high confidence

A new Razor class library sample is introduced that demonstrates an MVC structure with controllers and views. The change adds an AboutController and HomeController in the MyFeature area, along with their corresponding Razor views. The WebApplication entry point is configured to use AddControllersWithViews() and map area-based routes, enabling users to navigate to /MyFeature and /MyFeature/About.

projects/mvc/razor-class-library/razor-class-library-with-controllers · high confidence

A new sample project demonstrates how to handle MVC routing dynamically using MapDynamicControllerRoute and DynamicRouteValueTransformer. The example shows how to process a given URL pattern and set values in the RouteValueDictionary, allowing for custom route transformations.

projects/endpoint-routing/new-routing-25 · high confidence

A new MVC project has been added that demonstrates how to return JSON content from a controller action. The example includes a Person model and a controller that returns a JSON response, providing a practical reference for handling JSON in ASP.NET Core MVC applications.

projects/mvc/result-json · high confidence

A new MVC example project has been added that demonstrates how to serve a physical file (a PDF) from the web root. The project includes a HomeController with an Index page linking to the file and a Hegel action that returns a PhysicalFileResult, along with the sample PDF and a README explaining the feature.

projects/mvc/result-physicalfile · high confidence

The project now includes a complete MVC application that demonstrates ASP.NET Core localization with culture fallback. The \Program.cs\ configures the \AcceptLanguageHeaderRequestCultureProvider\ and supports French (fr-FR), US English (en-US), and generic English (en) cultures. Resource files (\.resx\) provide translated strings for 'Hello' and 'Goodbye' across English and French, while the \Index.cshtml\ view and API controller use \IStringLocalizer\ to display localized content based on the \Accept-Language\ header.

projects/mvc/localization/mvc-localization-9 · high confidence

The project now includes a functional MVC application demonstrating localization features. This includes a new \Program.cs\ that configures request localization for French (\fr-FR\), a \HomeController\ that uses \IStringLocalizer\ to display translated content, and a \MvcLocalization.HomeController.fr.resx\ resource file containing French translations for 'Hello', 'Goodbye', 'Yes', and 'No'. Additionally, VS Code debugging and build task configurations (\launch.json\, \tasks.json\) have been added to support the .NET Core development environment.

projects/mvc/localization/mvc-localization-1 · high confidence

A new sample project demonstrates how to implement a custom request culture provider in an ASP.NET Core MVC application. The \Program.cs\ configures localization services and registers a \CustomRequestCultureProvider\ that extracts the culture from the first segment of the URL path. The sample includes localized resource files (\Global.en.resx\, \Global.fr.resx\) and a view (\Views/Home/Index.cshtml\) that displays content based on the detected culture.

projects/mvc/localization/mvc-localization-10 · high confidence

The project now includes a working MVC application that supports French (fr-FR) localization. This is enabled by adding VS Code debugging and build task configurations, creating resource files for 'Global' and 'Messages' classes, and implementing controllers that display localized strings from these resources.

projects/mvc/localization/mvc-localization-7 · medium confidence

A new MVC project has been added that demonstrates binding query string parameters to a complex type using the \[FromQuery\] attribute. The example includes a GreetingParams class with various property types (int, string, bool, short?) and a HomeController that renders an HTML page displaying the bound values, providing a reference for how query string model binding works in ASP.NET Core.

projects/mvc/model-binding-from-query · high confidence

A new example project, \projects/mvc/model-binding-from-route\, has been added to demonstrate how to bind route parameters to a complex model class using the \\[FromRoute\]\ attribute in ASP.NET Core MVC. The sample includes a \Program.cs\ file that sets up the minimal hosting model and defines a \HomeController\ with multiple action methods that map to different route templates, showcasing various binding scenarios such as integer, boolean, and string route parameters.

projects/mvc/model-binding-from-route, projects/unpoly/up-poll, projects/unpoly/up-target · medium confidence

A new MVC project (tag-helper-4) is introduced that demonstrates custom TagHelpers (Hello, World, and Alert) integrated into an ASP.NET Core 6 application. The view uses Bootstrap 5 via CDN to style the alert component, providing a concrete example of server-side tag helper rendering and CSS integration for users building UIs with ASP.NET Core MVC.

projects/mvc/tag-helper/tag-helper-4 · high confidence

A new ASP.NET Core application has been added that demonstrates sending emails using the MailKit and MimeKit libraries. The application includes a HomeController with an Index view and a Send endpoint that utilizes an EmailService to connect to an SMTP server (configured with placeholder values) and dispatch messages. The UI provides a simple form to trigger the email sending process.

projects/mailkit/mailkit-1 · high confidence

The Mailkit project area now includes a README.md file that documents two sample implementations: one for sending email messages and another for connecting to a POP3 account. Additionally, build automation scripts (build.bat for Windows and build.sh for Unix-like systems) have been added to the project root, allowing users to build the sample projects directly.

projects/mailkit · high confidence

A new project, map-short-circuit, has been added, introducing the MapShortCircuit and ShortCircuit APIs. These allow developers to respond to requests without going through the full middleware pipeline, effectively skipping processes like authentication and CORS for improved efficiency.

projects/map-short-circuit · high confidence

A new middleware component has been introduced to serve Markdown files as HTML. It maps URL paths to corresponding .md files within a 'markdown' directory, supporting both default index pages and nested paths. The middleware renders Markdown content using the Markdig library.

projects/markdown-server-middleware · high confidence

A new Minimal API Pokedex sample is introduced, providing a Web API that serves Pokémon data from a static JSON file. The implementation uses .NET 10's built-in OpenAPI support (replacing the previous YARP-based approach) to generate API descriptions and expose an interactive documentation UI (Scalar) at the root of the site. The sample includes all necessary components: models, services, repository, and endpoint mappings.

projects/mini/minimal-api-pokedex · high confidence

A new ASP.NET Core MVC application named NewsServer has been added to the codebase. This demo application functions as an RSS reader, allowing users to select and view content from a configurable list of news feeds. The implementation includes the MVC controller, view models, Razor views for the index and error pages, and the program entry point that wires up dependency injection and routing. Configuration for the feed URLs is managed via appsettings.json, and the project includes a README.md file describing its purpose and usage.

(repo-wide) · high confidence

A new sample project demonstrates how to set up OpenTelemetry to record baggage and pass user-defined properties via the baggage HTTP header to downstream HTTP requests.

projects/open-telemetry/open-telemetry-4 · high confidence

The OpenTelemetry project area now includes three sample implementations: one for basic tracing with a service name, one for recording span events, and one for recording span attributes. A README has been added to document these examples, and build scripts (build.bat and build.sh) have been introduced to build all four OpenTelemetry sample projects (open-telemetry-1 through 4).

projects/open-telemetry · high confidence

A new sample project demonstrates how to configure OpenTelemetry tracing in an ASP.NET Core application. The sample configures the console exporter and adds ASP.NET Core instrumentation. It also shows how to record custom attributes (e.g., 'project' and 'location') into the current span using Activity.SetTag, allowing users to see these custom tags in the trace output.

projects/open-telemetry/open-telemetry-3 · high confidence

The project now includes a README.md introducing the Orchard Core Framework section, which provides infrastructure for modular and multi-tenant applications. New samples are added for routing (MVC and Razor Pages), static files, and multi-tenancy, each demonstrating specific capabilities of the framework. Additionally, build automation scripts (build.bat and build.sh) have been introduced to streamline building the various sample projects.

projects/orchard-core · high confidence

A new sample project (orleans-5) has been added that demonstrates how to use HttpClient within an Orleans grain. The sample configures a stateless worker grain that calls an external time API and displays the result in a simple HTML page, using the Orleans 8.0 framework.

projects/orleans/orleans-5 · high confidence

A new Orleans reminder sample has been added to the project, demonstrating the use of \Grain.RegisterOrUpdateReminder\ with a Redis-based persistent state. The sample includes a web application that allows users to set and remove reminders, storing greeting messages in Redis. The implementation uses C\# records for data models and configures Orleans with in-memory clustering and Redis grain storage.

projects/orleans/orleans-3, projects/orleans/reminder, projects/orleans/timer · medium confidence

A new sample application for an RSS reader has been added to the Orleans project. The app uses Orleans grains to fetch and store RSS/Atom feed items, with persistent storage backed by Redis. Users can run the app, open localhost:5000, and see a list of feed items that update as new content is fetched. The sample requires Redis to be running.

projects/orleans/rss-reader-2 · high confidence

A new sample project, 'projects/mini/pdf-viewer', has been added, providing a complete ASP.NET Core Razor Pages application that integrates Mozilla's PDF.js library. This includes the necessary C\# entry point (Program.cs), the main Razor page (Index.cshtml), and all required static assets (JavaScript, CSS, SVG icons, and CMap files) to render PDFs in the browser.

projects/mini/pdf-viewer · high confidence

A new sample project (path-string-1) has been added to demonstrate how \HttpContext.Request.Path\ behaves with various URL patterns, including double slashes, query strings, and trailing slashes. The sample includes build scripts, VS Code launch/tasks configurations, and a minimal ASP.NET Core application that renders the path value in HTML.

projects/path-string · high confidence

Added a new README and build scripts (build.bat and build.sh) for the Polly project, which provides examples on using the Polly library to improve application resiliency, specifically featuring a rate limiter implementation using HttpClient.

projects/polly · high confidence

Added three new sample projects (problem-details, problem-details-2, and problem-details-3) that demonstrate how to enable and customize HTTP 500 error responses using the Problem Details specification (RFC 7807) in unhandled exception scenarios. The samples show how to use the default behavior, customize the response via options, and manipulate the IProblemDetailsService interface directly. The directory also includes build scripts (build.bat, build.sh) and a README.md to guide users through these examples.

projects/problem-details-middleware · high confidence

A new endpoint in the syndication-2 project parses RSS feeds from a remote URL, extracts item details and custom 'source:outline' attributes, and renders them as styled HTML. This introduces a new capability to fetch and display syndicated content directly via the web application.

projects/syndications/syndication-2 · high confidence

A new endpoint has been added to the application that fetches an RSS feed from a remote URL, parses the items, and renders them as an HTML list on the page.

projects/syndications/syndication-1 · high confidence

The application now supports automatic RSS feed generation for controller actions returning \SyndicationItem\ objects. A new \RssOutputFormatter\ has been added to the MVC pipeline, enabling responses in \application/rss+xml\ format for single items or lists of items.

projects/mvc/output-formatter-syndication · high confidence

Added new Razor Pages for Module1 and Module2, each containing a corresponding .cshtml view and code-behind .cs file. A new WebApplication project was introduced with Program.cs using the minimal hosting model (WebApplication.CreateBuilder) to map Razor Pages, alongside appsettings.json and appsettings.Development.json for logging configuration.

projects/mvc/razor-class-library/razor-class-library-1 · high confidence

A new sample project for endpoint routing with Razor Pages areas is introduced, featuring a minimal ASP.NET Core 3.1 application that maps Razor Pages and defines Admin and Customer areas. The change also adds VS Code launch and task configurations to support local debugging and building of the sample.

projects/endpoint-routing/new-routing-28 · high confidence

The project now includes Razor Pages that demonstrate how to capture and display route data from the URL. Pages such as About, Blog, Catalog, and Contact expose different routing patterns (e.g., /About/{section}/{year}, /Blog/{\*path}) and render the captured values using @RouteData.Values. The main Index page lists links to these examples, showing how various route templates are handled.

projects/razor-pages/routing-2 · high confidence

The new-routing-29 sample now includes a complete, runnable ASP.NET Core application that demonstrates how to configure a fallback page for a specific Razor Pages area. The project adds \Program.cs\ to set up the web host and register Razor Pages, while the \Areas/Admin/Pages\ directory contains the fallback view (\Other.cshtml\) and other area-specific pages. The application maps the \/Other\ route to the \Admin\ area's \Other\ page, allowing unmatched non-file routes to be handled by this fallback. This change provides a concrete example of using \MapFallbackToAreaPage\ to manage routing for areas in an ASP.NET Core application.

projects/endpoint-routing/new-routing-29 · high confidence

A new sample application for Razor Pages has been added to demonstrate the use of TempData. The project includes a home page that displays a message stored in TempData, and a separate page that sets the TempData value. The sample also provides a README explaining that TempData is backed by cookies by default and that values are consumed after a single request unless Peek is used.

projects/configurations/configuration-bind-option, projects/razor-pages/temp-data · high confidence

The project now includes Razor Pages for 'Admin' and 'Customer' areas, each with a corresponding index page. The application is configured to map these areas to specific routes (/Manage and /CustomerService) using the AddAreaPageRoute convention, allowing users to navigate to these distinct sections of the application.

projects/endpoint-routing/new-routing-27 · high confidence

Introduces a new sample demonstrating Razor class libraries with static files. The change adds two Razor class libraries (RazorClassLibrary1 and RazorClassLibrary2), each containing Razor pages, CSS, and JavaScript assets. A WebApplication project is added to host these libraries, configuring static file serving and page routing to serve the embedded and wwwroot content.

projects/mvc/razor-class-library/razor-class-library-with-static-files · high confidence

A new middleware component, TerminalMiddleware, has been added to the application. This middleware logs incoming request paths and returns a response containing a timestamp that remains constant across requests, illustrating the behavior of a singleton-scoped middleware instance.

projects/middleware/middleware-10 · high confidence

A new middleware component, TerminalMiddleware, has been added to the application. This middleware logs incoming request paths and responds with a transient message containing the current date, demonstrating a simple middleware implementation in the project.

projects/middleware/middleware-11 · high confidence

The project now includes a new Program.cs that configures ASP.NET Core to rewrite incoming requests based on a regular expression pattern. Specifically, it captures path and extension segments from the URL and exposes them as query string parameters, allowing the application to process requests with file extensions (like .html or .aspx) by redirecting them to a root handler that displays the captured values.

projects/rewrite/rewrite-3 · high confidence

A new example project demonstrates how to use the \up-flashes\ attribute to display flash messages via Unpoly 3.8.0. The example includes a C\# server that serves an HTML page with navigation links and a container for flash alerts, alongside a solution file and VS Code settings to support the demo.

projects/unpoly/up-flashes · high confidence

A new sample project, uri-helper-build-absolute, was added to demonstrate the UriHelper.BuildAbsolute method. The sample provides a web application that renders nine different examples of constructing absolute URIs with varying combinations of scheme, host, path base, path, query string, and fragment, illustrating how the helper combines these components for use in HTTP headers.

projects/uri-helper/uri-helper-build-absolute · high confidence

A new ASP.NET 6 demo application has been added to showcase the \UriHelper.FromAbsolute\ method, which parses an absolute URI string into its constituent parts (scheme, host, path, query string, and fragment). The application renders an HTML page displaying these components for various test URLs.

projects/uri-helper/uri-helper-from-absolute · high confidence

A new Blazor Server-Side sample named 'Wall of Counters' has been added to the project. This demo showcases how to use System.Timers.Timers with Blazor to update the UI from background threads, featuring nine independent counters that increment at different intervals. The sample also demonstrates scoped CSS isolation using the BlazorStyled library.

projects/blazor-ss/WallOfCounters · high confidence

A new WebSockets sample application has been added to the web-sockets-4 project. The application implements a WebSocket server that supports both echo and broadcast functionality, allowing multiple clients to send messages that are either echoed back to the sender or broadcast to all connected clients. The sample includes a client-side interface for testing the WebSocket connections.

projects/web-sockets/web-sockets-1, projects/web-sockets/web-sockets-4 · high confidence

A new project has been added to demonstrate loading configuration from an XML file (settings.xml) using the Microsoft.Extensions.Configuration.Xml provider. The application reads key-value pairs from the XML and exposes them via a simple HTTP endpoint.

projects/configurations/configuration-xml · high confidence

A new ASP.NET Core 6 sample, xml-validation, has been added to the XML section. It provides a web application that allows users to validate an XML document against an XML Schema (XSD) by submitting both the schema and the document via a form, with results displayed as success or danger alerts.

projects/xml · high confidence

A new basic demo for YARP (Yet Another Reverse Proxy) has been added to the repository. This demo showcases creating a reverse proxy using YARP in an ASP.NET Core environment. The solution includes a BackEnd (ASP.NET Web API), a FrontEnd (Blazor WebAssembly), and a Proxy layer that routes requests. The demo is structured with separate projects for the backend API, the Blazor frontend, and the proxy implementation, along with necessary configuration files and CSS assets.

projects/yarp · high confidence

A new sample application is introduced in the \application-environment\ project, featuring a \Program.cs\ that displays runtime details such as the application name, base path, target framework, and version. The project includes a solution file (\application-environment.sln\) and a \README.md\ explaining the sample's purpose. Additionally, a \.vscode/settings.json\ file is added to configure a custom green/blue color theme for Visual Studio Code, enhancing the development environment's visual consistency.

projects/application-environment · high confidence

The project now includes controllers and views for 'Admin' and 'Customer' areas, each with their own home page. The application is configured to route requests to these areas using the new endpoint routing API (MapAreaControllerRoute), allowing users to access /Admin and /Customer sections of the site.

projects/endpoint-routing/new-routing-16 · high confidence

A new ihosted-service-2 project is introduced that registers a GreeterUpdaterService implementing IHostedService. This background task uses a timer to increment a counter every second, and the main web endpoint displays the updated greeting on each page reload, demonstrating how to run periodic background work in a hosted service.

projects/ihosted-service/ihosted-service-2 · high confidence

A new OpenTelemetry tracing example was added, featuring a minimal ASP.NET Core application that configures tracing with console export and AspNetCore instrumentation. The project includes a VS Code theme configuration for consistent development environment styling, a solution file for the .NET project, and a README explaining the basic trace and service name setup.

projects/open-telemetry/open-telemetry-1 · high confidence

A new basic authentication sample using Identity Core and SQLite has been added to the security section. This sample demonstrates how to register new users, sign in, and sign out. The entry also includes a README file that lists the available security sections and credits Adrien Torris for the sample. Additionally, build scripts (build.bat and build.sh) have been added to facilitate building the authentication-with-identity project.

projects/security · high confidence

A new Program.cs file was added to the middleware-2 project, implementing a custom middleware that buffers the HTTP response body. This allows subsequent middlewares to write to the response without immediately flushing to the client, enabling the aggregation of content before sending it out.

projects/middleware/middleware-2 · high confidence

Added build scripts (build.bat and build.sh) to automate the build process for the two background task examples (ihosted-service-1 and ihosted-service-2). A README.md was also added to document these examples, explaining that the first implements background tasks using the BackgroundService base class, while the second uses the IHostedService interface with a timer, referencing ASP.NET Core documentation.

projects/ihosted-service · high confidence

Users can now build and run the Uri Helper sample projects (GetDisplayUrl, GetEncodedUrl, GetEncodedPathAndQuery, FromAbsolute, BuildAbsolute) using the new build.bat and build.sh scripts. A README.md file has been added to document the available methods and their usage.

projects/uri-helper · high confidence

Users can now build the PDF viewer sample using new build scripts (build.bat and build.sh) that invoke dotnet build. The README has been updated to document the PDF viewer sample and the Pokedex API sample, noting that the Pokedex API uses .NET 10 built-in OpenAPI.

projects/mini · high confidence

Added build.bat, build.sh, clean.bat, clean.sh, restore.bat, and restore.sh scripts to the projects directory. These scripts automate the build, clean, and restore processes for all sample projects, including a recursive build mechanism that iterates through subdirectories and tracks failures. The scripts cover a wide range of .NET samples, including Blazor, gRPC, MVC, and generic host examples, ensuring consistent build and cleanup operations across the project structure.

projects · high confidence

The caching project now includes a README.md that documents five in-memory and Redis caching samples, including absolute/sliding expiration, file dependency, cache removal events, cancellation change tokens, and a Redis caching package. Additionally, build scripts (build.bat and build.sh) have been added to build all five caching samples.

(repo-wide) · high confidence

A new sample project has been added that demonstrates a classic MVC configuration using \AddControllersWithViews()\ to enable MVC with Views support, explicitly noting that Razor Pages are not available in this setup.

projects/endpoint-routing/new-routing-18 · high confidence

A new Program.cs file was added to the configuration-options project, demonstrating how to configure application settings using the Options pattern with .NET 6 minimal APIs. The file registers and retrieves configuration via IOptions, exposing the settings through a simple HTTP response.

projects/configurations/configuration-options · high confidence

Added new sample projects demonstrating how to read configuration values using the IOptions interface, including binding arrays from appsettings.json and loading environment variables. The update also includes build scripts (build.bat and build.sh) to compile all configuration examples, and updates the README to document these new samples.

projects/configurations · high confidence

The features-connection project now includes a new Program.cs file that defines a minimal HTTP endpoint. This endpoint retrieves and displays local and remote IP addresses, ports, and the connection ID using the ASP.NET Core HttpConnectionFeature, allowing users to verify network connection details directly from the service.

projects/features/features-connection · high confidence

A new 'connection-info' application has been added to the project. It is a minimal .NET 6 web service that responds to requests by returning the local and remote IP addresses and ports, as well as the client certificate friendly name, providing visibility into the connection details for debugging or monitoring purposes.

projects/connection-info · high confidence

A new sample project demonstrating convention-based routing using MapControllerRoute is added to the repository. The implementation includes controller classes for Home and Admin pages, a Program.cs file configuring routes for /Admin, /About, and a default route, along with a corresponding Razor view. This provides a reference for using the ASP.NET Core routing system.

projects/endpoint-routing/new-routing-20 · high confidence

A new example application was added to the request/cookies-1 project. It demonstrates how to read and write HTTP cookies using the minimal API pattern in .NET, specifically showing how to append a cookie named 'MyCookie' and read it from the request context.

projects/request/cookies-1, projects/request/cookies-2 · high confidence

A new ASP.NET Core MVC project is introduced that implements a custom API problem details pattern. It adds an ApiProblemsDetails class and a Controller extension method to standardize error responses, including request path, payload, validation messages, and stack traces in development.

projects/mvc/api-problem-details-2 · high confidence

The project now includes a complete, runnable ASP.NET Core MVC application that demonstrates a custom routing constraint attribute (NumberAttribute) which restricts access to the About page based on a numeric route parameter. The setup includes VS Code launch and task configurations to support debugging and building the project, with the main entry point (Program.cs) mapping a controller route and defining the constraint logic.

projects/mvc/routing/routing-9 · high confidence

Introduces the diagnostics project containing five diagnostic sample scenarios: a welcome page, a developer exception page, two custom global exception pages, and status pages. Includes build scripts (build.bat and build.sh) to build all samples and a README documenting each scenario.

projects/diagnostics · high confidence

A new diagnostics-5 application has been introduced, featuring a status code redirect to a custom error page that displays the HTTP status code in the response body.

projects/diagnostics/diagnostics-5 · high confidence

A new sample project demonstrates how to handle Razor Pages routing dynamically using \MapDynamicPageRoute\ and \DynamicRouteValueTransformer\. The example includes a \NumberTransformer\ class that maps numeric URL segments (1, 2, 3) to specific Razor Pages (/one, /two, /three) and falls back to an 'undefined' page for other inputs.

projects/endpoint-routing/new-routing-26 · high confidence

A new example project (endpoint-routing-2) demonstrates endpoint routing in a .NET 6 application. It uses the minimal API style (WebApplication.CreateBuilder) to configure controllers and maps default controller routes, showing how to generate URLs via LinkGenerator in a request pipeline.

projects/endpoint-routing/endpoint-routing-2 · high confidence

The endpoint-routing-4 project now includes a new sample demonstrating URL generation using the LinkGenerator service. The sample shows how to generate URIs for various controller actions with different route patterns, including optional route values, integer constraints, and required parameters. The project also includes VS Code launch and task configuration files to support debugging and building the sample.

projects/endpoint-routing/endpoint-routing-4 · high confidence

A new sample project, new-routing-30, has been added to demonstrate endpoint routing with Razor Pages areas. The sample configures fallback pages for the Admin and Customer areas using specific route patterns (e.g., /Other, {segment}/{segment2}, {number:int}), allowing the application to serve area-specific fallback pages when requests do not match existing routes.

projects/endpoint-routing/new-routing-30 · high confidence

A new sample project (endpoint-routing-3) was added, demonstrating URL generation via the LinkGenerator service in a .NET 6 application. The sample configures controllers with various route attributes and uses minimal API middleware to generate and display links for different controller/action combinations, including cases where routing information is missing.

projects/endpoint-routing/endpoint-routing-3 · high confidence

The middleware-13 project now includes a new Program.cs file that defines an ErrorHandlingMiddleware. This middleware catches unhandled exceptions during request processing and returns a structured JSON error response (containing status code and message) instead of a default server error, improving error visibility for API consumers.

projects/middleware/middleware-13 · medium confidence

A new sample project (json-21) has been added to demonstrate how to parse a JSON string into a JsonNode object and modify it. The example shows how to remove an object property and an array element using the System.Text.Json.Nodes API, providing a concrete reference for users needing to update JSON documents programmatically.

projects/json/json-21 · high confidence

A new sample project was added that demonstrates configuring endpoint routing to respond differently based on the request's host header. The example uses \IEndpointConventionBuilder.WithMetadata\ and \HostAttribute\ to bind routes to specific localhost ports (8111 and 8112), providing an alternative approach to the previous example that used \RequireHost\.

projects/endpoint-routing/new-routing-24 · high confidence

A new example project demonstrates how to log information about static files being served by configuring the OnPrepareResponse callback in the static file middleware. The example shows serving files from the default wwwroot folder and a custom wwwroot2 folder, with each request logged via the application logger.

projects/file-provider/serve-static-files-8 · high confidence

The logging project now includes two new sample applications. The first, logging-5, demonstrates how to create cached static loggers using a static class that caches \ILogger\ instances via \ConcurrentDictionary\. The second, logging-Loki, provides an example of sending log messages to Grafana Loki using a Docker Compose setup that includes Loki and Grafana services, allowing users to see logs in a Grafana dashboard.

projects/logging · high confidence

A new ASP.NET Core application is introduced in the 'features-max-request-body-size' directory, demonstrating how to configure and inspect the maximum request body size. The application sets a default limit of 5000 bytes via Kestrel and dynamically overrides it to 555 bytes within the request pipeline, exposing the 'IHttpMaxRequestBodySizeFeature' to show how to read and modify this limit at runtime.

projects/features/features-max-request-body-size · high confidence

Users can now run two new demo applications that showcase file provider capabilities. The 'file-provider-custom' demo implements a custom IFileProvider that serves a static HTML string, while the 'file-provider-physical' demo lists the contents of the content and web roots using the standard PhysicalFileProvider. These examples illustrate how to integrate and interact with file providers in an ASP.NET Core application.

projects/file-provider/file-provider-physical · high confidence

A new 'form-values' project has been introduced, providing a minimal web application that serves an HTML form containing text inputs, password fields, a textarea, select dropdowns, checkboxes, and a hidden field. Upon submission via POST to '/Upload', the application reads the form data and displays the submitted values on the response page, demonstrating how to handle multipart form data in a .NET 6 application.

projects/request/form-values · high confidence

Added new gRPC sample projects (grpc-13 through grpc-17) demonstrating JSON transcoding for various HTTP methods. These samples show how to map gRPC endpoints to RESTful HTTP endpoints, including GET requests with path parameters, POST requests with JSON bodies, PUT operations, and PATCH requests. Each sample includes the necessary .proto files, C\# implementation, and HTML/JavaScript client code to interact with the gRPC service via HTTP.

(repo-wide) · high confidence

The gRPC samples section now includes new examples for gRPC-Web, specifically a Blazor WebAssembly client sample for server streaming. The collection also expands to cover gRPC JSON transcoding for HTTP GET, POST, PUT, and PATCH operations. To support building these new samples, build scripts (build.bat and build.sh) have been added to automate the build process for all listed projects.

projects/grpc · high confidence

Introduced two new gRPC sample projects. The first demonstrates client streaming, where a client sends a sequence of fortune cookies to a server that processes them and returns a single aggregated response. The second demonstrates bidirectional streaming, where a client and server exchange continuous streams of messages (pings and pongs) with increasing delays. Both samples include the necessary C\# code and .proto definitions.

projects/grpc/grpc-3, projects/grpc/grpc-4 · high confidence

A new gRPC sample project has been added to the grpc-5 directory, featuring a client and server implementation. The sample demonstrates how to define and use Protocol Buffers to send and receive enum, string, and datetime values. The server exposes a 'ShowMessage' RPC that processes a message request containing sender, message content, and type, then returns a reply with the processed message and a timestamp.

projects/grpc/grpc-5 · high confidence

A new gRPC sample has been added to the \projects/grpc/grpc-7\ directory, featuring a client and server implementation that showcases sending map values (dictionaries) in Protocol Buffers. The sample includes C\# programs for both the client and server, along with the corresponding \.proto\ definitions, illustrating how to handle map types in gRPC services.

projects/grpc/grpc-7 · medium confidence

A new gRPC sample project for .NET 6 has been added, featuring a client and server implementation that exchange nested message types and repeated fields (lists). The sample includes the necessary Protocol Buffer definitions and C\# code to send and receive complex data structures, illustrating how to handle nested types and repeated values in gRPC services.

projects/grpc/grpc-6 · high confidence

A new gRPC sample project has been added to the repository, featuring a client and server implementation that utilize the 'oneof' type in the protobuf definition. This example demonstrates how to check whether a property value is set or not, effectively emulating a nullable type in the gRPC service contract.

projects/grpc/grpc-8 · medium confidence

A new gRPC sample has been added to the project, demonstrating a server-streaming pattern where a server sends a picture of a kitty to a client in chunks. The implementation includes a gRPC service and client application, along with the corresponding .proto definitions for the message types and service contract.

projects/grpc/grpc-9 · high confidence

A new gRPC-Web sample is introduced, featuring a simple Unary RPC where the client (in the \client\ folder) communicates with a server (in the \server\ folder). The server runs on HTTP 1.1 using gRPC-Web, while the client uses \GrpcWebHandler\ to interact with the service. The sample includes the necessary \billboard.proto\ files and a \README\ explaining the setup.

projects/grpc/grpc-10 · high confidence

A new gRPC-Web sample has been added to the grpc-12 project, featuring a Blazor WebAssembly client that connects to a server streaming gRPC service. The client (App, Index, Program, and layout components) uses GrpcWebHandler to communicate with the server, which is configured to support HTTP/2 and CORS for the Blazor WebAssembly app.

projects/grpc/grpc-12 · high confidence

A new gRPC-Web sample project has been added to the grpc-11 location, demonstrating server streaming functionality. The sample includes a .NET 6 server that runs on HTTP/1.1 using gRPC-Web, and a corresponding client that consumes the stream. The implementation uses the GrpcWebHandler and GrpcWebMode.GrpcWebText to facilitate communication over HTTP/1.1, with the server sending repeated messages every 5 seconds.

projects/grpc/grpc-11 · medium confidence

A new console application entry point (Program.cs) is introduced that configures a generic host with in-memory configuration values (Greet, Goodbye) and registers a background hosted service (HelloWorldService) that logs these values during startup and shutdown, with console logging filtering out Microsoft namespace messages.

projects/generic-host/generic-host-configure-app · high confidence

A new example project has been added that demonstrates a generic host implementation using the default builder. It registers a hosted service that logs debug messages to the console, with a filter applied to exclude Microsoft namespace logs.

projects/generic-host/generic-host-1 · medium confidence

A new Program.cs file has been added to the generic-host/logging project, demonstrating how to configure a generic host with console logging. The example sets up a hosted service that logs debug messages during start and stop, providing a concrete reference for configuring logging providers and minimum log levels in .NET generic hosts.

projects/generic-host/generic-host-configure-logging · high confidence

The health-check area now includes six sample projects (health-check-1 through health-check-6) that demonstrate progressively more complex health check configurations, including basic endpoints, custom response writers, failing checks, HTTP status code checks, and degraded status handling. A README.md file has been added to explain each sample, and build scripts (build.bat and build.sh) have been created to build all six samples.

projects/health-check · high confidence

A new hello-world sample for Razor Pages has been added, including the main application entry point (Program.cs) and the index page (Index.cshtml). To support local development, VS Code launch and task configuration files (launch.json, tasks.json) have been added, enabling users to build and debug the sample directly in VS Code.

projects/razor-pages/hello-world · high confidence

A new sample project demonstrates endpoint routing with host matching, configuring the application to respond differently to requests on localhost:8111 and localhost:8112.

projects/endpoint-routing/new-routing-23 · medium confidence

A new logging-4 project has been added to the repository, featuring a .NET Web API that demonstrates the use of the LoggerMessage attribute for source-generated, high-performance logging. The application includes a homepage that generates random numbers and links to a /log-it endpoint, which logs whether each number is even or odd using the generated logging methods. The project also includes VS Code color theme settings and a README explaining the LoggerMessageAttribute.

projects/logging/logging-4 · medium confidence

A new 'markdown-server' project has been added to the codebase. It is a .NET 6 web application that serves Markdown files from a 'markdown' directory as rendered HTML. The server maps URL paths to corresponding .md files (e.g., /about/us maps to markdown/about/us.md) and uses the Markdig library to convert Markdown to HTML. Default pages are served for the root and specific paths, with 404 responses for missing files.

projects/markdown-server · high confidence

A new utility application has been added to the codebase to display all available constants from the System.Net.Mime.MediaTypeNames class. This tool iterates through the Application, Text, and Image MIME type categories, presenting them in a web interface for easy reference. The addition includes the main Program.cs file which generates an HTML page listing these constants, along with a README.MD file explaining the utility's purpose.

projects/utils/media-type-names · high confidence

The middleware project now includes a comprehensive set of examples (Middleware 0–13) demonstrating various ASP.NET Core middleware concepts, including pipeline configuration, dependency injection, and error handling. To support building these examples, build scripts (build.bat and build.sh) have been added to automate the compilation of each middleware sample.

projects/middleware · high confidence

A new sample project, projects/middleware/middleware-1, has been added. It includes a Program.cs that defines a simple ASP.NET Core middleware pipeline, demonstrating how to use custom middleware to modify the HTTP context and response.

projects/middleware/middleware-1 · high confidence

Added new sample applications to the minimal-api project, including three antiforgery examples (HTML form, AJAX call, and cross-site implementation), four endpoint filter samples (single filter, multiple filters, execution sequence, and status code result handling), and file upload samples using IFormFile and IFormFileCollection. Also included a build script (build.bat and build.sh) to compile all samples.

projects/minimal-api · high confidence

A new minimal ASP.NET Core 6 application is introduced, featuring a default controller that renders a 'Hello World' page with links to various routes. This provides a starting point for MVC applications using the latest .NET 6 APIs.

projects/mvc/routing/routing-2 · high confidence

Added a new set of samples in the \projects/minimal-hosting\ directory demonstrating the new minimal hosting APIs. This includes \WebApplication.Create()\ for scenarios like middleware pipelines, configuration, and server setup, as well as \WebApplication.CreateBuilder()\ for configuring services such as MVC, Razor Pages, and logging. The collection also covers \WebApplication.CreateSlimBuilder()\ and \WebApplication.CreateEmptyBuilder()\ for more granular control over the default configuration. Build scripts (\build.bat\, \build.sh\) and a \README.md\ are included to guide users through these new patterns.

projects/minimal-hosting · high confidence

A new Razor page (Index.cshtml) has been added to the multi-tenant sample application. This page displays a table showing the current shell settings, including the shell name, state, request URL prefix, and custom settings (such as CustomerLevel). It also provides navigation links to the root, customer-a, and customer-b tenants, allowing users to see how shell settings change across different tenants.

projects/orchard-core/multi-tenant/Host/Pages · high confidence

A new demo project for the 'up-target-2' location introduces a multiple-target update scenario using Unpoly 3.8.0. The application serves a page with three distinct content areas (tag, id, and class selectors) and updates all of them simultaneously via a single link. The implementation includes a custom header check to identify Unpoly requests and returns the updated HTML fragments. The project is accompanied by a README explaining the multi-selector usage and a VS Code settings file for consistent development environment colors.

projects/unpoly/up-target-2 · high confidence

A new WebSockets example project is added, featuring an MVC controller that handles WebSocket connections and echoes messages back to the client. The example includes a built-in HTML/JavaScript client that allows users to open multiple browser tabs to test real-time bidirectional communication. A README file is also added to explain the example.

projects/web-sockets/web-sockets-6 · high confidence

A new sample project 'new-routing-4' is added, demonstrating how to use RequestDelegate directly with minimal APIs. The project uses the WebApplication.Create() API to define routes via MapGet, MapPost, MapPut, and MapDelete, providing a modern approach to endpoint routing in .NET.

projects/endpoint-routing/new-routing-4 · high confidence

A new sample project has been added to demonstrate endpoint routing capabilities in .NET 6. The sample includes a Program.cs that configures and exposes various HTTP endpoints (GET, POST, DELETE, PUT) alongside MVC controllers and Razor pages, and provides a diagnostic route that iterates through all available endpoints to display their metadata and route patterns. The project is configured with VS Code launch and build tasks, and includes an About page and README explaining the sample's purpose.

projects/endpoint-routing/new-routing-6, projects/mvc/hello-world · high confidence

A new sample project has been added to demonstrate how to configure an ASP.NET Core application to use only Razor Pages routing, explicitly noting that MVC Controllers will not function in this setup. The sample includes a minimal Program.cs that registers Razor Pages and maps them, an Index.cshtml page, and a README explaining the routing behavior.

projects/endpoint-routing/new-routing · high confidence

A new sample project named 'new-routing-10' has been added to demonstrate how to inspect the current endpoint within a custom middleware. The project includes Razor pages and a 'GreeterMiddleware' that uses the 'HttpContext.GetEndpoint' extension method to access the 'Endpoint' class, allowing the middleware to conditionally modify the HTTP context based on the active endpoint.

projects/endpoint-routing/new-routing-10 · high confidence

A new sample project has been added to demonstrate how to access attribute values from a Razor Page using the new \Endpoint.Metadata.GetMetadata\<\>()\ API. The sample includes a custom middleware that reads a \MessageAttribute\ from the current endpoint and stores its content in the HTTP context items, which is then displayed on the about page.

projects/endpoint-routing/new-routing-11 · high confidence

A new sample project 'new-routing-12' has been added to demonstrate how to access endpoint metadata from a custom middleware in a Razor Pages application. The sample includes a 'GreeterMiddleware' that reads a custom 'MessageAttribute' from the current endpoint to inject context-specific messages into the HTTP context based on the request method (GET vs POST). The project is configured with VS Code launch and task files, and includes Razor Pages for the home and about views.

projects/endpoint-routing/new-routing-12 · high confidence

A new sample project demonstrating endpoint routing with HTTP verb filtering is added. The sample uses the minimal API pattern to map a root URL to a GET request and the /about path to a POST request, illustrating how to handle specific HTTP methods with RequestDelegate.

projects/endpoint-routing/new-routing-7 · high confidence

A new sample project has been added to demonstrate endpoint routing with Razor Pages and MVC API. The sample includes a Razor Page and a controller-based API endpoint, illustrating how to configure and use both in the same application.

projects/endpoint-routing/new-routing-19 · high confidence

A new sample project has been added to demonstrate endpoint routing with a Razor page fallback. The project configures a default Razor page served when no other route matches, and includes VS Code launch and task configurations to support local development.

projects/endpoint-routing/new-routing-9 · high confidence

A new sample project named 'new-routing-8' has been added to demonstrate endpoint routing with a static file fallback. The application uses the minimal API pattern to map a '/contact/us' route and configures 'MapFallbackToFile' to serve 'index.html' from the 'static' directory when no other routes match. The project includes VS Code launch and task configurations, a README explaining the static file fallback behavior, and the necessary source files.

projects/endpoint-routing/new-routing-8 · high confidence

Added eight new sample projects (output-cache-1 through output-cache-8) demonstrating various output caching scenarios, including basic caching, varying by query string, tag-based eviction, base policies, and custom expiration times. Each sample includes a Program.cs and a Readme.md explaining the specific caching behavior. Build scripts (build.bat and build.sh) were also added to facilitate building all samples.

projects/output-cache-middleware · high confidence

A new Program.cs file was added to the query-string-2 project, implementing a minimal ASP.NET Core application that reads the 'message' query string parameter and displays its values in an HTML list. The application uses Microsoft.Extensions.Primitives.StringValues to handle multiple values for the same query string key, rendering each value as a list item. This provides a working example of query string processing in .NET 6.

projects/request/query-string-2 · high confidence

A new ASP.NET Core application was added at projects/request/query-string-1 that demonstrates how to read and display a single query string parameter ("message") in a web response.

projects/request/query-string-1 · high confidence

A new Program.cs file was added to the web-utilities-query-helpers project, providing a runnable example of the QueryHelpers.AddQueryString method. The example demonstrates how to construct and modify query strings in ASP.NET Core, specifically showing how to add multiple query parameters to a base path and then append additional parameters to the resulting URL.

projects/web-utilities/web-utilities-query-helpers · high confidence

A new Razor page and its code-behind are added to demonstrate rate limiting with an HTTP client. The page displays a list of tracked requests, and the backend logic sends 1,000 requests in batches of 20, handling RateLimiterRejectedException to prevent overwhelming the remote service.

projects/polly/rate-limiter-http-client/Pages · high confidence

A new standalone application has been added to the SFA project that allows users to visualize the remaining time in a project. The tool provides a simple interface where users can input their current progress and total project duration to generate a doughnut chart showing the remaining weeks. This feature relies on Chart.js and the Chart.js Data Labels plugin to render the visualization directly in the browser.

projects/sfa/remaining-time · high confidence

The request project now includes a comprehensive README.md that documents various ways to capture input and examine requests, covering anti-forgery tokens, HTTP verbs, headers, query strings, form values, file uploads, and cookies. Additionally, build scripts (build.bat and build.sh) have been added to compile all the individual sample projects within this directory.

projects/request · high confidence

Added a new 'request-timeouts-middleware' project containing six sample applications that demonstrate how to use the ASP.NET Core request timeout middleware. The samples cover configuring timeouts for Minimal APIs and MVC controllers, using both named and default timeout policies, and handling timeout exceptions.

projects/request-timeouts-middleware · high confidence

A new .NET 6 application has been introduced in the projects/request/request-verb directory. This service responds to all HTTP methods by returning the request method (e.g., GET, POST) in the response body.

projects/request/request-verb · high confidence

Added new examples for ASP.NET Core response handling: a 'response-header' example demonstrating how to add HTTP headers and handle header modification errors, and a 'trailing-headers' example showing how to issue trailing headers using Kestrel's HTTP/2 and HTTP/1.1 support. Included build scripts and README documentation for these examples.

projects/response · high confidence

A new sample application demonstrating routing in an Orchard Core Framework app has been added. It includes a host application and two modules, ForumModule and TicketModule, each with controllers, views, and startup configurations. The host provides a routes page to inspect the routing table and links to the modules.

projects/orchard-core/routing · high confidence

A new .NET 6 MVC API project has been added to the repository, featuring a basic controller at /api/anendpoint that returns a simple string response. The project includes a README explaining how to run the sample and access the endpoint.

projects/mvc/api · high confidence

A new sample application has been added to the request-headers-names project. It uses the Microsoft.Net.Http.Headers.HeaderNames class to display all common HTTP header names, demonstrating how to access these constants for easier header management.

projects/request/request-headers-names · high confidence

Introduces a sample application that demonstrates how custom routing works in an Orchard Core Framework application using Razor Pages. The change adds two sample modules, ForumModule and TicketModule, each containing Razor Pages with custom routes (e.g., /products, /users, /privacy). The host application is configured to use Orchard Core with MVC and Razor Pages support, and includes views and controllers to navigate to the module pages. This serves as a reference for integrating module-based routing in an OCF application.

projects/orchard-core/routing-2 · high confidence

A new sample project (new-routing-31) is introduced that demonstrates how to configure authentication and authorization in an ASP.NET Core application. The sample configures cookie authentication and the authorization service, then uses .AllowAnonymous() on the home page and .RequireAuthorization() on a protected endpoint, illustrating the difference between public and secured routes.

projects/endpoint-routing/new-routing-31 · high confidence

A new sample project demonstrates how to use \services.AddControllers\ to provide MVC without Views support, which is ideal for Web APIs. The project includes a \Program.cs\ that configures the minimal API with controllers and a \README.md\ explaining the use case.

projects/endpoint-routing/new-routing-17 · high confidence

A new sample project demonstrates how to use the \Microsoft.AspNetCore.Http.QueryString.Create\ method to generate URL-encoded query strings. The project includes a \Program.cs\ file that creates a web application displaying input key-value pairs and their corresponding URL-encoded query string output, along with a \README.MD\ explaining the usage.

projects/request/query-string-create · high confidence

A new sample project has been added that demonstrates how to use the \FormUrlEncodedContent\ class to generate a query string from a dictionary of name/value pairs. The sample includes a minimal ASP.NET Core application that renders an HTML page displaying the input data and the resulting URL-encoded string.

projects/request/form-url-encoded-content · high confidence

A new example project, cookies-3, has been added to demonstrate how to implement cross-site antiforgery and access cookies from a remote API. The sample consists of a backend API and a frontend application, each with their own configuration files (appsettings.json) and entry points (Program.cs). The frontend includes Razor pages and JavaScript to fetch cookies via AJAX, while the backend configures CORS to allow credentials from the frontend's origin.

projects/request/cookies-3 · high confidence

A new example (json-26) demonstrates how to detect the type of a JSON property using the \JsonValueKind\ enumeration from \System.Text.Json\. The sample parses a JSON string into a \JsonNode\ and iterates through its properties to identify whether each value is a string, boolean, number, array, or object, and writes the detected type to the response.

projects/json · high confidence

A new sample project has been added to demonstrate how to configure endpoint routing to enable only MVC routes (specifically attribute routing) while explicitly excluding Razor Pages support. The example uses the modern minimal API style with \WebApplication.CreateBuilder()\ and \app.MapControllers()\ to set up a basic controller-based application.

projects/endpoint-routing/new-routing-2 · high confidence

A new sample project demonstrates how to configure the static file middleware to serve content from multiple directories, including a secondary folder (wwwroot2) mapped to a specific request path (/2).

projects/file-provider/serve-static-files-7 · high confidence

A new sample project demonstrates how to configure the .NET logging system to output structured JSON logs to the console. The example configures log levels for specific namespaces and uses the built-in JSON console logging provider to format output as indented JSON.

projects/logging/logging-3 · high confidence

A new ASP.NET Core application is introduced in the features-server-addresses-2 project, featuring a custom middleware that retrieves and exposes the server's bound addresses via the IServerAddressesFeature.

projects/features/features-server-addresses-2 · medium confidence

A new server-side feature has been introduced that intercepts incoming HTTP requests to append a 'greetings' header with the value 'hello world'. When a request is processed, the application responds with a message including the greeting from the header, demonstrating a basic request modification and response generation capability.

projects/features/features-server-request · high confidence

The application now supports HTTP sessions. It configures a distributed memory cache and the session middleware, allowing the app to store and retrieve data (such as a message string and the current year) in the user's session. This enables stateful interactions where data persists across requests for a specific user.

projects/features/features-session · high confidence

A new Razor Pages routing example has been added, featuring custom page templates for the index, about, contact, and blog pages. The example demonstrates configuring routing using the @page directive with specific URL patterns (e.g., /AboutOurSchool, /Contact-Us, /Blog/2018/4/20/itsmybirthday). The setup includes the necessary Visual Studio Code launch and task configurations to support debugging and building the application.

projects/razor-pages/routing · medium confidence

The file-provider project now includes a minimal ASP.NET Core application (Program.cs) that serves static files from the wwwroot directory, including a CSS file (hello.css), an HTML page (index2.html), and a text file (secrets/one.txt). This introduces the ability to serve static content directly from the wwwroot folder.

projects/file-provider/serve-static-files-3 · medium confidence

The application now serves static files from the wwwroot directory and provides a custom directory browser for listing contents. The browser displays images (.png, .jpg) as thumbnails and lists other files, using Bootstrap 5.1.3 for styling. A hello.css file and an index.html file are also included in the wwwroot folder.

projects/file-provider/serve-static-files-4 · medium confidence

A new sample host application for static files has been added to the Orchard Core static-files module. This includes a minimal ASP.NET Core 6.0 application setup in Program.cs that initializes the Orchard Core host with MVC support, along with the necessary view imports, layout configuration, and app settings to run the static files sample.

projects/device-detection, projects/orchard-core/static-files/Host · medium confidence

Introduces a new sample module named 'ForumModule' that demonstrates serving static files. The module registers a route for the 'Home' controller, displays a heading and an image, and includes a CSS file that sets the body color to pink.

projects/orchard-core/static-files/ForumModule · medium confidence

The middleware-8 project now includes a new Program.cs file that demonstrates a terminal middleware (TerminalMiddleware) which writes a greeting message to the HTTP response. The example shows how to register services (Content, Greeting) and configure the middleware with specific parameters (city, name, greeting) in the application builder.

projects/middleware/middleware-8 · high confidence

A new .NET 6 sample project (projects/request/request-headers-typed) demonstrates accessing typed HTTP headers via HttpContext.Request.GetTypedHeaders(), specifically showing how to read the Accept and Accept-Language headers in a minimal API.

projects/request/request-headers-typed · high confidence

A new example project named 'up-hungry' has been added to demonstrate the 'up-hungry' attribute for loading content fragments on untargeted elements. The implementation uses Unpoly 3.8.0, as indicated by the script and CSS imports in the HTML template. The example includes a C\# WebApplication that serves an HTML page with navigation links and a div with the 'up-hungry' attribute, alongside a helper class to detect Unpoly requests via headers.

projects/unpoly/up-hungry · high confidence

A new MVC routing example was added to the project, featuring a HomeController that handles GET and POST requests on the /about path. The example includes VS Code launch and task configurations to support debugging and building the .NET 6 application.

projects/mvc/routing/routing-5 · medium confidence

Added a new WebSockets demo application in the web-sockets-5 project, implementing a simple chat system with commands for listing users, setting nicknames, sending private messages, and quitting. The application includes both the C\# server-side logic and an embedded HTML/JavaScript client for testing.

projects/web-sockets/web-sockets-5 · high confidence

A new example project (caching-4) demonstrates .NET 6 memory caching with expiration. The app registers an IMemoryCache and stores two cache entries that share a single CancellationTokenSource. After 8 page refreshes, the token is cancelled, causing both cache entries to expire simultaneously, which is confirmed by post-eviction callbacks and a message on the response.

projects/caching/caching-4 · medium confidence

Developers can now debug the generic-host-5 application directly in VS Code. This change introduces launch.json and tasks.json files that configure the .NET Core debugger (coreclr) and a build task for the generic-host-5 project. The Program.cs file implements a background hosted service (CountingService) that logs a counter every second, providing a concrete example of the application's runtime behavior.

projects/generic-host/generic-host-5 · medium confidence

The middleware-4 project now includes a Program.cs file that defines two new endpoints, /hello and /world, which return simple text responses. Additionally, the root path serves an HTML page containing links to these two endpoints.

projects/middleware/middleware-4 · high confidence

A new ASP.NET Core application was added to the localization-4 project, implementing a simple demo that switches the application's display language (French or English) via cookies. The app configures supported cultures (fr-FR, en-US) and uses a CookieRequestCultureProvider to persist the user's language preference, displaying localized strings from resource files.

projects/localization/localization-4 · high confidence

The Blazor Server application now includes a new App.razor component that defines the root routing structure, including a 404 Not Found fallback, and a \_Imports.razor file that registers common namespaces such as System.Net.Http, Microsoft.AspNetCore.Components, and Microsoft.JSInterop for use across the application.

projects/blazor-ss/JsIntegration/Components · high confidence

The project now includes the main HTML layout template (Index.cshtml) which bootstraps the Blazor Server application with Bootstrap 5.1.3 and the Blazor server.js script, alongside a \_ViewImports.cshtml file that configures namespace and tag helpers for the Pages directory.

projects/blazor-ss/JsIntegration/Pages · high confidence

A new Program.cs file was added to the web-utilities-reason-phrases project, implementing a minimal ASP.NET Core application that uses the ReasonPhrases utility to retrieve and display the standard HTTP reason phrases for status codes 200 and 500.

projects/web-utilities/web-utilities-reason-phrases · medium confidence

A new sample project (json-19) was added to demonstrate constructing JSON documents using the System.Text.Json DOM types. The sample shows how to parse JSON strings into JsonNode objects and build JSON structures programmatically using JsonArray and JsonObject, including both verbose and terse construction patterns.

projects/json/json-19 · high confidence

A new MVC application has been added that demonstrates JSON Web Token (JWT) authentication. Users can generate a signed JWT containing user claims (name and role) and view the encoded token. The application also provides a feature to decode a provided JWT and inspect its contents. The project includes a VS Code settings file with custom color themes and a solution file for the project.

projects/mvc/jwt · high confidence

Introduced a new ASP.NET Core MVC application structure for demonstrating localization. This includes configuring request localization to support French (fr-FR) as the default and supported culture, adding a resource file with French translations for keys like 'Hello', 'Goodbye', 'Yes', and 'No', and creating a view that displays the current culture and localized strings. The setup also includes VS Code debugging and task configuration files to support development workflows.

projects/mvc/localization/mvc-localization-5 · high confidence

Added new sample projects demonstrating ASP.NET Core MVC tag helpers and static file cache busting. The 'tag-helper-2' and 'tag-helper-3' directories introduce custom tag helpers that transform HTML elements, with the latter supporting configurable alert types. The 'tag-helper-img' and 'tag-helper-link' directories demonstrate using the built-in Image and Link tag helpers to append version strings to static assets, ensuring browsers download updated CSS and JavaScript files.

(repo-wide) · high confidence

Added Program.cs to demonstrate the use of MapWhenMiddleware and MapMiddleware for conditional and path-based routing in the middleware-7 project.

projects/middleware/middleware-7 · high confidence

A new Razor Pages handler sample has been added to the project, featuring a basic page that displays a message and HTTP method via GET and POST requests. The sample includes a C\# PageModel class in Pages/Index.cshtml that handles OnGet and OnPost actions. Additionally, VS Code debugging and build task configurations (launch.json and tasks.json) have been added to support local development and debugging of the .NET Core application.

projects/razor-pages/handler · high confidence

The Blazor Server application now includes the necessary Razor page templates to render the main layout and import required namespaces and tag helpers. Specifically, the Index.cshtml file defines the root page structure with Bootstrap 5.1.3 styling and Blazor Server script references, while \_ViewImports.cshtml configures the Layout.Components namespace and MVC tag helpers for the Pages directory.

projects/blazor-ss/Layout/Pages · medium confidence

The projects/rewrite directory now includes a README and build scripts for six URL rewriting and redirecting examples (rewrite-1 through rewrite-6). These examples demonstrate basic and permanent redirects (HTTP 302 and 301), regex-based path matching, and custom redirection logic using both IRule implementations and lambda expressions. The project is configured for .NET 6.

projects/rewrite · high confidence

The application now includes a rewrite rule that redirects requests to the root path when the URL ends with a trailing slash. This is implemented in the new Program.cs file, which also sets up a basic web server response for the root path.

projects/rewrite/rewrite-1 · high confidence

Added .vscode/launch.json and .vscode/tasks.json to enable .NET Core debugging and building within VS Code. The launch configuration targets netcoreapp3.1, while the tasks file defines a 'build' task that compiles mvc-localization-2.csproj. These files streamline the developer experience for running and debugging the MVC localization feature locally.

projects/mvc/localization/mvc-localization-2 · high confidence

A new WebSockets sample application has been added to the web-sockets-2 project. This includes a C\# backend that handles WebSocket connections and an embedded HTML/JavaScript client for interactive testing.

projects/web-sockets/web-sockets-2 · high confidence

A new demo project was added to the codebase that demonstrates how to load and use configuration values from an XML file. The project includes a Program.cs file that sets up an ASP.NET application to read settings from a settings.xml file, mapping them to a strongly-typed XmlOptions class. The settings.xml file contains sample configuration data including web pages, database connection details, and application-specific settings. This provides a working example of XML-based configuration in .NET applications.

projects/configurations/configuration-xml-options · high confidence

A new ASP.NET Core application was added at projects/request/anti-forgery/Program.cs that demonstrates anti-forgery token generation and validation. The application configures antiforgery services with a custom cookie name, domain, and form field name, then serves an HTML form that includes the generated token. On POST requests, it validates the anti-forgery token before responding, providing a concrete example of implementing anti-forgery protection in a web application.

projects/request/anti-forgery · high confidence

Added new files to the web-utilities project area: a README.md introducing the section and linking to Query Helpers, Parse Query String, and Reason Phrases utilities, along with build.bat and build.sh scripts to build the three associated projects.

projects/web-utilities · high confidence

Added a README.md file that documents the six localization samples, including their dependencies and features (e.g., query string and cookie-based culture switching, PO file support). Additionally, added build.bat and build.sh scripts that automate the build process for all six localization samples.

projects/localization · high confidence

Users can now build the utility projects (http-status-codes, media-type-names, media-type-names-2) using the newly added build.bat and build.sh scripts. A README.md file has also been added to the utils folder, documenting the available utilities including status code helpers and MIME type name constants.

projects/utils · high confidence

A new decoupled CMS sample project has been added to the Orchard Core repository. This includes a basic Razor page (Index.cshtml) that inherits from the OrchardCore Display Management, a Program.cs entry point that configures the ASP.NET Core pipeline with Orchard Core services, and a custom frontend layout view (Layout-Frontend.cshtml) that serves as the base template for the decoupled frontend. The sample provides a starting point for building headless CMS applications.

projects/generic-host/generic-host-configure-host, projects/orchard-core/decoupled-cms · high confidence

A new shared layout template (\_Layout.cshtml) has been added to the static-files sample project. This template provides a standard HTML5 structure with Bootstrap 5.1.3 styling, a main content area, and footer, establishing the default visual framework for the sample application.

projects/orchard-core/static-files/Host/Views · high confidence

The application now includes a custom rewrite rule that redirects requests for .png and .jpg files to specific image directories (/images/png and /images/jpeg respectively) using HTTP 301 redirects. This is implemented via a new Program.cs file that sets up routing, static file serving, and the extension-based redirection logic.

projects/rewrite/rewrite-5 · high confidence

A new file upload feature has been introduced, providing an HTML form for selecting and uploading files. The application now includes a GET endpoint that serves the upload form and a POST endpoint at /Upload that processes the submitted file, reads it from the request stream, and writes it to the content root directory.

projects/request/form-upload-file · high confidence

Added two new gRPC sample projects: a unary RPC example in \projects/grpc/grpc\ and a server-streaming RPC example in \projects/grpc/grpc-2\. Each project contains the necessary C\# client and server implementations along with the corresponding \.proto\ definitions, demonstrating how to build and consume gRPC services using ASP.NET Core and Kestrel.

projects/grpc/grpc, projects/grpc/grpc-2 · high confidence

A new generic host application was added to the projects/generic-host/generic-host-2 directory. This example configures a background hosted service (HelloWorldService) that logs debug messages to the console, while explicitly filtering out Microsoft framework logs to keep the output clean.

projects/generic-host/generic-host-2 · high confidence

A new generic-host example project has been added that demonstrates how to use IHostApplicationLifetime to register callbacks for application lifecycle events (started, stopping, stopped) within a HostBuilder-based application.

projects/generic-host/generic-host-ihostapplicationlifetime · high confidence

Added new example projects (generic-host-3 and generic-host-4) that demonstrate the use of IHostedService for background tasks. The generic-host-3 example registers three hosted services (HelloWorldService, HelloWorldService2, HelloWorldService3) and configures console logging to filter out Microsoft namespace logs. The generic-host-4 example registers a single hosted service (HelloWorldService) and explicitly manages the host lifecycle by calling Start() and StopAsync().

projects/generic-host/generic-host-3 · high confidence

A new HostBuilder configuration was added in the generic-host-environment project, establishing a console-based application that registers a HelloWorldService. This service logs environment-specific messages (development, staging, or production) to the console, with Microsoft framework logs filtered out.

projects/generic-host/generic-host-environment · high confidence

A new example project was added that implements several custom middleware components to demonstrate ASP.NET Core request pipeline behavior. The code showcases the use of \MapWhen\ and \UseWhen\ to conditionally execute middleware based on request paths, illustrating the differences between branching (\MapWhen\) and non-branching (\UseWhen\) execution flows.

projects/middleware/middleware-12 · high confidence

A new Program.cs file was added to the middleware-0 project, implementing a simple ASP.NET Core application that demonstrates the execution order of three middleware components. The pipeline logs content at each stage of the request processing, showing how the middleware stack processes and modifies the response.

projects/middleware/middleware-0 · high confidence

A new endpoint was added to the application that renders an HTML page displaying all current query string parameters. The page iterates through the request's query string keys and values, listing each as a list item, and includes a link to add multiple query string values for testing purposes.

projects/request/query-string-3 · high confidence

A new project was added that demonstrates how to parse and display raw query string parameters using the \Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery\ method within a minimal API application. The example renders an HTML page showing the parsed key-value pairs from the URL, including support for multiple values per key.

projects/web-utilities/web-utilities-query-helpers-2 · high confidence

The application now includes response compression capabilities. Users will benefit from reduced bandwidth usage and faster response times when the server compresses the response body. The implementation registers the compression middleware and handles the Vary header for Accept-Encoding to ensure correct caching and proxy behavior.

projects/response/compression-response · high confidence

A new sample project (json-16) was added to demonstrate parsing a JSON array using System.Text.Json.Nodes and using LINQ to find a node based on the absence of a property. The sample includes a README explaining the scenario and a Program.cs file that parses a JSON string, iterates through the array, and identifies the entry missing the 'favoriteNumbers' property.

projects/json/json-16 · high confidence

A new entry point (Program.cs) was added to the features-server-addresses project, implementing a minimal ASP.NET Core application that enumerates and returns the server's bound addresses.

projects/features/features-server-addresses · high confidence

A new ASP.NET Core application was added to the middleware-3 project, featuring a terminal middleware that writes 'Hello world' to the response. The implementation demonstrates a simple middleware class that takes a RequestDelegate in its constructor and implements an Invoke method, serving as a basic example of terminal middleware behavior.

projects/middleware/middleware-3 · high confidence

The project introduces a new Blazor Server application that supports switching between English and Arabic locales, with the Arabic locale triggering right-to-left (RTL) text direction. The implementation uses Portable Object (PO) files for string resources and configures cookie-based culture switching to persist the user's language preference.

projects/blazor-ss/Localization-4 · medium confidence

The application now supports French (fr-FR) localization. A new \Program.cs\ configures the ASP.NET Core request localization middleware to use French as the default and supported culture. Additionally, French translation resources (e.g., 'Bonjour', 'Au Revoir') are provided in \Global.fr.resx\, enabling the MVC controllers to display localized content to French-speaking users.

projects/mvc/localization/mvc-localization-3 · high confidence

The sample project now includes a custom \IHtmlGenerator\ implementation (\LowerCaseIdHtmlGenerator\) that overrides the default behavior of ASP.NET Core Tag Helpers. By registering this custom generator in \Program.cs\, all automatically generated HTML element IDs (such as those for input fields) are converted to snake\_case format (e.g., \input\_first\_name\ instead of \Input\_FirstName\), making them easier to reference in JavaScript.

projects/razor-pages/custom-html-generator · high confidence

The \projects/blazor-ssr\ directory has been reorganized and expanded with multiple new sample projects demonstrating various Blazor rendering modes. These include server-side rendering (RazorComponentOne), MVC integration with \RazorComponentResult\ and \Html.RenderComponentAsync\ (RazorComponentFour, RazorComponentFive), multi-rendering pages combining static, server, and WebAssembly components (RazorComponentSeven, RazorComponentTen), streaming rendering updates (RazorComponentEleven), and query parameter binding (RazorComponentNine). Each sample includes the necessary Razor components, layout files, and configuration to showcase specific Blazor features.

projects/blazor-ssr · high confidence

The \projects/htmx\ directory now contains a comprehensive set of sample applications demonstrating how to integrate HTMX 2 with ASP.NET Core Minimal API. These examples cover a wide range of HTMX features, including HTTP verb handling, form processing, and various response headers such as \HX-Refresh\, \HX-Replace-Url\, \HX-Reselect\, and \HX-Retarget\. The samples also illustrate client-side event handling, anti-forgery token management, and the use of the \Htmx\ NuGet package to simplify header configuration.

projects/htmx · high confidence

Added a README.md file that documents the Generic Host feature, including links to various sample projects such as 'Hello World', 'Startup and Shutdown order', and 'Configure Environment'. Additionally, build scripts (build.bat and build.sh) were added to automate the build process for these samples.

projects/generic-host · medium confidence

Added the core components for the Blazor Server chat application. This includes the main App.razor router configuration, the Index.razor page which handles the SignalR connection, message broadcasting, and user interaction, and an \_Imports.razor file to expose necessary namespaces. The implementation uses the @code block for C\# logic, enabling users to connect to a broadcast service and send/receive messages.

projects/blazor-ss/ChatR/Components · high confidence

A new .NET 6-based middleware sample has been added to the project. It demonstrates dynamic routing using MapWhen to conditionally handle requests to /hello, which then maps /world as a nested route. The application also includes a fallback route that renders a simple HTML page with links to the /hello and /hello/world endpoints.

projects/middleware/middleware-6 · high confidence

Added a new Orleans-based RSS reader sample that configures a localhost cluster with in-memory reminders and Redis-based storage for both feed sources and fetched items. The application exposes a root endpoint that initializes feed sources, fetches content via grains, and renders the aggregated results as HTML. The accompanying README clarifies that the sample requires a running Redis instance.

projects/orleans/rss-reader · high confidence

Added a new RSS reader application built on the Orleans framework, featuring a web interface that fetches and displays feed items from an OPML subscription list. The application uses Orleans reminders to periodically fetch updates from each RSS source and persists the feed source metadata and fetched items in a Redis store.

projects/orleans/rss-reader-3, projects/orleans/rss-reader-4 · high confidence

Added a new RSS reader application built on the Orleans framework, featuring a reminder-based mechanism to periodically fetch and process RSS feeds. The application utilizes Redis for persistent storage of feed sources and results, and implements a stream-based architecture where each feed source is fetched on a configurable schedule. The entry point initializes the Orleans cluster with localhost clustering, in-memory reminder services, and Redis grain storage, while the main program maps HTTP endpoints to display feed items and manage feed sources.

projects/orleans/rss-reader-5, projects/orleans/rss-reader-6 · high confidence

The rate-limiter-http-client project now enforces a concurrency limit of 5 permits with a queue of 5, configured via the Polly resilience handler. The policy is set to retry up to 3 times for non-200 status codes and when a RateLimiterRejectedException is thrown, using a backoff strategy of 0s, 1s, and 5s.

projects/polly/rate-limiter-http-client · high confidence

The application now serves static files from the wwwroot directory, including a sample HTML page, a CSS stylesheet, and a nested text file. This adds the ability to serve and browse static content directly from the web root.

projects/file-provider/serve-static-files-2 · high confidence

Added new App.razor and \_Imports.razor files to the Blazor Server project's Layout/Components directory. The App.razor file defines the root router with a 404 fallback, while \_Imports.razor adds standard namespace imports for HTTP, forms, routing, JS interop, and authorization, enabling the application's core navigation and layout structure.

projects/blazor-ss/Layout/Components · medium confidence

A new sample application has been added to demonstrate Server-Side Blazor with multiple entry points. The project includes Razor Pages at /Admin/Blazor, /Manage, and /Secure, each serving as a distinct starting point for different navigation paths within the Blazor app. The sample is built on .NET 6 and uses Bootstrap 5 for styling.

projects/blazor-ss/StartingVariation · high confidence

Added four new sample projects (httpclientfactory-1 through 4) that illustrate how to use IHttpClientFactory for managing HttpClient instances via dependency injection. The samples progress from basic usage to configuring named clients, injecting into classes, and using interface-based registration. Build scripts (build.bat and build.sh) and VS Code configuration files were also added to support the new samples.

projects/httpclientfactory · high confidence

A new sample project (windows-service-1) has been added to demonstrate how to host a Kestrel server within a Windows Service. The sample includes a Program.cs that configures the host using Microsoft.Extensions.Hosting.WindowsServices and sets up a basic HTTP response. The accompanying README provides instructions for installing and managing the service via the Windows sc.exe tool.

projects/windows-service · high confidence

Added new sample applications demonstrating ASP.NET Core Data Protection configurations. These include samples for storing keys in Azure Blob Storage, using Azure Key Vault for encryption, and implementing a custom XML encryptor. The changes add complete project structures for these scenarios, including Razor pages for encryption/decryption demonstrations, startup configurations, and supporting files, providing practical examples for developers looking to secure data protection keys in cloud or custom storage environments.

projects/security/dataprotection · high confidence

A new ASP.NET Core web application has been introduced that exposes a password hashing service. Users can now send a 'password' query parameter to the root URL to receive the hashed version of the input, along with a verification result. The implementation utilizes the built-in ASP.NET Identity PasswordHasher to demonstrate password hashing and verification capabilities.

projects/password-hasher · high confidence

The RssReader-2 project introduces a server-side Blazor application that fetches and displays RSS feeds. The UI progressively updates as news items are streamed from multiple sources using C\# 8's IAsyncEnumerable, providing a live-updating list of headlines.

projects/blazor-ss/RssReader-2 · high confidence

The Razor Pages sample project now demonstrates two new capabilities: using markup inside methods within the \@functions\ block and using markup inside local functions within a code block. These changes allow developers to embed HTML elements directly within C\# methods and local functions, enhancing the flexibility of Razor syntax.

projects/razor-pages/razor · medium confidence

Added a README.md file that documents the three syndication samples (RSS reader, RSS with extensions, and a NewsServer MVC demo) and provides links to each example. Also added build scripts (build.bat and build.sh) to build the three sample projects (newsserver-mvc, syndication-1, syndication-2) using dotnet build.

projects/syndications · high confidence

A new ASP.NET Core 6 application has been added to demonstrate the \GetDisplayUrl\ helper method. The app serves an HTML page that displays the unescaped request URL and includes links to test various URL formats, such as those with query strings and special characters.

projects/uri-helper/uri-helper-get-display-url · high confidence

A new sample project (json-9) has been added to demonstrate System.Text.Json usage in .NET 6. It includes a Web API endpoint that serializes a Person object using a custom TimeSpanConverter, with options for camel-case naming and null-ignoring.

projects/json/json-9 · high confidence

A new example project at projects/mvc/api-problem-details demonstrates how to return standardized error responses using Microsoft.AspNetCore.Mvc.ProblemDetails. The implementation catches exceptions in a controller and returns a ProblemDetails object with a title, detail message, and HTTP 500 status code, following RFC 7807.

projects/mvc/api-problem-details · medium confidence

The application now supports French (France) translations. Users will see localized strings for 'Hello', 'Goodbye', 'Yes', and 'No' when the request culture is set to fr-FR. The application is configured to use French as the default request culture and to accept French (fr-FR) as a supported culture for both content and UI localization.

projects/localization/localization-1 · medium confidence

The application now explicitly registers the XmlSerializerOutputFormatter, enabling the MVC pipeline to serialize responses as XML. The default controller returns a Greeting object, which will be formatted as XML in the HTTP response.

projects/mvc/mvc-output-xml · high confidence

The diagnostics-3 project now includes a Program.cs file that configures a custom exception handler. This handler catches unhandled exceptions and returns a 500 status code with a simple HTML page displaying the error message and source, rather than the default ASP.NET Core yellow screen.

projects/diagnostics/diagnostics-3 · medium confidence

The server now includes a new middleware component that sets and retrieves a custom feature via the request context. This allows previous middleware to inject a custom feature that subsequent handlers can access, returning a greeting message in the response.

projects/features/features-server-custom · medium confidence

A new server component has been introduced in the features-server-custom-override project. This C\# application implements a custom feature override mechanism using ASP.NET Core minimal APIs, featuring a custom ICustomFeature interface and middleware pipeline that modifies request context features before and after processing.

projects/features/features-server-custom-override · medium confidence

The application now includes a custom error page that displays the exception message and source for unhandled exceptions. This change introduces a global exception handler that returns a 500 status code with an HTML response containing the error details, improving the user experience by providing clear feedback when an internal error occurs.

projects/diagnostics/diagnostics-4 · medium confidence

A new sample project (json-14) was added to the repository, featuring a minimal ASP.NET Core application that parses a JSON array using System.Text.Json.Nodes. The example demonstrates how to locate a specific object within the JSON structure by filtering on a property value (age) using LINQ, and then outputting the matched node and its path.

projects/json/json-14 · medium confidence

A new sample project at projects/configurations/configuration-IOption has been added, illustrating how to bind configuration values using the IOptions interface. The sample registers MyOptions with the configuration section 'MyOptions' and exposes the bound values via a web endpoint.

projects/configurations/configuration-IOption · high confidence

The application now serves static files from the wwwroot directory and provides a custom directory browser for folder contents. The browser displays directories as links, images as thumbnails, and other files as links, using Bootstrap 5 for styling. A hello.css stylesheet and an index.html file are also included in the wwwroot folder.

projects/file-provider/serve-static-files-5 · high confidence

The Blazor Server application now includes the main layout page (Index.cshtml) and the corresponding \_ViewImports.cshtml file, which configures the Razor namespace and tag helpers required for the server-side rendering of the app.

projects/blazor-ss/HelloWorld/Pages · medium confidence

The rewrite-2 project now includes a new Program.cs file that implements a URL rewrite rule to redirect paths ending with a file extension (e.g., .html, .aspx) to a query-string-based route. This allows the application to capture path and extension values from the URL and display them on a generated HTML page, effectively enabling a new routing and rewriting capability within this specific project.

projects/rewrite/rewrite-2 · high confidence

Developers can now debug the diagnostics-2 application directly in VS Code. This change adds .vscode/launch.json and .vscode/tasks.json files, configuring the .NET Core debugger to launch the web application and attach to processes, while also defining a build task that compiles diagnostics-2.csproj.

projects/diagnostics/diagnostics-2 · high confidence

The application now uses ASP.NET Core's URL Rewrite middleware to permanently redirect any request ending in .html or .aspx to a root handler, capturing the path and extension as query parameters. This change introduces a new Program.cs file that defines this redirect logic, replacing the previous structure where the project likely relied on a different configuration or file layout.

projects/rewrite/rewrite-4 · high confidence

The application now includes a rewrite rule that intercepts requests for .jpg files and redirects them to /images/jpeg with the original filename. This is implemented using a custom IRule that checks the request path, sets a 301 Moved Permanently status code, and updates the Location header to the new path, preventing infinite redirect loops.

projects/rewrite/rewrite-6 · medium confidence

The Wiki application has been migrated to use ASP.NET Core Minimal APIs, replacing the previous controller-based or legacy routing approach. This change updates the application's request handling to use the modern \MapGet\ and \MapPost\ endpoints for all wiki operations, including page creation, editing, deletion, and attachment management, providing a more concise and modern routing structure.

projects/sfa/wiki · high confidence

The application now supports storing HTTP session data in a Redis cache. This is achieved by configuring the ASP.NET Core session middleware to use StackExchange.Redis for persistence, allowing session state to be shared across multiple instances or survive server restarts.

projects/features/features-session-redis-2 · high confidence

The project now uses a minimal API entry point (Program.cs) to bootstrap the application, replacing the previous template structure. This includes a new HomeController that demonstrates MVC routing with \[controller\] and \[action\] replacement tokens, alongside VS Code launch and task configurations to support debugging and building the project.

projects/mvc/routing/routing-8 · high confidence

The MVC samples have been updated to demonstrate .NET 10 features, including automatic dependency inference in action methods (removing the need for \\[FromServices\]\), the built-in OpenAPI support (replacing NSwag), and the use of \Microsoft.AspNetCore.Mvc.ProblemDetails\ for API error handling. The README and build scripts have been reorganized to reflect these changes and include new examples for localization, routing, tag helpers, and view components.

projects/mvc · medium confidence

The Mailkit application has been refactored to use the ASP.NET Core minimal API pattern, replacing the previous startup configuration with a concise Program.cs that registers the EmailService and defines the default route. The application now uses controller-based routing for the Mailkit controller, which retrieves emails via POP3 and displays them on the Index view, accessible through a new Retrieve endpoint.

projects/mailkit/mailkit-2 · high confidence

The Blazor Server application has been upgraded to .NET 6, which includes updating the root layout page (Index.cshtml) to use Bootstrap 5 via a CDN link. Additionally, the \_ViewImports.cshtml file was created to explicitly import the ChatR.Components namespace and configure MVC tag helpers, reflecting the structural changes required for the .NET 6 Blazor Server template.

projects/blazor-ss/ChatR/Pages · medium confidence

The Razor Pages basic sample has been updated to use the .NET 6 minimal hosting model, replacing the previous traditional configuration approach. The application now uses the simplified \WebApplication.CreateBuilder()\ and \app.MapRazorPages()\ pattern in \Program.cs\, providing a more concise entry point for Razor Pages applications.

projects/razor-pages/razor-pages-basic · medium confidence

The configuration-1 project has been upgraded to .NET 6, adopting the minimal hosting model for the application entry point. This change updates the runtime environment and associated build scripts to align with the new framework version.

projects/configurations/configuration-1 · medium confidence

The dependency injection samples in the \projects/dependency-injection\ directory have been migrated to .NET 6. This includes updating the \README.md\ to reference .NET 6, adding \build.bat\ and \build.sh\ scripts to build the sample projects, and updating the C\# source files (e.g., \Program.cs\) to use the .NET 6 Web API template patterns (such as \WebApplication.CreateBuilder()\ and minimal API endpoints). The samples demonstrate basic lifetime registrations (singleton, scoped, transient), use of \IServiceProvider\ for service location, lazy type registration, and keyed service registration for both minimal APIs and MVC controllers.

projects/dependency-injection · medium confidence

The sample application now uses the modern endpoint routing API for health checks. Instead of the legacy \IApplicationBuilder.UseHealthChecks\ pattern, the app registers health checks via \builder.Services.AddHealthChecks()\ and maps the \/WhatsUp\ endpoint using \app.MapHealthChecks()\. This aligns the sample with ASP.NET Core 2.2+ conventions where health checks are mapped as endpoints rather than middleware.

projects/endpoint-routing/new-routing-21 · high confidence

The nswag sample has been updated to use .NET 10's built-in OpenAPI support, replacing the previous NSwag.AspNetCore dependency. This change simplifies the project by removing the external library in favor of the native framework features, while also adding VS Code color theme settings for the project directory.

projects/mvc/nswag · medium confidence

The nswag-2 sample has been migrated from the external NSwag library to .NET 10's built-in OpenAPI support. This change removes the NSwag.AspNetCore dependency in favor of native OpenAPI generation, integrates the Scalar.AspNetCore package for a modern interactive documentation UI, and updates controller attributes to use the new \\[Tags\]\ and \\[ApiExplorerSettings\]\ attributes. Users will see the API documentation at /scalar and the OpenAPI JSON at /openapi/v1.json.

projects/mvc/nswag-2 · high confidence

The sample application has been updated to use the .NET 6 minimal hosting model, replacing the previous configuration approach with a concise setup using WebApplication.CreateBuilder and builder.Services.AddControllersWithViews. This change aligns the project with current ASP.NET Core standards, providing a more streamlined and performant routing experience as described in the embedded HTML content.

projects/endpoint-routing/endpoint-routing · high confidence

The diagnostics-1 project has been updated to use the .NET 6 minimal hosting model, replacing the previous project structure with a simplified entry point in Program.cs that creates a WebApplication, enables the welcome page, and runs the app. This change reflects the architectural shift in .NET 6 where the traditional Program.cs template is replaced by top-level statements and implicit global usings.

projects/diagnostics/diagnostics-1 · high confidence

The middleware-9 project has been upgraded to .NET 6, adopting the minimal API pattern for application startup. This change replaces the previous project structure with a concise \Program.cs\ that configures dependency injection for \Greeting\ and \Goodbye\ services and registers the \TerminalMiddleware\. Users will now interact with the middleware using the updated .NET 6 runtime and minimal API conventions.

projects/middleware/middleware-9 · medium confidence

The multi-tenant sample host has been modernized to use the ASP.NET Core minimal hosting model. The application entry point now uses the simplified \WebApplication.CreateBuilder()\ API, and the startup pipeline is configured with \AddOrchardCore().AddMvc().WithTenants()\ followed by \UseOrchardCore()\. The sample also includes a shared layout view with Bootstrap 4.3.1, standard view imports, and a basic logging configuration.

projects/orchard-core/multi-tenant/Host · high confidence

The orleans-2 sample has been updated to use Microsoft.Orleans.Persistence.Redis for state persistence, configuring a Redis connection to localhost:6379. The application now stores and retrieves greeting messages in Redis, allowing data to persist across application restarts.

projects/orleans/orleans-2 · high confidence

The Orleans samples have been upgraded to Microsoft Orleans 8 and .NET 10 RC 1, introducing a new minimal API configuration approach and updated samples for timers, reminders, and HTTP clients. The project now targets .NET 10, as reflected in the global.json SDK version bump to 10.0.0-rc.1.25451.107, and includes a new README documenting the Orleans 8 samples while archiving older RSS reader examples.

projects/orleans · medium confidence

The Blazor Server sample applications (ChatR, HelloWorld, JsIntegration, and Layout) now each contain their own dedicated 'css' folder with a 'site.css' file. This change reorganizes the project structure to better separate static assets for each sample application.

(repo-wide) · low confidence

The ihosted-service-1 sample was refactored to use the built-in BackgroundService base class instead of a custom IHostedService implementation. This change reduces boilerplate code, simplifies cancellation token handling, and follows the standard Microsoft-recommended pattern for background tasks in ASP.NET Core.

projects/ihosted-service/ihosted-service-1 · medium confidence

The JSON serialization sample in the json-4 project has been updated to target .NET 6 and utilize the System.Text.Json library. The example now demonstrates how to control serialization behavior using the \[JsonPropertyName\] and \[JsonIgnore\] attributes, which allow for explicit property naming and the exclusion of specific properties from the serialized output. This change reflects a move away from older frameworks and source folder structures, providing a modern, attribute-driven approach to JSON handling.

projects/json/json-4 · medium confidence

The Orleans samples have been updated to use Orleans 8.0, introducing modernized patterns such as POCO grains implementing IGrain, the new \[GenerateSerializer\] attribute for serialization, and simplified configuration via Microsoft.Orleans.Server. The orleans-1 sample demonstrates basic grain storage, while orleans-4 adds support for grain reminders and Redis-based persistent state, requiring a running Redis instance.

projects/orleans/orleans-1, projects/orleans/orleans-4 · high confidence

The View Component samples in the MVC section have been upgraded to .NET 6. This includes updating the project structure to use the modern minimal hosting model (Program.cs) and ensuring compatibility with .NET 6 runtime and framework features.

projects/mvc/view-component · medium confidence

The sample in projects/endpoint-routing/new-routing-5 has been updated to demonstrate the modern .NET minimal hosting model. The project now uses the simplified WebApplication builder pattern in Program.cs, replacing the previous approach with a concise setup for controllers and a direct RequestDelegate mapping. Additionally, VS Code launch and task configurations have been added to support debugging and building the project in the new environment.

projects/endpoint-routing/new-routing-5 · medium confidence

The logging application now supports filtered log output. Specifically, logs from the 'Microsoft' namespace are restricted to Warning level and above, while logs from 'AppLogger' are set to Trace level, allowing for more granular control over which messages are displayed in the console.

projects/logging/logging-2 · medium confidence

Added a new sample project under projects/testing/nunit-1 that demonstrates how to write unit tests using the \WebApplicationFactory\<T\>\ from \Microsoft.AspNetCore.Mvc.Testing\. The sample includes a simple ASP.NET Core application and a corresponding NUnit test project that uses \WebApplicationFactory\ to start an in-process instance of the web application, allowing unit tests to query the application directly via \HttpClient\ without hitting the wire. The entry also includes README files explaining the sample and its usage.

projects/testing · high confidence

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

• First survey — no prior run to compare against. CAI 37.

• Code Health 59
• Architecture 100
• Maturity 61
• Readiness 19
• Security 81
• Accessibility 39

• 300 commits — 276 feature/other, 24 fixes

• projects/htmx — 65 commits
• projects/net10 — 29 commits
• (repo) — 28 commits
• projects/datastar — 28 commits
• (root) — 25 commits
• projects/unpoly — 12 commits
• projects/elsa — 9 commits
• projects/hydro — 9 commits
• projects/minimal-api — 9 commits
• projects/net9 — 8 commits
• projects/polly — 8 commits
• projects/open-telemetry — 7 commits
• projects/mvc — 6 commits
• projects/blazor-ssr — 3 commits
• projects/build.bat — 3 commits
• projects/logging — 3 commits
• projects/mailkit — 3 commits
• projects/net11 — 3 commits
• projects/razor-slices — 3 commits
• projects/authentication — 2 commits

• fix: Fix Orleans reminder sample for .NET 10 (logging API, reminder methods); remove missing response-buffering build entry; align nested global.json to preview SDK
• fix: Fix broken link
• fix: Fix compilation
• fix: Fix compiler error
• fix: Fix compiler error
• fix: Fix instruction
• fix: Fix links
• fix: Fix missing attribute
• fix: Fix name
• fix: Fix syntax change for Preview 6
• fix: Fix title
• fix: Fix title
• fix: Fix url
• fix: Fix warning
• fix: Fix warnings
• fix: Fix warnings
• fix: Fix warnings
• fix: Fix warnings
• fix: Fix warnings
• fix: Fix warnings
• …and 280 more

• 125 HTTP endpoints (baseline)

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

dodyg/practical-aspnetcore 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.