/* See also Methods.cs and BaseExamples.cs on when to use a Class versus Struct. * * Value Types are Independent Instances or Copies. Value Change doesn't affect other copies. * Classes versus Structs * { * A struct is a value type where a class is a reference type. Structs cannot have a default constructor. * * All the differences that are applicable to a value type and reference types are also applicable to classes and structs. * * Value types hold their value in memory where they are declared, but reference types hold a reference to an object in * memory. * * Value types are destroyed immediately after the scope is lost, where as for reference types only the reference * variable is destroyed after the scope is lost. The object is later destroyed by garabage collectors. * * When you copy a struct into another struct, a new copy of that struct gets created and modifications on one * struct will not affect the values contained by another struct. * * When you copy a class into another class, we only get a copy of the reference variable. Both the * reference variables point to the same object on the heap. So operations on one variable will affect the values * contained by the other reference variable. * * Structs cannot be declared as protected because structs do not support inheritance. This is another way * of saying Structs are sealed types. * * Structs can't have destructors, but classes can have destructors * * Structs cannot have explicit parameter less constructor where as a class can. * * Structs can't inherit from another class where where as a class can, Both Structs and classes can inherit from * an interface. * * Structs are sealed types. A class or a struct cannot inherit from another struct. * You use sealed keyword to prevent your classes from being inherited by another class. * * Examples of structs in the .NET Framework - int(System.Int32), double(System.Double) etc. * } * * Stack and Heap * { * Physical Memory is divided into a Stack and Heap * * Stack - Values types are stored here. Object Reference Variables are also stored here. * Static Memory Allocation. * * Heap - The place in memory where Object Reference Variables will point to. * Dynamic Memory Allocation. * } * * /* * The 'var' key word indicates implicit typing * string[] colorOptions = new string[4]; Is the same as * var colorOptions = new string[4]; * * The 'var' key word is also useful for complex return types such as Linq since you do not have to figure out * what is being returned. Especially when you don't really care about what is being returned you just want to * iterate through the result. So use the 'var' keyword wherever it makes sense and does not detract from * readablity. * * Reference Types can represent a non-existent value with a null reference. * Value Types cannot represent null values. * * string s = null; - ok, Nullable type * int i = null; - Compile error, value type cannot be null * * Boxing is the act of converting a VALUE type instance to a REFERENCE type * instance. * * int x = 9; * object = x; - box the int * * Unboxing casts the object back to the VALUE type * * int y = (int)obj; // unbox the int * */ public static void Menu() { int x = 0; do { Console.Clear(); Console.WriteLine(" Value Types Menu \n "); Console.WriteLine(" 0. Structs \n "); Console.WriteLine(" 1. Enums \n "); Console.WriteLine(" 2. Numeric \n"); Console.WriteLine(" 3. Char \n"); Console.WriteLine(" 9. Quit \n\n "); Console.Write(" Enter Number to execute Routine "); int selection; selection = Common.readInt("Enter Number to Execute Routine : ", 0, 9); switch (selection) { case 0: Struct1.Menu(); Console.ReadKey(); break; case 1: ExamLibrary.CreateAndUseTypes.EnumTest.EnumMain(); break; case 9: x = 9; break; default: Console.WriteLine(" Invalid Number"); break; } } while (x < 9); }
public static void Menu() { int x = 0; do { /* * Every method has zero or more parameters * Use params keyword to accept a variable number of parameters * The params parameter must be the last parameter in a parameter list * The params keyworkd must be applied to an array modifiers. * The params parameter must always be the last modifier. * * Example * private void WriteDebug(string message, params object[] objects) * { * Debug.WriteLine(message); * foreach (var o in objects) * { * Debug.WriteLine(o); * } * * } * */ Console.Clear(); Console.WriteLine(" Methods Menu \n "); Console.WriteLine(" 0. Constructors and Finalizers \n "); Console.WriteLine(" 1. Overloading \n "); Console.WriteLine(" 2. Parameters and Extension Methods\n"); Console.WriteLine(" 3. ... \n"); Console.WriteLine(" 4. User Defined Conversions \n"); Console.WriteLine(" 5. ...."); Console.WriteLine(" 6. GetProperty Method \n"); Console.WriteLine(" 7. Class versus Struct \n"); Console.WriteLine(" 9. Quit \n\n "); Console.Write(" Enter Number to execute Routine "); eMenu selection = (eMenu)(Common.readInt("Enter Number to Execute Routine : ", 0, 9)); switch (selection) { case eMenu.ConstructorsandFinalizers: ConstructorsFinalizers(); break; case eMenu.Overloading: overloadingsub(); break; case eMenu.Parameters: Parameters(); break; //case eMenu.Pinvoke: // PreProcessing(); // break; //case eMenu.EnumerableMethods: // EnumerableMethods.Menu(); // Console.ReadKey(); // break; case eMenu.GetPropertyMethods: MyTypeClass.MainMTC(); Console.ReadKey(); break; case eMenu.ClassVsStruct: // TestClassAndStruct.TCAS_Main(); Struct1.Menu(); Console.ReadKey(); break; case eMenu.Quit: x = 9; break; default: Console.WriteLine(" Invalid Number"); break; } } while (x < 9); } // End Menu