Add lang identifiers (dotnet#168)

Author: ChrisMaddock

xml/System.Xml/XmlTextReader.xml

@@ -282,7 +282,7 @@
 > [!NOTE]
 >  In version 1.1 of the [!INCLUDE[dnprdnshort](~/includes/dnprdnshort-md.md)], partially trusted code cannot set the `XmlResolver` property. The workaround is to create an <xref:System.Xml.XmlUrlResolver> with the necessary credentials, pass the URI to the <xref:System.Xml.XmlUrlResolver.GetEntity%2A?displayProperty=nameWithType> method, and then construct the `XmlTextReader` using the resulting <xref:System.IO.Stream> object. The workaround is described in the following C# code.  
   
-```  
+```csharp  
 // Create a resolver with the necessary credentials.  
 XmlUrlResolver resolver = new XmlUrlResolver();  
 NetworkCredential nc = new NetworkCredential(SecurelyStoredUserName, SecurelyStoredPassword, SecurelyStoredDomain);  
@@ -1510,20 +1510,20 @@ XmlTextReader reader = new XmlTextReader(s);
   
  The following XML contains an attribute in a specific namespace:  
   
-```  
+```xml  
 <test xmlns:dt="urn:datatypes" dt:type="int"/>  
 ```  
   
  You can lookup the `dt:type` attribute using one argument (prefix and local name) or two arguments (local name and namespace URI):  
   
-```  
+```csharp  
 String dt = reader.GetAttribute("dt:type");  
 String dt2 = reader.GetAttribute("type","urn:datatypes");  
 ```  
   
  To lookup the `xmlns:dt` attribute, use one of the following arguments:  
   
-```  
+```csharp  
 String dt3 = reader.GetAttribute("xmlns:dt");  
 String dt4 = reader.GetAttribute("dt",http://www.w3.org/2000/xmlns/);  
 ```  
@@ -2090,7 +2090,7 @@ abc<tag/>
   
  In the following XML, if the reader is positioned on the `href` attribute, the prefix `a` is resolved by calling `reader.LookupNamespace("a")`. The returned string is `urn:456`.  
   
-```  
+```xml  
 <root xmlns:a="urn:456">  
  <item>  
  <ref href="a:b"/>  
@@ -3225,7 +3225,7 @@ abc<tag/>
   
  In the following XML, if the reader is positioned on the start tag, `ReadChars` returns `test` and positions the reader after the end tag.  
   
-```  
+```xml  
 <Item>test</Item>  
 ```  
   
@@ -3245,7 +3245,7 @@ abc<tag/>
   
  For example, using the following XML:  
   
-```  
+```xml  
 <thing>  
  some text  
 </thing>  
@@ -3255,7 +3255,7 @@ abc<tag/>
   
  The reader is positioned on the `<item>` element at the end of the while loop.  
   
-```  
+```csharp  
 if (XmlNodeType.Element == reader.NodeType && "thing" == reader.Name)  
 {  
  while(0 != reader.ReadChars(buffer, 0, 1)  
@@ -3818,7 +3818,7 @@ if (XmlNodeType.Element == reader.NodeType && "thing" == reader.Name)
   
  If the reader is positioned on a leaf node already (such as the `<x>` node or the text node `abc`), calling `Skip` is the same as calling <xref:System.Xml.XmlTextReader.Read%2A>.  
   
-```  
+```xml  
 <a name="bob" age="123">  
   <x/>abc<y/>  
 </a>  

xml/System.Xml/XmlTextWriter.xml

@@ -42,7 +42,7 @@
   
  `XmlTextWriter` maintains a namespace stack corresponding to all the namespaces defined in the current element stack. Using `XmlTextWriter` you can declare namespaces manually.  
   
-```  
+```csharp  
 w.WriteStartElement("root");  
 w.WriteAttributeString("xmlns", "x", null, "urn:1");  
  w.WriteStartElement("item","urn:1");  
@@ -54,7 +54,7 @@ w.WriteEndElement();
   
  The above C# code produces the following output. `XmlTextWriter` promotes the namespace declaration to the root element to avoid having it duplicated on the two child elements. The child elements pick up the prefix from the namespace declaration.  
   
-```  
+```xml  
 <root xmlns:x="urn:1">  
  <x:item/>  
  <x:item/>  
@@ -63,14 +63,14 @@ w.WriteEndElement();
   
  `XmlTextWriter` also allows you to override the current namespace declaration. In the following example, the namespace URI "123" is overridden by "abc" to produce the XML element `<x:node xmlns:x="abc"/>`.  
   
-```  
+```csharp  
 w.WriteStartElement("x","node","123");  
 w.WriteAttributeString("xmlns","x",null,"abc");  
 ```  
   
  By using the write methods that take a prefix as an argument you can also specify which prefix to use. In the following example, two different prefixes are mapped to the same namespace URI to produce the XML text `<x:root xmlns:x="urn:1"><y:item xmlns:y="urn:1"/></x:root>`.  
   
-```  
+```csharp  
 XmlTextWriter w = new XmlTextWriter(Console.Out);  
 w.WriteStartElement("x","root","urn:1");  
  w.WriteStartElement("y","item","urn:1");  
@@ -81,7 +81,7 @@ w.Close();
   
  If there are multiple namespace declarations mapping different prefixes to the same namespace URI, `XmlTextWriter` walks the stack of namespace declarations backwards and picks the closest one.  
   
-```  
+```csharp  
 XmlTextWriter w = new XmlTextWriter(Console.Out);  
 w.Formatting = Formatting.Indented;  
 w.WriteStartElement("x","root","urn:1");  
@@ -94,7 +94,7 @@ w.Close();
   
  In the above C# example, because the `WriteAttributeString` call does not specify a prefix, the writer uses the last prefix pushed onto the namespace stack, and produces the following XML:  
   
-```  
+```xml  
 <x:root xmlns:x="urn:1">  
  <y:item y:attr="123" xmlns:y="urn:1" />  
 </x:root>  
@@ -110,7 +110,7 @@ w.Close();
   
  To write strongly typed data, use the <xref:System.Xml.XmlConvert> class to convert data types to string. For example, the following C# code converts the data from `Double` to `String` and writes the element `<price>19.95</price>`.  
   
-```  
+```csharp  
 Double price = 19.95;  
 writer.WriteElementString("price", XmlConvert.ToString(price));  
 ```  
@@ -470,7 +470,7 @@ writer.WriteElementString("price", XmlConvert.ToString(price));
   
  If the `Indented` option is set, child elements are indented using the <xref:System.Xml.XmlTextWriter.Indentation%2A> and <xref:System.Xml.XmlTextWriter.IndentChar%2A> properties. Only element content is indented. The following C# code writes out HTML elements including mixed content:  
   
-```  
+```csharp  
 XmlTextWriter w = new XmlTextWriter(Console.Out);   
  w.Formatting = Formatting.Indented;   
  w.WriteStartElement("ol");   
@@ -485,7 +485,7 @@ XmlTextWriter w = new XmlTextWriter(Console.Out);
   
  The above code produces the following output:  
   
-```  
+```xml  
 <ol>   
   <li>The big <b>E</b><i>lephant</i> walks slowly.</li>   
 </ol>  
@@ -547,7 +547,7 @@ XmlTextWriter w = new XmlTextWriter(Console.Out);
   
  Indentation is performed on following node types: `DocumentType`, `Element`, `Comment`, `ProcessingInstruction`, and `CDATASection`. All other node types are not affected. The `XmlTextWriter` does not indent the internal DTD subset. However, you could do the following to apply formatting to the internal DTD subset.  
   
-```  
+```csharp  
 String name = "Employees";  
 String pubid = null;  
 String sysid = null;  
@@ -1621,7 +1621,7 @@ tw.WriteDocType(name, pubid, sysid, subset);
   
  For example, the following Microsoft Visual C# code:  
   
-```  
+```csharp  
 writer.Formatting = Formatting.Indented;  
 writer.WriteStartElement("root");  
  writer.WriteAttributeString("xmlns","x",null,"urn:abc");  
@@ -1637,7 +1637,7 @@ writer.WriteStartElement("root");
   
  Generates the following output:  
   
-```  
+```xml  
 <root xmlns:x="urn:abc">  
  <item href="#x:test"/>  
  </root>  

xml/System.Xml/XmlUrlResolver.xml

@@ -165,7 +165,7 @@
   
  The following C# code shows how to set the <xref:System.Xml.XmlUrlResolver.Credentials%2A> property to a credential cache.  
   
-```  
+```csharp  
 NetworkCredential myCred = new NetworkCredential(UserName,SecurelyStoredPassword,Domain);   
 CredentialCache myCache = new CredentialCache();   
 myCache.Add(new Uri("http://www.contoso.com/"), "Basic", myCred);   

xml/System.Xml/XmlValidatingReader.xml

@@ -649,7 +649,7 @@
   
  To illustrate the difference between the entity handling modes consider the following XML:  
   
-```  
+```xml  
 <!DOCTYPE doc [<!ENTITY num "123">]>  
  <doc> &#65; &num; </doc>  
 ```  
@@ -888,20 +888,20 @@
   
  The following XML contains an attribute in a specific namespace:  
   
-```  
+```xml  
 <test xmlns:dt="urn:datatypes" dt:type="int"/>  
 ```  
   
  You can look up the `dt:type` attribute by using one argument (prefix and local name) or two arguments (local name and namespace URI):  
   
-```  
+```csharp  
 String dt = reader.GetAttribute("dt:type");  
 String dt2 = reader.GetAttribute("type","urn:datatypes");  
 ```  
   
  To look up the `xmlns:dt` attribute, use one of the following arguments:  
   
-```  
+```csharp  
 String dt3 = reader.GetAttribute("xmlns:dt");  
 String dt4 = reader.GetAttribute("dt",http://www.w3.org/2000/xmlns/);  
 ```  
@@ -1234,7 +1234,7 @@ String dt4 = reader.GetAttribute("dt",http://www.w3.org/2000/xmlns/);
   
  The position indicated is the first character of text in the markup.  
   
-```  
+```xml  
 <root>  
  abc<tag/>  
 </root>  
@@ -1343,7 +1343,7 @@ String dt4 = reader.GetAttribute("dt",http://www.w3.org/2000/xmlns/);
   
  In the following XML string, if the reader is positioned on the `href` attribute, the prefix `a` is resolved by calling `reader.LookupNamespace("a", true)`. The returned string is `urn:456`.  
   
-```  
+```xml  
 <root xmlns:a="urn:456">  
  <item>  
  <ref href="a:b"/>  
@@ -2138,7 +2138,7 @@ String dt4 = reader.GetAttribute("dt",http://www.w3.org/2000/xmlns/);
   
  If <xref:System.Xml.XmlValidatingReader.EntityHandling%2A> is set to `ExpandCharEntities`, the following C# code returns the attribute value as two text nodes and one entity reference node:  
   
-```  
+```csharp  
 reader.MoveToAttribute("name");  
   while (reader.ReadAttributeValue())  
   {  
@@ -2840,7 +2840,7 @@ reader.MoveToAttribute("name");
   
  The user needs to test for the returned type. For example,  
   
-```  
+```csharp  
 object obj = vreader.SchemaType;  
  if (obj is XmlSchemaType)  
  {  
@@ -3279,7 +3279,7 @@ object obj = vreader.SchemaType;
   
  This property represents the xml:lang scope within which the current node resides. For example, here is an XML fragment with `xml:lang` set to U.S. English in the root element:  
   
-```  
+```xml  
 <root xml:lang="en-us">   
 <name>Fred</name>   
 </root>   

xml/System.Xml/XmlWriter.xml

@@ -141,7 +141,7 @@
   
      The code generates the following XML string:  
   
-    ```  
+    ```xml  
     <x:root xmlns:x="123">  
       <item xmlns:x="abc" />  
     </x:root>  
@@ -182,7 +182,7 @@
 ## Examples  
  The following example code shows how to use the asynchronous API to generate XML.  
   
-```  
+```csharp  
 async Task TestWriter(Stream stream)   
 {  
     XmlWriterSettings settings = new XmlWriterSettings();  
@@ -3352,15 +3352,15 @@ async Task TestWriter(Stream stream)
   
  The following C# code copies an entire XML input document to the console:  
   
-```  
+```csharp  
 XmlReader reader = XmlReader.Create(myfile);  
 XmlWriter writer = XmlWriter.Create(Console.Out);  
 writer.WriteNode(reader, false);  
 ```  
   
  If you have moved off the root node and are positioned elsewhere in the document the following C# example correctly writes out the nodes.  
   
-```  
+```csharp  
 XmlReader reader = XmlReader.Create(myfile);  
 reader.Read(); // Read PI  
 reader.Read(); // Read Comment  
@@ -3631,7 +3631,7 @@ while (!reader.EOF){
 ## Remarks  
  This method can be used to write the XML declaration (rather than <xref:System.Xml.XmlWriter.WriteStartDocument%2A>). This could result in the encoding attribute being incorrectly written. For example, the following C# code would result in an invalid XML document because the default encoding is UTF-8.  
   
-```  
+```csharp  
 XmlWriter writer = XmlWriter.Create("output.xml");  
 writer.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-16'");  
 writer.WriteStartElement("root");  
@@ -3762,7 +3762,7 @@ writer.Close();
 ## Examples  
  The example writes the following element:  
   
-```  
+```xml  
 <root xmlns:x="urn:abc">  
   <item href="#x:test"/>  
 </root>  
@@ -4647,15 +4647,15 @@ writer.Close();
 ## Remarks  
  After calling this method you can either write attributes, or create content using <xref:System.Xml.XmlWriter.WriteComment%2A>, <xref:System.Xml.XmlWriter.WriteString%2A>, or `WriteStartElement` for child elements. You can close the element with either <xref:System.Xml.XmlWriter.WriteEndElement%2A> or <xref:System.Xml.XmlWriter.WriteFullEndElement%2A>. For example, the following C# code:  
   
-```  
+```csharp  
 writer.WriteStartElement("item",null);  
 writer.WriteString("some text");  
 writer.WriteEndElement();  
 ```  
   
  Generates the following output:  
   
-```  
+```xml  
 <item>some text</item>  
 ```  
   

xml/System.Xml/XmlWriterSettings.xml

@@ -68,7 +68,7 @@
   
  The sample produces the following output:  
   
-```  
+```xml  
 <order  
   orderID="367A54"  
   date="2001-05-03">  
@@ -813,7 +813,7 @@ using (StreamWriter output =
   
  The sample produces the following output:  
   
-```  
+```xml  
 <order  
   orderID="367A54"  
   date="2001-05-03">