# ASP.NET Core Samples: 15+ Example Applications in the dotnet/aspnetcore Repository

> Explore 15+ ASP.NET Core samples in the dotnet/aspnetcore repository. Discover authentication, middleware, hosting, and API patterns with runnable examples using dotnet run.

- Repository: [.NET Platform/aspnetcore](https://github.com/dotnet/aspnetcore)
- Tags: getting-started
- Published: 2026-08-01

---

**The samples directory in the dotnet/aspnetcore repository contains self-contained, runnable applications demonstrating authentication patterns, middleware configurations, hosting scenarios, and API styles that developers can execute directly with `dotnet run`.**

The dotnet/aspnetcore repository includes a comprehensive collection of example applications organized by subsystem. These **ASP.NET Core samples** provide focused implementations of specific framework features, allowing developers to examine working code without scaffolding entire projects. Each sample targets a single scenario—such as cookie authentication, output caching, or Azure deployment—and includes a project file, README, and complete source code.

## Security and Authentication Samples

The `src/Security/samples` folder contains the most extensive collection of **ASP.NET Core samples**, covering everything from static file protection to dynamic scheme selection.

### StaticFilesAuth

**StaticFilesAuth** demonstrates how to restrict access to static files using authentication and authorization policies. Located in `src/Security/samples/StaticFilesAuth`, this sample implements two distinct approaches: `MapAuthenticatedFiles` (allowing any authenticated user) and `MapImperativeFiles` (enforcing policy-based per-user directories).

The configuration in [`Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/Startup.cs) wires up a sub-pipeline that only serves files after authentication:

```csharp
// Inside Startup.Configure (lines 88-93)
app.Map("/MapAuthenticatedFiles", branch =>
{
    // No policy – any authenticated user can read files
    branch.Use((ctx, nxt) => { SetFileEndpoint(ctx, files, null); return nxt(ctx); });
    branch.UseAuthorization();                      // <-- enforces authentication
    SetupFileServer(branch, files);
});

```

Key files include [`Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/Startup.cs) and [`Program.cs`](https://github.com/dotnet/aspnetcore/blob/main/Program.cs) in the sample root.

### PathSchemeSelection

This sample shows how to select between cookie-based and API authentication schemes based on the request path. Using `AddPolicyScheme`, the application routes `/api` requests to a bearer token handler while routing standard MVC requests to cookie authentication. The implementation lives in [`src/Security/samples/PathSchemeSelection/Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Security/samples/PathSchemeSelection/Startup.cs).

### Identity.ExternalClaims

Located in `src/Security/samples/Identity.ExternalClaims`, this example copies static claims (such as gender) and dynamic claims (access tokens) from Google OAuth into the local identity cookie. It highlights the `OnCreatingTicket` event and claim-mapping techniques for external identity providers.

### Additional Security Examples

- **DynamicSchemes**: Located in `src/Security/samples/DynamicSchemes`, this sample demonstrates adding authentication schemes at runtime and selecting them per request.
- **CustomPolicyProvider**: Shows how to implement a custom `IAuthorizationPolicyProvider` to generate policies dynamically. See [`CustomPolicyProvider.cs`](https://github.com/dotnet/aspnetcore/blob/main/CustomPolicyProvider.cs) in `src/Security/samples/CustomPolicyProvider`.
- **ClaimsTransformation**: Located in `src/Security/samples/ClaimsTransformation`, this example uses `IClaimsTransformation` to add claims to a principal after authentication completes.

## Hosting and Deployment Samples

The `src/Azure/samples` directory contains **ASP.NET Core samples** specifically targeting cloud deployment scenarios.

### AzureAppServicesSample

This sample demonstrates deploying to Azure App Service using `UseAzureAppServices` and app-service-specific configuration. The setup is contained in [`src/Azure/samples/AzureAppServicesSample/Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Azure/samples/AzureAppServicesSample/Startup.cs).

### AzureAppServicesHostingStartupSample

Located in the same Azure samples directory, this example implements a *hosting startup* assembly that runs automatically when the application starts on Azure, illustrating how to inject configuration without modifying the main project code.

## Middleware Samples

The `src/Middleware` directory contains focused examples of ASP.NET Core's middleware pipeline.

### Caching Middleware

- **ResponseCachingSample**: Located in `src/Middleware/ResponseCaching/samples/ResponseCachingSample`, this shows how to enable response caching with `AddResponseCaching` and the `[ResponseCache]` attribute.
- **OutputCachingSample**: Found in `src/Middleware/OutputCaching/samples/OutputCachingSample`, this demonstrates the newer output-caching middleware (`AddOutputCache`) including Vary-by-query support.

### WebSockets and Session

- **WebSockets**: A simple echo server using `UseWebSockets` and custom `WebSocketMiddleware`, located in [`src/Middleware/WebSockets/samples/Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Middleware/WebSockets/samples/Startup.cs).
- **Session**: Shows how to configure distributed session state with `AddDistributedMemoryCache` and `AddSession` in [`src/Middleware/Session/samples/Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Middleware/Session/samples/Startup.cs).

## MVC and Minimal API Samples

The repository includes contrasting examples of controller-based and minimalist API approaches.

### MvcSample

Located in `src/Mvc/samples`, this full-featured MVC application demonstrates controllers, views, Razor Pages, routing, model binding, and view components. The configuration is centralized in [`src/Mvc/samples/Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Mvc/samples/Startup.cs).

### Minimal API Samples

The `src/Http/samples` directory contains several **ASP.NET Core samples** using the minimal API syntax:

- **MinimalSample**: Shows low-overhead services using `MapGet` and `MapPost` without controllers. See [`src/Http/samples/MinimalSample/Program.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/samples/MinimalSample/Program.cs).
- **MinimalValidationSample**: Demonstrates model validation in minimal APIs using `Validate` attributes and `IValidator`, located in [`src/Http/samples/MinimalValidationSample/Program.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/samples/MinimalValidationSample/Program.cs).
- **MinimalSampleFSharp**: The same minimal-API concept expressed in F#, showcasing cross-language support in `src/Http/samples/MinimalSampleFSharp/Program.fs`.
- **MinimalSampleOwin**: Shows how to use the OWIN pipeline (`app.Use`) inside a minimal API project in [`src/Http/samples/MinimalSampleOwin/Program.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Http/samples/MinimalSampleOwin/Program.cs).

## Specialized Server and Protocol Samples

Beyond the main categories, several **ASP.NET Core samples** demonstrate specific server configurations and protocols.

### SampleApp (HTTP)

Located in `src/Http/samples/SampleApp`, this example uses low-level `HttpContext` manipulation to build requests manually, useful for unit-testing request handling without the full middleware pipeline.

### SignalR

The SignalR sample in `src/SignalR/samples` provides a basic real-time messaging hub with client-side JavaScript, demonstrating persistent connections and message broadcasting.

### Server Configuration

- **Kestrel Samples**: Show how to configure the Kestrel web server, including HTTPS endpoints.
- **HttpSys Samples**: Demonstrate Windows-specific features like Windows Authentication and kernel-mode caching.

## How to Run the Samples

All samples are standard .NET projects that can be executed from the command line. Navigate to the sample directory and run:

```bash
cd src/Security/samples/StaticFilesAuth
dotnet run

```

By default, the application launches on `https://localhost:5001`. You can then explore the protected routes (such as `/MapAuthenticatedFiles` or `/MapImperativeFiles`) as documented in each sample's README.

## Summary

- The **samples directory** in dotnet/aspnetcore contains self-contained applications organized by subsystem (Security, Hosting, Middleware, MVC).
- **Security samples** like StaticFilesAuth and DynamicSchemes demonstrate authentication patterns using real file paths such as [`src/Security/samples/StaticFilesAuth/Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/src/Security/samples/StaticFilesAuth/Startup.cs).
- **Minimal API samples** in `src/Http/samples` contrast with traditional MVC approaches found in `src/Mvc/samples`.
- All samples are runnable via `dotnet run` and include complete project files and documentation.
- The repository includes cross-language support with F# examples and platform-specific configurations for Azure and Windows Authentication.

## Frequently Asked Questions

### Where are the ASP.NET Core samples located in the repository?

The samples are distributed throughout the repository under individual subsystem directories. Security samples reside in `src/Security/samples`, middleware samples in `src/Middleware/<feature>/samples`, and minimal API samples in `src/Http/samples`. Each folder contains a runnable `.csproj` or `.fsproj` file with accompanying source code.

### How do I run the StaticFilesAuth sample locally?

Navigate to `src/Security/samples/StaticFilesAuth` and execute `dotnet run`. The application will start on `https://localhost:5001` by default. You can then test the authentication-protected static files by visiting `/MapAuthenticatedFiles` (requires any authenticated user) or `/MapImperativeFiles` (requires specific policy authorization).

### What is the difference between the MinimalSample and MvcSample?

**MvcSample** in `src/Mvc/samples` uses the traditional controller-based architecture with views and Razor Pages, configured through [`Startup.cs`](https://github.com/dotnet/aspnetcore/blob/main/Startup.cs). **MinimalSample** in `src/Http/samples` uses the minimal API approach with `app.MapGet` and `app.MapPost` directly in [`Program.cs`](https://github.com/dotnet/aspnetcore/blob/main/Program.cs), eliminating controllers for lower overhead and simpler service scenarios.

### Are there F# examples in the ASP.NET Core samples?

Yes, the repository includes `MinimalSampleFSharp` located in `src/Http/samples/MinimalSampleFSharp`. This sample demonstrates the minimal API pattern using F# syntax in `Program.fs`, proving that the framework's core abstractions work across .NET languages.