changed files by pdets auto publish service, publishid[e2dc1a22-bcef-46e0-9fdb-3f0e904ee9b1] and do [publish].

wwlpublish · web-flow · commit 9fd92ad1aa0e · 2025-03-18T09:12:15.000+08:00
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/1-introduction.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/1-introduction.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.introduction
 title: Introduction
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Introduction
   description: "Introduction"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 3
 content: |
   [!include[](includes/1-introduction.md)]
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/2-azure-cache-redis-overview.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/2-azure-cache-redis-overview.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.explore
 title: Explore Azure Cache for Redis
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Explore Azure Cache for Redis
   description: "Explore Azure Cache for Redis"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 3
 content: |
   [!include[](includes/2-azure-cache-redis-overview.md)]
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/3-configure-azure-cache-redis.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/3-configure-azure-cache-redis.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.configure
 title: Configure Azure Cache for Redis
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Configure Azure Cache for Redis
   description: "Configure Azure Cache for Redis"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 5
 content: |
   [!include[](includes/3-configure-azure-cache-redis.md)]
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/4-interact-redis-api.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/4-interact-redis-api.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.interact-by-using-net
 title: Interact with Azure Cache for Redis by using .NET
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Interact with Azure Cache for Redis by using .NET
   description: "Interact with Azure Cache for Redis by using .NET"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 3
 content: |
   [!include[](includes/4-interact-redis-api.md)]
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/5-console-app-azure-cache-redis.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/5-console-app-azure-cache-redis.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.exercise-connect-app-to-by-using-net-core
 title: Exercise - Connect an app to Azure Cache for Redis by using .NET Core
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Exercise - Connect an app to Azure Cache for Redis by using .NET Core
   description: "Exercise - Connect an app to Azure Cache for Redis by using .NET Core"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 10
 content: |
   [!include[](includes/5-console-app-azure-cache-redis.md)]
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/6-knowledge-check.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/6-knowledge-check.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.knowledge-check
 title: Knowledge check
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Knowledge check
   description: "Knowledge check"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 3
 quiz:
   title: "Check your knowledge"
@@ -24,7 +27,7 @@ quiz:
     - content: "Premium"
       isCorrect: false
       explanation: "Incorrect. The premium tier is suitable for production, but it isn't the lowest tier recommended for production."
-  - content: "Which of the following represents the expire time resolution when applying a time to live (TTL) to a key in Redis?"
+  - content: "Which of the following choices represents the expire time resolution when applying a time to live (TTL) to a key in Redis?"
     choices:
     - content: "1-millisecond"
       isCorrect: true
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/7-summary.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/7-summary.yml
@@ -2,13 +2,16 @@
 uid: learn.wwl.develop-for-azure-cache-for-redis.summary
 title: Summary
 metadata:
+  adobe-target: true
+  prefetch-feature-rollout: true
   title: Summary
   description: "Summary"
-  ms.date: 04/24/2023
+  ms.date: 03/18/2025
   author: wwlpublish
   ms.author: jeffko
-  ms.topic: interactive-tutorial
-  ms.prod: learning-azure
+  ms.topic: unit
+  ms.custom:
+  - N/A
 durationInMinutes: 3
 content: |
   [!include[](includes/7-summary.md)]
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/1-introduction.md b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/1-introduction.md
@@ -1,8 +1,7 @@
-
-Caching is a common technique that aims to improve the performance and scalability of a system. It does this by temporarily copying frequently accessed data to fast storage that's located close to the application. If this fast data storage is located closer to the application than the original source, then caching can significantly improve response times for client applications by serving data more quickly.
+Caching is a common technique that aims to improve the performance and scalability of a system. It does this by temporarily copying frequently accessed data to fast storage located close to the application. If this fast data storage is located closer to the application than the original source, then caching can significantly improve response times for client applications by serving data more quickly.
 
 After completing this module, you'll be able to:
 
 * Explain the key scenarios Azure Cache for Redis covers and its service tiers
 * Identify the key parameters for creating an Azure Cache for Redis instance and interact with the cache
-* Connect an app to Azure Cache for Redis by using .NET 6
+* Connect an app to Azure Cache for Redis by using .NET
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/2-azure-cache-redis-overview.md b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/2-azure-cache-redis-overview.md
@@ -1,7 +1,6 @@
-
 Azure Cache for Redis provides an in-memory data store based on the [Redis](https://redis.io/) software. Redis improves the performance and scalability of an application that uses backend data stores heavily. It's able to process large volumes of application requests by keeping frequently accessed data in the server memory, which can be written to and read from quickly. Redis brings a critical low-latency and high-throughput data storage solution to modern applications.
 
-Azure Cache for Redis offers both the Redis open-source (OSS Redis) and a commercial product from Redis Labs (Redis Enterprise) as a managed service. It provides secure and dedicated Redis server instances and full Redis API compatibility. The service is operated by Microsoft, hosted on Azure, and usable by any application within or outside of Azure.
+Azure Cache for Redis offers both the Redis open-source (OSS Redis) and a commercial product from Redis Labs (Redis Enterprise) as a managed service. It provides secure and dedicated Redis server instances and full Redis API compatibility. Microsoft operates the service, hosted on Azure, and usable by any application within or outside of Azure.
 
 ## Key scenarios
 
@@ -12,7 +11,7 @@ Azure Cache for Redis improves application performance by supporting common appl
 | Data cache | Databases are often too large to load directly into a cache. It's common to use the [cache-aside](/azure/architecture/patterns/cache-aside) pattern to load data into the cache only as needed. When the system makes changes to the data, the system can also update the cache, which is then distributed to other clients. |
 | Content cache | Many web pages are generated from templates that use static content such as headers, footers, banners. These static items shouldn't change often. Using an in-memory cache provides quick access to static content compared to backend datastores. |
 | Session store | This pattern is commonly used with shopping carts and other user history data that a web application might associate with user cookies. Storing too much in a cookie can have a negative effect on performance as the cookie size grows and is passed and validated with every request. A typical solution uses the cookie as a key to query the data in a database. Using an in-memory cache, like Azure Cache for Redis, to associate information with a user is faster than interacting with a full relational database. |
-| Job and message queuing | Applications often add tasks to a queue when the operations associated with the request take time to execute. Longer running operations are queued to be processed in sequence, often by another server.  This method of deferring work is called task queuing. |
+| Job and message queuing | Applications often add tasks to a queue when the operations associated with the request take time to execute. Longer running operations are queued to be processed in sequence, often by another server. This method of deferring work is called task queuing. |
 | Distributed transactions | Applications sometimes require a series of commands against a backend data-store to execute as a single atomic operation. All commands must succeed, or all must be rolled back to the initial state. Azure Cache for Redis supports executing a batch of commands as a single [transaction](https://redis.io/topics/transactions). |
 
 ## Service tiers
@@ -21,7 +20,7 @@ Azure Cache for Redis is available in these tiers:
 
 | Tier | Description |
 |--|--|
-| Basic | An OSS Redis cache running on a single VM. This tier has no service-level agreement (SLA) and is ideal for development/test and noncritical workloads. |
+| Basic | An OSS Redis cache running on a single virtual machine (VM). This tier has no service-level agreement (SLA) and is ideal for development/test and noncritical workloads. |
 | Standard | An OSS Redis cache running on two VMs in a replicated configuration. |
 | Premium | High-performance OSS Redis caches. This tier offers higher throughput, lower latency, better availability, and more features. Premium caches are deployed on more powerful VMs compared to the VMs for Basic or Standard caches. |
 | Enterprise | High-performance caches powered by Redis Labs' Redis Enterprise software. This tier supports Redis modules including RediSearch, RedisBloom, and RedisTimeSeries. Also, it offers even higher availability than the Premium tier. |
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/3-configure-azure-cache-redis.md b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/3-configure-azure-cache-redis.md
@@ -1,4 +1,3 @@
-
 You can create a Redis cache using the Azure portal, the Azure CLI, or Azure PowerShell. 
 
 ## Create and configure an Azure Cache for Redis instance
@@ -20,7 +19,7 @@ You should always place your cache instance and your application in the same reg
 The tier determines the size, performance, and features that are available for the cache. For more information, visit [Azure Cache for Redis pricing](https://azure.microsoft.com/pricing/details/cache/).
 
 > [!TIP]
-> Microsoft recommends you always use Standard tier or higher for production systems. The Basic tier is a single node system with no data replication and no SLA. 
+> Microsoft recommends you always use Standard tier or higher for production systems. The Basic tier is a single node system with no data replication and no service level agreement. 
 
 ### Clustering support
 
@@ -36,13 +35,13 @@ Here are some common commands you can use:
 
 | Command | Description |
 |--|--|
-| `ping` | Ping the server. Returns "PONG". |
+| `ping` | Ping the server. Returns `PONG`. |
 | `set [key] [value]` | Sets a key/value in the cache. Returns "OK" on success. |
 | `get [key]` | Gets a value from the cache. |
 | `exists [key]` | Returns '1' if the **key** exists in the cache, '0' if it doesn't. |
 | `type [key]` | Returns the type associated to the value for the given **key**. |
 | `incr [key]` | Increment the given value associated with **key** by '1'. The value must be an integer or double value. This returns the new value. |
-| `incrby [key] [amount]` | Increment the given value associated with **key** by the specified amount. The value must be an integer or double value. This returns the new value. |
+| `incrby [key] [amount]` | Increment the given value associated with **key** by the specified amount. The value must be an integer or double value. Returns the new value. |
 | `del [key]` | Deletes the value associated with the **key**. |
 | `flushdb` | Delete *all* keys and values in the database. |
 
@@ -63,7 +62,7 @@ OK
 
 ### Adding an expiration time to values
 
-Caching is important because it allows us to store commonly used values in memory. However, we also need a way to expire values when they're stale. In Redis this is done by applying a time to live (TTL) to a key.
+Caching is important because it allows us to store commonly used values in memory. However, we also need a way to expire values when they're stale. In Redis expiring values is done by applying a time to live (TTL) to a key.
 
 When the TTL elapses, the key is automatically deleted, exactly as if the DEL command were issued. Here are some notes on TTL expirations.
 
@@ -91,7 +90,7 @@ To connect to an Azure Cache for Redis instance, you need several pieces of info
 
 * The host name is the public Internet address of your cache, which was created using the name of the cache. For example, `sportsresults.redis.cache.windows.net`.
 
-* The access key acts as a password for your cache. There are two keys created: primary and secondary. You can use either key, two are provided in case you need to change the primary key. You can switch all of your clients to the secondary key, and regenerate the primary key. This would block any applications using the original primary key. Microsoft recommends periodically regenerating the keys - much like you would your personal passwords.
+* The access key acts as a password for your cache. There are two keys created: primary and secondary. You can use either key. Two are provided in case you need to change the primary key. You can switch all of your clients to the secondary key, and regenerate the primary key. This would block any applications using the original primary key. Microsoft recommends periodically regenerating the keys - much like you would your personal passwords.
 
 > [!WARNING]
-> Your access keys should be considered confidential information, treat them like you would a password. Anyone who has an access key can perform any operation on your cache!
+> Your access keys should be considered confidential information. Treat them like you would a password. Anyone who has an access key can perform any operation on your cache!
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/4-interact-redis-api.md b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/4-interact-redis-api.md
@@ -1,4 +1,3 @@
-
 Typically, a client application uses a client library to form requests and execute commands on a Redis cache. You can get a list of client libraries directly from the Redis clients page. 
 
 ## Executing commands on the Redis cache
@@ -18,7 +17,7 @@ You can pass this string to **StackExchange.Redis** to create a connection the s
 Notice that there are two more parameters at the end:
 
 * **ssl** - ensures that communication is encrypted.
-* **abortConnection** - allows a connection to be created even if the server is unavailable at that moment.
+* **abortConnect** - allows a connection to be created even if the server is unavailable at that moment.
 
 There are several other [optional parameters](https://github.com/StackExchange/StackExchange.Redis/blob/master/docs/Configuration.md#configuration-options) you can append to the string to configure the client library.
 
@@ -39,20 +38,20 @@ var redisConnection = ConnectionMultiplexer.Connect(connectionString);
 
 Once you have a `ConnectionMultiplexer`, there are three primary things you might want to do:
 
-* Access a Redis Database. This is what we will focus on here.
-* Make use of the publisher/subscriber features of Redis. This is outside the scope of this module.
+* Access a Redis Database.
+* Make use of the publisher/subscriber features of Redis, which is outside the scope of this module.
 * Access an individual server for maintenance or monitoring purposes.
 
 ### Accessing a Redis database
 
-The Redis database is represented by the `IDatabase` type. You can retrieve one using the `GetDatabase()` method:
+The `IDatabase` type represents the Redis database. You can retrieve one using the `GetDatabase()` method:
 
 ```csharp
 IDatabase db = redisConnection.GetDatabase();
 ```
 
 > [!TIP]
-> The object returned from `GetDatabase` is a lightweight object, and does not need to be stored. Only the `ConnectionMultiplexer` needs to be kept alive.
+> The object returned from `GetDatabase` is a lightweight object, and doesn't need to be stored. Only the `ConnectionMultiplexer` needs to be kept alive.
 
 Once you have a `IDatabase` object, you can execute methods to interact with the cache. All methods have synchronous and asynchronous versions that return `Task` objects to make them compatible with the `async` and `await` keywords.
 
@@ -95,14 +94,14 @@ Here are some of the more common ones that work with single keys, you can [read
 
 |Method|Description|
 |--- |--- |
-|`CreateBatch`|Creates a group of operations that will be sent to the server as a single unit, but not necessarily processed as a unit.|
-|`CreateTransaction`|Creates a group of operations that will be sent to the server as a single unit and processed on the server as a single unit.|
+|`CreateBatch`|Creates a group of operations to be sent to the server as a single unit, but not necessarily processed as a unit.|
+|`CreateTransaction`|Creates a group of operations to be sent to the server as a single unit and processed on the server as a single unit.|
 |`KeyDelete`|Delete the key/value.|
 |`KeyExists`|Returns whether the given key exists in cache.|
 |`KeyExpire`|Sets a time-to-live (TTL) expiration on a key.|
 |`KeyRename`|Renames a key.|
 |`KeyTimeToLive`|Returns the TTL for a key.|
-|`KeyType`|Returns the string representation of the type of the value stored at key. The different types that can be returned are: string, list, set, zset and hash.|
+|`KeyType`|Returns the string representation of the type of the value stored at key. The different types that can be returned are: string, list, set, zset, and hash.|
 
 ### Executing other commands
 
@@ -115,7 +114,7 @@ Console.WriteLine(result.ToString()); // displays: "PONG"
 
 The `Execute` and `ExecuteAsync` methods return a `RedisResult` object that is a data holder that includes two properties:
 
-* `Type` that returns a `string` indicating the type of the result - "STRING", "INTEGER", etc.
+* `Resp2Type` that returns a `string` indicating the type of the result - `STRING`, `INTEGER`, etc.
 * `IsNull` a true/false value to detect when the result is `null`.
 
 You can then use `ToString()` on the `RedisResult` to get the actual return value.
@@ -124,10 +123,10 @@ You can use `Execute` to perform any supported commands - for example, we can ge
 
 ```csharp
 var result = await db.ExecuteAsync("client", "list");
-Console.WriteLine($"Type = {result.Type}\r\nResult = {result}");
+Console.WriteLine($"Type = {result.Resp2Type}\r\nResult = {result}");
 ```
 
-This would output all the connected clients:
+This outputs all the connected clients:
 
 ```
 Type = BulkString
@@ -176,7 +175,7 @@ var stat = new GameStat("Soccer", new DateTime(2019, 7, 16), "Local Game",
                 new[] { ("Team 1", 2), ("Team 2", 1) });
 
 string serializedValue = Newtonsoft.Json.JsonConvert.SerializeObject(stat);
-bool added = db.StringSet("event:1950-world-cup", serializedValue);
+bool added = db.StringSet("event:2019-local-game", serializedValue);
 ```
 
 We could retrieve it and turn it back into an object using the reverse process:
@@ -189,9 +188,10 @@ Console.WriteLine(stat.Sport); // displays "Soccer"
 
 ## Cleaning up the connection
 
-Once you're done with the Redis connection, you can `Dispose` the `ConnectionMultiplexer`. This closes all connections and shutdown the communication to the server.
+When the connection is no longer needed, you can `Dispose` the `ConnectionMultiplexer`. This closes all connections and shutdown the communication to the server.
 
 ```csharp
 redisConnection.Dispose();
 redisConnection = null;
 ```
+
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/5-console-app-azure-cache-redis.md b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/5-console-app-azure-cache-redis.md
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/7-summary.md b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/includes/7-summary.md
diff --git a/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/index.yml b/learn-pr/wwl-azure/develop-for-azure-cache-for-redis/index.yml
