Merge pull request #98668 from MicrosoftDocs/master

12/11 AM Publish

Author: huypub

articles/active-directory-b2c/b2clogin.md

@@ -89,7 +89,7 @@ For migrating Azure API Management APIs protected by Azure AD B2C, see the [Migr
 
 If you're using [MSAL.NET][msal-dotnet] v2 or earlier, set the **ValidateAuthority** property to `false` on client instantiation to allow redirects to *b2clogin.com*. This setting is not required for MSAL.NET v3 and above.
 
-```CSharp
+```csharp
 ConfidentialClientApplication client = new ConfidentialClientApplication(...); // Can also be PublicClientApplication
 client.ValidateAuthority = false; // MSAL.NET v2 and earlier **ONLY**
 ```

articles/active-directory/develop/howto-restrict-your-app-to-a-set-of-users.md

@@ -42,7 +42,7 @@ The option to restrict an app to a specific set of users or security groups in a
 
 There are two ways to create an application with enabled user assignment. One requires the **Global Administrator** role, the second does not.
 
-### Enterprise applications (requires the Global Adminstrator role)
+### Enterprise applications (requires the Global Administrator role)
 
 1. Go to the [**Azure portal**](https://portal.azure.com/) and sign in as a **Global Administrator**.
 1. On the top bar, select the signed-in account. 

articles/active-directory/develop/msal-net-client-assertions.md

@@ -39,7 +39,7 @@ MSAL.NET has four methods to provide either credentials or assertions to the con
 
 A signed client assertion takes the form of a signed JWT with the payload containing the required authentication claims mandated by Azure AD, Base64 encoded. To use it:
 
-```CSharp
+```csharp
 string signedClientAssertion = ComputeAssertion();
 app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
                                           .WithClientAssertion(signedClientAssertion)
@@ -59,7 +59,7 @@ sub | {ClientID} | The "sub" (subject) claim identifies the subject of the JWT.
 
 Here is an example of how to craft these claims:
 
-```CSharp
+```csharp
 private static IDictionary<string, string> GetClaims()
 {
       //aud = https://login.microsoftonline.com/ + Tenant ID + /v2.0
@@ -85,7 +85,7 @@ private static IDictionary<string, string> GetClaims()
 
 Here is how to craft a signed client assertion:
 
-```CSharp
+```csharp
 string Encode(byte[] arg)
 {
     char Base64PadCharacter = '=';
@@ -135,7 +135,7 @@ string GetSignedClientAssertion()
 
 You also have the option of using [Microsoft.IdentityModel.JsonWebTokens](https://www.nuget.org/packages/Microsoft.IdentityModel.JsonWebTokens/) to create the assertion for you. The code will be a more elegant as shown in the example below:
 
-```CSharp
+```csharp
         string GetSignedClientAssertion()
         {
             var cert = new X509Certificate2("Certificate.pfx", "Password", X509KeyStorageFlags.EphemeralKeySet);
@@ -168,7 +168,7 @@ You also have the option of using [Microsoft.IdentityModel.JsonWebTokens](https:
 
 Once you have your signed client assertion, you can use it with the MSAL apis as shown below.
 
-```CSharp
+```csharp
             string signedClientAssertion = GetSignedClientAssertion();
 
             var confidentialApp = ConfidentialClientApplicationBuilder
@@ -181,7 +181,7 @@ Once you have your signed client assertion, you can use it with the MSAL apis as
 
 `WithClientClaims(X509Certificate2 certificate, IDictionary<string, string> claimsToSign, bool mergeWithDefaultClaims = true)` by default will produce a signed assertion containing the claims expected by Azure AD plus additional client claims that you want to send. Here is a code snippet on how to do that.
 
-```CSharp
+```csharp
 string ipAddress = "192.168.1.2";
 X509Certificate2 certificate = ReadCertificate(config.CertificateName);
 app = ConfidentialClientApplicationBuilder.Create(config.ClientId)

articles/active-directory/develop/msal-net-migration-ios-broker.md

@@ -49,23 +49,23 @@ In ADAL.NET, broker support was enabled on a per-authentication context basis. I
 
 `useBroker` flag to true in the `PlatformParameters` constructor to call the broker:
 
-```CSharp
+```csharp
 public PlatformParameters(
         UIViewController callerViewController, 
         bool useBroker)
 ```
 Also, in the platform-specific code, in this example, in the page renderer for iOS, set the 
 `useBroker` 
 flag to true:
-```CSharp
+```csharp
 page.BrokerParameters = new PlatformParameters(
           this, 
           true, 
           PromptBehavior.SelectAccount);
 ```
 
 Then, include the parameters in the acquire token call:
-```CSharp
+```csharp
  AuthenticationResult result =
                     await
                         AuthContext.AcquireTokenAsync(
@@ -82,15 +82,15 @@ In MSAL.NET, broker support is enabled on a per-PublicClientApplication basis. I
 `WithBroker()` 
 parameter (set to true by default) in order to call the broker:
 
-```CSharp
+```csharp
 var app = PublicClientApplicationBuilder
                 .Create(ClientId)
                 .WithBroker()
                 .WithReplyUri(redirectUriOnIos)
                 .Build();
 ```
 In the acquire token call:
-```CSharp
+```csharp
 result = await app.AcquireTokenInteractive(scopes)
              .WithParentActivityOrWindow(App.RootViewController)
              .ExecuteAsync();
@@ -106,7 +106,7 @@ A UIViewController is passed into
 
 `PlatformParameters` in the iOS-specific platform.
 
-```CSharp
+```csharp
 page.BrokerParameters = new PlatformParameters(
           this, 
           true, 
@@ -125,16 +125,16 @@ This assignment ensures that there's a UIViewController with the call to the bro
 **For example:**
 
 In `App.cs`:
-```CSharp
+```csharp
    public static object RootViewController { get; set; }
 ```
 In `AppDelegate.cs`:
-```CSharp
+```csharp
    LoadApplication(new App());
    App.RootViewController = new UIViewController();
 ```
 In the acquire token call:
-```CSharp
+```csharp
 result = await app.AcquireTokenInteractive(scopes)
              .WithParentActivityOrWindow(App.RootViewController)
              .ExecuteAsync();
@@ -168,7 +168,7 @@ as a prefix, followed by your
 For example:
 `$"msauth.(BundleId")`
 
-```CSharp
+```csharp
  <key>CFBundleURLTypes</key>
     <array>
       <dict>
@@ -201,7 +201,7 @@ Uses
 `msauth`
 
 
-```CSharp
+```csharp
 <key>LSApplicationQueriesSchemes</key>
 <array>
      <string>msauth</string>
@@ -213,7 +213,7 @@ Uses
 `msauthv2`
 
 
-```CSharp
+```csharp
 <key>LSApplicationQueriesSchemes</key>
 <array>
      <string>msauthv2</string>

articles/active-directory/develop/msal-net-migration.md

@@ -222,7 +222,7 @@ MSAL.NET does not expose refresh tokens, for security reasons: MSAL handles refr
 
 Fortunately, MSAL.NET now has an API that allows you to migrate your previous refresh tokens (acquired with ADAL) into the `IConfidentialClientApplication`:
 
-```CSharp
+```csharp
 /// <summary>
 /// Acquires an access token from an existing refresh token and stores it and the refresh token into 
 /// the application user token cache, where it will be available for further AcquireTokenSilent calls.

articles/active-directory/develop/msal-net-use-brokers-with-xamarin-apps.md

@@ -35,7 +35,7 @@ Follow these steps to enable your Xamarin.iOS app to talk with the [Microsoft Au
 ### Step 1: Enable broker support
 Broker support is enabled on a per-PublicClientApplication basis. It's disabled by default. Use the `WithBroker()` parameter (set to true by default) when you create the PublicClientApplication through the PublicClientApplicationBuilder.
 
-```CSharp
+```csharp
 var app = PublicClientApplicationBuilder
                 .Create(ClientId)
                 .WithBroker()
@@ -46,7 +46,7 @@ var app = PublicClientApplicationBuilder
 ### Step 2: Update AppDelegate to handle the callback
 When the Microsoft Authentication Library for .NET (MSAL.NET) calls the broker, the broker in turn calls back to your application through the `OpenUrl` method of the `AppDelegate` class. Because MSAL waits for the response from the broker, your application needs to cooperate to call MSAL.NET back. To enable this cooperation, update the `AppDelegate.cs` file to override the following method.
 
-```CSharp
+```csharp
 public override bool OpenUrl(UIApplication app, NSUrl url, 
                              string sourceApplication,
                              NSObject annotation)
@@ -79,16 +79,16 @@ To do this, you do two things.
 **For example:**
 
 In `App.cs`:
-```CSharp
+```csharp
    public static object RootViewController { get; set; }
 ```
 In `AppDelegate.cs`:
-```CSharp
+```csharp
    LoadApplication(new App());
    App.RootViewController = new UIViewController();
 ```
 In the acquire token call:
-```CSharp
+```csharp
 result = await app.AcquireTokenInteractive(scopes)
              .WithParentActivityOrWindow(App.RootViewController)
              .ExecuteAsync();
@@ -138,11 +138,11 @@ Add `msauthv2` to the `LSApplicationQueriesSchemes` section of the `Info.plist`
 
 ### Step 6: Register your redirect URI in the application portal
 Using the broker adds an extra requirement on your redirect URI. The redirect URI _must_ have the following format:
-```CSharp
+```csharp
 $"msauth.{BundleId}://auth"
 ```
 **For example:**
-```CSharp
+```csharp
 public static string redirectUriOnIos = "msauth.com.yourcompany.XForms://auth"; 
 ```
 Notice that the redirect URI matches the `CFBundleURLSchemes` name you included in the `Info.plist` file.

articles/active-directory/develop/msal-net-xamarin-android-considerations.md

@@ -32,7 +32,7 @@ var authResult = AcquireTokenInteractive(scopes)
 ```
 You can also set this at the PublicClientApplication level (in MSAL4.2+) via a callback.
 
-```CSharp
+```csharp
 // Requires MSAL.NET 4.2 or above
 var pca = PublicClientApplicationBuilder
   .Create("<your-client-id-here>")
@@ -42,7 +42,7 @@ var pca = PublicClientApplicationBuilder
 
 A recommendation is to use the CurrentActivityPlugin [here](https://github.com/jamesmontemagno/CurrentActivityPlugin).  Then your PublicClientApplication builder code would look like this:
 
-```CSharp
+```csharp
 // Requires MSAL.NET 4.2 or above
 var pca = PublicClientApplicationBuilder
   .Create("<your-client-id-here>")

articles/active-directory/develop/msal-net-xamarin-ios-considerations.md

@@ -38,7 +38,7 @@ You might also see a break in ASP.NET Core OIDC authentication with iOS 12 Safar
 
 First you need to override the `OpenUrl` method of the `FormsApplicationDelegate` derived class and call `AuthenticationContinuationHelper.SetAuthenticationContinuationEventArgs`.
 
-```CSharp
+```csharp
 public override bool OpenUrl(UIApplication app, NSUrl url, NSDictionary options)
 {
     AuthenticationContinuationHelper.SetAuthenticationContinuationEventArgs(url);

articles/active-directory/develop/scenario-daemon-acquire-token.md

@@ -30,7 +30,7 @@ The scope to request for a client credential flow is the name of the resource fo
 
 # [.NET](#tab/dotnet)
 
-```CSharp
+```csharp
 ResourceId = "someAppIDURI";
 var scopes = new [] {  ResourceId+"/.default"};
 ```
@@ -67,7 +67,7 @@ To acquire a token for the app, you'll use `AcquireTokenForClient` or the equiva
 
 # [.NET](#tab/dotnet)
 
-```CSharp
+```csharp
 using Microsoft.Identity.Client;
 
 // With client credentials flows the scopes is ALWAYS of the shape "resource/.default", as the

articles/active-directory/develop/scenario-daemon-app-configuration.md

@@ -133,7 +133,7 @@ Add the [Microsoft.IdentityClient](https://www.nuget.org/packages/Microsoft.Iden
 In MSAL.NET, the confidential client application is represented by the `IConfidentialClientApplication` interface.
 Use MSAL.NET namespace in the source code
 
-```CSharp
+```csharp
 using Microsoft.Identity.Client;
 IConfidentialClientApplication app;
 ```
@@ -161,7 +161,7 @@ Here is the code to instantiate the confidential client application with a clien
 
 # [.NET](#tab/dotnet)
 
-```CSharp
+```csharp
 app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
            .WithClientSecret(config.ClientSecret)
            .WithAuthority(new Uri(config.Authority))
@@ -201,7 +201,7 @@ Here is the code to build an application with a certificate:
 
 # [.NET](#tab/dotnet)
 
-```CSharp
+```csharp
 X509Certificate2 certificate = ReadCertificate(config.CertificateName);
 app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
     .WithCertificate(certificate)
@@ -268,7 +268,7 @@ MSAL.NET has two methods to provide signed assertions to the confidential client
 
 When you use `WithClientAssertion`, you need to provide a signed JWT. This advanced scenario is detailed in [Client assertions](msal-net-client-assertions.md)
 
-```CSharp
+```csharp
 string signedClientAssertion = ComputeAssertion();
 app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
                                           .WithClientAssertion(signedClientAssertion)
@@ -278,7 +278,7 @@ app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
 When you use `WithClientClaims`, MSAL.NET will compute itself a signed assertion containing the claims expected by Azure AD plus additional client claims that you want to send.
 Here is a code snippet on how to do that:
 
-```CSharp
+```csharp
 string ipAddress = "192.168.1.2";
 var claims = new Dictionary<string, string> { { "client_ip", ipAddress } };
 X509Certificate2 certificate = ReadCertificate(config.CertificateName);