static int Sum(params int[] ints)
{

}

static void Main()
{
    int total = Sum(1, 2, 3, 4);
    //inttotal=Sum(new int[]{1,2,3,4});
    Console. WriteLine(total); //10
}

void Foo(int x= 23)
{
    Console.WriteLine(x);
}

void Foo2(int x, int y) { Console.WriteLine(x + ","+ y); }
void Test2()
{
    Foo2(x: 1, y: 2); //1, 2
    Foo2(y: 2, x: 1);//1, 2
}

static void Main()
{
    int a=0;
    Foo2(y: ++a, x: --a); // 0,1
    int b=0;
    Foo2(x: --b, y: ++b);//-1,0
}

void Test2( )
{
    Foo2(1, y: 2); 
}

void Bar(int a=0,int b=0,int c=0, int d=0){}
void Test2()
{
    Bar(d:3);
}

int[] numbers= {0,1,2, 3,4};
ref int numRef= ref numbers[2];

static string X = "Old Value";
static ref string GetX() => ref X; //This method returns a ref

static void Main()
{
    ref string xRef = ref GetX(); //Assign result to a ref local             
    xRef = "New Value";
    Console.WriteLine(X); //New Value
}

static void TellMeTheType(object x)//object allows any type.
{
    switch(x)
    {
        case bool b when b=true://Fires only when b is true         
        Console.WriteLine("True!"); 
        break; 
        case bool b: 
        Console. WriteLine("False!");
        break;
    }
}        

static void Main(string[] args)
{
    int i=1; 

startLoop: 
    if(i≤5)
    {
        Console.write(i+"");
         i++; 
        goto startLoop;
    }
}

namespace Outer.Middle.Inner
{
    class Class1{}
    class class2{}
}

namespace Outer
{
    namespace Middle
    {
        namespace Inner
        {
            class class3{}
            class class4{}
        }
    }
}

using static System.Console;

class Test2
{
    static void Main(){ writeLine("Hello");}
}

namespace MyTradingCompany
{
     namespace Common
    {
        class ReportBase{}
    }

    namespace ManagementReporting
    {
        class SalesReport:Common.ReportBase{}
    }
}

namespace outer.Middle.Inner
{
    class Class1{}
}

namespace Outer.Middle.Inner
{
    class Class2{}
}

namespace N1
{
    class Class1{}
}

namespace N2
{
    using N1；
    class Class2：Class1{}
}

namespace N2
{
    class Class3：Class1{}//Compile-time error
}

using PropertyInfo2 = System.Reflection.PropertyInfo;
class Program1 { PropertyInfo2 p;}

using R = System.Reflection;//给命名空间起别名
class Program { R.PropertyInfo p; }

//csc /r:W1=Widgets1.dll /r:W2=Widgets2.dll application.cs 
//相当于给dll起了别名

extern alias W1; 
extern alias W2; 

class Test static void Main()
{
    W1.Widgets.Widget W1 = new W1.Widgets.Widget(); 
    W2.Widgets.Widget W2 = new W2.Widgets.Widget();
}

namespace N
{
    class A
    {
        public class B { } //Nested type
        static void Main() { new global::A.B(); }//global::A.B指命名空间A下的class B
    }
}

namespace A
{
    class B{}
}

string[] arr = null;
arr?[0]. Trim();//不会报空引用异常，?[是针对索引表示法的null条件操作符

static readonly int legs = 8, eyes = 2;

void Foo (int x) {...}
void Foo (ref int x) {...}//OK so far 
void Foo (out int x) {...}//Compile-time error

void WriteCubes()
{
    Console.WriteLine (Cube (3)); 
    Console.WriteLine (Cube (4)); 
    Console.WriteLine (Cube (5));
     int Cube(int value) => value *value * value;
}

using System; 

public class Wine 
{
    public decimal Price; 
    public int Year ; 
    public Wine (decimal price) { Price = price; }
    public Wine (decimal price, int year) : this(price){ Year = year } ;
}

public wine(decimal price, DateTime date) : this(price, this.GetYear())//this. GetYear()报错
{
    Date = date;
}

public int GetYear()
{
    return 1988;
}

class Rectangle
{
    public readonly float width, Height;

    public Rectangle(float width, float height)
    {
        Width = width; Height = height;
    }

    public void Deconstruct(out float width, out float height)
    {
        width = Width; height = Height;
    }
}

class Test
{
    public static void Main(string[] args)
    {
        var rect = new Rectangle(3, 4);
        (float width, float height) = rect;//Deconstruction

        //float width, height;
        //rect.Deconstruct(out width, out height);
        //rect.Deconstruct(out var width, out var height);

        Console.WriteLine(width +""+ height); //3 4
    }
}

class Rectangle
{
    public readonly float width, Height;

    public Rectangle(float width, float height)
    {
        Width = width; Height = height;
    }
}

public static class Extensions
{
    public static void Deconstruct(this Rectangle rect, out float width, out float height)
    {
        width = rect.Width; height = rect.Height;
    }
}

class Test
{
    public static void Main(string[] args)
    {
        var rect = new Rectangle(3, 4);
        //Extensions.Deconstruct(rect, out var width, out var height); 
        rect.Deconstruct(out var width, out var height);
    }
}

public class Bunny
{
    public string Name;
    public bool LikesCarrots;
    public bool LikesHumans; 

    public Bunny(){}
    public Bunny(string n){ Name = n;}
}

Bunny b1 = new Bunny { Name="Bo", LikesCarrots=true, LikesHumans=false }; 
Bunny b2 = new Bunny ("Bo") { LikesCarrots=true, LikesHumans=false };

Bunny temp1 = new Bunny(); 
temp1.Name = "Bo"; 
temp1.LikesCarrots = true; 
temp1.LikesHumans = false; 
Bunny b1 = temp1; 

Bunny temp2 = new Bunny ("Bo"); 
temp2.LikesCarrots = true; 
temp2.LikesHumans = false; 
Bunny b2 = temp2;

public class Test
{
    string name; 
    public Test (string name) { this.name = name;}
}

public decimal Worth 
{
    get => currentPrice * sharesOwned; 
    set => sharesOwned = value / currentPrice;
}

public class Stock
{
    ...
    public decimal CurrentPrice{get；set；}
}

public decimal CurrentPrice{get；set；}= 123；

public int Maximum{get；}= 999；

public decimal get_CurrentPrice{...}
public void set_CurrentPrice（decinal value）{..}

string s ="hello"；
Console.WriteLine（s[0]）;//'h'
Console.WriteLine（s[3]）;//'l'

string s = null；
Console.WriteLine(s?[0]);//s为null不会抛出异常，而是返回null

class Sentence
{
    string[] words = "The quick brown fox".Split();

    public string this[ int wordNum]//indexer
    {
        get { return words[ wordNun];}
        set { words[ wordNum] = value;}
    }
}

//使用索引器
Sentence s =new Sentence() ; 
Console.WriteLine (s[3]);//fox 
s[3] = "kangaroo";
Console.WriteLine (s[3]);//kangaroo

public string this[int arg1，string arg2]
{
    get{...}set{...}
}

public string get_Item（int wordNum）{...}
public void set_Item（int wordNum，string value）{...}

public const decimal ProgramVersion = 2.3；

class Test
{
    static Test(){Console.WriteLine（"Type Initialized"）;}
}

class Foo
{
    public static int X = Y；//0
    public static int Y = 3；//3
}

class Class1
{
    ~Class1()
    {
        ...
    }
}

protected override void Finalize()
{
    ...
    base.Finalize();
}

partial class PaymentForm  //In auto-generated file
{
    ...
    partial void ValidatePayment (decimal amount);
}

partial class PaymentForm  //In hand-authored file
{
    ...
    partial void ValidatePayment (decinal amount)
    {
        if (amount > 100)
            ...
    }
}

int count = 123；
string name = nameof(count); //name is"count"
string name = nameof(StringBuilder.Length); //This evaluates to "Length”.

//House、Stock都是Asset的子类
House h = new House(); 
Asset a = h;        // Upcast always succeeds 
Stock s = (Stock)a; // Downcast fails: a is not a Stock

Asset a = new Asset(); 
Stock s = a as Stock;// s is null; no exception thrown

if（a is Stock）
    Console.WriteLine(((Stock)a).SharesOwned);

if (a is Stock s)
    Console.WriteLine (s.SharesOwned); 

//相当于
stock s; 
if (a is Stock)
{
    s = (Stock) a; 
    Console.WriteLine (s.SharesOwned):
}

if (a is Stock s && s.SharesOwned > 100000)
    Console.WriteLine ("Wealthy");

public abstract class Asset
{
    //Note empty implementation 
    public abstract decimal NetValue (get; }
}

public class stock : Asset 
{
    public long SharesOwned; 
    public decimal currentPrice;

    //Override like a virtual method.
    public override decimal NetValue => CurrentPrice * SharesOwned;
}

public class A{public int Counter = 1;}
public class B：A{public int Counter =2;}

A a = new A(); System.Console.writeLine(a. Counter); //1
B b = new B(); System.Console.WriteLine(b. Counter); //2
A x = new B(); System.Console.writeLine(x. Counter); //1

public class A {public int Counter = 1;}
public class B: A { public new int Counter = 2;}

public class Baseclass 
{
    public virtual void Foo() 
    { 
        Console. WriteLine ("Baseclass.Foo"); }
    }
}

public class Overrider: BaseClass 
{
    public override void Foo()
    {
        Console.WriteLine ("Overrider.Foo"); 
    }
}

public class Hider : Baseclass 
{
    public new void Foo()
    { 
        Console.Writeline ("Hider.Foo");
    }
}

Overrider over = new Overrider(); 
Baseclass b1 = over; 
over.Foo();     //Overrider. Foo1
b1.Foo();       //Overrider. Foo1

Hider h = new Hider(); 
Baseclass b2 = h; 
h.Foo();       //Hider.Foo
b2.Foo();      //BaseClass.Foo

public sealed override decimal Liability{get{return Mortgage;}}

public class House：Asset
{
    public override decimal Liability => base.Liability + Mortgage；
}

public class BaseClass
{
    public int x; 
    public Baseclass(){x = 1;}
}

public class Subclass : BaseClass 
{
    public subclass(){Console.WriteLine(x);} //1，先调用父类构造函数
}

public class B
{
    int x = 1;                  //Executes 3rd
    public B (int x)
    {
        ...                    // Executes 4th
    }
}

public class D: B
{
    int y = 1;                  //Executes 1st
    public D (int x)
    : base (x+1)               // Executes 2nd
    {
        ...                    // Executes 5th
    }
}

static void Foo (Asset a) {}
static void Foo (Hguse h) {}

//重载方法被调用时，更具体的类型拥有更高的优先级
House h = new House（...）；
Foo(h)；     //calls Foo(House)

//调用哪个重载方法是在编译时就确定下来的
Asset a = new House(...);
Foo(a)；    // calls Foo(Asset)

object obj =9;           //9 is inferred to be of type int
long x = (long) obj;   //InvalidCastException

object obj =9; 
long x= (int) obj; 

object obj =3.5;             //3.5 is inferred to be of type double
int x= (int) (double) obj; //x is now 3

object[] a1 = new string[3]; //Legal 
object[] a2 = new int[3];    //Error

int i = 3;
object boxed = i;
i = 5;
Console.WriteLine(boxed);//3

public class Point { public int x, Y; }

Point p = new Point(); 
Console.WriteLine(p.GetType().Name);              //Point
Console.WriteLine(typeof(Point).Name);            //Point
Console.WriteLine(p.GetType() == typeof(Point));  //True 
Console.WriteLine(p.X.GetType().Name);            //Int32
Console.WriteLine(p.Y.GetType().FullName);        //System.Int32

int x = 1；
string s1 = x.Tostring();   //Calling on nonboxed value 
object box =x；
string s2 = box.Tostring(); //Calling on boxed value，使用的是装箱后的值

public class object 
{
    public object(); 

    public extern Type GetType(); 

    public virtual bool Equals (object obj); 
    public static bool Equals (object objA, object objB); 
    public static bool ReferenceEquals (object objA, object objB); 

    public virtual int GetHashCode();

    public virtual string Tostring(); 

    protected virtual void Finalize(); 
    protected extern object Memberwiseclone();
}

public struct Point 
{
    int x, y; 
    public Point(int x, int y){this.x =x;this.y =y;}
}

...
Point p1 = new Point();      //p1.x and p1.y will be 0
Point p2 = new Point(1, 1);//p1.x and p1.y will be 1

class Class1{} //Class1 is internal (default)
class ClassA { int x;} // x is private (default)

class C { public void Foo() {}}

[assembly: InternalsvisibleTo("Friend")]

[assembly: InternalsvisibleTo("StrongFriend, Publickey=9024f000048c...")]

interface I1{void Foo();}
interface I2{int Foo();}

public class Widget: I1, I2
{
    public void Foo()
    {
        Console.WriteLine ("Widget's implementation of I1.Foo");
    }

    int I2.Foo()
    {
    　　Console.WriteLine ("Widget's implementation of I2.Foo");        
    　　return 42;
    }
}

widget w = new widget();
w.Foo();             //Widget's implementation of I1.Foo
((I1)w).Foo();       //Widget's implementation of I1.Foo
((I2)w).Foo();       //Widget's implementation of I2.Foo

public interface IUndoable { void Undo(); }

public class TextBox: IUndoable
{
    public virtual void Undo() => Console.WriteLine ("TextBox.Undo"); 
}

public class RichTextBox:TextBox 
{
    public override void Undo() => Console.WriteLine ("RichTextBox.Undo");
}

RichTextBox r = new RichTextBox();
r.Undo();                     //RichTextBox.Undo
((IUndoable)r).Undo();        //RichTextBox.Undo
((TextBox)r).Undo();          //RichTextBox.Undo

public interface IUndoable { void Undo(); }

public class TextBox: IUndoable
{
    public void Undo() => Console.WriteLine ("TextBox.Undo"); 
}

public class RichTextBox:TextBox 
{
    public void Undo() => Console.WriteLine ("RichTextBox.Undo");
}

public interface IUndoable { void Undo(); }

public class TextBox: IUndoable
{
    public void Undo() => Console.WriteLine ("TextBox.Undo"); 
}

public class RichTextBox:TextBox,IUndoable
{
    public void Undo() => Console.WriteLine ("RichTextBox.Undo");
}

RichTextBox r = new RichTextBox();
r.Undo();                      //RichTextBox.Undo
((IUndoable)r).Undo();         //RichTextBox.Undo，因为RichTextBox也继承接口并实现其Undo方法
((TextBox)r).Undo();           //TextBox.Undo 

interface I { void Foo();}
struct s : I { public void Foo(){}}

S s = new S();
s. Foo();     //No boxing 
I i=s;        //Box occurs when casting to interface.
i.Foo();

public enum BorderSide{Left，Right，Top，Bottom}

public enum Borderside：byte{Left，Right，Top，Bottom}

public enum BorderSide：byte{Left=1，Right=2，Top=10，Bottom=11}

int i =(int)BorderSide.Left；
BorderSide side =(BorderSide)i；
bool leftOrRight =(int)side <= 2；

BorderSide b = 0;
if(b == 0)
...

[Flags]
public enum Bordersides{None=0，Left=1，Right=2，Top=4，Bottom=8}

BorderSides leftRight = BorderSides.Left | BorderSides. Right; 
string formatted = LeftRight. ToString();   //"Left, Right"

if((leftRight & BorderSides.Left) !=0)
    Console.WriteLine ("Includes Left");    //Includes Left 

[Flags]
public enum BorderSides 
{
    None=0，
    Left=1，
    Right=2，
    Top=4，
    Bottom=8，
    LeftRight = Left | Right，
    TopBotton = Top | Bottom，
    ALL= LeftRight | TopBottom
}

public enum BorderSide { Left, Right, Top, Bottom }
BorderSide b = (BorderSide)12345; 
Console.WriteLine(b);                             //12345
BorderSide b = BorderSide.Bottom; 
b++;                                              //No errors

BorderSide side = (BorderSide)12345; 
Console.WriteLine(Enum.IsDefined(typeof(BorderSide), side));//False

public class TopLevel 
{
    public class Nested {}               //Nested class 
    public enüm Color{ Red, Blue, Tan } //Nested enum
}

public class Stack<T>
{
    int position; 
    T[] data = new T[100]; 
    public void Push (T obj)=> data[position++] = obj;
    public T Pop()=> data[--position];
}

var stack = new Stack<int>(); 
stack.Push (5); 
stack.Push (10);
int x = stack.Pop(); //x is 10
int y = stack.Pop(); //y is 5

public class ObjectStack
{
    int position; 
    object[] data = new object[10]; 
    public void Push(object obj) => data[position++] = obj; 
    public object Pop()=> data[--position];
}

//需要装箱和向下转换，这种转换在编译时无法进行检查
stack.Push("s");               //wrong type，but no error！
int i =(int)stack.Pop();      //Downcast-runtime error

static void Swap<T>(ref T a, ref T b)
{
    T temp = a; 
    a = b;
    b = temp;
}

int x= 5;
int y = 10; 
Swap(ref x, ref y);//可以不指定T的类型，因为编译器可以隐式推断

public T this[int index] => data [index]; //索引器可以使用类型参数
public Stack<T>() {}// ，构造函数声明类型参数，Illegal

public struct Nullable<T>
{
    public T value {get;}
}

class Dictionary<TKey, TValue> {...}
Dictionary<int,string> myDic = new Dictionary<int,string>();
var myDic = new Dictionary<int,string>(); 

class A {} 
class A<T> {} 
class A<T1,T2> {} 

static void Zap<T> (T[] array)
{
    for (int i = 0; i < array.Length; i++)
        array[i] = default(T);
}

class A<T>{}
class A《T1，T2>{}
Type a1 = typeof(A<>); //Unbound type（notice no type arguments）.
Type a2 = typeof(A<,>);//Use commas to tndicate multiple type args.

where T: base-class  //Base-class constraint。某个父类的子类
where T: interface   //Interface constraint。实现某个接口
where T: class       //Reference-type constraint。引用类型
where T: struct      //Value-type constraint (excludes Nullable types)。值类型，不包括可空值类型
where T: new()       //Parameterless constructor constraint。类型里必须有一个无参构造函数
where u: T           //Naked type constraint。U继承于T

class SomeClass (}
interface Interface1 (}

class GenericClass<T,U> where T: SomeClass, Interface1
                        where U: new()
{...}

struct Nullable<T> where T : struct {...}

static void Initialize<T> (T[] array) where T:new()
{
    for (int i= 0; i<array.Length; i++)
        array[i] = new T();
}

//裸类型约束。泛型类里有一个泛型方法，U继承于T

class Stack<T>
[
    Stack<U> Filteredstack<U>() where U : T {...}
]

public interface IComparable<T>
{
    int CompareTo(T other);
}

static T Max<T> (T a, T b) where T: IComparable<T>//我认为，这几个T的类型都是一样的，包括IComparable<T>，它实际上是封闭泛型。也就是说，这里IComparable<T>的T是特指而不是泛指
{
    return a.CompareTo (b) >0? a:b;
}

int z=Max (5, 10);//10
string Last = Max ("ant", "zoo"); //zoo

class Stack<T>{...}
class SpecialStack<T> : Stack<T> {...}

class IntStack：Stack<int>{...}

class List<T>{...}
class KeyedList<T，Tkey>：List<T>{...}

class List<T>{...}
class KeyedList<TElement，Tkey>：List<TELement>{...}

public interface IEquatable<T> { bool Equals (T obj); }

public class Balloon : IEquatable<Balloon>//这里有点怪的地方是，还没有完成Balloon的定义，就使用了它。Balloon实现了IEquatable<T>泛型接口
{
    public string Color { get; set; }
    public int cc { get; set; }

    public bool Equals (Balloon b)
    {
        if (b = null) return false;
            return b.Color == Color && b.CC == CC; 
    }
}

class Foo<T> where T: IComparable<T>{...}//比较怪的是T: IComparable<T>，接口里有T类型，而T实现了IComparable<T>，所以T引用了自己

class Bar<T> where T : Bar<T> {...}//这里的怪异感是上面两个例子的合并，泛型类Bar<T>还没定义完就使用了它。类Bar中有类型T，T又继承了Bar，也即是类bar中有自己的子类，是自引用

class Bob<T> { public static int Count; }

class Test
{
    static void Main()
    {
        Console. WriteLine (++Bob<int>.Count); //1
        Console. WriteLine (++Bob<int>.Count); //2
        Console. WriteLine (++Bob<string>.Count); //1
        Console. WriteLine (++Bob<object>.Count);//1
    }
}

StringBuilder Foo<T> (T arg)
{
    tf (arg is StringBuilder)
        return (StringBuilder) arg;//will not compile，会被编译器以为是自定义转换
}

StringBuilder Foo<T> (T arg)
{
    StringButlder sb = arg as StringBuilder;//使用as操作符消除自定义转换的歧义
    if (sb != null) return sb;
    ...
}

//更常见的解决方案，先转换为object，会被认为是引用转换
return (stringBuilder) (object) arg;

int Foo<T> (T x) =>(int) x; // Compile-time error，有可能是数值转换，拆箱操作，自定义转换，无法确定是哪种，所以编译时不通过

//解决方案，先转换为object，那么最后就是拆箱操作。没有了歧义，就不会报错
int Foo<T> (T x) => (int) (object) x;

public interface IEnumerable<out T>
public delegate void Action<inT>
public interface IList<T>

IEnumerable<string> strings = new List<string> { "a", "b", "c" };
IEnumerable<object> objects = strings;

IList<string> strings = new List<string> { "a", "b", "c"}; 
IList<object> objects = strings; 
//假如上述转换成功(实际上报错)
objects.Add(new object()); 
//第4个元素实际上不是字符串，不安全
string element = strings[3];

delegate int Transformer (int x); //委托类型名是Transformer
static int Square (int x) { return x*x; }

Transformer t = Square；

int answer = t(3);   //answer is 9

delegate int Transformer(int x); 

class Test 
{
    static void Main()
    {
        Transformer t = Square;      //Create delegate instance。简写，完整写法是Transformer t = new Transformer(Square);
        int result = t(3);           //Invoke delegate。简写，完整的写法是t.Invoke(3)
        Console.WriteLine(result); //9
    }

    static int Square(int x) =>x*x;
}

namespace Demo
{
    public delegate int Transformer(int x);

    class Util
    {
        public static void Transform(int[] values, Transformer t)
        {
            for (int i= 0; i<values.Length; i++)
            {
                values[i] = t(values[i]);
            }
        }
    }

    public class Program
    {
        static int square(int x) =x * x; 
        static void Main()
        {
            int[] values ={1, 2, 3}; 
            util.Transform(values, Square); 
            foreach (int i in values)
            {
                Console. writeLine($"{i} ");
            }
        }
    }
}

SomeDelegate d = SomeMethod1; 
d += SomeMethod2; 
d = d + SomeMethod2;

d-= SomeMethod1；

SomeDelegate d = null;
d += SomeMethod1;

d = SomeMethod1;

public delegate T Transformer<T>(T arg);

namespace Demo
{
    public delegate T Transformer<T>(T arg);

    class Util
    {
        public static void Transform<T>(T[] values, Transformer<T> t)
        {
            for (int i= 0; i<values.Length; i++)
            {
                values[i] = t(values[i]);
            }
        }
    }

    public class Program
    {
        static int square(int x) =x * x; 
        static void Main()
        {
            int[] values ={1, 2, 3}; 
            util.Transform(values, Square); //Hook in Square. 完整的写法是util.Transform<int>(values, Square);但是因为可以通过传入的参数推断，所以可以省略不写
            foreach (int i in values)
            {
                Console.writeLine(i + "  ");
            }
        }
    }
}

delegate TResult Func <out TResult>();
delegate TResult Func <in T, out TResult>(т arg);
delegate TResult Func <in T1, in T2, out TResult>(T1 arg1, T2 arg2);
... and so on, up to T16

delegate void Action();
delegate void Action <in T>(T arg);
delegate void Action <in T1, in T2>(T1 arg1, T2 arg2);
.. and so on, up to T16

public static void Transform<T>(T[] values, Func<T,T> transformer)//这里可以看到，Func的类型参数可以是一样的。注意这里的T不是泛指，而是泛型Transform<T>的类型参数
{
    for (int i= 0; i<values.Length; i++)
        values[i] = t(values[i]);
}

delegate void D1();
delegate void D2();

D1 d1 = Method1; 
D2 d2 = d1; //Compile-time error

delegate void stringAction (string s);
 
class Test
{
    static void Main()
    {
        StringAction sa = new StringAction(ActOnobject); 
        sa ("hello"); //hello
    }

    static void ActOnobject (object o) => Console.WriteLine (o);
}

delegate object ObjectRetriever(); 

class Test 
{
    static void Main()
    {
        ObjectRetriever o = new ObjectRetriever(Retrievestring);
        object result = o(); 
        onsole.WriteLine(result);//hello
    }

     static string Retrievestring() => "hello";
}

//Delegate definition 
public delegate void PriceChangedHandler (decimal oldPrice, decimal newPrice);

public class Broadcaster
{
    //Event declaration 
    public event PriceChangedHandler PriceChanged;
}

PriceChangedHandler priceChanged; // private delegate 

public event PriceChangedHandler PriceChanged 
{
    add {priceChanged += value; }
    remove { priceChanged -= value;}
}

public class PriceChangedEventArgs : Systen. EyentArgs 
{
    public readonly decimal LastPrice; 
    public readonly decimal NewPrice; 

    public PriceChangedEventArgs (decimal LastPrice, decimal newPrice)
    {
        LastPrice = lastPrice; 
        NewPrice = newPrice;
    }
}

public delegate void EventHandler<TEventArgs>(object source, TEventArgs e) where TEventArgs:EventArgs;

public class Stock
{
    ...
    public event EventHandler<PriceChangedEventArgs> PriceChanged；
}

public class Stock
{
    ...
    public event EventHandler<PriceChangedEventArgs> PriceChanged;

    protected virtual void OnPriceChanged（PriceChangedEventArgs e）
    {
        if（PriceChanged！= nulL）PriceChanged（this，e）；
    }
}

var temp = PriceChanged;
if(temp！= null)tenp(this，e);

PriceChanged?.Invoke(this,e)；

public class Stock
{
    string symbol; 
    decimal price; 

    public Stock (string symbol) { this.synbol = symbol; }

    public event EvenHandler PriceChanged; 
    protected virtual void OnPriceChanged (EventArgs e)
    {
         PriceChanged?.Invoke(this, e); 
    }

    public decimal Price 
    {
        get { return price; }
        set
        {
            if (price = value) return; 
            price = value; 
            OnPriceChanged(EventArgs.Empty);
        }
    }
}

public event EventHandler PriceChanged;

private EventHandler priceChanged; 

public event EventHandler PriceChanged
{
    add { priceChanged += value; }
    remove { priceChanged -= value; }
}

public class Foo
{
    public static event EventHandler<EventArgs> StaticEvent；
    public virtual event EventHandler<EventArgs> virtualEvent；
}

delegate int Transformer(int i); 
Transformer sqr = x =>x*x; 
Console.WriteLine(sqr(3));//9

x => { return x*x; };

Func<int, int> sgr = x=>x*x; 
Func<string, string, int> totalLength = (s1, s2) => s1.Length + s2.Length;
int total = totalLength("hello", "world"); //total is 10;

void Foo<T>(T x)(}
void Bar<T>(Action<T> a)//泛型方法Bar接受的参数是一个委托，这个委托有一个输入参数，类型是泛型方法Bar的类型参数T的类型
Bar(x => Foo(x));// what type is x? 注意这样的写法，=>还可以直接指向一个方法。Bar的类型参数T的类型就是x的类型。委托指向的方法就是Foo

//解决方法
Bar ((int x) =>Foo (x));
Bar<int> (x => Foo (x)); // Specify type parameter for Bar 
Bar<int> (Foo);//As above, but with method group

static void Main()
{
    int factor = 2; 
    Func<int, int> multiplier =n => n* factor; 
    Console.WriteLine (multiplier(3));  //6
}

int factor = 2；
Func<int，int> multiplier = n =>n*factor；
factor = 10；
Console.writeLine(multiplier(3))；//30

int seed =0；
Func<int> natural = ()=>seed++；
Console.WriteLine(natural());//0
Console.WriteLine(natural());//1
Console.WriteLine(seed);     //2

static Func<int> Natural()//一个方法，返回类型是一个委托
{
    int seed =0; 
    return () => seed++;//Returns a closure 
}

static void Main()
{
    Func<int> natural = Natural();//正常来说，Natural方法调用完后，方法里的本地变量就不存在
    Console.WriteLine(natural()); //0
    Console.WriteLine(natural()); //1
}

static Func<int> Natural()//一个方法，返回类型是一个委托
{
    return () => { int seed =0; return seed++;};
}

static void Main()
{
    Func<int> natural = Natural();//正常来说，Natural方法调用完后，方法里的本地变量就不存在
    Console.WriteLine(natural()); //0
    Console.WriteLine(natural()); //0
}

Action[] actions = new Action[3]; //思考题：有一个int类型输入参数的Action是否写成Action<int>[] actions = new Action<int>[3]; 

for (int i=0; i<3; i++)
    actions[i]= () => Console.Write (i); //每个Action都是无参无返回的Action

foreach (Action a in actions)a();//333，i的值是实际调用委托的时候才被计算

Action[] actions = new Action[3];

for (int i=0; i<3; i++)
{
    int LoopSçopedi = i; //循环的每一轮产生的整型变量loopScopedi对应的内存空间是不同的，所以有3个副本，值分别是0、1、2，这3个副本都被延长了生命周期
    actions[i]= () => Console.Write(LoopScopedi);
}

foreach (Action a in actions)a();//012

delegate int Transformer(int i); 
Transformer sqr = delegate (int x) { return x*x;}; 
Console.WriteLine (sqr(3));//9

public event EventHandler Clicked = delegate{};

//Notice that we omit the parameters：
Clicked += delegate{Console.WriteLine("clicked");}；

try
{
    .. //exception may get thrown within execution of this block
}
catch (ExceptionA ex)
{
    ... //handle exception of type ExceptionA
}
catch (ExceptionB ex)
{
    ... //handle exception of type ExceptionB
}
finally
{
    .. //cleanup code
}

catch(OverflowException)
{
    ...
}

catch{...}

catch (WebException ex) when (ex.status == WebExceptionstatus.Timeout)
{
    ...
}

catch (WebException ex) when (ex.Status == WebExceptionStatus.Timeout)
[...}
catch (WebException ex) when (ex.Status == WebExceptionstatus.SendFailure)
{...}

using (StreamReader reader = File.OpenText("file.txt"))
{
    ...
}
//等价于
{
    StreamReader reader = File.OpenText("file.txt"); 
    try
    {
        ...
    }
    finally
    {
        if (reader != null)
        {
            ((IDisposable)reader).Dispose();
        }
    }
}    

public string Foo() => throw new NotImplementedException();

string ProperCase (string value) => value == null?throw new ArgumentException("value"):value 

try { ... }
catch (Exception ex)
{
    //Log erron 
    ...
    throw; //Rethrow same exception
}

string s = null; 
using(Webclient wc = new WebClient())

try
{ 
    s = wc.Downloadstring ("http://www.albahari. com/nutshell/"); 
}
catch(WebException ex).
{
    if (ex.Status == WebExceptionStatus.Timeout)
        Console.WriteLine("Timeout"); 
    else 
        throw;//Can't handle other sorts of webException, so rethrow
}

catch（WebException ex）when（ex.Status == WebExceptionStatus.Timeout）
{
    Console.WriteLine("Timeout")；
}

сгу
{
    ...//Parse a DateTime from XML element data 
}
catch（FormatException ex）
{
    throw new xmLException("Invalid DateTime"，ex);
}

public int Parse(string input);
public bool TryParse(string input，out int returnValue);

class Enumerator //Typically implements IEnumerator or IEnumerator<T>
{
    public IteratorVariableType Current { get {...}}
    public bool MoveNext() {...}
}

class Enumerable //Typically implements IEnumerable or IEnumerable<T>
{
    public Enumerator GetEnunerator() {...}
}

using (var enumerator = "beer".GetEnumerator())

while (enumerator.MoveNext())
{
    var element = enumerator.Current; 
    Console.WriteLine (element);
}

using System.Collections.Generic;
...
List<int> list = new List<int> {1, 2, 3};

using Systen.Collections.Generic；
...
List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);

using system; 
using System.Collections.Generic; 

class Test
{
    static void Main()
    {
        foreach (int fib in Fibs(6))
            Console. Write(fib +""); 
    }

    static IEnumerable<int> Fibs(int fibCount)
    {
        for (int i=0, prevFib = 1, curFib = 1; i < fibCount; i++)
        {
            yield return prevFib; 
            int newFib = prevFib+curFib; 
            prevFib = curFib; 
            curFib = newFib;
        }
    }
}

//Enumerable interfaces
System.Collections.lEnumerable
System.Collections.Generic.IEnumerable<T>

//Enumerator interfaces
System.Collections.lEnumerator
System.Collections.Generic.lEnumerator<T>

class Test 
static void Main()
{
    foreach (string s in Foo())
        Console.WriteLine(s);//Prints "One", "Two", "Three"
}

static IEnumerable<string> Foo()
{
    yield return "One";
    yield return "Two"; 
    yield return "Three";
}

static IEnumerable<string> Foo (bool breakEarly)
{
    yield return "One";
    yield return "Two"; 

    if (breakEarly)
        yield break; 

    yield return "Three";
}

IEnumerable<string> Foo()
{
    try{yield return"One";}//Illegal
    catch{...}
}

IEnumerable<string> Foo()
{
    try{yield return"One";}//ok
    finally{...}
}

string firstElement = null; 
var sequence = Foo(); 
using (var enumerator = sequence.GetEnumerator())
    if (enumerator.MoveNext())
        firstElement = enumerator.Current;    

using system; 
using System.Collections.Generic; 

class Test
{
    static void Main()
    {
        foreach (int fib in EvenNumbersonly (Fibs(6)))
            Console.WriteLine(fib);
    }

    static IEnumerable<int> Fibs(int fibCount)
    {
        for (int i=0, prevFib = 1, curFib = 1; i < fibCount; i++)
        {
            yield return prevFib; 
            int newFib = prevFib+curFib; 
            prevFib = curFib; 
            curFib = newFib;
        }
    }

    static IEnumerable<int> EvenNumbersOnly(IEnumerable<int> sequence)
    {
        foreach (int x in sequence)
        if ((x%2) == 0)
            yield return x;
    }
}

string s = null;// OK, Reference Type
int i = null;// Compile Error, value Type cannot be null

int? i = null;// OK, Nullable Type 
Console.WriteLine(i== null);//True

public struct Nullable<T> where T: struct
{
    private readonly T value; 
    private readonly bool hąsValue; 

    public Nullable(T value)
    {
        this.value =value; 
        this.hasValue = true; 
    }

    public bool HasValue { get { return hasValue; }}

    public T Value
    {
        get
        {
            if (!hasValue)
            {
                throw new InvalidOperationException();
            }
            return value;
        }
    }
}

int? i = null;// OK, Nullable Type 
Console.WriteLine(i== null);//True

Nullablecint> i = new Nullable<int>(); 
Console.WriteLine (! i.HasValue); //True

int? x = 5;     //implicit 
int y = (int)x; //explicit

int a = 3; 
decimal b = a;

int? a1 = 4;
decimal? b1 = a1; 

decimal? b2 = a;

decimal b3 = (decimal)a1

object o = "string";
int? x= o as int?; 
Console.WriteLine (x.HasValue);//False

int x = 5;
object o = x;

Nullable<int> noValue = new Nullablekint>(); 
object noValueBoxed = noValue; 
Console.WriteLine(noValueBoxed == null); 

Nullable<int> someValue = new Nullable<int>(5); 
object someValueBoxed = someValue; 
Console.WriteLine (someValueBoxed.GetType());

Nullable<int> noValue = new Nullable<int>();
//Console. WriteLine(noValue.GetType()); 

Nullable<int> someValue = new Nullable<int>(5); 
Console.WriteLine (someValue.GetType());

int？x = new int？();//使用无参构造函数进行初始化，HasValue为false
int？x = null；

int? x= 5; 
int? y = 10;
bool b =x<y; //true

bool b = (x.HasValue && y.Hasvalue) ? (x.Value < y.value) : false;

Console.WriteLine (null == null); //True
Console.WriteLine ((bool?) null == (bool?) nulL); //True

bool b =x<y; //Translation: 

bool b= (x.HasValue && y.HasValue)
? (x.Value < y.Value)
: false;

int? c=x +y; //Translation: 

int? c= (x.HasValue && y.HasValue)
? (int?)(x.Value + y.Value)
null;

bool? n = null; 
bool? f= false;
bool? t= true; 

Console.WriteLine (n | n);//(null)
Console.WriteLine (n | f);//(null)
Console.WriteLine (n | t);//True 
Console.WriteLine (n & n);//(null)
Console.WriteLine (n & f); //False 
Console.WriteLine (n & t);//(null)

int? a = null; 
int b = 2; 
int? c = a+b; //c is null - equivalent to a + (int?)b

int? x = null; 
int y = x ?? 5; //y is 5

int? a = null, b= 1, c= 2;
Console.WriteLine (a ?? b ?? c); //1 (first non-null value)

System.Text.StringBuilder sb = null; 
int? length = sb?.ToString().Length;
int length = sb?.Tostring().Length ?? 0; //Evaluates to 0 if sb is null

static void PrintValueAsInt32 (object o)
{
    int? nullable = o as int?; 
    Console.WriteLine(nullable.HasValue ?
　　 　　　　　　　　　　 nullable.value.ToString() : "null");
}
...
PrintValueAsInt32(5); //5
PrintValueAsInt32 ("some string");//null

public static class StringHelper
{
    public static bool IsCapitalized（this string s）
    {
        if(string.IsNullOrEmpty(s))
            return false；
        return char.IsUpper(s[0]);
    }
}
//这里的IsCapitalized方法可以被这样调用：
Console.WriteLine(StringHelper.IsCapitalized("Perth"))；
Console.WriteLine("Perth".IsCapitalized())；

argo.Method(arg1, arg2, ...);             //Extension method call 
Staticclass.Method(arg0, arg1, arg2, ...);//Static method call

public static T First<T> (this IEnunerable<T> sequence)
{
    foreach (T element in sequence)
        return element; 

    throw new InvalidOperationException ("No elements!");
}
...
Console.WriteLine ("Seattle".First()); //S

public static class StringHelper
{
    public static string Pluralize(this string s){...}
    public static string Capitalize(this string s){...}
}

string x ="sausage".Pluralize().Capitalize();
string y = StringHelper.Capitalize(StringHelper.Pluralize("sausage"));

class Test public void Foo(object x){}//This method always wins 
static class Extensions 
{
    public static void Foo(this Test t, int x){}
}

//调用
var test = new Test(); 
test.Foo(12);

static class StringHelper
{
    public static bool IsCapitalized（this string s）{...}
}

static class ObjectHelper 
{
    public static bool IsCapitalized（this object s）{...}
}

bool test1 ="Perth".IsCapitalized();

var dude = new { Name = "Bob", Age = 23 };

int Age = 23;
var dude= new { Name= "Bob", Age, Age.ToString().Length }; 
//等价于
var dude = new { Name = "Bob", Age = Age, Length = Age.ToString().Length };

var a1 = new {x =2, Y=4 }; 
var a2 = new {x =2, Y=4}; 
Console.writeLine(a1.GetType() == a2.GetType()); //True

var a1 = new {y =2, x=4 }; 
var a2 = new {x =2, Y=4}; 
Console.writeLine(a1.GetType() == a2.GetType()); //false

var a1 = new {x=2, Y=4}; 
var a2 = new {x=2, Y=4}; 
Console.WriteLine(a1.GetType(); 
== a2.GetType()); //True 类型相同
Console.writeLine(a1 ==a2); //False 引用不同的实例
Console.writeLine(a1.Equals(a2)); //True 两个实例的值相等

var dudes = new[]
{
    new { Name = "Bob", Age = 30 }, 
    new { Name = "Tom", Age =40 }
};

dynamic Foo() =>new { Name = "Bob", Age = 30 }; //no static type safety.

var bob=("Bob", 23);

var joe =bob; //joe is a * copy* of job 
joe.Item1 = "Joe"; //Change joe's Item1 from Bob to Joe 
Console.WriteLine(bob); //(Bob, 23)
Console.WriteLine(joe); //(Joe, 23)

(string, int) bob = ("Bob", 23); // var is not compulsory with tuples!

static (string, int) GetPerson() = ("Bob", 23);

static void Main()
{
    (string, int) person = GetPerson(); //Could use 'var' here if we want 
    Console.WriteLine(person.Item1); //Bob 
    Console.WriteLine(person.Item2); //23
}

Task<(string, int)> a; 
Dictionary<(string, int), Uri> b; 
IEnumerable<(int ID, string Name)> c;// See below for naming elements

var tuple =(Name: "Bob", Age: 23); 
Console.Writeline(tuple.Name); //Bob 
Console.Writeline(tuple.Age); //23

static (string Name, int Age) GetPerson()=("Bob", 23);

(string Name, int Age, char Sex) bob1 = ("Bob", 23, 'M');
(string Age, int Sex, char Name) bob2 = bob1; //No error!

valueTuple<string, int> bob1 = ValueTuple.Create("Bob", 23);
(string, int) bob2 = ValueTuple.Create("Bob", 23);

//常规写法
var bob=("Bob"，23);
string name = bob.Item1；
int age = bob.Item2；

//Deconstruction 模式
var bob =("Bob"，23);
(string name，int age) = bob;//Deconstruct the bob tuple into separate variables(name and age)
Console.Writeline(name);
Console.WriteLine(age);

//语法别混淆了
(string name，int age)= bob；//Deconstructing a tuple
(string name，int age)bob2=bob；//声明一个新tuple

[obsoleteAttribute]
public class Foo[...}

[obsolete]
public class Foo[...}

[XmLElement("Customer"，Namespace="http://oreilLy.com"）]
public class CustomerEntity{...}

[assembly:CLSCompliant(true)]

[Serializable,Obsolete,CLSCompliant(false)]
public class Bar{...}

[Serializable][obsolete][CLSCompliant(false)]
public class Bar{...}

[Serializable,Obsolete]
[CLSCompliant(false)]
public class Bar{...}

static void Main() => Foo();

static void Foo(
    [CallerMemberName] string memberName = null,
    [CallerFilePath] string filePath-= null,
    [CallerLineNumber] int lineNumber =0)
{
    Console.WriteLine(memberName); //Main
    Console.WriteLine(filePath); //D:\Projects\dotnet\Demo\Program.cs
    Console.WriteLine(lineNumber);//9，Main方法所在的行

}

static void Main()=> Foo（"Main"，@"D:\Projects\dotnet\Demo\Program.cs"，9）；

Animal a = new Animal();
a.Roar(); //The compiler can resolve this method call statically.

public void MakeSomeNoise(object a) {
//Things happen...
    ((Animal) a).Roar(); //You won't know if this works until runtime!
}

dynamic d = GetSomeObject();
d.Quack();

Duck d = ...
d.Quack();

typeof(dynamic) == typeof(object)
typeof(List<dynamic>) == typeof(List<object>)
typeof(dynamic[]) == typeof(object[])

dynamic x = "hello"; 
Console.WriteLine (x.GetType().Name); //String 
x= 123; //No error (despite same variable)
Console.WriteLine (x.GetType().Name); //Int32

object o = new System.Text.StringBuilder();//向上转换，对象o上看不到StringBuilder的操作，此时转换为dynamic就可以执行tringBuilder的操作了
dynamic d =o;
d.Append("hello");
Console.WriteLine(o);//hello

public class Test 
{
    public dynamic Foo;
}

//is equivalent to:

public class Test
{
    [System.Runtime.CompilerServices.DynamicAttribute]
    public object Foo;
}

int i = 7; 
dynamic d = i;
long j =d;//No cast required (implicit conversion)

int i = 7; 
dynamic d = i; 
short j = d;// throws RuntimeBinderException。实际类型是int，不可隐式转short。也就是说，dynamic要隐式转换，是有条件的，就是实际的类型可以隐式转换

dynamic x = "hello"; // static type is dynamic, runtime type is string
var y = "hello"; //static type is string, runtime type is string
int i = x;  //Runtime error(cannot convert string to int)
int j=y;//Compile-time error (cannot convert string to int)

dynamic x = "hello"; 
var y = x; //static type of y is dynamic
int z = y; //Runtime error (cannot convert string to int)

dynamic x=2；
var y =x*3；//Static type of y is dynamic

dynamic x = 2;
var y = (int)x; // static type of y is int

dynamic capacity = 10;
var x = new System.Text.StringBuilder(capacity);

dynamic list = new List<int>();
var result = list.Add(5); //RuntimeBinderException thrown

dynamic x = ... ; 
x.Foo(); //x.Foo()是一个动态的调用，没有接受者，x is the receiver

class Program
{ 
    static void Foo (int x) { Console.WriteLine ("1"); }
    static void Foo (string x) { Console.WriteLine ("2"); }

    static void Main()
    {
        dynamic x = 5; 
        dynamic y = "watermelon"; 

        Foo(x); //1
        Foo(y);//2
    }
}

class Program
{
    static void Foo (int x){Console.Writeline ("1"); }
    static void Foo (string x) { Console.Writeline ("2"); }

    static void Main()
    {
        dynamic x = 5; 
        Foo (x, x);  //Compiler error -wrong number of parameters 
        Fook(x);//Compiler error-no such method name
    }
}

static void Foo(object x, object y) { Console.WriteLine ("oo"); } 
static void Foo(object x, string y) { Console.WriteLine ("os"); } 
static void Foo(string x, object y) {Console.WriteLine ("so"); } 
static void Foo(string x, string y) { Console.WriteLine ("ss"); }

static void Main()
{
    object o = "hello"; 
    dynamic d ="goodbye"; 
    Foo (o, d);    //动态绑定，因为d参数是dynamic类型的，输出结果os
}

public static void Main(string[] args)
{
    dynamic d = 5; 
    d.Hello();
    //编译器这样编译上面两行，dynamic没有用到int的扩展方法（因为类型不同嘛）所以，相当于静态类对这两行来说消失了，编译完了，也没有生成IntHelper.Hello(x);这样的形式。运行时，只能从int类本身找Hello方法，自然找不到了

    int x= 5;
    x.Hello(); 
    //编译器会在编译时将上两句编译为：IntHelper.Hello(x);
}

public static çlass IntHelper 
{
    public static void Hello(this int x)
    {
        System.Console.WriteLine(x);
    }
}

interface IFoo { void Test(); }
class Foo : IFoo { void IFoo.Test(){}}

public class Program
{
    public static void Main(string[] args)
    {

        IFoo f = new Foo();//Implicit cast to interface 
        f.Test();

        IFoo f = new Foo();
        dynamic d = f；
        d.Test();//Exception thrown。运行时，d是Foo类型的，Foo类型没有Test方法
        Console.writeLine(f.GetType().Name); //Foo
    }
}

static void Main(string[] args)
{
    Note B = new Note(2); 
    Note CSharp = B+ 2; 
    CSharp +=2;//重载了+后，对应的复合运算符也被重载了
}

public struct Note
{
    int value;

    public Note(int semitonesFromA)
    {
        value = semitonesFromA;
    }

    public static Note operator +(Note x, int semitones)
    {
        return new Note(x.value + semitones);
    }
}

Note n= (Note)554.37; //explicit conversion 显式转换
double x = n;  //implicit conversion 隐式转换

public struct Note
{
    int value;

    public Note(int semitonesFromA)
    {
        value = semitonesFromA;
    }

    //Convert to hertz 隐式转换 implicit[ɪmˈplɪsɪt]
    public static implicit operator double(Note x) =>440 * Math.Pow(2, (double)x.value /12); 

    //Convert from hertz (accurate to the nearest semitone) 显式转换
    public static explicit operator Note(double x) => new Note((int)(0.5 + 12 * (Math.Log(x /440)/Math...));
}

//即使做了自定义转换，仍然不被is和as认可
Console.WriteLine(554.37 is Note); //False 
Note n1 = 554.37 as Note; //Error

SqLBoolean a = SqlBoolean.Null;
if (a)
    Console.writeLine("True"); 
else if (!a)
    Console.writeLine("False"); 
else 
    Console.writeLine("Null");

public struct sqLBoolean
{
    public static bool operator true(SqLBoolean x) => x.m_value==True.m_value;
    public static bool operator false(SgLBoolean x) => x.m_ value==False.m_value; 

    public static SqlBoolean operator !(SqlBoolean x) 
    {
        if (x.m_value == Null.m_value) return Null; 
        if (x.m_value == False.m_value) return True; 
        return False;
    }

    public static readonly SqlBoolean Null = new SqLBoolean(0);

    public static readonly SqlBoolean False = new SqlBoolean(1);

    public static readonly SqlBoolean True = new SqLBoolean(2);

    private sqlBoolean(byte value) { m_value = value; }

    private byte m_value;
}

Console.WriteLine(System.Char.ToUpper('c')); //c 
Console.WriteLine(char.IsWhiteSpace('\t')); //True

Console.write(new string('*', 10)); /**********

char[] ca = "Hello".ToCharArray(); 
string s = new string(ca); //s= "Hello"

Console.Write("ab, cd ef".IndexofAny(new char[] {' ' , ','})):