acrolinx, linter, documentor

Author: flang-msft

articles/redis/aspnet.md

@@ -1,5 +1,5 @@
 ---
-title: Create an ASP.NET Core web app with an Azure Redis cache
+title: Create an ASP.NET web app with an Azure Managed Redis cache
 description: In this quickstart, you learn how to create an ASP.NET Core web app with an Azure Redis cache.
 ms.date: 01/30/2026
 ms.topic: quickstart
@@ -10,23 +10,23 @@ appliesto:
 # Customer intent: As an ASP.NET developer, new to Azure Redis, I want to create a new Node.js app that uses Azure Managed Redis or Azure Cache for Redis.
 ---
 
-# Azure Managed Redis Sample - ASP.NET Core Web API
+# Azure Managed Redis sample - ASP.NET Core Web API
 
-This sample demonstrates how to connect an ASP.NET Core Web API to **Azure Managed Redis** using **Microsoft Entra ID authentication** (formerly Azure Active Directory) with the `DefaultAzureCredential` flow. The application avoids traditional connection string-based authentication in favor of token-based, identity-driven access—aligning with modern security best practices.
+This sample shows how to connect an ASP.NET Core Web API to Azure Managed Redis by using Microsoft Entra ID authentication  with the `DefaultAzureCredential` flow. The application avoids traditional connection string-based authentication in favor of token-based, Microsoft Entra ID access, which aligns with modern security best practices.
 
 ## Overview
 
 The application is a minimal ASP.NET Core 8.0 Web API that:
 
-1. Establishes a secure, authenticated connection to Azure Managed Redis at startup
-2. Exposes a simple REST endpoint that reads and writes data to the cache
-3. Demonstrates proper Redis connection lifecycle management with dependency injection
+1. Establishes a secure, authenticated connection to Azure Managed Redis at startup.
+1. Exposes a simple REST endpoint that reads and writes data to the cache.
+1. Demonstrates proper Redis connection lifecycle management by using dependency injection.
 
 ## Prerequisites
 
 - [.NET 8.0 SDK](https://dotnet.microsoft.com/download/dotnet/8.0)
 - An **Azure Managed Redis** instance provisioned in your Azure subscription
-- Your Azure user or service principal must have the appropriate **Data Access Policy** assigned on the Redis resource (e.g., `Data Owner`, `Data Contributor`, or a custom policy with read/write permissions)
+- Your Azure user or service principal must have the appropriate **Data Access Policy** assigned on the Redis resource, such as `Data Owner`, `Data Contributor`, or a custom policy with read and write permissions
 - [Azure CLI](https://docs.microsoft.com/cli/azure/install-azure-cli) for local development authentication
 
 ## Required NuGet Packages
@@ -44,7 +44,7 @@ Install the primary package:
 dotnet add package Microsoft.Azure.StackExchangeRedis
 ```
 
-This package transitively brings in `StackExchange.Redis` and `Azure.Identity`.
+This package brings in `StackExchange.Redis` and `Azure.Identity` as dependencies.
 
 ## Configuration
 
@@ -58,7 +58,8 @@ The application reads the Redis endpoint from configuration. Update `appsettings
 }
 ```
 
-> **Note:** Azure Managed Redis uses port `10000` by default. The endpoint format follows `<cache-name>.<region>.redis.azure.net:10000`.
+> [!NOTE]
+> Azure Managed Redis uses port `10000` by default. The endpoint format follows `<cache-name>.<region>.redis.azure.net:10000`.
 
 ## Authentication Flow
 
@@ -70,23 +71,23 @@ Before running the application locally, authenticate with Azure:
 az login
 ```
 
-The `DefaultAzureCredential` will automatically pick up your Azure CLI credentials and use them to obtain an access token for the Redis resource. This eliminates the need to manage or rotate secrets locally.
+The `DefaultAzureCredential` automatically picks up your Azure CLI credentials and uses them to get an access token for the Redis resource. This approach eliminates the need to manage or rotate secrets locally.
 
-### Production Environments
+### Production environments
 
-In Azure-hosted environments (App Service, Container Apps, AKS, etc.), `DefaultAzureCredential` will leverage:
+In Azure-hosted environments such as App Service, Container Apps, and AKS, `DefaultAzureCredential` uses:
 
 - **Managed Identity** (system-assigned or user-assigned)
 - **Workload Identity** (for Kubernetes scenarios)
 - **Environment variables** (for service principal authentication)
 
-No code changes are required—the same `DefaultAzureCredential` seamlessly adapts to the environment.
+You don't need to change your code. The same `DefaultAzureCredential` seamlessly adapts to the environment.
 
 ## Architecture
 
-### Redis Service (`Services/Redis.cs`)
+### Redis service (`Services/Redis.cs`)
 
-The `Redis` class encapsulates the connection lifecycle:
+The `Redis` class manages the connection lifecycle:
 
 ```csharp
 var options = new ConfigurationOptions()
@@ -102,13 +103,13 @@ _connection = await ConnectionMultiplexer.ConnectAsync(options);
 
 Key points:
 
-- `ConfigureForAzureWithTokenCredentialAsync` is the extension method from `Microsoft.Azure.StackExchangeRedis` that configures token-based authentication
-- The `DefaultAzureCredential` handles the token acquisition and refresh automatically
-- The connection is established once at startup and shared across requests
+- `ConfigureForAzureWithTokenCredentialAsync` is an extension method from `Microsoft.Azure.StackExchangeRedis` that sets up token-based authentication
+- `DefaultAzureCredential` automatically handles token acquisition and refresh
+- The app establishes the connection once at startup and shares it across requests
 
-### Dependency Injection (`Program.cs`)
+### Dependency injection (`Program.cs`)
 
-The Redis service is registered as a singleton and initialized during application startup:
+The app registers the Redis service as a singleton and initializes it during startup:
 
 ```csharp
 builder.Services.AddSingleton<Redis>();
@@ -128,25 +129,25 @@ The controller injects the `Redis` service and demonstrates basic cache operatio
 
 - **GET `/Sample`**: Reads the previous visit timestamp from the cache and updates it with the current time
 
-## Running the Application
+## Running the application
 
 1. Ensure you're authenticated:
 
    ```bash
    az login
    ```
 
-1. Update the Redis endpoint in `appsettings.Development.json`
+1. Update the Redis endpoint in `appsettings.Development.json`.
 
 1. Run the application:
 
   ```bash
    dotnet run
    ```
 
-1. Navigate to `https://localhost:<port>/swagger` to access the Swagger UI
+1. Navigate to `https://localhost:<port>/swagger` to access the Swagger UI.
 
-## Expected Output
+## Expected output
 
 When invoking the `GET /Sample` endpoint:
 
@@ -163,32 +164,32 @@ Previous visit was at: 2026-01-30T14:23:45
 (Returns the ISO 8601 formatted timestamp of the previous request)
 ```
 
-The console logs will display:
+The console logs display:
 
 ```bash
 info: Microsoft.Azure.StackExchangeRedis.Sample.AspNet.Controllers.SampleController
       Handled GET request. Previous visit time: 2026-01-30T14:23:45
 ```
 
-## Key Implementation Details
+## Key implementation details
 
-1. **Token Refresh**: The `Microsoft.Azure.StackExchangeRedis` library automatically handles token refresh before expiration—no manual intervention required.
+- **Token refresh**: The `Microsoft.Azure.StackExchangeRedis` library automatically refreshes tokens before they expire, so you don't need to handle refresh manually.
 
-1. **Connection Resilience**: The `ConnectionMultiplexer` from StackExchange.Redis handles reconnection logic internally.
+- **Connection resilience**: The `ConnectionMultiplexer` from StackExchange.Redis manages reconnection logic on its own.
 
-1. **Resource Cleanup**: The `Redis` service implements `IDisposable` to properly close the connection when the application shuts down.
+- **Resource cleanup**: The `Redis` service implements `IDisposable` to properly close the connection when the application shuts down.
 
-1. **Logging Integration**: The Redis client integrates with .NET's `ILoggerFactory` for unified logging output.
+- **Logging integration**: The Redis client works with .NET's `ILoggerFactory` for unified logging output.
 
 ## Troubleshooting
 
 | Issue | Resolution |
 | ------- | ------------ |
-| `No connection is available` | Verify the endpoint format and port (`10000`). Ensure the Redis instance is provisioned and accessible. |
+| `No connection is available` | Verify the endpoint format and port (`10000`). Make sure the Redis instance is provisioned and accessible. |
 | `AuthenticationFailedException` | Run `az login` to refresh credentials. Verify your identity has the required Data Access Policy on the Redis resource. |
-| `Unauthorized` | Ensure your Microsoft Entra ID identity is assigned a data access role on the Azure Managed Redis instance. |
+| `Unauthorized` | Ensure your Microsoft Entra ID identity is assigned to a data access role on the Azure Managed Redis instance. |
 
-## Additional Resources
+## Related content
 
 - [Azure Managed Redis documentation](https://learn.microsoft.com/azure/azure-cache-for-redis/)
 - [Microsoft Entra ID authentication for Azure Cache for Redis](https://learn.microsoft.com/azure/azure-cache-for-redis/cache-azure-active-directory-for-authentication)