C# Learning Based On The Book illustrated C#7(Fifth Edition)

/*
Core:
•	Declaring a class
•	Creating instances of the class
•	Accessing the class members (that is, writing to a field and reading from a field)
Output:
•	t1:76,57,66
*/
using System;

namespace Anonymous
{
    class DaysTemp              //Declare the class
    {
        public int High,Low;    //Declare the instance fields
        public int Average()    //Declare the insntance method
        {
            return (High+Low)/2;//We use int as the return type, so the decimal part is ignored if there is a decimal
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //Create one instances of DaysTemp
            DaysTemp t1 = new DaysTemp();
            //Write to the fields of each instance
            t1.High = 76;
            t1.Low = 57;
            //Read from the fields of the instance and call a meathod of the instance 
            Console.WriteLine($"t1:{t1.High},{t1.Low},{t1.Average()}");
        }
    }
}

/*
Core: Value Parameters
Analysis:
•	Before the method call, variables a1 and a2, which will be used as the actual
parameters, are already on the stack.
•	By the beginning of the method, the system will have allocated space on the stack for
the formal parameters and copied the values from the actual parameters.
        – Since a1 is a reference type, the reference is copied, resulting in both the actual
and formal parameters referring to the same object in the heap.
        – Since a2 is a value type, the value is copied, producing an independent data item.
•	At the end of the method, both f2 and the field of object f1 have been incremented by 5.
        – After method execution, the formal parameters are popped off the stack.
        – The value of a2, the value type, is unaffected by the activity in the method.
        – The value of a1, the reference type, however, has been changed by the activity
in the method.
Output:
•   f1.Val: 25, f2: 15
•   a1.Val: 25, a2: 10
*/
using System;

namespace Anonymous
{
    class MyClass
    {
        public int Val = 20; // Initialize the field to 20.
    }
    class Program 
    {
        static void MyMethod( MyClass f1, int f2 )
        {
            f1.Val = f1.Val + 5; // Add 5 to field of f1 param.
            f2 = f2 + 5; // Add 5 to second param.
            Console.WriteLine($"f1.Val: { f1.Val }, f2: { f2 }");
        }
        static void Main()
        {
            MyClass a1 = new MyClass();
            int a2 = 10;
            MyMethod( a1, a2 ); // Call the method.
            Console.WriteLine($"a1.Val: { a1.Val }, a2: { a2 }");
        }
    }
}

/*
Core: Reference Parameters
Analysis:
•	 Before the method call, variables a1 and a2, which will be used as the actual
parameters, are already on the stack.
•	 By the beginning of the method, the names of the formal parameters will have been
set as aliases for the actual parameters. Variables a1 and f1 reference the same
memory location, and a2 and f2 also reference the same memory location.
•	 At the end of the method, both f2 and the field of the object of f1 have been
incremented by 5.
•	 After method execution, the names of the formal parameters are gone (“out of
scope”), but both the value of a2, which is the value type, and the value of the
object pointed at by a1, which is the reference type, have been changed by the
activity in the method.
Output:
•   f1.Val: 25, f2: 15
•   a1.Val: 25, a2: 10
*/
using System;

namespace Anonymous
{
    class MyClass
    {
        public int Val = 20; // Initialize the field to 20.
    }
    class Program 
    {
        static void MyMethod(ref MyClass f1,ref int f2)
        {
            f1.Val = f1.Val + 5; // Add 5 to field of f1 param.
            f2 = f2 + 5; // Add 5 to second param.
            Console.WriteLine($"f1.Val: { f1.Val }, f2: { f2 }");
        }
        static void Main()
        {
            MyClass a1 = new MyClass();
            int a2 = 10;
            MyMethod(ref a1,ref a2); // Call the method.
            Console.WriteLine($"a1.Val: { a1.Val }, a2: { a2 }");
        }
    }
}

/*
Core: Output Parameters
Analysis:
•	 Before the method call, variables a1 and a2, which will be used as the actual
parameters, are already on the stack.
•	 At the beginning of the method, the names of the formal parameters are set as aliases
for the actual parameters. Therefore, variables a1 and f1 reference the same memory
location, and a2 and f2 also reference the same memory location. The names a1 and
a2 are out of scope and cannot be accessed from inside MyMethod.
•	 Inside the method, the code creates an object of type MyClass and assigns it to f1. It
then assigns a value to f1’s field and also assigns a value to f2. The assignments to f1
and f2 are both required since they’re output parameters.
•	 After method execution, the names of the formal parameters are out of scope, but
the values of both a1, the reference type, and a2, the value type, have been changed
by the activity in the method.
Output:
•	 After method call: a1:25 a2:15
*/
using System;

namespace Anonymous
{
    class MyClass
    {
        public int Val = 20; // Initialize the field to 20.
    }
    class Program 
    {
        static void MyMethod(out MyClass f1,out int f2)
        {
            f1 = new MyClass();
            f1.Val = 25;
            f2 = 15;
        }
        static void Main( )
        {
            MyClass a1 = null;
            int a2;
            MyMethod(out a1,out a2);
			//In the C#7,you can institute the three line with MyMethod(out MyClass a1,out int a2);
            Console.WriteLine($"After method call: a1:{a1.Val} a2:{a2}");
        }
    }
}

/*
Core: Reference Types As Value Parameters
Analysis:
•	 Passing a reference type object as a value parameter: If you create a new object inside
the method and assign it to the formal parameter, it breaks the connection between
the formal parameter and the actual parameter, and the new object does not persist
after the method call.
•	 At the beginning of the method, both the actual parameter and the formal parameter
point to the same object in the heap.
•	 After the assignment to the object’s member, they still point at the same object in
the heap.
•	 When the method allocates a new object and assigns it to the formal parameter, the
actual parameter (outside the method) still points at the original object, and the
formal parameter points at the new object.
•	 After the method call, the actual parameter points to the original object, and the
formal parameter and new object are gone.
Output:
•	 Before method call: 20
•	 After member assignment: 50
•	 After new object creation: 20
•	 After method call: 50
*/
using System;

namespace Anonymous
{
    class MyClass
    {
        public int Val = 20; // Initialize the field to 20.
    }
    class Program 
    {
        static void RefAsParameter( MyClass f1 )
        {
            f1.Val = 50;
            Console.WriteLine($"After member assignment: { f1.Val }");
            f1 = new MyClass();
            Console.WriteLine($"After new object creation: { f1.Val }");
        }
        static void Main( )
        {
            MyClass a1 = new MyClass();
            Console.WriteLine($"Before method call: { a1.Val }");
            RefAsParameter( a1 );
            Console.WriteLine($"After method call: { a1.Val }");
        }
    }
}

/*
Core: Reference Types As Reference Parameters
Analysis:
•	 Passing a reference type object as a reference parameter: If you create a new object
inside the method and assign it to the formal parameter, that new object persists
after the method is ended and is the value referenced by the actual parameter.
•	 At the beginning of the method, both the actual parameter and the formal parameter
point to the same object in the heap.
•	 After the assignment to the object’s member, they still point at the same object in
the heap.
•	 When the method allocates a new object and assigns it to the formal parameter, the
actual parameter (outside the method) still points at the original object, and the
formal parameter points at the new object.
•	 After the method call, the actual parameter points to the original object, and the
formal parameter and new object are gone.
Output:
•	 Before method call: 20
•	 After member assignment: 50
•	 After new object creation: 20
•	 After method call: 20
*/
using System;

namespace Anonymous
{
    class MyClass
    {
        public int Val = 20; // Initialize the field to 20.
    }
    class Program 
    {
        static void RefAsParameter( ref MyClass f1 )
        {
            f1.Val = 50;
            Console.WriteLine($"After member assignment: { f1.Val }");
            f1 = new MyClass();
            Console.WriteLine($"After new object creation: { f1.Val }");
        }
        static void Main( )
        {
            MyClass a1 = new MyClass();
            Console.WriteLine($"Before method call: { a1.Val }");
            RefAsParameter( ref a1 );
            Console.WriteLine($"After method call: { a1.Val }");
        }
    }
}

/*
Core: Properties and Associated Fields
Analysis:
The implicit parameter value in the set accessor is a normal value parameter. Like other value
parameters, you can use it to send data into a method body—or in this case, the accessor block. Once inside
the block, you can use value like a normal variable, including assigning values to it.
Other important points about accessors are the following:
•	 All paths through the implementation of a get accessor must include a return
statement that returns a value of the property type.
•	 The set and get accessors can be declared in either order, and no methods other
than the two accessors are allowed on a property.
Output:
•	 MyValue:10
•	 MyValue:20
*/
using System;

namespace Anonymous
{
    class C1
    {
        private int _myValue = 10;//Backing Field:memory allocated
        public int MyValue//Property:no memory allocated
        {
            set{_myValue = value;}//Sets the value of field theRealValue
            get{return _myValue;}//Gets the value of the field
        }
    }
    class Program 
    {

        static void Main( )
        {
            C1 c = new C1();
            //Read from the property as if it were a field
            Console.WriteLine("MyVlaue:{0}",c.MyValue);

            c.MyValue = 20;
            //Use assignment to set the value of a property
            Console.WriteLine("MyValue:{0}",c.MyValue);
        }
    }
}

/*
Core: Static Properties
Analysis:
•	 They cannot access instance members of a class—although they can be accessed
by them.
•	 They exist regardless of whether there are instances of the class.
•	 From inside the class, you reference the static property using just its name.
•	 From outside the class, you must reference the property either using its class name
or using the using static construct, as described earlier in this chapter.
Output:
•	 Init Value:0
•	 New Value:10
•	 New Value:20
•	 Value from inside:20
*/
using System;
using static Anonymous.Trivial;
namespace Anonymous
{
    class Trivial
    {
        public static int MyValue
        {
            get;//auto-properties
            set;//auto-properties
        }
        public void PrintValue()
        {
            Console.WriteLine("Value from inside:{0}",MyValue);
        }
    }
    class Program 
    {

        static void Main( )
        {
            Console.WriteLine("Init Value:{0}",Trivial.MyValue);//Read from outside the class
            Trivial.MyValue = 10;//Write from outside the class
            Console.WriteLine("New Value:{0}",Trivial.MyValue);//Read from outside the class

            MyValue =20;//Write from outside the class,but no class beacause of using static
            Console.WriteLine($"New Value:{MyValue}");

            Trivial tr = new Trivial();
            tr.PrintValue();
            //From the result,we can see Class's static members occupy only the same area in memory
        }
    }
}

/*
Core: Static Constructor
Analysis:
•	 The constructor is used to "assign values to the initialization of an object"
Output:
•	 Next Random #: 47857058
•	 Next Random #: 47857058
*/
using System;
namespace Anonymous
{
	class RandomNumberClass
	{
		private static Random RandomKey; // Private static field
		static RandomNumberClass() // Static constructor
		{
			RandomKey = new Random(); // Initialize RandomKey
		}
		public int GetRandomNumber()
		{
			return RandomKey.Next();
		}
	}
	class Program
	{
		static void Main()
		{
			RandomNumberClass a = new RandomNumberClass();
			RandomNumberClass b = new RandomNumberClass();
			Console.WriteLine("Next Random #: {0}", a.GetRandomNumber());
			Console.WriteLine($"Next Random #: { b.GetRandomNumber() }");
		}
	}
}

/*
Core: Declare an indexer
Analysis:
•	 The indexer must read and write values of type string—so string must be declared
as the indexer’s type. It must be declared public so that it can be accessed from
outside the class.
•	 The three fields in the example have been arbitrarily indexed as integers 0 through 2, so
the formal parameter between the square brackets, named index in this case, must
be of type int.
•	 In the body of the set accessor, the code determines which field the index refers to
and assigns the value of implicit variable value to it. In the body of the get accessor,
the code determines which field the index refers to and returns that field’s value.
Output:
•	 Person LastName:Doe,FirstName:Jane,CityOfBirth:Dallas
*/
using System;
namespace Anonymous
{
	class Employee
	{
		private string LastName;
		private string FirstName;
		private string CityOfBirth;
		public string this[int index]
		{
			set
			{
				switch(index)
				{
					case 0:LastName = value;break;
					case 1:FirstName = value;break;
					case 2:CityOfBirth = value;break;
					default: throw new ArgumentOutOfRangeException("index");
				}
			}
			get
			{
				switch(index)
				{
					case 0: return LastName;
					case 1:return FirstName;
					case 2:return CityOfBirth;
					default:throw new ArgumentOutOfRangeException("index");
				}
			}
		}
	}
	class Program
	{
		static void Main()
		{
			Employee Person = new Employee();
			Person[0] = "Doe";
			Person[1] = "Jane";
			Person[2] = "Dallas";
			Console.WriteLine($"Person LastName:{Person[0]},FirstName:{Person[1]},CityOfBirth:{Person[2]}");
		}
	}
}

/*
Core: Mask Members of a Base Class+Base Access+Cast to base class
Analysis:
•	 To mask an inherited data member, declare a new member of the same type and
with the same name.
•	 To mask an inherited function member, declare a new function member with the
same signature. Remember that the signature consists of the name and parameter
list but does not include the return type.
•	 To let the compiler know that you’re purposely masking an inherited member, use
the new modifier. Without it, the program will compile successfully, but the compiler
will warn you that you’re hiding an inherited member.
•	 You can also mask static members.
Output:
•	 Field1 -- In the derived class
•	 Field1 -- In the base class
•	 Field1 -- In the base class
*/
using System;
namespace Anonymous
{
	class SomeClass
	{
		public string Field1 = "Field1 -- In the base class";
		public void PrintField1()
		{
			Console.WriteLine(Field1);
		}
	}
	class OtherClass : SomeClass 
	{
		new public string Field1 = "Field1 -- In the derived class";
		new public void PrintField1()
		{
			Console.WriteLine(Field1);
		}
		public void PrintBaseField1()
		{
			Console.WriteLine(base.Field1);//To an elegant program,wo need to use 'base' less.
		}	
	}
	class Program
	{
		static void Main()
		{
			OtherClass oc =  new OtherClass();
			SomeClass a = (SomeClass)oc;//cast to base class
			oc.PrintField1();
			oc.PrintBaseField1();
			a.PrintField1();
		}
	}
}

/*
Core: Override a Method+Distingish between 'new' and 'override'
Analysis:
•	 When you use a reference to the base class part of an object to call an overridden
method, the method call is passed up the derivation hierarchy for execution to the
most derived version of the method marked as override.
•	 If there are other declarations of the method at higher levels of derivation that are
not marked as override, they are not invoked.
Output:
•	 Override:This is the second derived class
•	 Override:This is the second derived class
•	 New:This is the second derived class
•	 This is the derived class
*/
using System;
namespace Anonymous
{
	class MyBaseClass
	{
		virtual public void Print()
		{
			Console.WriteLine("This is the base class");
		}
	}
	class MyDerivedClass : MyBaseClass
	{
		override public void Print()
		{
			Console.WriteLine("This is the derived class");
		}
	}
	class SecondDerived1 : MyDerivedClass
	{
		override public void Print()
		{
			Console.WriteLine("Override:This is the second derived class");
		}
	}
		class SecondDerived2 : MyDerivedClass
	{
		new public void Print()
		{
			Console.WriteLine("New:This is the second derived class");
		}
	}
	class Program
	{
		static void Main()
		{
			SecondDerived1 derived1 = new SecondDerived1();
			MyBaseClass mybc1 = (MyBaseClass)derived1;

			derived1.Print();
			mybc1.Print();
			/*********************************************/
			SecondDerived2 derived2 = new SecondDerived2();
			MyBaseClass mybc2 = (MyBaseClass)derived2;

			derived2.Print();
			mybc2.Print();
		}
	}
}

/*
Core: Abstract Classes And Abstract Methods
Analysis:
•	 It must be a function member. That is, fields and constants cannot be abstract
members.
•	 It must be marked with the abstract modifier.
•	 It must not have an implementation code block. The code of an abstract member is
represented by a semicolon.
•	 You cannot create instances of an abstract class.
•	 An abstract class is declared using the abstract modifier.
Output:
•	 This is a string.
•	 28
•	 Perimeter Length: 30
*/
using System;
namespace Anonymous
{
	abstract class MyBase
	{
		public int SideLength = 10;//The data member-fields and constants
		const int TriangleSideCount = 3;//-cannot be declared as abstract
		abstract public void PrintStuff(string s);//Abstact method:It must not have an implementation code block
		abstract public int MyInt{get;set;}//Abstract property
		public int PerimeterLength()
		{
			return TriangleSideCount * SideLength;
		}
	}
	class MyClass : MyBase
	{
		public override void PrintStuff(string s)//Override abstract method
		{
			Console.WriteLine(s);
		}
		private int _myInt;
		public override int MyInt//Override abstract property
		{
			get
			{
				return _myInt;
			}
			set
			{
				_myInt = value;
			}
		}
	}
	class Program
	{
		static void Main(string[] args)
		{
			// MyBase oc = new MyBase(); //Error.Cannot instantiate an abstract class
			MyClass mc = new MyClass();
			mc.PrintStuff("This is a string.");
			mc.MyInt = 28;
			Console.WriteLine(mc.MyInt);
			Console.WriteLine($"Perimeter Length:{mc.PerimeterLength()}");//Inheritance
		}
	}
}

/*
Core: User-Defined Type Conversions
Analysis:
•	 The public and static modifiers are required for all user-defined conversions.
•	 C# provides implicit and explicit conversions.
– With an implicit conversion, the compiler automatically makes the conversion,
if necessary, when it is resolving what types to use in a particular context.
– With an explicit conversion, the compiler will make the conversion only when
an explicit cast operator is used.
Output:
•	 li:100,value:100
*/
using System;
namespace Anonymous
{
	class LimitedInt
	{
		const int MaxValue = 100;
		const int MinValue = 0;
		private int mTheValue = 0;
		public int TheValue//Property:Convert rules
		{
			get
			{
				return mTheValue;
			}
			set
			{
				if(value < MinValue)
					mTheValue = 0;
				else
					mTheValue = value > MaxValue
									? MaxValue
									: value;
			}
		}
		public static implicit operator int(LimitedInt li)//Convert to int type
		{
			return li.TheValue;
		}
		public static implicit operator LimitedInt(int x)//Convert to LimitedInt type
		{
			LimitedInt li = new LimitedInt();
			li.TheValue = x;
			return li;
		}
	}
	
	class Program
	{
		static void Main(string[] args)
		{
			LimitedInt li = 500;//Convert 500 to LimitedInt
			int value = li;//Convert LImitedInt to int
			Console.WriteLine($"li:{li.TheValue},value:{value}");
		}
	}
}

/*
Core: User-Defined Type Conversions
Analysis:
•	 The public and static modifiers are required for all user-defined conversions.
•	 C# provides implicit and explicit conversions.
– With an implicit conversion, the compiler automatically makes the conversion,
if necessary, when it is resolving what types to use in a particular context.
– With an explicit conversion, the compiler will make the conversion only when
an explicit cast operator is used.
Output:
•	 li:100,value:100
*/
using System;
namespace Anonymous
{
	class LimitedInt
	{
		const int MaxValue = 100;
		const int MinValue = 0;
		private int mTheValue = 0;
		public int TheValue//Property:Convert rules
		{
			get
			{
				return mTheValue;
			}
			set
			{
				if(value < MinValue)
					mTheValue = 0;
				else
					mTheValue = value > MaxValue
									? MaxValue
									: value;
			}
		}
		public static explicit operator int(LimitedInt li)//Convert to int type
		{
			return li.TheValue;
		}
		public static explicit operator LimitedInt(int x)//Convert to LimitedInt type
		{
			LimitedInt li = new LimitedInt();
			li.TheValue = x;
			return li;
		}
	}
	
	class Program
	{
		static void Main(string[] args)
		{
			LimitedInt li = (LimitedInt)500;//Convert 500 to LimitedInt
			int value = (int)li;//Convert LImitedInt to int
			Console.WriteLine($"li:{li.TheValue},value:{value}");
		}
	}
}

/*
Core: Operator Overloading
Analysis:
•	 Operator overloading is available only for classes and structs.
•	 You can overload an operator x for use with your class or struct by declaring a
method named operator x that implements the behavior (for example, operator +,
operator -, and so on).
– The overload methods for unary operators take a single parameter of the class
or struct type.
– The overload methods for binary operators take two parameters, at least one of
which must be of the class or struct type.
Output:
•	 li1:10,li2:100
•	 li3:0
•	 li3:90
•	 li3:0
•	 li3:20
*/
using System;
namespace Anonymous
{
	class LimitedInt
	{
		const int MaxValue = 100;
		const int MinValue = 0;
		public static LimitedInt operator -(LimitedInt x)
		{
			//In this strange class,negating a value just sets its value to 0.
			LimitedInt li = new LimitedInt();
			li.TheValue = 0;
			return li;
		}
		public static LimitedInt operator -(LimitedInt x,LimitedInt y)
		{
			LimitedInt li = new LimitedInt();
			li.TheValue = x.TheValue - y.TheValue;
			return li;
		}
		public static LimitedInt operator +(LimitedInt x,double y)
		{
			LimitedInt li = new LimitedInt();
			li.TheValue = x.TheValue + (int)y;
			return li;
		}
		private int _theValue = 0;
		public int TheValue
		{
			/*
			Scenario one:we use the default setting
			set;
			get;
			*/
			get{return _theValue;}
			set
			{
				if(value < MinValue)
					_theValue = 0;
				else
					_theValue = value > MaxValue
									? MaxValue
									: value;
			}
		}
	}
	
	class Program
	{
		static void Main(string[] args)
		{
			LimitedInt li1 = new LimitedInt();
			LimitedInt li2 = new LimitedInt();
			LimitedInt li3 = new LimitedInt();
			double plusnumber = 10.0;
			/*
			Scenario one:we can see the output "li1:0,li2:100"
			li1.TheValue =-10;
			li2.TheValue =101;
			Console.WriteLine($"li1:{li1.TheValue},li2:{li2.TheValue}");
			*/
			li1.TheValue =10;
			li2.TheValue =101;
			Console.WriteLine($"li1:{li1.TheValue},li2:{li2.TheValue}");

			li3 = -li1;
			Console.WriteLine($"li3:{li3.TheValue}");

			li3 = li2 - li1;//Properity:larger than 0 lower than 100 set the real value
			Console.WriteLine($"li3:{li3.TheValue}");

			li3 = li1 - li2;//Properity:lower than 0 set 0
			Console.WriteLine($"li3:{li3.TheValue}");

			li3 = li1 + plusnumber;//Properity:larger than 0 lower than 100 set the real value
			Console.WriteLine($"li3:{li3.TheValue}");


		}
	}
}

/*
Core: The Using Statement
Analysis:
•	 The standard way of handling the possibility of exceptions is to place the code that might cause an exception in a try block
and place any code that must be executed, whether or not there is an exception, into a finally block.
•	 Allocating the resource
•	 Placing Statement in a try block
•	 Creating a call to the resource’s Dispose method and placing it in a finally block
Output:
•	 Four score and seven years ago,...
*/
using System; //Using directive,not using statement;
using System.IO;
namespace Anonymous
{
	class Program
	{
		static void Main()
		{
			//using statement
			using (TextWriter tw = File.CreateText("Lincoln.txt"))
			{
				tw.WriteLine("Four score and seven years ago,...");
			}
			//using statement
			using (TextReader tr = File.OpenText("Lincoln.txt"))
			{
				string InputString;
				while(null!=(InputString = tr.ReadLine()))
					Console.WriteLine(InputString);
			}
		}
	}
}

/*
Core: Differece Between Struct And Class
Analysis:
•	 Classes are reference types, and structs are value types.
•	 Structs are implicitly sealed, which means they cannot be derived from.
•	 A variable of a struct type cannot be null.
•	 Two struct variables cannot refer to the same object
Output:
•	 Class Initialize:cs1.X:0,CS1.Y:0
•	 Stuct Initialize:ss1.X:0,ss1.Y:0,ss2.X:0,ss2.Y:0
•	 Reference Type Pointer:cs1.X:5,cs1.Y:10,cs2.X:5,cs1.Y:10
•	 Value Type Copy:ss1.X:5,ss1.Y:10,ss2.X:5,ss2.Y:10
*/
using System; //Using directive,not using statement;
using System.IO;
namespace Anonymous
{
	class CSimple
	{
		public int X,Y;
	}
	struct Simple
	{
		public int X,Y;
	}
	class Program
	{
		static void Main()
		{
			/*
			we can assign 'null' to the reference types,
			but in the following code if we want to use it,we must point the 'null pointer' to the specific place;
			*/
			CSimple cs1 = new CSimple(),cs2=null;
			Console.WriteLine($"Class Initialize:cs1.X:{cs1.X},cs1.Y:{cs1.Y}");
			//Console.WriteLine($"Class Initialize:cs2.X:{cs2.X},cs2.Y:{cs2.Y}");
			//This will cause errors:because cs2 Object reference not set to an instance of an object
			/* 
			We should know the truth ,we use 'new' to initialize the struct,
			system will automaticly assign initial value to struct variable,such as
			ss1.X=0;ss1.Y=0;ss2.X=0;ss2.Y=0;If we do not initialize the initial value,
			we can not use the struct variable.
			*/
			Simple ss1 = new Simple(),ss2 = new Simple();
		    Console.WriteLine($"Struct Initialize:ss1.X:{ss1.X},ss1.Y:{ss1.Y},ss2.X:{ss2.X},ss2.Y:{ss2.Y}");

			cs1.X = ss1.X = 5;
			cs1.Y = ss1.Y = 10;
			Console.WriteLine($"Assign Value:ss1.X:{ss1.X},ss1.Y:{ss1.Y},cs1.X:{cs1.X},cs1.Y:{cs1.Y}");

			cs2 = cs1;//The pointer points to the heap where CS1 resides.
			Console.WriteLine($"Reference Type Pointer:cs1.X:{cs1.X},cs1.Y:{cs1.Y},cs2.X:{cs2.X},cs1.Y:{cs2.Y}");
			ss2 = ss1;//The struct variables of ss1 are copied to SS2
			Console.WriteLine($"Value Type Copy:ss1.X:{ss1.X},ss1.Y:{ss1.Y},ss2.X:{ss2.X},ss2.Y:{ss2.Y}");	
		}
	}
}

/*
Core: Using Bit Flags
Analysis:
•    If somewhere do not understand,read the book Chapter Enum
Output:
•	 Option settings:
•	 Use Single Deck - True
•	 Use Large Pictures - False
•	 Use Fancy Numbers - True
•	 Use Animation - True
•	 Use Animation and FancyNumbers - False
*/
using System; //Using directive,not using statement;
using System.IO;
namespace Anonymous
{
	[Flags]
	enum CardDeckSettings:uint
	{
		SingleDeck = 0x01, //bit 0
		LargePictures = 0x02,//bit 1
		FancyNumbers = 0x04,//bit 2
		Animation = 0x08 //bit 3
	}
	class MyClass
	{
		bool UseSingleDeck = false,
			UseLargePictures = false,
			UseFancyNumbers = false,
			UseAnimation = false,
			UseAnimationAndFancyNumbers = false;
		public void SetOptions(CardDeckSettings ops)
		{
			UseSingleDeck = ops.HasFlag(CardDeckSettings.SingleDeck);
			UseLargePictures = ops.HasFlag(CardDeckSettings.LargePictures);
			UseFancyNumbers = ops.HasFlag(CardDeckSettings.FancyNumbers);
			UseAnimation = ops.HasFlag(CardDeckSettings.Animation);
			CardDeckSettings testFlags = CardDeckSettings.Animation | CardDeckSettings.FancyNumbers;
			UseAnimationAndFancyNumbers = ops.HasFlag(testFlags);
		}
		public void PrintOptions()
		{
			Console.WriteLine("Option settings:");
			Console.WriteLine($"Use Single Deck - {UseSingleDeck}");
			Console.WriteLine($"Use Large Pictures - {UseLargePictures}");
			Console.WriteLine($"Use Fancy Numbers - {UseFancyNumbers}");
			Console.WriteLine($"Use Animation - {UseAnimation}");
			Console.WriteLine($"Use Animation and FancyNumbers - {UseAnimationAndFancyNumbers}");
		}
	}
	class Program
	{
		static void Main()
		{
			MyClass mc = new MyClass();
			CardDeckSettings ops = CardDeckSettings.SingleDeck | CardDeckSettings.FancyNumbers;
			mc.SetOptions(ops);
			mc.PrintOptions();
				
		}
	}
}

/*
Core: Subarrays in Jagged Arrays
Analysis:
•    If somewhere do not understand,read the book Chapter Array
Output:
•	 ArrOption settings:
•	 Arr[0][0,0] = 10
•	 Arr[0][0,1] = 20
•	
•	 Arr[0][1,0] = 100
•	 Arr[0][1,1] = 200
•	
•	 Arr[1][0,0] = 30
•	 Arr[1][0,1] = 40
•	 Arr[1][0,2] = 50
•	
•	 Arr[1][1,0] = 300
•	 Arr[1][1,1] = 400
•	 Arr[1][1,2] = 500
•	
•	 Arr[2][0,0] = 60
•	 Arr[2][0,1] = 70
•	 Arr[2][0,2] = 80
•	 Arr[2][0,3] = 90
•	
•	 Arr[2][1,0] = 600
•	 Arr[2][1,1] = 700
•	 Arr[2][1,2] = 800
•	 Arr[2][1,3] = 900
*/
using System; 
namespace Anonymous
{
	
		class Program
	{
		static void Main()
		{
			int[][,] Arr;  //Declare an array of 2D arrays
			Arr = new int[3][,];//Instantiate an array of three 2D arrays
			Arr[0]= new int[,]{{10,20},{100,200}};
			Arr[1]= new int[,]{{30,40,50},{300,400,500}};
			Arr[2]= new int[,]{{60,70,80,90},{600,700,800,900}};
			//Get length of dimension 0 of Arr,in this Arr.GetLength(0)=3
			for (int i = 0;i < Arr.GetLength(0);i++)
			{   //Get length of dimension 0 of Arr[i],in this  Arr[0].GetLength(0)=2;Arr[1].GetLength(0)=2;Arr[2].GetLength(0)=2
				for (int j = 0; j < Arr[i].GetLength(0);j++)
				{	//Get length of dimension 1 of Arr[i],in this  Arr[0].GetLength(1)=2;Arr[1].GetLength(1)=3;Arr[2].GetLength(1)=4
					for (int k = 0; k < Arr[i].GetLength(1);k++)
					{
						Console.WriteLine($"Arr[{i}][{j},{k}] = {Arr[i][j,k]}");
					}
					Console.WriteLine(" ");
				}
				Console.WriteLine(" ");
			}	
		}
	}
}

/*
Core: Delegate Example
Analysis:
The following code defines and uses a delegate with no parameters and no return value. Note the following
about the code:
•	 Class Test defines two print functions.
•	 Method Main creates an instance of the delegate and then adds three more methods.
•	 The program then invokes the delegate, which calls its methods. Before invoking the
delegate, however, it checks to make sure it’s not null.
Output:
•	 Print1 -- instance
•	 Print2 -- static
•	 Print1 -- instance
•	 Print2 -- static
*/
using System; 
namespace Anonymous
{
	//Define a delegate type with no return value and no parameters.
	delegate void PrintFunction();
	class Test
	{
		public void Print1()
		{
			Console.WriteLine("Print1 -- instance");
		}
		public static void Print2()
		{
			Console.WriteLine("Print2 -- static")
		}
	}
		class Program
	{
		static void Main()
		{
			Test t = new Test();//Create a test class instance
			PrintFunction pf;//Create a null delegate

			pf = t.Print1; //Instantiate and initialize the delegate

			//Add three more methods to the delegate
			pf += Test.Print2;
			pf += t.Print1;
			pf += Test.Print2;
			//The delegate now contains four methods
			if(null != pf)//Make sure the delegate isn't null
				pf();//Invoke the delegate
			else
				Console.WriteLine("Delegate is empty");
	
		}
	}
}

/*
Core: Nonstandard Event Usage
Analysis:
•	 In its constructor, class Dozens subscribes to the event, supplying method
IncrementDozensCount as its event handler.
•	 In method DoCount in class Incrementer, event CountedADozen is raised each time
the method increments another 12 times.
Output:
•	 Number of dozens = 8
*/
using System; 
namespace Anonymous
{
	delegate void Handler(); //1.Delegate Type Declaration

	/*****Pbulisher******/
	class Incrementer
	{
		public event Handler CountedADozen;//2.Event Declaration:Create and publish an event
		public void DoCount()
		{
			for(int i=1;i<100;i++)
				if(i%12==0 && CountedADozen != null)
					CountedADozen();//3.Raise the event:Raise the event every 12 counts
		}
	}
	/*****Subscriber*****/
	class Dozens
	{
		public int DozensCount{get;private set;}
		public Dozens(Incrementer incrementer)
		{
			DozensCount = 0;
			incrementer.CountedADozen += IncrementDozensCount;//4.Subscribe to the event
		}
		void IncrementDozensCount()//5.Declare the event handler
		{
			DozensCount++;
		}
	}
	/*****Main Program*****/
	class Program
	{
		static void Main()
		{
			Incrementer incrementer = new Incrementer();
			Dozens dozensCounter = new Dozens(incrementer);
			incrementer.DoCount();//Once invoke the 'Raise the event',it will invoke 'the event handler' at the same time
			Console.WriteLine("Number of dozens = {0}",dozensCounter.DozensCount);
		}
	}
}

/*
Core: Standard Event Usage
Analysis:
•	 The declaration for delegate Handler has been removed since the event uses the
system-defined EventHandler delegate.
•	 The signature of the event handler declaration in the subscriber class must match
the signature (and return type) of the event delegate, which now uses parameters of
type object and EventArgs. In the case of event handler IncrementDozensCount, the
method just ignores the formal parameters.
•	 The code that raises the event must invoke the event with objects of the appropriate
parameter types.
Output:
•	 Number of dozens = 8
*/
using System; 
namespace Anonymous
{
	//delegate void Handler(); //No more need,because we use the system-defined EventHandler delegate

	/*****Pbulisher******/
	class Incrementer
	{
		public event EventHandler CountedADozen;//2.Event Declaration:Create and publish an event
		public void DoCount()
		{
			for(int i=1;i<100;i++)
				if(i%12==0 && CountedADozen != null)
					CountedADozen(this,null);//3.Raise the event:Use EventHandler's parameters when raising the event
		}
	}
	/*****Subscriber*****/
	class Dozens
	{
		public int DozensCount{get;private set;}
		public Dozens(Incrementer incrementer)
		{
			DozensCount = 0;
			incrementer.CountedADozen += IncrementDozensCount;//4.Subscribe to the event
		}
		void IncrementDozensCount(object source,EventArgs e)//5.Declare the event handler:The signature of the event handler must match that of the delegate
		{
			DozensCount++;
		}
	}
	/*****Main Program*****/
	class Program
	{
		static void Main()
		{
			Incrementer incrementer = new Incrementer();
			Dozens dozensCounter = new Dozens(incrementer);
			incrementer.DoCount();//Once invoke the 'Raise the event',it will invoke 'the event handler' at the same time
			Console.WriteLine("Number of dozens = {0}",dozensCounter.DozensCount);
		}
	}
}

/*
Core: Passing Data by Extending EventArgs
Analysis:
•	 To pass data in the second parameter of your event handler and adhere to the standard conventions,
you need to declare a custom class derived from EventArgs that can store the data you need passed. By
convention, the name of the class should end in EventArgs. 
Output:
•	 Incremented at iteration:12 in Anonymous.Incrementer
•	 Incremented at iteration:24 in Anonymous.Incrementer
•	 Incremented at iteration:36 in Anonymous.Incrementer
•	 Incremented at iteration:48 in Anonymous.Incrementer
•	 Incremented at iteration:60 in Anonymous.Incrementer
•	 Incremented at iteration:72 in Anonymous.Incrementer
•	 Incremented at iteration:84 in Anonymous.Incrementer
•	 Incremented at iteration:96 in Anonymous.Incrementer
•	 Number of dozens = 8
*/
using System; 
namespace Anonymous
{
	public class IncrementerEventArgs : EventArgs//Custom class derived from EventArgs
	{
		public int IterationCount{get;set;}//Stores an integer
	}
	class Incrementer
	{
		public event EventHandler<IncrementerEventArgs> CountedADozen;//Generic delegate using custom class
		public void DoCount()
		{
			IncrementerEventArgs args = new IncrementerEventArgs();
			for(int i = 1;i < 100;i++)
				if(i%12==0 && CountedADozen != null)
				{
					args.IterationCount = i;
					CountedADozen(this,args);//Pass parameters when raising the event
				}
		}
	}
		class Dozens
	{
		public int DozensCount{get;private set;}
		public Dozens(Incrementer incrementer)
		{
			DozensCount = 0;
			incrementer.CountedADozen += IncrementDozensCount;
		}
		void IncrementDozensCount(object source,IncrementerEventArgs e)
		{
			Console.WriteLine($"Incremented at iteration:{e.IterationCount} in {source.ToString()}");
			DozensCount++;
		}
	}
	class Program
	{
		static void Main()
		{
			Incrementer incrementer = new Incrementer();
			Dozens dozensCounter = new Dozens(incrementer);
			incrementer.DoCount();
			Console.WriteLine($"Number of dozens = {dozensCounter.DozensCount}");
		}
	}

}

/*
Core: An Interface Is a Reference Type(A Simple Example)
Analysis:
•	 For example, the following code declares an interface and a class that implements it. The code in Main
creates an object of the class and calls the implementation method through the class object. It also creates
a variable of the interface type, casts the reference of the class object to the interface type,or use the 
'as' opertor to convert to the interface type and calls the implementation method through the reference to 
the interface. 
Output:
•	 Calling through: object
•	 Calling through: interface
•	 Calling through: interface
*/
using System; 
namespace Anonymous
{
	interface IIfc1
	{
		void PrintOut(string s);
	}
	class MyClass : IIfc1
	{
		public void PrintOut(string s)
		{
			Console.WriteLine($"Calling through: {s}");
		}
	}
	class Program
	{
		static void Main()
		{
			MyClass mc = new MyClass();
			mc.PrintOut("object");

			IIfc1 ifc = (IIfc1)mc;
			ifc.PrintOut("interface");
			
			IIfc1 ift = mc as IIfc1;
			ift.PrintOut("interface");
		}
	}
}

/*
Core: An Interface Is a Reference Type(A Simple Example)
Analysis:
•	 The program declares
a class called Animal, which is used as a base class for several other classes that represent various types of
animals. It also declares an interface named ILiveBirth.
	Classes Cat, Dog, and Bird all derive from base class Animal. Cat and Dog both implement the
ILiveBirth interface, but class Bird does not.
	In Main, the program creates an array of Animal objects and populates it with a class object of each of
the three types of animal classes. The program then iterates through the array and, using the as operator,
retrieves a reference to the ILiveBirth interface of each object that has one and calls its BabyCalled
method.
Output:
•	 Baby is called: kitten
•	 Baby is called: puppy
*/
using System; 
namespace Anonymous
{
	interface ILiveBirth//Declare interface
	{
		string BabyCalled();
	}
	class Animal//Base class Animal
	{

	}
	class Cat : Animal, ILiveBirth//Declare class Cat
	{
		string ILiveBirth.BabyCalled()
		{
			return "kitten";
		}
	}
	class Dog : Animal, ILiveBirth//Declare class Dog
	{
		string ILiveBirth.BabyCalled()
		{
			return "puppy";
		}
	}
	class Bird : Animal//Declare class Bird
	{

	}
	class Program
	{
		static void Main()
		{
			Animal[] animalArray = new Animal[3];//Create Animal array
			animalArray[0] = new Cat();//Insert Cat class object
			animalArray[1] = new Bird();//Insert Bird class object
			animalArray[2] = new Dog();//Insert Dog class object
		
			foreach(Animal a in animalArray)//Cycle through array
			{
				ILiveBirth b = a as ILiveBirth;//if implements ILiveBirth..
				if(b != null)
					Console.WriteLine($"Baby is called: {b.BabyCalled()}");
			}
		}
	}
}

/*
Core: A User-Defined Conversion
Analysis:
•	 The following code defines a class called Person that contains a person’s name and age. The class also
defines two implicit conversions. The first converts a Person object to an int value. The target int value is
the age of the person. The second converts an int to a Person object.
Output:
•	 Person Info: bill, 25
•	 Person Info: Nemo, 35
*/
using System; 
namespace Anonymous
{
	class Person
	{
		public string Name;
		public int Age;
		public Person(string name,int age)
		{
			Name = name;
			Age = age;
		}
		public static implicit operator int(Person p)//Convert Person to int
		{
			return p.Age;
		}
		public static implicit operator Person(int i)//Convert int to Person
		{
			return new Person("Nemo",i);
		}
	}
	class Program
	{
		static void Main()
		{
			Person bill = new Person("bill",25);
			int age = bill;//Convert a Person object to an int
			Console.WriteLine($"Person Info: {bill.Name},{age}");

			Person anon = 35;//Convert an int to a Person object
			Console.WriteLine($"Person Info: {anon.Name},{anon.Age}");
		}
	}
}