edits

Author: ktoliver

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

@@ -9,13 +9,16 @@ ms.custom: devx-track-csharp, mvc, mode-other, devx-track-dotnet
 ms.topic: quickstart
 ms.date: 03/25/2022
 ---
+
 # Quickstart: Use Azure Cache for Redis in .NET Core
 
 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.
 
-## Skip to the code on GitHub
+## 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.
 
-Clone the repo [https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet-core](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/dotnet-core) on GitHub.
+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.
 
 ## Prerequisites
 
@@ -28,33 +31,33 @@ Clone the repo [https://github.com/Azure-Samples/azure-cache-redis-samples/tree/
 
 [!INCLUDE [redis-cache-access-keys](includes/redis-cache-access-keys.md)]
 
-Make a note of the **HOST NAME** and the **Primary** access key. You'll use these values later to construct the *CacheConnection* secret.
+Make a note of the values for **HOST NAME** and the **Primary** access key. You'll 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 replacing the placeholders (including angle brackets) for your cache name and primary access key:
+In your command window, execute the following command to store a new secret named *CacheConnection* after you replac 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 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, you make the connection in this statement from *Program.cs*:
 
 ```csharp
       _redisConnection = await RedisConnection.InitializeAsync(connectionString: configuration["CacheConnection"].ToString());
 
 ```
 
-In `RedisConnection.cs`, you see the `StackExchange.Redis` namespace has been added to the code. This is needed for the `RedisConnection` class.
+In *RedisConnection.cs*, the `StackExchange.Redis` namespace has been added to the code. The namespace is required for the `RedisConnection` class.
 
 ```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` code ensures that there is 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.
 
 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).
 
@@ -63,7 +66,9 @@ For more information, see [StackExchange.Redis](https://stackexchange.github.io/
 ## Executing cache commands
 
 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 -->
+
 ```csharp
 private static async Task RunRedisCommandsAsync(string prefix)
     {
@@ -104,19 +109,19 @@ private static async Task RunRedisCommandsAsync(string prefix)
 
 ```
 
-Cache items can be stored and retrieved by using the `StringSetAsync` and `StringGetAsync` methods.
+You can store and retrieve cache items by using the `StringSetAsync` and `StringGetAsync` methods.
 
-In the example, you can see the `Message` key is set to value. The app updated that cached value. The app also executed the `PING` and command.
+In the example, you can see the `Message` key is set to a value. The app updated that cached value. The app also executed the `PING` and command.
 
 ### Work with .NET objects in the cache
 
-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.
+The Redis server stores most data in string format. The strings can contain many types of data, including serialized binary data. You can use serialized binary data when you store .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.
+The .NET object serialization is the responsibility of the application developer. The object serialization gives the developer flexibility in their choice of the serializer.
 
-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 could also show how to get and set a serialized object:
 
 ```csharp
 class Employee
@@ -136,7 +141,7 @@ class Employee
 
 ## Run the sample
 
-If you have opened any files, save them and build the app with the following command:
+If you opened any files, save the files. Then, build the app by using the following command:
 
 ```dos
 dotnet build
@@ -150,28 +155,11 @@ dotnet run
 
 :::image type="content" source="media/cache-dotnet-core-quickstart/cache-console-app-complete.png" alt-text="Console app completed":::
 
-## Clean up resources
-
-If you continue to use this quickstart, you can keep the resources you created and reuse them.
-
-Otherwise, if you're 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.
->
-### To delete a resource group
-
-1. Sign in to the [Azure portal](https://portal.azure.com) and select **Resource groups**.
-
-1. 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**.
-
-    :::image type="content" source="media/cache-dotnet-core-quickstart/cache-delete-resource-group.png" alt-text="Delete":::
-
-1. You'll be 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)

articles/azure-cache-for-redis/cache-go-get-started.md

@@ -14,18 +14,20 @@ ms.custom: mode-api, devx-track-go
 
 In this article, you learn how to build a REST API in Go that stores and retrieves user information backed by a [HASH](https://redis.io/topics/data-types-intro#redis-hashes) data structure in [Azure Cache for Redis](./cache-overview.md).
 
-## Skip to the code on GitHub
+## Skip to the code
 
-If you want to skip straight to the code, see the [Go quickstart](https://github.com/Azure-Samples/azure-redis-cache-go-quickstart/) on GitHub.
+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.
+
+If you want to go straight to the code, see the [Go quickstart sample](https://github.com/Azure-Samples/azure-redis-cache-go-quickstart/) on GitHub.
 
 ## Prerequisites
 
 - Azure subscription - [create one for free](https://azure.microsoft.com/free/)
-- [Go](https://go.dev/doc/install) (preferably version 1.13 or above)
+- [Go](https://go.dev/doc/install) (preferably version 1.13 or later)
 - [Git](https://git-scm.com/downloads)
-- An HTTP client such [curl](https://curl.se/)
+- An HTTP client like [cURL](https://curl.se/)
 
-## Create an Azure Cache for Redis instance
+## Create a cache
 
 [!INCLUDE [redis-cache-create](~/reusable-content/ce-skilling/azure/includes/azure-cache-for-redis/includes/redis-cache-create.md)]
 
@@ -64,7 +66,7 @@ if err != nil {
 If the connection is successful, [HTTP handlers](https://go.dev/pkg/net/http/#HandleFunc) are configured to handle `POST` and `GET` operations and the HTTP server is started.
 
 > [!NOTE]
-> [gorilla mux library](https://github.com/gorilla/mux) is used for routing (although it's not strictly necessary and we could have gotten away by using the standard library for this sample application).
+>The [gorilla mux library](https://github.com/gorilla/mux) is used for routing (although it's not strictly necessary, and using the standard library for this sample application is an option).
 >
 
 ```go
@@ -77,10 +79,10 @@ router.HandleFunc("/users/{userid}", uh.getUser).Methods(http.MethodGet)
 log.Fatal(http.ListenAndServe(":8080", router))
 ```
 
-`userHandler` struct encapsulates a [redis.Client](https://pkg.go.dev/github.com/go-redis/redis/v8#Client), which is used by the `createUser`, `getUser` methods - code for these methods isn't included for brevity.
+The `userHandler` struct encapsulates a [redis.Client](https://pkg.go.dev/github.com/go-redis/redis/v8#Client). The `createUser` and `getUser` methods use the redis.Client. For brevity, the code for these methods isn't included in this article.
 
-- `createUser`: accepts a JSON payload (containing user information) and saves it as a `HASH` in Azure Cache for Redis.
-- `getUser`: fetches user info from `HASH` or returns an HTTP `404` response if not found.
+- `createUser`: Accepts a JSON payload (that has user information) and saves it as a `HASH` in Azure Cache for Redis.
+- `getUser`: Fetches user info from `HASH` or returns an HTTP `404` response if it's not found.
 
 ```go
 type userHandler struct {
@@ -100,15 +102,15 @@ func (uh userHandler) getUser(rw http.ResponseWriter, r *http.Request) {
 
 ## Clone the sample application
 
-Start by cloning the application from GitHub.
+Start by cloning the application on GitHub:
 
-1. Open a command prompt and create a new folder named `git-samples`.
+1. At the command prompt for your computer's root directory, create a new folder named `git-samples`:
 
     ```bash
     md "C:\git-samples"
     ```
 
-1. Open a git terminal window, such as git bash. Use the `cd` command to change to the new folder where you want to clone the sample app.
+1. Open a git terminal window, such as by using Git Bash. Use the `cd` command to go to the new folder to clone the sample app.
 
     ```bash
     cd "C:\git-samples"
@@ -124,12 +126,12 @@ Start by cloning the application from GitHub.
 
 The application accepts connectivity and credentials in the form of environment variables.
 
-1. Fetch the **Host name** and **Access Keys** (available via Access Keys) for Azure Cache for Redis instance in the [Azure portal](https://portal.azure.com/)
+1. In the [Azure portal](https://portal.azure.com/), get the host name and access keys for the Azure Cache for Redis instance.
 
 1. Set them to the respective environment variables:
 
     ```console
-    set REDIS_HOST=<Host name>:<port> (e.g. <name of cache>.redis.cache.windows.net:6380)
+    set REDIS_HOST=<Host name>:<port> (for example, <name of cache>.redis.cache.windows.net:6380)
     set REDIS_PASSWORD=<Primary Access Key>
     ```
 
@@ -145,25 +147,27 @@ The application accepts connectivity and credentials in the form of environment
     go run main.go
     ```
 
-The HTTP server will start on port `8080`.
+The HTTP server starts on port `8080`.
 
 ## Test the application
 
-1. Create a few user entries. The below example uses curl:
+1. Create a few user entries. 
+
+   The following example uses cURL:
 
     ```bash
     curl -i -X POST -d '{"id":"1","name":"foo1", "email":"[email protected]"}' localhost:8080/users/
     curl -i -X POST -d '{"id":"2","name":"foo2", "email":"[email protected]"}' localhost:8080/users/
     curl -i -X POST -d '{"id":"3","name":"foo3", "email":"[email protected]"}' localhost:8080/users/
     ```
 
-1. Fetch an existing user with its `id`:
+1. Fetch an existing user by using the value for the `id`:
 
     ```bash
     curl -i localhost:8080/users/1
     ```
 
-    You should get JSON response as such:
+    You should get a JSON response that is similar to this example:
 
     ```json
     {
@@ -173,7 +177,9 @@ The HTTP server will start on port `8080`.
     }
     ```
 
-1. If you try to fetch a user who doesn't exist, you get an HTTP `404`. For example:
+1. If you try to fetch a user who doesn't exist, you get an HTTP `404`.
+ 
+   For example:
 
     ```bash
     curl -i localhost:8080/users/100
@@ -185,23 +191,11 @@ The HTTP server will start on port `8080`.
     Content-Length: 0
     ```
 
-## Clean up resources
-
-If you're finished with the Azure resource group and resources you created in this quickstart, you can delete them to avoid charges.
-
-> [!IMPORTANT]
-> Deleting a resource group is irreversible, and the resource group and all the resources in it are permanently deleted. If you created your Azure Cache for Redis instance in an existing resource group that you want to keep, you can delete just the cache by selecting **Delete** from the cache **Overview** page.
-
-To delete the resource group and its Redis Cache for Azure instance:
-
-1. From the [Azure portal](https://portal.azure.com), search for and select **Resource groups**.
-1. In the **Filter by name** text box, enter the name of the resource group that contains your cache instance, and then select it from the search results.
-1. On your resource group page, select **Delete resource group**.
-1. Type the resource group name, and then select **Delete**.
+<!-- Clean up include -->
 
-   ![Delete your resource group for Azure Cache for Redis](./media/cache-python-get-started/delete-your-resource-group-for-azure-cache-for-redis.png)
+[!INCLUDE [cache-delete-resource-group](includes/cache-delete-resource-group.md)]
 
-## Next steps
+## Related content
 
 In this quickstart, you learned how to get started using Go with Azure Cache for Redis. You configured and ran a simple REST API-based application to create and get user information backed by a Redis `HASH` data structure.
 

articles/azure-cache-for-redis/cache-java-get-started.md

@@ -16,14 +16,16 @@ In this quickstart, you incorporate Azure Cache for Redis into a Java app by usi
 
 ## Skip to the code
 
-Clone the repo on GitHub: [Java quickstart](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/java)
+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.
+
+If you want to go straight to the code, see the [Java quickstart sample](https://github.com/Azure-Samples/azure-cache-redis-samples/tree/main/quickstart/java) on GitHub.
 
 ## Prerequisites
 
 - Azure subscription - [create one for free](https://azure.microsoft.com/free/)
 - [Apache Maven](https://maven.apache.org/download.cgi)
 
-## Create an Azure Cache for Redis
+## Create a cache
 
 [!INCLUDE [redis-cache-create](~/reusable-content/ce-skilling/azure/includes/azure-cache-for-redis/includes/redis-cache-create.md)]
 
@@ -188,27 +190,11 @@ Cache Command  : CLIENT LIST
 Cache Response : id=777430 addr=             :58989 fd=22 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 ow=0 owmem=0 events=r cmd=client numops=6
 ```
 
-## Clean up resources
-
-If you continue to use the quickstart code, you can keep the resources created in this quickstart and reuse them.
-
-Otherwise, if you're 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 instead of deleting the resource group.
->
-
-1. Sign in to the [Azure portal](https://portal.azure.com) and select **Resource groups**.
-
-1. 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**.
-
-   :::image type="content" source="media/cache-java-get-started/azure-cache-redis-delete-resource-group.png" alt-text="Screenshot of the Azure portal that shows the Resource groups page with the Delete resource group button highlighted." lightbox="media/cache-java-get-started/azure-cache-redis-delete-resource-group.png":::
-
-1. Type the name of your resource group to confirm deletion and then 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
 
 In this quickstart, you learned how to use Azure Cache for Redis from a Java application. Continue to the next quickstart to use Azure Cache for Redis with an ASP.NET web app.