chore: Cleanup devlang for code blocks (#20609)

* chore: Cleanup devlang for code blocks

Automated cleanup from docs authoring pack

* fix: "docker" devlang to "console"

* fix: "docker" devlang to "dockerfile

Author: nschonni

docs/architecture/cloud-native/feature-flags.md

@@ -24,7 +24,7 @@ Feature flags also promote `trunk-based` development. It's a source-control bran
 
 At its core, a feature flag is a reference to a simple `decision object`. It returns a Boolean state of `on` or `off`. The flag typically wraps a block of code that encapsulates a feature capability. The state of the flag determines whether that code block executes for a given user. Figure 10-11 shows the implementation.
 
-```c#
+```csharp
 if (featureFlag) {
     // Run this code block if the featureFlag value is true
 } else {
@@ -44,15 +44,15 @@ Feature flags can be easily implemented in an [ASP.NET Core service](https://doc
 
 Once configured in your Startup class, you can add feature flag functionality at the controller, action, or middleware level. Figure 10-12 presents controller and action implementation:
 
-```c#
+```csharp
 [FeatureGate(MyFeatureFlags.FeatureA)]
 public class ProductController : Controller
 {
     ...
 }
 ```
 
-```c#
+```csharp
 [FeatureGate(MyFeatureFlags.FeatureA)]
 public IActionResult UpdateProductStatus()
 {
@@ -66,7 +66,7 @@ If a feature flag is disabled, the user will receive a 404 (Not Found) status co
 
 Feature flags can also be injected directly into C# classes. Figure 10-13 shows feature flag injection:
 
-```c#
+```csharp
 public class ProductController : Controller
 {
     private readonly IFeatureManager _featureManager;

docs/architecture/cloud-native/leverage-containers-orchestrators.md

@@ -178,7 +178,7 @@ Visual Studio supports Docker development for web-based applications. When you c
 
 When this option is selected, the project is created with a `Dockerfile` in its root, which can be used to build and host the app in a Docker container. An example Dockerfile is shown in Figure 3-6.git
 
-```docker
+```dockerfile
 FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base
 WORKDIR /app
 EXPOSE 80

docs/architecture/containerized-lifecycle/design-develop-containerized-apps/docker-apps-inner-loop-workflow.md

@@ -113,7 +113,7 @@ Using an official repository of a language stack with a version number ensures t
 
 The following is a sample DockerFile for a .NET Core container:
 
-```Dockerfile
+```dockerfile
 FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
 WORKDIR /app
 EXPOSE 80

docs/architecture/containerized-lifecycle/design-develop-containerized-apps/set-up-windows-containers-with-powershell.md

@@ -9,7 +9,7 @@ With [Windows Containers](/virtualization/windowscontainers/about/index), you ca
 
 To use Windows Containers, you just need to write Windows PowerShell commands in the DockerFile, as demonstrated in the following example:
 
-```Dockerfile
+```dockerfile
 FROM microsoft/windowsservercore
 LABEL Description="IIS" Vendor="Microsoft" Version="10"
 RUN powershell -Command Add-WindowsFeature Web-Server
@@ -20,7 +20,7 @@ In this case, we're using Windows PowerShell to install a Windows Server Core ba
 
 In a similar way, you also could use Windows PowerShell commands to set up additional components like the traditional ASP.NET 4.x and .NET 4.6 or any other Windows software, as shown here:
 
-```Dockerfile
+```dockerfile
 RUN powershell add-windowsfeature web-asp-net45
 ```
 

docs/architecture/microservices/docker-application-development-process/docker-app-development-workflow.md

@@ -97,7 +97,7 @@ Using an official .NET image repository from Docker Hub with a version number en
 
 The following example shows a sample Dockerfile for an ASP.NET Core container.
 
-```Dockerfile
+```dockerfile
 FROM mcr.microsoft.com/dotnet/core/aspnet:3.1
 ARG source
 WORKDIR /app
@@ -167,7 +167,7 @@ Probably the best way to understand multi-stage is going through a Dockerfile in
 
 The initial Dockerfile might look something like this:
 
-```Dockerfile
+```dockerfile
  1  FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
  2  WORKDIR /app
  3  EXPOSE 80
@@ -238,7 +238,7 @@ You'll take advantage of Docker's layer cache feature, which is quite simple: if
 
 So, let's focus on the **build** stage, lines 5-6 are mostly the same, but lines 7-17 are different for every service from eShopOnContainers, so they have to execute every single time, however if you changed lines 7-16 to:
 
-```Dockerfile
+```dockerfile
 COPY . .
 ```
 
@@ -250,7 +250,7 @@ Then it would be just the same for every service, it would copy the whole soluti
 
 The next significant optimization involves the `restore` command executed in line 17, which is also different for every service of eShopOnContainers. If you change that line to just:
 
-```Dockerfile
+```dockerfile
 RUN dotnet restore
 ```
 
@@ -270,7 +270,7 @@ For the final optimization, it just happens that line 20 is redundant, as line 2
 
 The resulting file is then:
 
-```Dockerfile
+```dockerfile
  1  FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
  2  WORKDIR /app
  3  EXPOSE 80
@@ -553,7 +553,7 @@ In addition, you need to perform step 2 (adding Docker support to your projects)
 
 [Windows Containers](https://docs.microsoft.com/virtualization/windowscontainers/about/index) allow you to convert your existing Windows applications into Docker images and deploy them with the same tools as the rest of the Docker ecosystem. To use Windows Containers, you run PowerShell commands in the Dockerfile, as shown in the following example:
 
-```Dockerfile
+```dockerfile
 FROM mcr.microsoft.com/windows/servercore
 LABEL Description="IIS" Vendor="Microsoft" Version="10"
 RUN powershell -Command Add-WindowsFeature Web-Server
@@ -562,7 +562,7 @@ CMD [ "ping", "localhost", "-t" ]
 
 In this case, we are using a Windows Server Core base image (the FROM setting) and installing IIS with a PowerShell command (the RUN setting). In a similar way, you could also use PowerShell commands to set up additional components like ASP.NET 4.x, .NET 4.6, or any other Windows software. For example, the following command in a Dockerfile sets up ASP.NET 4.5:
 
-```Dockerfile
+```dockerfile
 RUN powershell add-windowsfeature web-asp-net45
 ```
 

docs/architecture/microservices/multi-container-microservice-net-applications/database-server-container.md

@@ -95,7 +95,7 @@ public static int Main(string[] args)
 
 There's an important caveat when applying migrations and seeding a database during container startup. Since the database server might not be available for whatever reason, you must handle retries while waiting for the server to be available. This retry logic is handled by the `MigrateDbContext()` extension method, as shown in the following code:
 
-```cs
+```csharp
 public static IWebHost MigrateDbContext<TContext>(
     this IWebHost host,
     Action<TContext,

docs/architecture/microservices/multi-container-microservice-net-applications/implement-api-gateways-with-ocelot.md

@@ -82,7 +82,7 @@ The HTTP request will end up running that kind of C# code accessing the microser
 
 Regarding the microservice URL, when the containers are deployed in your local development PC (local Docker host), each microservice's container always has an internal port (usually port 80) specified in its dockerfile, as in the following dockerfile:
 
-```Dockerfile
+```dockerfile
 FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
 WORKDIR /app
 EXPOSE 80

docs/architecture/microservices/multi-container-microservice-net-applications/multi-container-applications-docker-compose.md

@@ -431,7 +431,7 @@ The values set in the run-time environment always override the values defined in
 
 If you are exploring Docker and .NET Core on sources on the Internet, you will find Dockerfiles that demonstrate the simplicity of building a Docker image by copying your source into a container. These examples suggest that by using a simple configuration, you can have a Docker image with the environment packaged with your application. The following example shows a simple Dockerfile in this vein.
 
-```Dockerfile
+```dockerfile
 FROM mcr.microsoft.com/dotnet/core/sdk:3.1
 WORKDIR /app
 ENV ASPNETCORE_URLS http://+:80

docs/architecture/modern-web-apps-azure/common-web-application-architectures.md

@@ -261,7 +261,7 @@ networks:
 
 The `docker-compose.yml` file references the `Dockerfile` in the `Web` project. The `Dockerfile` is used to specify which base container will be used and how the application will be configured on it. The `Web`' `Dockerfile`:
 
-```Dockerfile
+```dockerfile
 FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS build
 WORKDIR /app
 

docs/architecture/modern-web-apps-azure/test-asp-net-core-mvc-apps.md

@@ -252,7 +252,7 @@ namespace Microsoft.eShopWeb.FunctionalTests.Web
 
 Tests can make use of this custom WebApplicationFactory by using it to create a client and then making requests to the application using this client instance. The application will have data seeded that can be used as part of the test's assertions. The following test verifies that the home page of the eShopOnWeb application loads correctly and includes a product listing that was added to the application as part of the seed data.
 
-```cs
+```csharp
 using Microsoft.eShopWeb.FunctionalTests.Web;
 using System.Net.Http;
 using System.Threading.Tasks;