Fix class name CoOrds (#544)

Thraka · web-flow · commit 6010947c9c77 · 2019-01-01T17:56:39.000-08:00
diff --git a/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideObjects/CS/Objects.cs b/snippets/csharp/VS_Snippets_VBCSharp/csProgGuideObjects/CS/Objects.cs
@@ -10,17 +10,17 @@ namespace CsCsrefProgrammingObjects
     // but as the framework already includes a POINT structure, this was troublesome
     //-----------------------------------------------------------------------------
     // 05/06/05 Per mblome
-    // Yes, use CoOrds instead of Point everywhere
+    // Yes, use Coords instead of Point everywhere
     //-----------------------------------------------------------------------------
 
 
     //-----------------------------------------------------------------------------
     //<Snippet1>
-    public struct CoOrds
+    public struct Coords
     {
         public int x, y;
 
-        public CoOrds(int p1, int p2)
+        public Coords(int p1, int p2)
         {
             x = p1;
             y = p2;
@@ -32,19 +32,19 @@ public CoOrds(int p1, int p2)
     //-----------------------------------------------------------------------------
     //<Snippet2>
     // Declare and initialize struct objects.
-    class TestCoOrds
+    class TestCoords
     {
         static void Main()
         {
             // Initialize:   
-            CoOrds coords1 = new CoOrds();
-            CoOrds coords2 = new CoOrds(10, 10);
+            Coords coords1 = new Coords();
+            Coords coords2 = new Coords(10, 10);
 
             // Display results:
-            Console.Write("CoOrds 1: ");
+            Console.Write("Coords 1: ");
             Console.WriteLine("x = {0}, y = {1}", coords1.x, coords1.y);
 
-            Console.Write("CoOrds 2: ");
+            Console.Write("Coords 2: ");
             Console.WriteLine("x = {0}, y = {1}", coords2.x, coords2.y);
 
             // Keep the console window open in debug mode.
@@ -53,57 +53,57 @@ static void Main()
         }
     }
     /* Output:
-        CoOrds 1: x = 0, y = 0
-        CoOrds 2: x = 10, y = 10
+        Coords 1: x = 0, y = 0
+        Coords 2: x = 10, y = 10
     */
     //</Snippet2>
 
 
     //-----------------------------------------------------------------------------
     //<Snippet3>
     // Declare a struct object without "new."
-    class TestCoOrdsNoNew
+    class TestCoordsNoNew
     {
         static void Main()
         {
             // Declare an object:
-            CoOrds coords1;
+            Coords coords1;
 
             // Initialize:
             coords1.x = 10;
             coords1.y = 20;
 
             // Display results:
-            Console.Write("CoOrds 1: ");
+            Console.Write("Coords 1: ");
             Console.WriteLine("x = {0}, y = {1}", coords1.x, coords1.y);
 
             // Keep the console window open in debug mode.
             Console.WriteLine("Press any key to exit.");
             Console.ReadKey();
         }
     }
-    // Output: CoOrds 1: x = 10, y = 20
+    // Output: Coords 1: x = 10, y = 20
     //</Snippet3>
 
 
     //-----------------------------------------------------------------------------
-    namespace WrapCoOrds
+    namespace WrapCoords
     {
         //<Snippet4>
-        class CoOrds
+        class Coords
         {
             public int x, y;
 
             // Default constructor:
-            public CoOrds()
+            public Coords()
             {
                 x = 0;
                 y = 0;
             }
 
             //<Snippet76>
             // A constructor with two arguments:
-            public CoOrds(int x, int y)
+            public Coords(int x, int y)
             {
                 this.x = x;
                 this.y = y;
@@ -122,34 +122,34 @@ class MainClass
             static void Main()
             {
                 //<Snippet77>
-                CoOrds p1 = new CoOrds();
-                CoOrds p2 = new CoOrds(5, 3);
+                Coords p1 = new Coords();
+                Coords p2 = new Coords(5, 3);
                 //</Snippet77>
 
                 // Display the results using the overriden ToString method:
-                Console.WriteLine("CoOrds #1 at {0}", p1);
-                Console.WriteLine("CoOrds #2 at {0}", p2);
+                Console.WriteLine("Coords #1 at {0}", p1);
+                Console.WriteLine("Coords #2 at {0}", p2);
                 Console.ReadKey();
             }
         }
         /* Output:
-         CoOrds #1 at (0,0)
-         CoOrds #2 at (5,3)        
+         Coords #1 at (0,0)
+         Coords #2 at (5,3)        
         */
         //</Snippet4>
     }
 
 
     //-----------------------------------------------------------------------------
-    namespace WrapCoOrdsDefaultConstructorOnly
+    namespace WrapCoordsDefaultConstructorOnly
     {
         //<Snippet5>
-        class CoOrds
+        class Coords
         {
             public int x, y;
 
             // constructor
-            public CoOrds()
+            public Coords()
             {
                 x = 0;
                 y = 0;
@@ -178,13 +178,13 @@ public Cylinder(double radius, double height)
             }
             //</Snippet6>
         }
-        class CoOrds
+        class Coords
         {
-            public CoOrds(int x, int y)
+            public Coords(int x, int y)
             {
             }
             //<Snippet7>
-            public CoOrds()
+            public Coords()
                 : this(0, 20)
             {
             }
@@ -580,43 +580,43 @@ static void Main()
 
 
     //-----------------------------------------------------------------------------
-    namespace WrapCoOrds2
+    namespace WrapCoords2
     {
         //<Snippet17>
-        public partial class CoOrds
+        public partial class Coords
         {
             private int x;
             private int y;
 
-            public CoOrds(int x, int y)
+            public Coords(int x, int y)
             {
                 this.x = x;
                 this.y = y;
             }
         }
 
-        public partial class CoOrds
+        public partial class Coords
         {
-            public void PrintCoOrds()
+            public void PrintCoords()
             {
-                Console.WriteLine("CoOrds: {0},{1}", x, y);
+                Console.WriteLine("Coords: {0},{1}", x, y);
             }
 
         }
 
-        class TestCoOrds
+        class TestCoords
         {
             static void Main()
             {
-                CoOrds myCoOrds = new CoOrds(10, 15);
-                myCoOrds.PrintCoOrds();
+                Coords myCoords = new Coords(10, 15);
+                myCoords.PrintCoords();
 
                 // Keep the console window open in debug mode.
                 Console.WriteLine("Press any key to exit.");
                 Console.ReadKey();
             }
         }
-        // Output: CoOrds: 10,15
+        // Output: Coords: 10,15
         //</Snippet17>
     }
 
diff --git a/snippets/csharp/VS_Snippets_VBCSharp/csProgGuidePointers/CS/Pointers.cs b/snippets/csharp/VS_Snippets_VBCSharp/csProgGuidePointers/CS/Pointers.cs
@@ -221,7 +221,7 @@ static void Main()
 
 
 //<Snippet10>
-struct CoOrds
+struct Coords
 {
     public int x;
     public int y;
@@ -231,11 +231,11 @@ class AccessMembers
 {
     static void Main() 
     {
-        CoOrds home;
+        Coords home;
 
         unsafe 
         {
-            CoOrds* p = &home;
+            Coords* p = &home;
             p->x = 25;
             p->y = 12;
 
diff --git a/snippets/csharp/concepts/structs/struct-keyword.cs b/snippets/csharp/concepts/structs/struct-keyword.cs
@@ -1,8 +1,8 @@
-public struct CoOrds
+public struct Coords
 {
     public int x, y;
 
-    public CoOrds(int p1, int p2)
+    public Coords(int p1, int p2)
     {
         x = p1;
         y = p2;

Original file line number	Diff line number	Diff line change
`@@ -10,17 +10,17 @@ namespace CsCsrefProgrammingObjects`
`10`	`10`	`// but as the framework already includes a POINT structure, this was troublesome`
`11`	`11`	`//-----------------------------------------------------------------------------`
`12`	`12`	`// 05/06/05 Per mblome`
`13`		`- // Yes, use CoOrds instead of Point everywhere`
	`13`	`+ // Yes, use Coords instead of Point everywhere`
`14`	`14`	`//-----------------------------------------------------------------------------`
`15`	`15`
`16`	`16`
`17`	`17`	`//-----------------------------------------------------------------------------`
`18`	`18`	`//<Snippet1>`
`19`		`- public struct CoOrds`
	`19`	`+ public struct Coords`
`20`	`20`	`{`
`21`	`21`	`public int x, y;`
`22`	`22`
`23`		`- public CoOrds(int p1, int p2)`
	`23`	`+ public Coords(int p1, int p2)`
`24`	`24`	`{`
`25`	`25`	`x = p1;`
`26`	`26`	`y = p2;`
`@@ -32,19 +32,19 @@ public CoOrds(int p1, int p2)`
`32`	`32`	`//-----------------------------------------------------------------------------`
`33`	`33`	`//<Snippet2>`
`34`	`34`	`// Declare and initialize struct objects.`
`35`		`- class TestCoOrds`
	`35`	`+ class TestCoords`
`36`	`36`	`{`
`37`	`37`	`static void Main()`
`38`	`38`	`{`
`39`	`39`	`// Initialize:`
`40`		`- CoOrds coords1 = new CoOrds();`
`41`		`- CoOrds coords2 = new CoOrds(10, 10);`
	`40`	`+ Coords coords1 = new Coords();`
	`41`	`+ Coords coords2 = new Coords(10, 10);`
`42`	`42`
`43`	`43`	`// Display results:`
`44`		`- Console.Write("CoOrds 1: ");`
	`44`	`+ Console.Write("Coords 1: ");`
`45`	`45`	`Console.WriteLine("x = {0}, y = {1}", coords1.x, coords1.y);`
`46`	`46`
`47`		`- Console.Write("CoOrds 2: ");`
	`47`	`+ Console.Write("Coords 2: ");`
`48`	`48`	`Console.WriteLine("x = {0}, y = {1}", coords2.x, coords2.y);`
`49`	`49`
`50`	`50`	`// Keep the console window open in debug mode.`
`@@ -53,57 +53,57 @@ static void Main()`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`/* Output:`
`56`		`- CoOrds 1: x = 0, y = 0`
`57`		`- CoOrds 2: x = 10, y = 10`
	`56`	`+ Coords 1: x = 0, y = 0`
	`57`	`+ Coords 2: x = 10, y = 10`
`58`	`58`	`*/`
`59`	`59`	`//</Snippet2>`
`60`	`60`
`61`	`61`
`62`	`62`	`//-----------------------------------------------------------------------------`
`63`	`63`	`//<Snippet3>`
`64`	`64`	`// Declare a struct object without "new."`
`65`		`- class TestCoOrdsNoNew`
	`65`	`+ class TestCoordsNoNew`
`66`	`66`	`{`
`67`	`67`	`static void Main()`
`68`	`68`	`{`
`69`	`69`	`// Declare an object:`
`70`		`- CoOrds coords1;`
	`70`	`+ Coords coords1;`
`71`	`71`
`72`	`72`	`// Initialize:`
`73`	`73`	`coords1.x = 10;`
`74`	`74`	`coords1.y = 20;`
`75`	`75`
`76`	`76`	`// Display results:`
`77`		`- Console.Write("CoOrds 1: ");`
	`77`	`+ Console.Write("Coords 1: ");`
`78`	`78`	`Console.WriteLine("x = {0}, y = {1}", coords1.x, coords1.y);`
`79`	`79`
`80`	`80`	`// Keep the console window open in debug mode.`
`81`	`81`	`Console.WriteLine("Press any key to exit.");`
`82`	`82`	`Console.ReadKey();`
`83`	`83`	`}`
`84`	`84`	`}`
`85`		`- // Output: CoOrds 1: x = 10, y = 20`
	`85`	`+ // Output: Coords 1: x = 10, y = 20`
`86`	`86`	`//</Snippet3>`
`87`	`87`
`88`	`88`
`89`	`89`	`//-----------------------------------------------------------------------------`
`90`		`- namespace WrapCoOrds`
	`90`	`+ namespace WrapCoords`
`91`	`91`	`{`
`92`	`92`	`//<Snippet4>`
`93`		`- class CoOrds`
	`93`	`+ class Coords`
`94`	`94`	`{`
`95`	`95`	`public int x, y;`
`96`	`96`
`97`	`97`	`// Default constructor:`
`98`		`- public CoOrds()`
	`98`	`+ public Coords()`
`99`	`99`	`{`
`100`	`100`	`x = 0;`
`101`	`101`	`y = 0;`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`//<Snippet76>`
`105`	`105`	`// A constructor with two arguments:`
`106`		`- public CoOrds(int x, int y)`
	`106`	`+ public Coords(int x, int y)`
`107`	`107`	`{`
`108`	`108`	`this.x = x;`
`109`	`109`	`this.y = y;`
`@@ -122,34 +122,34 @@ class MainClass`
`122`	`122`	`static void Main()`
`123`	`123`	`{`
`124`	`124`	`//<Snippet77>`
`125`		`- CoOrds p1 = new CoOrds();`
`126`		`- CoOrds p2 = new CoOrds(5, 3);`
	`125`	`+ Coords p1 = new Coords();`
	`126`	`+ Coords p2 = new Coords(5, 3);`
`127`	`127`	`//</Snippet77>`
`128`	`128`
`129`	`129`	`// Display the results using the overriden ToString method:`
`130`		`- Console.WriteLine("CoOrds #1 at {0}", p1);`
`131`		`- Console.WriteLine("CoOrds #2 at {0}", p2);`
	`130`	`+ Console.WriteLine("Coords #1 at {0}", p1);`
	`131`	`+ Console.WriteLine("Coords #2 at {0}", p2);`
`132`	`132`	`Console.ReadKey();`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`	`/* Output:`
`136`		`- CoOrds #1 at (0,0)`
`137`		`- CoOrds #2 at (5,3)`
	`136`	`+ Coords #1 at (0,0)`
	`137`	`+ Coords #2 at (5,3)`
`138`	`138`	`*/`
`139`	`139`	`//</Snippet4>`
`140`	`140`	`}`
`141`	`141`
`142`	`142`
`143`	`143`	`//-----------------------------------------------------------------------------`
`144`		`- namespace WrapCoOrdsDefaultConstructorOnly`
	`144`	`+ namespace WrapCoordsDefaultConstructorOnly`
`145`	`145`	`{`
`146`	`146`	`//<Snippet5>`
`147`		`- class CoOrds`
	`147`	`+ class Coords`
`148`	`148`	`{`
`149`	`149`	`public int x, y;`
`150`	`150`
`151`	`151`	`// constructor`
`152`		`- public CoOrds()`
	`152`	`+ public Coords()`
`153`	`153`	`{`
`154`	`154`	`x = 0;`
`155`	`155`	`y = 0;`
`@@ -178,13 +178,13 @@ public Cylinder(double radius, double height)`
`178`	`178`	`}`
`179`	`179`	`//</Snippet6>`
`180`	`180`	`}`
`181`		`- class CoOrds`
	`181`	`+ class Coords`
`182`	`182`	`{`
`183`		`- public CoOrds(int x, int y)`
	`183`	`+ public Coords(int x, int y)`
`184`	`184`	`{`
`185`	`185`	`}`
`186`	`186`	`//<Snippet7>`
`187`		`- public CoOrds()`
	`187`	`+ public Coords()`
`188`	`188`	`: this(0, 20)`
`189`	`189`	`{`
`190`	`190`	`}`
`@@ -580,43 +580,43 @@ static void Main()`
`580`	`580`
`581`	`581`
`582`	`582`	`//-----------------------------------------------------------------------------`
`583`		`- namespace WrapCoOrds2`
	`583`	`+ namespace WrapCoords2`
`584`	`584`	`{`
`585`	`585`	`//<Snippet17>`
`586`		`- public partial class CoOrds`
	`586`	`+ public partial class Coords`
`587`	`587`	`{`
`588`	`588`	`private int x;`
`589`	`589`	`private int y;`
`590`	`590`
`591`		`- public CoOrds(int x, int y)`
	`591`	`+ public Coords(int x, int y)`
`592`	`592`	`{`
`593`	`593`	`this.x = x;`
`594`	`594`	`this.y = y;`
`595`	`595`	`}`
`596`	`596`	`}`
`597`	`597`
`598`		`- public partial class CoOrds`
	`598`	`+ public partial class Coords`
`599`	`599`	`{`
`600`		`- public void PrintCoOrds()`
	`600`	`+ public void PrintCoords()`
`601`	`601`	`{`
`602`		`- Console.WriteLine("CoOrds: {0},{1}", x, y);`
	`602`	`+ Console.WriteLine("Coords: {0},{1}", x, y);`
`603`	`603`	`}`
`604`	`604`
`605`	`605`	`}`
`606`	`606`
`607`		`- class TestCoOrds`
	`607`	`+ class TestCoords`
`608`	`608`	`{`
`609`	`609`	`static void Main()`
`610`	`610`	`{`
`611`		`- CoOrds myCoOrds = new CoOrds(10, 15);`
`612`		`- myCoOrds.PrintCoOrds();`
	`611`	`+ Coords myCoords = new Coords(10, 15);`
	`612`	`+ myCoords.PrintCoords();`
`613`	`613`
`614`	`614`	`// Keep the console window open in debug mode.`
`615`	`615`	`Console.WriteLine("Press any key to exit.");`
`616`	`616`	`Console.ReadKey();`
`617`	`617`	`}`
`618`	`618`	`}`
`619`		`- // Output: CoOrds: 10,15`
	`619`	`+ // Output: Coords: 10,15`
`620`	`620`	`//</Snippet17>`
`621`	`621`	`}`
`622`	`622`
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,7 @@ static void Main()`
`221`	`221`
`222`	`222`
`223`	`223`	`//<Snippet10>`
`224`		`-struct CoOrds`
	`224`	`+struct Coords`
`225`	`225`	`{`
`226`	`226`	`public int x;`
`227`	`227`	`public int y;`
`@@ -231,11 +231,11 @@ class AccessMembers`
`231`	`231`	`{`
`232`	`232`	`static void Main()`
`233`	`233`	`{`
`234`		`- CoOrds home;`
	`234`	`+ Coords home;`
`235`	`235`
`236`	`236`	`unsafe`
`237`	`237`	`{`
`238`		`- CoOrds* p = &home;`
	`238`	`+ Coords* p = &home;`
`239`	`239`	`p->x = 25;`
`240`	`240`	`p->y = 12;`
`241`	`241`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`		`-public struct CoOrds`
	`1`	`+public struct Coords`
`2`	`2`	`{`
`3`	`3`	`public int x, y;`
`4`	`4`
`5`		`- public CoOrds(int p1, int p2)`
	`5`	`+ public Coords(int p1, int p2)`
`6`	`6`	`{`
`7`	`7`	`x = p1;`
`8`	`8`	`y = p2;`