edits

Author: ktoliver

articles/azure-cache-for-redis/cache-dotnet-core-quickstart.md

@@ -1,6 +1,6 @@
 ---
-title: 'Quickstart: Use Azure Cache for Redis in .NET Core'
-description: In this quickstart, learn how to access Azure Cache for Redis in your .NET Core apps
+title: 'Quickstart: Use Azure Cache for Redis with .NET Core'
+description: Modify a sample .NET Core app and connect the app to Azure Cache for Redis.
 
 
 
@@ -10,19 +10,19 @@ ms.topic: quickstart
 ms.date: 03/25/2022
 ---
 
-# Quickstart: Use Azure Cache for Redis in .NET Core
+# Quickstart: Use Azure Cache for Redis with a .NET Core app
 
-In this quickstart, you incorporate Azure Cache for Redis into a .NET Core app to have access to a secure, dedicated cache that is accessible from any application within Azure. You specifically use the [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis) client with C# code in a .NET Core console app.
+In this quickstart, you incorporate Azure Cache for Redis into a .NET Core app to have access to a secure, dedicated cache that is accessible from any application in Azure. You specifically use the [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis) client with C# code in a .NET Core console app.
 
 ## Skip to the code
 
-This article describes how to create an app by using the Azure portal and then modify the code to end up with a working sample app.
+This article describes how to modify the code for a sample app to create a working app that connects to Azure Cache for Redis.
 
-If you want to go straight to the code, see the [.NET Core sample](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet-core) on GitHub.
+If you want to go straight to the sample code, see the [.NET Core quickstart sample](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet-core) on GitHub.
 
 ## Prerequisites
 
-- Azure subscription - [create one for free](https://azure.microsoft.com/free/)
+- An Azure subscription. [Create one for free](https://azure.microsoft.com/free/)
 - [.NET Core SDK](https://dotnet.microsoft.com/download)
 
 ## Create a cache
@@ -31,41 +31,41 @@ If you want to go straight to the code, see the [.NET Core sample](https://githu
 
 [!INCLUDE [redis-cache-access-keys](includes/redis-cache-access-keys.md)]
 
-Make a note of the values for **HOST NAME** and the **Primary** access key. You ise these values later to construct the `CacheConnection` secret.
+Make a note of the values for **HOST NAME** and the **Primary** access key. You use these values later to construct the `CacheConnection` secret.
 
 ## Add a local secret for the connection string
 
-In your command window, execute the following command to store a new secret named *CacheConnection* after you replace the placeholders (including angle brackets) with your cache name (`<cache name>`) and primary access key (`<primary-access-key>`):
+In your command window, execute the following command to store a new secret named `CacheConnection`. Replace the placeholders (including angle brackets) with your cache name (`<cache name>`) and primary access key (`<primary-access-key>`):
 
 ```dos
 dotnet user-secrets set CacheConnection "<cache name>.redis.cache.windows.net,abortConnect=false,ssl=true,allowAdmin=true,password=<primary-access-key>"
 ```
 
 ## Connect to the cache by using RedisConnection
 
-The connection to your cache is managed by the `RedisConnection` class. First, you make the connection in this statement from *Program.cs*:
+The connection to your cache is managed by the `RedisConnection` class. First, make the connection in this statement in *Program.cs*:
 
 ```csharp
       _redisConnection = await RedisConnection.InitializeAsync(connectionString: configuration["CacheConnection"].ToString());
 
 ```
 
-In *RedisConnection.cs*, the `StackExchange.Redis` namespace was added to the code. The namespace is required for the `RedisConnection` class.
+In *RedisConnection.cs*, the StackExchange.Redis namespace is added to the code. The namespace is required for the `RedisConnection` class.
 
 ```csharp
 using StackExchange.Redis;
 
 ```
 
-The `RedisConnection` code ensures that there's always a healthy connection to the cache by managing the `ConnectionMultiplexer` instance from `StackExchange.Redis`. The `RedisConnection` class re-creates the connection when a connection is lost and unable to reconnect automatically.
+The `RedisConnection` class code ensures that there's always a healthy connection to the cache. The connection is managed by the `ConnectionMultiplexer` instance from StackExchange.Redis. The `RedisConnection` class re-creates the connection when a connection is lost and can't reconnect automatically.
 
-For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in a [GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
+For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in the [StackExchange.Redis GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
 
 <!-- :::code language="csharp" source="~/samples-cache/quickstart/dotnet-core/RedisConnection.cs"::: -->
 
-## Executing cache commands
+## Execute cache commands
 
-In `program.cs`, you can see the following code for the `RunRedisCommandsAsync` method in the `Program` class for the console application:
+In *Program.cs*, you can see the following code for the `RunRedisCommandsAsync` method in the `Program` class for the console application:
 
 <!-- Replaced this code with lines 57-81 from dotnet-core/Program.cs -->
 
@@ -153,13 +153,13 @@ To test serialization of .NET objects, run this command:
 dotnet run
 ```
 
-:::image type="content" source="media/cache-dotnet-core-quickstart/cache-console-app-complete.png" alt-text="Console app completed":::
+:::image type="content" source="media/cache-dotnet-core-quickstart/cache-console-app-complete.png" alt-text="Screenshot that shows a console test completed.":::
 
 <!-- Clean up include -->
 
 [!INCLUDE [cache-delete-resource-group](includes/cache-delete-resource-group.md)]
 
 ## Related content
 
-- [Connection resilience](cache-best-practices-connection.md)
-- [Best Practices Development](cache-best-practices-development.md)
+- [Connection resilience best practices for your cache](cache-best-practices-connection.md)
+- [Development best practices for your cache](cache-best-practices-development.md)

articles/azure-cache-for-redis/cache-dotnet-how-to-use-azure-redis-cache.md

@@ -1,6 +1,6 @@
 ---
-title: 'Quickstart: Use Azure Cache for Redis in .NET Framework'
-description: In this quickstart, learn how to access Azure Cache for Redis from your .NET apps
+title: 'Quickstart: Use Azure Cache for Redis with .NET'
+description: Modify a sample .NET app and connect the app to Azure Cache for Redis.
 
 
 
@@ -9,27 +9,30 @@ ms.topic: quickstart
 ms.custom: devx-track-csharp, mvc, mode-other, devx-track-dotnet
 ms.date: 03/25/2022
 ---
-# Quickstart: Use Azure Cache for Redis in .NET Framework
 
-In this quickstart, you incorporate Azure Cache for Redis into a .NET Framework app to have access to a secure, dedicated cache that is accessible from any application within Azure. You specifically use the [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis) client with C# code in a .NET console app.
+# Quickstart: Use Azure Cache for Redis with a .NET app
+
+In this quickstart, you incorporate Azure Cache for Redis into a .NET app to access a secure, dedicated cache that is accessible from any application in Azure. You specifically use the [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis) client with C# code in a .NET console app.
 
 ## Skip to the code on GitHub
 
-Clone the repo from [(https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet) on GitHub.
+This article describes how to modify the code for a sample app to create a working app that connects to Azure Cache for Redis.
+
+If you want to go straight to the code, see the [.NET quickstart sample](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet) on GitHub.
 
 ## Prerequisites
 
-- Azure subscription - [create one for free](https://azure.microsoft.com/free/)
+- An Azure subscription. [Create one for free](https://azure.microsoft.com/free/)
 - [Visual Studio 2019](https://www.visualstudio.com/downloads/)
-- [.NET Framework 4 or higher](https://dotnet.microsoft.com/download/dotnet-framework), which is required by the StackExchange.Redis client.
+- [.NET Framework 4 or later](https://dotnet.microsoft.com/download/dotnet-framework) as required by the StackExchange.Redis client
 
 ## Create a cache
 
 [!INCLUDE [redis-cache-create](~/reusable-content/ce-skilling/azure/includes/azure-cache-for-redis/includes/redis-cache-create.md)]
 
 [!INCLUDE [redis-cache-access-keys](includes/redis-cache-access-keys.md)]
 
-1. Create a file on your computer named *CacheSecrets.config* and place it *C:\AppSecrets\CacheSecrets.config*. 
+1. Create a file on your computer named *CacheSecrets.config*. Place it in the *C:\AppSecrets\* folder.
 
 1. Edit the *CacheSecrets.config* file and add the following contents:
 
@@ -39,9 +42,9 @@ Clone the repo from [(https://github.com/Azure-Samples/azure-cache-redis-samples
     </appSettings>
     ```
 
-1. Replace `<host-name>` with your cache host name.
+   - Replace `<host-name>` with your cache host name.
 
-1. Replace `<access-key>` with the primary key for your cache.
+   - Replace `<access-key>` with the primary key for your cache.
 
 1. Save the file.
 
@@ -50,17 +53,17 @@ Clone the repo from [(https://github.com/Azure-Samples/azure-cache-redis-samples
 <!-- this section was removed from the core sample -->
 In this section, you prepare the console application to use the [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis) client for .NET.
 
-1. In Visual Studio, select **Tools** > **NuGet Package Manager** > **Package Manager Console**, and run the following command from the Package Manager Console window.
+1. In Visual Studio, select **Tools** > **NuGet Package Manager** > **Package Manager Console**. Run the following command in the Package Manager Console window:
 
     ```powershell
     Install-Package StackExchange.Redis
     ```
-    
-1. Once the installation is completed, the *StackExchange.Redis* cache client is available to use with your project.
+ 
+1. When the installation is finished, the *StackExchange.Redis* cache client is available to use with your project.
 
 ## Connect to the Secrets cache
 
-In Visual Studio, open your *App.config* file to verify it contains an `appSettings` `file` attribute that references the *CacheSecrets.config* file.
+In Visual Studio, open your *App.config* file to verify it contains an `appSettings` `file` attribute that references the *CacheSecrets.config* file:
 
 ```xml
 <?xml version="1.0" encoding="utf-8" ?>
@@ -73,36 +76,35 @@ In Visual Studio, open your *App.config* file to verify it contains an `appSetti
 </configuration>
 ```
 
-Never store credentials in source code. To keep this sample simple, we use an external secrets config file. A better approach would be to use [Azure Key Vault with certificates](/rest/api/keyvault/certificate-scenarios).
+Never store credentials in your source code. To keep this sample simple, we use an external secrets config file. A better approach would be to use [Azure Key Vault with certificates](/rest/api/keyvault/certificate-scenarios).
 
-## Connect to the cache with RedisConnection
+## Connect to the cache by using RedisConnection
 
-The connection to your cache is managed by the `RedisConnection` class. The connection is first made in this statement from `Program.cs`:
+The connection to your cache is managed by the `RedisConnection` class. First, make the connection in this statement in *Program.cs*:
 
 ```csharp
      _redisConnection = await RedisConnection.InitializeAsync(connectionString: ConfigurationManager.AppSettings["CacheConnection"].ToString());
 
 
 ```
 
-The value of the *CacheConnection* appSetting is used to reference the cache connection string from the Azure portal as the password parameter.
+The value of the *CacheConnection* app setting is used to reference the cache connection string from the Azure portal as the password parameter.
 
-In `RedisConnection.cs`, you see the `StackExchange.Redis` namespace with the `using` keyword. This is needed for the `RedisConnection` class.
+In *RedisConnection.cs*, the StackExchange.Redis namespace appears as a `using` statement that the `RedisConnection` class requires:
 
 ```csharp
 using StackExchange.Redis;
 ```
 
-<!-- Is this right Philo -->
-The `RedisConnection` code ensures that there is always a healthy connection to the cache by managing the `ConnectionMultiplexer` instance from `StackExchange.Redis`. The `RedisConnection` class recreates the connection when a connection is lost and unable to reconnect automatically.
+The `RedisConnection` class code ensures that there's always a healthy connection to the cache. The connection is managed by the `ConnectionMultiplexer` instance from StackExchange.Redis. The `RedisConnection` class re-creates the connection when a connection is lost and can't reconnect automatically.
 
-For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in a [GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
+For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in the [StackExchange.Redis GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
 
 <!-- :::code language="csharp" source="~/samples-cache/quickstart/dotnet/Redistest/RedisConnection.cs"::: -->
 
-## Executing cache commands
+## Execute cache commands
 
-In `program.cs`, you can see the following code for the `RunRedisCommandsAsync` method in the `Program` class for the console application:
+In *Program.cs*, you can see the following code for the `RunRedisCommandsAsync` method in the `Program` class for the console application:
 
 ```csharp
 private static async Task RunRedisCommandsAsync(string prefix)
@@ -153,24 +155,25 @@ In the example, you can see the `Message` key is set to value. The app updated t
 
 The Redis server stores most data as strings, but these strings can contain many types of data, including serialized binary data, which can be used when storing .NET objects in the cache.
 
-Azure Cache for Redis can cache both .NET objects and primitive data types, but before a .NET object can be cached it must be serialized.
+Azure Cache for Redis can cache both .NET objects and primitive data types, but before a .NET object can be cached, it must be serialized.
 
-This .NET object serialization is the responsibility of the application developer, and gives the developer flexibility in the choice of the serializer.
+This .NET object serialization is the responsibility of the application developer. You have some flexibility in your choice of the serializer.
 
-One simple way to serialize objects is to use the `JsonConvert` serialization methods in `System.text.Json`.
+A simple way to serialize objects is to use the `JsonConvert` serialization methods in *System.text.Json*.
 
-Add the `System.text.Json` namespace to Visual Studio:
+Add the System.text.Json namespace in Visual Studio:
 
 1. Select **Tools** > **NuGet Package Manager** > *Package Manager Console**.
 
-1. Then, run the following command from the Package Manager Console window.
+1. Then, run the following command in the Package Manager Console window:
+
     ```powershell
     Install-Package system.text.json
     ```
     
-<!-- :::image type="content" source="media/cache-dotnet-how-to-use-azure-redis-cache/cache-console-app-partial.png" alt-text="Console app partial"::: -->
+<!-- :::image type="content" source="media/cache-dotnet-how-to-use-azure-redis-cache/cache-console-app-partial.png" alt-text="Screenshot that shows a partial console app."::: -->
 
-The following `Employee` class was defined in *Program.cs*  so that the sample could also show how to get and set a serialized object :
+The following `Employee` class was defined in *Program.cs* so that the sample can show how to get and set a serialized object:
 
 ```csharp
 class Employee
@@ -190,31 +193,15 @@ class Employee
 
 ## Run the sample
 
-Press **Ctrl+F5** to build and run the console app to test serialization of .NET objects.
-
-:::image type="content" source="media/cache-dotnet-core-quickstart/cache-console-app-complete.png" alt-text="Console app completed":::
-
-## Clean up resources
-
-If you continuing to the use this quickstart, you can keep the resources created and reuse them.
-
-Otherwise, if you are finished with the quickstart sample application, you can delete the Azure resources created in this quickstart to avoid charges.
-
-> [!IMPORTANT]
-> Deleting a resource group is irreversible and that the resource group and all the resources in it are permanently deleted. Make sure that you do not accidentally delete the wrong resource group or resources. If you created the resources for hosting this sample inside an existing resource group that contains resources you want to keep, you can delete each resource individually on the left instead of deleting the resource group.
->
-
-Sign in to the [Azure portal](https://portal.azure.com) and select **Resource groups**.
-
-In the **Filter by name...** textbox, type the name of your resource group. The instructions for this article used a resource group named *TestResources*. On your resource group in the result list, select **...** then **Delete resource group**.
+To build and run the console app to test serialization of .NET objects, select Ctrl+F5.
 
-:::image type="content" source="media/cache-dotnet-core-quickstart/cache-delete-resource-group.png" alt-text="Delete":::
+:::image type="content" source="media/cache-dotnet-core-quickstart/cache-console-app-complete.png" alt-text="Screenshot that shows the console app completed.":::
 
-You are asked to confirm the deletion of the resource group. Type the name of your resource group to confirm, and select **Delete**.
+<!-- Clean up include -->
 
-After a few moments, the resource group and all of its contained resources are deleted.
+[!INCLUDE [cache-delete-resource-group](includes/cache-delete-resource-group.md)]
 
-## Next steps
+## Related content
 
-- [Connection resilience](cache-best-practices-connection.md)
-- [Best Practices Development](cache-best-practices-development.md)
+- [Connection resilience best practices for your cache](cache-best-practices-connection.md)
+- [Development best practices for your cache](cache-best-practices-development.md)