Fix code snippets (#3089)

* Fix code snippets

* Apply suggestions from code review

Co-Authored-By: Maira Wenzel <[email protected]>

* Apply missing fix

* Apply missing fix

* Apply missing fix

* Apply missing fix

* Apply suggestions from code review

Co-Authored-By: Maira Wenzel <[email protected]>

* Apply missing fix

* minor fix

* Apply missing fix

* Update DataContext.xml

* Apply suggestions from code review

Co-Authored-By: Maira Wenzel <[email protected]>

Co-authored-by: Maira Wenzel <[email protected]>

Author: Youssef1313

xml/System.Data.Linq/DataContext.xml

@@ -580,21 +580,28 @@
   
  `ExecuteQuery` and `ExecuteCommand` allow you to specify a variable number of arguments for parameter substitution. For example, you can specify the parameters when invoking ExecuteQuery\<TResult>:  
   
-```  
-db.ExecuteQuery<Customer>("select * from dbo.Customers where City = {0}", "London");  
-```  
+```csharp
+db.ExecuteQuery<Customer>("SELECT * FROM dbo.Customers WHERE City = {0}", "London");
+```
+
+```vb
+db.ExecuteQuery(Of Customer)("SELECT * FROM dbo.Customers WHERE City = {0}", "London")
+```
   
  And, another example:  
   
-```  
-db.ExecuteCommand("UPDATE Products SET QuantityPerUnit = {0} WHERE ProductID = {1}", "24 boxes", 5);  
-```  
-  
- The following example opens a connection and passes a SQL `UPDATE` command to the SQL engine.  
-  
-   
-  
-## Examples  
+```csharp
+db.ExecuteCommand("UPDATE Products SET QuantityPerUnit = {0} WHERE ProductID = {1}", "24 boxes", 5);
+```
+
+```vb
+db.ExecuteCommand("UPDATE Products SET QuantityPerUnit = {0} WHERE ProductID = {1}", "24 boxes", 5)
+```
+
+
+## Examples
+The following example opens a connection and passes a SQL `UPDATE` command to the SQL engine.
+
  [!code-csharp[DLinqCommunicatingWithDatabase#3](~/samples/snippets/csharp/VS_Snippets_Data/DLinqCommunicatingWithDatabase/cs/Program.cs#3)]
  [!code-vb[DLinqCommunicatingWithDatabase#3](~/samples/snippets/visualbasic/VS_Snippets_Data/DLinqCommunicatingWithDatabase/vb/Module1.vb#3)]  
   
@@ -883,29 +890,30 @@ db.ExecuteCommand("UPDATE Products SET QuantityPerUnit = {0} WHERE ProductID = {
   
 -   In all other cases, the query can retrieve just a subset of the tracked fields and properties for the object.  
   
- The following C# snippet shows one use for this method:  
+## Examples  
+
+ The following example shows one use for this method:  
   
-```  
-var customers = db.ExecuteQuery<Customer>(@"SELECT CustomerID, CompanyName, ContactName, ContactTitle,   
+```csharp
+var customers = db.ExecuteQuery<Customer>(@"SELECT CustomerID, CompanyName, ContactName, ContactTitle,
    Address, City, Region, PostalCode, Country, Phone, Fax  
-   FROM   dbo.Customers  
-   WHERE  City = {0}", "London");  
+   FROM   dbo.Customers
+   WHERE  City = {0}", "London");
   
-foreach (Customer c in customers)  
-   Console.WriteLine(c.ContactName);  
+foreach (Customer c in customers)
+    Console.WriteLine(c.ContactName);
 ```  
   
- In Visual Basic  
-  
-```  
-Dim customers = db.ExecuteQuery(Of Customer)("SELECT CustomerID, _    CompanyName, ContactName, ContactTitle, _  
-   Address, City, Region, PostalCode, Country, Phone, Fax _  
-   FROM dbo.Customers _  
-WHERE City = {0}", "London")  
-  
-For Each c As Customer In customers  
-    Console.WriteLine(c.ContactName)  
-Next  
+```vb
+Dim customers = db.ExecuteQuery(Of Customer)("SELECT CustomerID, _    
+    CompanyName, ContactName, ContactTitle, _
+   Address, City, Region, PostalCode, Country, Phone, Fax _
+   FROM dbo.Customers _
+WHERE City = {0}", "London")
+
+For Each c As Customer In customers
+    Console.WriteLine(c.ContactName)
+Next
 ```  
   
  ]]></format>
@@ -1508,7 +1516,7 @@ Next
 ## Remarks  
  Each row in the <xref:System.Data.IDataReader> is converted to an object in the <xref:System.Collections.Generic.IEnumerable%601>.  
   
-```  
+```csharp
 public IEnumerable<T> Translate<T>(IDataReader reader) {}  
 ```  
   

xml/System.Data.Linq/EntitySet`1.xml

@@ -284,26 +284,26 @@
         <remarks>
           <format type="text/markdown"><![CDATA[  
   
-## Remarks  
- The following C# sample shows one use of this method:  
+## Examples
+
+ The following example shows one use of this method:  
   
-```  
+```csharp
 var customer = (from c in db.Customers  
    where c.CustomerID == "ALFKI"  
-   select c).Single();  
-  
-Order[] orderArray = new Order[customer.Orders.Count];  
+   select c).Single();
+
+var orderArray = new Order[customer.Orders.Count];
+customer.Orders.CopyTo(orderArray,0);
 ```  
   
- customer.Orders.CopyTo(orderArray,0);In Visual Basic:  
-  
-```  
+```vb
 Dim customer = (From c In db.Customers _   
    Where c.CustomerID = "ALFKI" _   
    Select c).[Single]()  
   
-Dim orderArray As Order() = New Order(customer.Orders.Count - 1) {}  
-customer.Orders.CopyTo(orderArray, 0)  
+Dim orderArray As New Order(customer.Orders.Count - 1) {}
+customer.Orders.CopyTo(orderArray, 0)
 ```  
   
  ]]></format>

xml/System.Data.Linq/Table`1.xml

@@ -57,16 +57,19 @@
   
  An application can access a <xref:System.Data.Linq.Table%601> instance via <xref:System.Data.Linq.DataContext.GetTable%2A> or by using a strongly typed property for the strongly typed <xref:System.Data.Linq.DataContext>. That is, when the designer generates a DataContext object, it generates properties to represent each Table. For example:  
   
-```  
+```csharp
 [global::System.Data.Linq.Mapping.DatabaseAttribute(Name="SignOffTool")]  
-public partial class DataClasses1DataContext : System.Data.Linq.DataContext {  
-   public System.Data.Linq.Table<User> Users {  
-      get {  
-         return this.GetTable<User>();  
-      }  
-   }  
-}  
-```  
+public partial class DataClasses1DataContext : System.Data.Linq.DataContext 
+{
+    public System.Data.Linq.Table<User> Users
+    {
+        get
+        {
+            return this.GetTable<User>();
+        }
+    }
+}
+```
   
  For this strongly typed DataContext, you can access the Users property to get `Table<User>`.  
   
@@ -91,16 +94,17 @@ public partial class DataClasses1DataContext : System.Data.Linq.DataContext {
   
  When a new entity is attached, deferred loaders for any child collections (for example, `EntitySet` collections of entities from associated tables) are initialized. When <xref:System.Data.Linq.DataContext.SubmitChanges%2A> is called, members of the child collections are put into an `Unmodified` state. To update members of a child collection, you must explicitly call `Attach` and specify that entity.  
   
- `Attach` attaches all entities in the object graph of the provided object. For example, the following C# code:  
+ `Attach` attaches all entities in the object graph of the provided object. For example:
   
-```  
-using (SampleDataContext db = new SampleDataContext()) {  
-    Employee employee = new Employee { employeeId = 1 };  
+```csharp
+using (var db = new SampleDataContext())
+{  
+    var employee = new Employee { employeeId = 1 };  
   
-    Master master = new Master();  
+    var master = new Master();  
     master.Employee = employee;  
   
-    Child child = new Child();  
+    var child = new Child();  
     child.Employee = employee;  
   
     db.Employees.Attach(employee);  
@@ -110,14 +114,12 @@ using (SampleDataContext db = new SampleDataContext()) {
     db.Masters.InsertOnSubmit(master);  
   
     db.SubmitChanges();  
-}  
-  
+} 
 ```  
-  
- The equivalent Visual Basic code is:  
-  
-```  
-Using db As New SampleDataContext()    Dim employee As New Employee With { .employeeId = 1 }  
+
+```vb
+Using db As New SampleDataContext()
+    Dim employee As New Employee With { .employeeId = 1 }
   
     Dim master As New Master()  
     master.Employee = employee  
@@ -449,20 +451,20 @@ End Using
 ## Remarks  
  Entities that are put into the pending delete state with this method do not disappear from query results until after <xref:System.Data.Linq.DataContext.SubmitChanges%2A> is called. Disconnected entities must be attached before they can be deleted. For more information, see [Data Retrieval and CUD Operations in N-Tier Applications (LINQ to SQL)](~/docs/framework/data/adonet/sql/linq/data-retrieval-and-cud-operations-in-n-tier-applications.md).  
   
- The following C# snippet shows one use for this method:  
+## Examples
+
+The following example shows one use for this method:
   
-```  
+```csharp
 IEnumerable<Customer> customersWithoutOrders = (from c in db.Customers  
    where c.Orders.Count == 0  
    select c).ToList();  
-  
+
 db.Customers.DeleteAllOnSubmit(customersWithoutOrders);  
 db.SubmitChanges();  
 ```  
   
- In Visual Basic:  
-  
-```  
+```vb
 Dim customersWithoutOrders As IEnumerable(Of Customer) = (From c In db.Customers _   
     Where c.Orders.Count = 0 _   
     Select c).ToList()