US 1583733 Add missing language IDs - 42

docs/machine-learning/how-to-guides/matchup-app-infer-net.md

@@ -134,7 +134,7 @@ dotnet run
 
 Your results should be similar to the following:
 
-```
+```console
 Compiling model...done.
 Iterating:
 .........|.........|.........|.........|.........| 50

docs/machine-learning/tutorials/mlnet-cli.md

@@ -200,7 +200,7 @@ Those enumerated assets are explained in the following steps of the tutorial.
 
     Run the console app from the command-prompt by typing the following commands:
 
-     ```
+     ```bash
      > cd SampleBinaryClassification
      > cd SampleBinaryClassification.ConsoleApp
 

docs/spark/tutorials/databricks-deployment.md

@@ -115,11 +115,11 @@ You can use `set JAR` or `spark-submit` to submit your job to Databricks.
 
 3. Set the parameters appropriately.
 
-   ```
-   Main Class: org.apache.spark.deploy.dotnet.DotnetRunner
-   Arguments /dbfs/apps/<your-app-name>.zip <your-app-main-class>
-   ```
- 
+   | Parameter   | Value                                                |
+   |-------------|------------------------------------------------------|
+   | Main Class  | org.apache.spark.deploy.dotnet.DotnetRunner          |
+   | Arguments   | /dbfs/apps/<your-app-name>.zip <your-app-main-class> |
+
 4. Configure the **Cluster** to point to the existing cluster you created the **Init Script** for in the previous section.
 
 #### Publish and run your app

docs/standard/asynchronous-programming-patterns/component-that-supports-the-event-based-asynchronous-pattern.md

@@ -85,7 +85,7 @@ If you are writing a class with some operations that may incur noticeable delays
 
      You will receive two compiler warnings:  
 
-    ```  
+    ```console  
     warning CS0067: The event 'AsynchronousPatternExample.PrimeNumberCalculator.ProgressChanged' is never used  
     warning CS0067: The event 'AsynchronousPatternExample.PrimeNumberCalculator.CalculatePrimeCompleted' is never used  
     ```  
@@ -156,7 +156,7 @@ If you are writing a class with some operations that may incur noticeable delays
 
      You will receive one compiler warning:  
 
-    ```  
+    ```console  
     warning CS0169: The private field 'AsynchronousPatternExample.PrimeNumberCalculator.workerDelegate' is never used  
     ```  
 

docs/standard/attributes/retrieving-information-stored-in-attributes.md

@@ -38,15 +38,15 @@ Retrieving a custom attribute is a simple process. First, declare an instance of
 
  This program displays the following text when executed.  
 
-```  
+```console  
 The Name Attribute is: Joan Smith.  
 The Level Attribute is: 42.  
 The Reviewed Attribute is: True.  
 ```  
 
  If the attribute is not found, the **GetCustomAttribute** method initializes `MyAttribute` to a null value. This example checks `MyAttribute` for such an instance and notifies the user if no attribute is found. If the `DeveloperAttribute` is not found in the class scope, the following message displays to the console.  
 
-```  
+```console  
 The attribute was not found.   
 ```  
 

docs/standard/base-types/character-classes-in-regular-expressions.md

@@ -53,17 +53,13 @@ A character class defines a set of characters, any one of which can occur in an
 
  The syntax for specifying a list of individual characters is as follows:  
 
-```  
-[*character_group*]  
-```
+`[*character_group*]`
 
  where *character_group* is a list of the individual characters that can appear in the input string for a match to succeed. *character_group* can consist of any combination of one or more literal characters, [escape characters](../../../docs/standard/base-types/character-escapes-in-regular-expressions.md), or character classes.  
 
  The syntax for specifying a range of characters is as follows:  
 
-```  
-[firstCharacter-lastCharacter]  
-```  
+`[firstCharacter-lastCharacter]`  
 
  where *firstCharacter* is the character that begins the range and *lastCharacter* is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points. *firstCharacter* must be the character with the lower code point, and *lastCharacter* must be the character with the higher code point.
 
@@ -113,17 +109,13 @@ Some common regular expression patterns that contain positive character classes
 
 The syntax for specifying a list of individual characters is as follows:  
 
-```
-[*^character_group*]  
-```
+`[*^character_group*]`
 
  where *character_group* is a list of the individual characters that cannot appear in the input string for a match to succeed. *character_group* can consist of any combination of one or more literal characters, [escape characters](../../../docs/standard/base-types/character-escapes-in-regular-expressions.md), or character classes.  
 
  The syntax for specifying a range of characters is as follows:  
 
-```
-[^*firstCharacter*-*lastCharacter*]  
-```
+`[^*firstCharacter*-*lastCharacter*]`
 
 where *firstCharacter* is the character that begins the range and *lastCharacter* is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points. *firstCharacter* must be the character with the lower code point, and *lastCharacter* must be the character with the higher code point.
 
@@ -261,9 +253,7 @@ where *firstCharacter* is the character that begins the range and *lastCharacter
 ## Non-word character: \W  
  `\W` matches any non-word character. The \W language element is equivalent to the following character class:  
 
-```  
-[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]  
-```  
+`[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]`  
 
  In other words, it matches any character except for those in the Unicode categories listed in the following table.  
 

docs/standard/base-types/grouping-constructs-in-regular-expressions.md

@@ -72,9 +72,7 @@ Grouping constructs delineate the subexpressions of a regular expression and cap
 
  The regular expression pattern is the following:  
 
-```  
-(\w+)\s(\1)\W  
-```  
+`(\w+)\s(\1)\W`  
 
  The following table shows how the regular expression pattern is interpreted.  
 
@@ -89,15 +87,11 @@ Grouping constructs delineate the subexpressions of a regular expression and cap
 ## Named Matched Subexpressions  
  The following grouping construct captures a matched subexpression and lets you access it by name or by number:  
 
-```  
-(?<name>subexpression)  
-```  
+`(?<name>subexpression)`  
 
  or:  
 
-```  
-(?'name'subexpression)  
-```  
+`(?'name'subexpression)`  
 
  where *name* is a valid group name, and *subexpression* is any valid regular expression pattern. *name* must not contain any punctuation characters and cannot begin with a number.  
 
@@ -135,9 +129,7 @@ Grouping constructs delineate the subexpressions of a regular expression and cap
 
  The regular expression pattern is as follows:  
 
-```  
-(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)  
-```  
+`(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)`  
 
  The following table shows how the regular expression is interpreted.  
 
@@ -169,15 +161,11 @@ Grouping constructs delineate the subexpressions of a regular expression and cap
 ## Balancing Group Definitions  
  A balancing group definition deletes the definition of a previously defined group and stores, in the current group, the interval between the previously defined group and the current group. This grouping construct has the following format:  
 
-```  
-(?<name1-name2>subexpression)  
-```  
+`(?<name1-name2>subexpression)`  
 
  or:  
 
-```  
-(?'name1-name2' subexpression)  
-```  
+`(?'name1-name2' subexpression)`
 
  where *name1* is the current group (optional), *name2* is a previously defined group, and *subexpression* is any valid regular expression pattern. The balancing group definition deletes the definition of *name2* and stores the interval between *name2* and *name1* in *name1*. If no *name2* group is defined, the match backtracks. Because deleting the last definition of *name2* reveals the previous definition of *name2*, this construct lets you use the stack of captures for group *name2* as a counter for keeping track of nested constructs such as parentheses or opening and closing brackets.  
 
@@ -193,9 +181,7 @@ Grouping constructs delineate the subexpressions of a regular expression and cap
 
  The regular expression pattern is:  
 
-```  
-^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$  
-```  
+`^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$`  
 
  The regular expression is interpreted as follows:  
 
@@ -248,9 +234,7 @@ Grouping constructs delineate the subexpressions of a regular expression and cap
 ## Noncapturing Groups  
  The following grouping construct does not capture the substring that is matched by a subexpression:  
 
-```  
-(?:subexpression)  
-```  
+`(?:subexpression)`
 
  where *subexpression* is any valid regular expression pattern. The noncapturing group construct is typically used when a quantifier is applied to a group, but the substrings captured by the group are of no interest.  
 

docs/standard/base-types/miscellaneous-constructs-in-regular-expressions.md

@@ -19,9 +19,7 @@ Regular expressions in .NET include three miscellaneous language constructs. One
 ## Inline Options  
  You can set or disable specific pattern matching options for part of a regular expression by using the syntax  
 
-```  
-(?imnsx-imnsx)  
-```  
+`(?imnsx-imnsx)`  
 
  You list the options you want to enable after the question mark, and the options you want to disable after the minus sign. The following table describes each option. For more information about each option, see [Regular Expression Options](../../../docs/standard/base-types/regular-expression-options.md).  
 

docs/standard/base-types/regular-expression-options.md

@@ -209,9 +209,7 @@ By default, capturing groups are defined by the use of parentheses in the regula
 
 Grouping constructs are often used only to apply quantifiers to multiple language elements, and the captured substrings are of no interest. For example, if the following regular expression:
 
-```
-\b\(?((\w+),?\s?)+[\.!?]\)?
-```
+`\b\(?((\w+),?\s?)+[\.!?]\)?`
 
 is intended only to extract sentences that end with a period, exclamation point, or question mark from a document, only the resulting sentence (which is represented by the <xref:System.Text.RegularExpressions.Match> object) is of interest. The individual words in the collection are not.
 

docs/standard/data/xml/accessing-attributes-in-the-dom.md

@@ -117,7 +117,7 @@ This example displays the following output:
 
 Display all the attributes in the collection.
 
-```
+```console
 genre = novel
 ISBN = 1-861001-57-5
 misc = sale item

docs/standard/data/xml/how-to-perform-an-xslt-transformation-by-using-an-assembly.md

@@ -128,52 +128,52 @@ The XSLT compiler (xsltc.exe) compiles XSLT style sheets and generates an assemb
 
 1. Executing the following command from the command line creates two assemblies named `Transform.dll` and `Transform_Script1.dll` (This is the default behavior. Unless otherwise specified, the name of the class and the assembly defaults to the name of the main style sheet):  
 
-    ```  
+    ```console  
     xsltc /settings:script+ Transform.xsl  
-    ```  
+    ```
 
- The following command explicitly sets the class name to Transform:  
+    The following command explicitly sets the class name to Transform:  
 
-```  
-xsltc /settings:script+ /class:Transform Transform.xsl  
-```  
+    ```console  
+    xsltc /settings:script+ /class:Transform Transform.xsl  
+    ```  
 
 ### To include the compiled assembly as a reference when you compile your code.  
 
 1. You can include an assembly in Visual Studio by adding a reference in the Solution Explorer, or from the command line.  
 
 2. For the command line with C#, use the following:  
 
-    ```  
+    ```console  
     csc myCode.cs /r:system.dll;system.xml.dll;Transform.dll  
     ```  
 
 3. For the command line with Visual Basic, use the following  
 
-    ```  
+    ```console  
     vbc myCode.vb /r:system.dll;system.xml.dll;Transform.dll  
     ```  
 
 ### To use the compiled assembly in your code.  
 
-1. The following example shows how to execute the XSLT transformation by using the compiled style sheet.  
+The following example shows how to execute the XSLT transformation by using the compiled style sheet.  
 
- [!code-csharp[XslTransform_XSLTC#1](../../../../samples/snippets/csharp/VS_Snippets_Data/XslTransform_XSLTC/CS/XslTransform_XSLTC.cs#1)]
- [!code-vb[XslTransform_XSLTC#1](../../../../samples/snippets/visualbasic/VS_Snippets_Data/XslTransform_XSLTC/VB/XslTransform_XSLTC.vb#1)]  
+[!code-csharp[XslTransform_XSLTC#1](../../../../samples/snippets/csharp/VS_Snippets_Data/XslTransform_XSLTC/CS/XslTransform_XSLTC.cs#1)]
+[!code-vb[XslTransform_XSLTC#1](../../../../samples/snippets/visualbasic/VS_Snippets_Data/XslTransform_XSLTC/VB/XslTransform_XSLTC.vb#1)]  
 
- To dynamically link to the compiled assembly, replace  
+To dynamically link to the compiled assembly, replace
 
-```  
-xslt.Load(typeof(Transform))  
+```csharp  
+xslt.Load(typeof(Transform));  
 ```  
 
- with  
+with  
 
-```  
-xslt.Load(System.Reflection.Assembly.Load("Transform").GetType("Transform"))  
-```  
+```csharp 
+xslt.Load(System.Reflection.Assembly.Load("Transform").GetType("Transform"));  
+``` 
 
- in the example above. For more information on the Assembly.Load method, see <xref:System.Reflection.Assembly.Load%2A>  
+in the example above. For more information on the Assembly.Load method, see <xref:System.Reflection.Assembly.Load%2A>.  
 
 ## See also
 

docs/standard/data/xml/node-sets-in-transformations.md

@@ -54,7 +54,7 @@ Node sets are one of four basic data types that are returned from XML Path Langu
 
 ## Output  
 
-```  
+```output  
 ******  
 Seven Years in Trenton  
 ******  

docs/standard/data/xml/xdr-validation-with-xmlschemacollection.md

@@ -18,10 +18,14 @@ If the XML-Data Reduced (XDR) schema you are validating against is stored in the
 
 For example, if the root element of the XML document is `<bookstore xmlns="urn:newbooks-schema">`, when the schema is added to the **XmlSchemaCollection** it references the same namespace, as follows:
 
-```
+```vb
 xsc.Add("urn:newbooks-schema", "newbooks.xdr")
 ```
 
+```csharp
+xsc.Add("urn:newbooks-schema", "newbooks.xdr");
+```
+
 The following code example creates an **XmlValidatingReader** that takes an **XmlTextReader** and adds an XDR schema, HeadCount.xdr, to the **XmlSchemaCollection**:
 
 ```vb

docs/standard/data/xml/xpath-namespace-navigation.md

@@ -34,32 +34,26 @@ To use XPath queries with XML documents, you have to correctly address XML names
 ## Navigation by Namespace Prefix  
  The code in this section uses <xref:System.Xml.XPath.XPathNavigator> and <xref:System.Xml.XmlNamespaceManager> objects to select the `Search` element from the XML document in the previous section. The query `xpath` includes namespace prefixes on each element in the path. Specifying the precise identity of the namespaces that contain each element assures correct navigation to the `Search` element by the <xref:System.Xml.XPath.XPathNavigator.SelectSingleNode%2A> method.  
 
-```  
+```csharp  
 using (XmlReader reader = XmlReader.Create("response.xml"))  
-            {  
-                XPathDocument doc = new XPathDocument(reader);  
-                XPathNavigator nav = doc.CreateNavigator();  
-                XmlNamespaceManager nsmgr =  
-                         new XmlNamespaceManager(nav.NameTable);  
-                nsmgr.AddNamespace("e",   
-                         @"http://schemas.xmlsoap.org/soap/envelope/");  
-                nsmgr.AddNamespace("s",   
-                            @"http://schemas.microsoft.com/v1/Search");  
-                nsmgr.AddNamespace("r",   
-                   @"http://schemas.microsoft.com/v1/Search/metadata");  
-                nsmgr.AddNamespace("i",   
-                         @"http://www.w3.org/2001/XMLSchema-instance");  
+{  
+    XPathDocument doc = new XPathDocument(reader);  
+    XPathNavigator nav = doc.CreateNavigator();
 
-                string xpath = "/e:Envelope/e:Body/s:Search";  
+    XmlNamespaceManager nsmgr = new XmlNamespaceManager(nav.NameTable);  
+    nsmgr.AddNamespace("e", @"http://schemas.xmlsoap.org/soap/envelope/");  
+    nsmgr.AddNamespace("s", @"http://schemas.microsoft.com/v1/Search");  
+    nsmgr.AddNamespace("r", @"http://schemas.microsoft.com/v1/Search/metadata");  
+    nsmgr.AddNamespace("i", @"http://www.w3.org/2001/XMLSchema-instance");  
 
-                XPathNavigator element = nav.SelectSingleNode(xpath, nsmgr);  
+    string xpath = "/e:Envelope/e:Body/s:Search";  
 
-                Console.WriteLine("Element Prefix:" + element.Prefix +   
-                           " Local name:" + element.LocalName);  
-                Console.WriteLine("Namespace URI: " +   
-                            element.NamespaceURI);  
+    XPathNavigator element = nav.SelectSingleNode(xpath, nsmgr);  
 
-            }  
+    Console.WriteLine("Element Prefix:" + element.Prefix +   
+    " Local name:" + element.LocalName);  
+    Console.WriteLine("Namespace URI: " + element.NamespaceURI);  
+}  
 ```  
 
  The precision of fully qualifying namespaces and names is more than a convenience. A little experimentation with the document definition and code in the previous examples will verify that navigation without fully qualified element names throws exceptions. For example, the element definition: `<Search xmlns="http://schemas.microsoft.com/v1/Search">`, and query: string `xpath = "/s:Envelope/s:Body/Search";` without the namespace prefix on the `Search` element returns `null` instead of the `Search` element.