fix issue 1255: Move snippets to the snippets location #2 (#10817)

* fix issue 1255: Move snippets to the snippets location

* fix issue 1255: Move snippets to the snippets location #2

Author: yishengjin1413

docs/csharp/programming-guide/arrays/implicitly-typed-arrays.md

@@ -16,15 +16,15 @@ You can create an implicitly-typed array in which the type of the array instance
 
  The following examples show how to create an implicitly-typed array:  
 
- [!code-csharp[csProgGuideLINQ#37](../../../csharp/programming-guide/arrays/codesnippet/CSharp/implicitly-typed-arrays_1.cs)]  
+ [!code-csharp[csProgGuideLINQ#37](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideLINQ/CS/csRef30LangFeatures_2.cs#37)]  
 
  In the previous example, notice that with implicitly-typed arrays, no square brackets are used on the left side of the initialization statement. Note also that jagged arrays are initialized by using `new []` just like single-dimension arrays.  
 
 ## Implicitly-typed Arrays in Object Initializers
 
  When you create an anonymous type that contains an array, the array must be implicitly typed in the type's object initializer. In the following example, `contacts` is an implicitly-typed array of anonymous types, each of which contains an array named `PhoneNumbers`. Note that the `var` keyword is not used inside the object initializers.  
 
- [!code-csharp[csProgGuideLINQ#38](../../../csharp/programming-guide/arrays/codesnippet/CSharp/implicitly-typed-arrays_2.cs)]  
+ [!code-csharp[csProgGuideLINQ#38](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideLINQ/CS/csRef30LangFeatures_2.cs#38)]  
 
 ## See also
 

docs/csharp/programming-guide/arrays/jagged-arrays.md

@@ -27,11 +27,11 @@ A jagged array is an array whose elements are arrays. The elements of a jagged a
 
  You can also initialize the array upon declaration like this:  
 
- [!code-csharp[csProgGuideArrays#22](../../../csharp/programming-guide/arrays/codesnippet/CSharp/jagged-arrays_4.cs)]  
+ [!code-csharp[csProgGuideArrays#22](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideArrays/CS/Arrays.cs#22)]  
 
  You can use the following shorthand form. Notice that you cannot omit the `new` operator from the elements initialization because there is no default initialization for the elements:  
 
- [!code-csharp[csProgGuideArrays#23](../../../csharp/programming-guide/arrays/codesnippet/CSharp/jagged-arrays_5.cs)]  
+ [!code-csharp[csProgGuideArrays#23](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideArrays/CS/Arrays.cs#23)]  
 
  A jagged array is an array of arrays, and therefore its elements are reference types and are initialized to `null`.  
 

docs/csharp/programming-guide/classes-and-structs/auto-implemented-properties.md

@@ -13,7 +13,7 @@ In C# 3.0 and later, auto-implemented properties make property-declaration more
 ## Example  
  The following example shows a simple class that has some auto-implemented properties:  
 
- [!code-csharp[csProgGuideLINQ#28](../../../csharp/programming-guide/arrays/codesnippet/CSharp/auto-implemented-properties_1.cs)]  
+ [!code-csharp[csProgGuideLINQ#28](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideLINQ/CS/csRef30LangFeatures_2.cs#28)]  
 
  In C# 6 and later, you can initialize auto-implemented properties similarly to fields:  
 

docs/csharp/programming-guide/classes-and-structs/destructors.md

@@ -25,7 +25,7 @@ Finalizers (which are also called **destructors**) are used to perform any neces
 
  For example, the following is a declaration of a finalizer for the `Car` class.
 
- [!code-csharp[csProgGuideObjects#86](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/destructors_1.cs)]  
+ [!code-csharp[csProgGuideObjects#86](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideObjects/CS/Objects.cs#86)]  
 
 A finalizer can also be implemented as an expression body definition, as the following example shows.
 
@@ -75,7 +75,7 @@ protected override void Finalize()
 ## Example  
  The following example creates three classes that make a chain of inheritance. The class `First` is the base class, `Second` is derived from `First`, and `Third` is derived from `Second`. All three have finalizers. In `Main`, an instance of the most-derived class is created. When the program runs, notice that the finalizers for the three classes are called automatically, and in order, from the most-derived to the least-derived.  
 
- [!code-csharp[csProgGuideObjects#85](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/destructors_2.cs)]  
+ [!code-csharp[csProgGuideObjects#85](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideObjects/CS/Objects.cs#85)]  
 
 ## C# language specification  
 

docs/csharp/programming-guide/classes-and-structs/extension-methods.md

@@ -58,7 +58,7 @@ using System.Linq;
 
  When the compiler cannot find an instance method with a matching signature, it will bind to a matching extension method if one exists.  
 
- [!code-csharp[csProgGuideExtensionMethods#5](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/extension-methods_3.cs)]  
+ [!code-csharp[csProgGuideExtensionMethods#5](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideExtensionMethods/cs/extensionmethods.cs#5)]  
 
 ## General Guidelines  
  In general, we recommend that you implement extension methods sparingly and only when you have to. Whenever possible, client code that must extend an existing type should do so by creating a new type derived from the existing type. For more information, see [Inheritance](../../../csharp/programming-guide/classes-and-structs/inheritance.md).  

docs/csharp/programming-guide/classes-and-structs/how-to-define-abstract-properties.md

@@ -27,7 +27,7 @@ The following example shows how to define [abstract](../../../csharp/language-re
 ## Example  
  This file declares the `Shape` class that contains the `Area` property of the type `double`.  
 
- [!code-csharp[csProgGuideInheritance#1](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/how-to-define-abstract-properties_1.cs)]  
+ [!code-csharp[csProgGuideInheritance#1](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideInheritance/CS/Inheritance.cs#1)]  
 
 -   Modifiers on the property are placed on the property declaration itself. For example:  
 

docs/csharp/programming-guide/classes-and-structs/how-to-define-constants.md

@@ -17,7 +17,7 @@ Constants are fields whose values are set at compile time and can never be chang
  To define non-integral constants, one approach is to group them in a single static class named `Constants`. This will require that all references to the constants be prefaced with the class name, as shown in the following example.  
 
 ## Example  
- [!code-csharp[csProgGuideObjects#89](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/how-to-define-constants_1.cs)]  
+ [!code-csharp[csProgGuideObjects#89](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideObjects/CS/Objects.cs#89)]  
 
  The use of the class name qualifier helps ensure that you and others who use the constant understand that it is constant and cannot be modified.  
 

docs/csharp/programming-guide/classes-and-structs/how-to-implement-and-call-a-custom-extension-method.md

@@ -28,7 +28,7 @@ This topic shows how to implement your own extension methods for any .NET type.
 ## Example  
  The following example implements an extension method named `WordCount` in the `CustomExtensions.StringExtension` class. The method operates on the <xref:System.String> class, which is specified as the first method parameter. The `CustomExtensions` namespace is imported into the application namespace, and the method is called inside the `Main` method.  
 
- [!code-csharp[csProgGuideExtensionMethods#1](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/how-to-implement-and-call-a-custom-extension-method_1.cs)]  
+ [!code-csharp[csProgGuideExtensionMethods#1](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideExtensionMethods/cs/extensionmethods.cs#1)]  
 
 ## Compiling the Code  
  To run this code, copy and paste it into a Visual C# console application project that has been created in Visual Studio. By default, this project targets version 3.5 of the [!INCLUDE[dnprdnshort](~/includes/dnprdnshort-md.md)], and it has a reference to System.Core.dll and a `using` directive for System.Linq. If one or more of these requirements are missing from the project, you can add them manually.  

docs/csharp/programming-guide/classes-and-structs/how-to-override-the-tostring-method.md

@@ -31,7 +31,7 @@ Every class or struct in C# implicitly inherits the <xref:System.Object> class.
 
      The following example returns the name of the class in addition to the data specific to a particular instance of the class.  
 
-     [!code-csharp[csProgGuideInheritance#36](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/how-to-override-the-tostring-method_2.cs)]  
+     [!code-csharp[csProgGuideInheritance#36](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideInheritance/CS/Inheritance.cs#36)]  
 
      You can test the `ToString` method as shown in the following code example:  
 

docs/csharp/programming-guide/classes-and-structs/inheritance.md

@@ -29,7 +29,7 @@ Class inheritance
 
  The following example shows how the class relationships demonstrated in the previous illustration are expressed in C#. The example also shows how `WorkItem` overrides the virtual method <xref:System.Object.ToString%2A?displayProperty=nameWithType>, and how the `ChangeRequest` class inherits the `WorkItem` implementation of the method.  
 
- [!code-csharp[csProgGuideInheritance#49](../../../csharp/programming-guide/classes-and-structs/codesnippet/CSharp/inheritance_1.cs)]  
+ [!code-csharp[csProgGuideInheritance#49](~/samples/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideInheritance/CS/Inheritance.cs#49)]  
 
 ## Abstract and Virtual Methods  
  When a base class declares a method as [virtual](../../../csharp/language-reference/keywords/virtual.md), a derived class can [override](../../../csharp/language-reference/keywords/override.md) the method with its own implementation. If a base class declares a member as [abstract](../../../csharp/language-reference/keywords/abstract.md), that method must be overridden in any non-abstract class that directly inherits from that class. If a derived class is itself abstract, it inherits abstract members without implementing them. Abstract and virtual members are the basis for polymorphism, which is the second primary characteristic of object-oriented programming. For more information, see [Polymorphism](../../../csharp/programming-guide/classes-and-structs/polymorphism.md).