Learning hard C#学习笔记

委托：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DelegateUse
{
// 委托使用演示
class Program
{
// 1. 使用delegate关键字来定义一个委托类型
delegate void MyDelegate(int para1, int para2);

static void Main(string[] args)
{
// 2. 声明委托变量d
MyDelegate d;
// 3. 实例化委托类型,传递的方法也可以为静态方法，这里传递的是实例方法
d = new MyDelegate(new Program().Add);

// 4. 委托类型作为参数传递给另一个方法
MyMethod(d);
Console.Read();
}

// 该方法的定义必须与委托定义相同，即返回类型为void, 两个int类型的参数
void Add(int para1, int para2)
{
int sum = para1 + para2;
Console.WriteLine("两个数的和为:"+sum);
}

// 方法的参数是委托类型
private static void MyMethod(MyDelegate mydelegate)
{
// 5.在方法中调用委托
mydelegate(1,2);
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DelegateOrigin
{
class Program
{
static void Main(string[] args)
{
// 引入委托之后
// 初始化对象
Program p = new Program();
p.Greeting("李志", p.ChineseGreeting);
p.Greeting("Tommy Li", p.EnglishGreeting);
Console.Read();
}
#region 引入委托之后
// 定义委托类型
public delegate void GreetingDelegate(string name);
// 有了委托之后，可以像如下实现打招呼方法
public void Greeting(string name, GreetingDelegate callback)
{
// 调用委托
callback(name);
}

// 英国人打招呼方法
public void EnglishGreeting(string name)
{
Console.WriteLine("Hello,  " + name);
}

// 中国人打招呼方法
public void ChineseGreeting(string name)
{
Console.WriteLine("你好, " + name);
}
public void JapaneseGreeting(string name)
{
Console.WriteLine("こんにちは, "+name);
}
#endregion

#region 没有委托的情况
//// 不使用委托实现打招呼方法
//public void Greeting(string name,string language)
//{
//    switch (language)
//    {
//        case "zh-cn":
//            ChineseGreeting(name);
//            break;
//        case "en-us":
//            EnglishGreeting(name);
//            break;
//        default:
//            EnglishGreeting(name);
//            break;
//    }
//}

//// 英国人打招呼方法
//public void EnglishGreeting(string name)
//{
//    Console.WriteLine("Hello,  "+name);
//}

//// 中国人打招呼方法
//public void ChineseGreeting(string name)
//{
//    Console.WriteLine("你好, "+name);
//}
#endregion
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MulticastDelegates
{
class Program
{
// 声明一个委托类型
public delegate void DelegateTest();
static void Main(string[] args)
{
// 用静态方法来实例化委托
DelegateTest dtstatic = new DelegateTest(Program.method1);

DelegateTest dtinstance= new DelegateTest(new Program().method2);

// 定义一个委托对象，一开始初始化为null，就是不代表任何方法（我就是我，我不代表任何人）
DelegateTest delegatechain = null;

// 使用+符号链接委托，链接多个委托后就成为委托链了
delegatechain += dtstatic;
delegatechain += dtinstance;

// 使用-运算符把dtstatic委托从委托链中移除
delegatechain -= dtstatic;

// 调用委托链
delegatechain();
Console.Read();
}

// 静态方法
private static void method1()
{
Console.WriteLine( "这是静态方法");
}

// 实例方法
private void method2()
{
Console.WriteLine( "这是实例方法");
}
}
}

事件：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EventUse
{
// 新郎官类，充当事件发布者角色
public class Bridegroom
{
// 自定义委托
public delegate void MarryHandler(string msg);

// 使用自定义委托类型定义事件，事件名为BirthdayEvent
public event MarryHandler MarryEvent;

// 发出事件
public void OnBirthdayComing(string msg)
{
// 判断是否绑定了事件处理方法
if (MarryEvent != null)
{
// 触发事件
MarryEvent(msg);
}
}

static void Main(string[] args)
{
//初始化新郎官对象
Bridegroom bridegroom =new Bridegroom();

// 实例化朋友对象
Friend friend1 = new Friend("张三");
Friend friend2= new Friend("李四");
Friend friend3 = new Friend("王五");

// 使用+=订阅事件
bridegroom.MarryEvent+=new MarryHandler(friend1.SendMessage);
bridegroom.MarryEvent += new MarryHandler(friend2.SendMessage);

// 发出通知,此时订阅了事件的对象才能收到通知
bridegroom.OnBirthdayComing("朋友们，我结婚了，到时候准时参加婚礼!");
Console.WriteLine("------------------------------------");

// 使用-=取消订阅事件,此时李四将收不到通知
bridegroom.MarryEvent -= new MarryHandler(friend2.SendMessage);

// 使用+=订阅事件，此时王五可以收到通知
bridegroom.MarryEvent += new MarryHandler(friend3.SendMessage);

// 发出通知
bridegroom.OnBirthdayComing("朋友们，我结婚了，到时候准时参加婚礼!");
Console.Read();
}
}

// 朋友类
public class Friend
{
// 字段
public string Name;

// 构造函数
public Friend(string name)
{
Name = name;
}

// 事件处理函数,该函数需要符合MarryHandler委托的定义
public void SendMessage(string mssage)
{
// 输出通知信息
Console.WriteLine(mssage);

// 对事件做出处理
Console.WriteLine(this.Name + "收到了，到时候准时参加");
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EventUseInNET
{
// 新郎官类，充当事件发布者角色
public class Bridegroom
{
// 使用.NET类库中预定义的委托类型EventHandler来定义事件
public event EventHandler MarryEvent;

// 发出事件
public void OnBirthdayComing(string msg)
{
// 判断是否绑定了事件处理方法
if (MarryEvent != null)
{
Console.WriteLine(msg);

// 触发事件
MarryEvent(this,new EventArgs());
}
}

static void Main(string[] args)
{
//初始化新郎官对象
Bridegroom bridegroom = new Bridegroom();

// 实例化朋友对象
Friend friend1 = new Friend("张三");
Friend friend2 = new Friend("李四");
Friend friend3 = new Friend("王五");

// 使用+=订阅事件
bridegroom.MarryEvent += new EventHandler(friend1.SendMessage);
bridegroom.MarryEvent += new EventHandler(friend2.SendMessage);

// 发出通知,此时订阅了事件的对象才能收到通知
bridegroom.OnBirthdayComing("朋友们，我结婚了，到时候准时参加婚礼!");
Console.WriteLine("------------------------------------");

// 使用-=取消订阅事件,此时李四将收不到通知
bridegroom.MarryEvent -= new EventHandler(friend2.SendMessage);

// 使用+=订阅事件，此时王五可以收到通知
bridegroom.MarryEvent += new EventHandler(friend3.SendMessage);

// 发出通知
bridegroom.OnBirthdayComing("朋友们，我结婚了，到时候准时参加婚礼!");
Console.Read();
}
}

// 朋友类
public class Friend
{
// 字段
public string Name;

// 构造函数
public Friend(string name)
{
Name = name;
}

// 事件处理函数，该函数需要符合EventHandler委托的定义
public void SendMessage(object s, EventArgs e)
{
// 对事件做出处理
Console.WriteLine(this.Name + "收到了，到时候准时参加");
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EventArgsExt
{
// 自定义事件类，使其带有事件数据
public class MarryEventArgs : EventArgs
{
public string Message;
public MarryEventArgs(string msg)
{
Message = msg;
}
}

// 新郎官类，充当事件发布者角色
public class Bridegroom
{
// 自定义委托类型，委托具有两个参数
public delegate void MarryHandler(object sender, MarryEventArgs e);

// 定义事件
public event MarryHandler MarryEvent;

// 发出事件
public void OnBirthdayComing(string msg)
{
// 判断是否绑定了事件处理方法
if (MarryEvent != null)
{
// 触发事件
MarryEvent(this, new MarryEventArgs(msg));
}
}

static void Main(string[] args)
{
//初始化新郎官对象
Bridegroom bridegroom = new Bridegroom();

// 实例化朋友对象
Friend friend1 = new Friend("张三");
Friend friend2 = new Friend("李四");
Friend friend3 = new Friend("王五");

// 使用+=订阅事件
bridegroom.MarryEvent += new MarryHandler(friend1.SendMessage);
bridegroom.MarryEvent += new MarryHandler(friend2.SendMessage);

// 发出通知,此时订阅了事件的对象才能收到通知
bridegroom.OnBirthdayComing("朋友们，我结婚了，到时候准时参加婚礼!");
Console.WriteLine("------------------------------------");

// 使用-=取消订阅事件,此时李四将收不到通知
bridegroom.MarryEvent -= new MarryHandler(friend2.SendMessage);

// 使用+=订阅事件，此时王五可以收到通知
bridegroom.MarryEvent += new MarryHandler(friend3.SendMessage);

// 发出通知
bridegroom.OnBirthdayComing("朋友们，我结婚了，到时候准时参加婚礼!");
Console.Read();
}
}

// 朋友类
public class Friend
{
// 字段
public string Name;

// 构造函数
public Friend(string name)
{
Name = name;
}

// 事件处理函数，该函数需要符合MarryHandler委托的定义
public void SendMessage(object s, MarryEventArgs e)
{
// 输出通知信息
Console.WriteLine(e.Message);

// 对事件做出处理
Console.WriteLine(this.Name + "收到了，到时候准时参加");
}
}
}

泛型：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _11._3__3
{
class Program
{
static void Main(string[] args)
{
// 每个封闭泛型类型都会调用其构造函数
GenericClass<int>.Print();
GenericClass<string>.Print();

// 对于非泛型类型，其构造函数只会调用一次
NonGenericClass.Print();
NonGenericClass.Print();
Console.Read();
}
}

// 泛型类
public static class GenericClass<T>
{
// 静态构造函数
static GenericClass()
{
Console.WriteLine("泛型的静态构造函数被调用了,实际类型为："+typeof(T));
}

// 静态方法
public static void Print()
{
}
}
// 非泛型类
public static class NonGenericClass
{
static NonGenericClass()
{
Console.WriteLine("非泛型的静态构造函数被调用了");
}

public static void Print()
{
}
}
}


可空类型、匿名方法、迭代器：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _12._1
{
class Program
{
static void Main(string[] args)
{
// 下面代码也可以这样子定义int? value=1;
Nullable<int> value = 1;

Console.WriteLine("可空类型有值的输出情况：");
Display(value);
Console.WriteLine();
Console.WriteLine();

value = new Nullable<int>();
Console.WriteLine("可空类型没有值的输出情况：");
Display(value);
Console.Read();
}

// 输出方法，演示可空类型中的方法和属性的使用
private static void Display(int? nullable)
{
// HasValue 属性代表指示可空对象是否有值
Console.WriteLine("可空类型是否有值：{0}", nullable.HasValue);
if (nullable.HasValue)
{
Console.WriteLine("值为: {0}", nullable.Value);
}

// GetValueOrDefault(代表如果可空对象有值,就用它的值返回,如果可空对象不包含值时,使用默认值0返回)相当与下面的语句
// if (!nullable.HasValue)
// {
// result = d.Value;
// }

Console.WriteLine("GetValueorDefault():{0}", nullable.GetValueOrDefault());

// GetValueOrDefault(T)方法代表如果 HasValue 属性为 true，则为 Value 属性的值；否则为 defaultValue 参数值,即2。
Console.WriteLine("GetValueorDefalut重载方法使用：{0}", nullable.GetValueOrDefault(2));

// GetHashCode()代表如果 HasValue 属性为 true，则为 Value 属性返回的对象的哈希代码；如果 HasValue 属性为 false，则为零
Console.WriteLine("GetHashCode()方法的使用：{0}", nullable.GetHashCode());
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _12._2
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("??运算符的使用如下：");
NullcoalescingOperator();
Console.Read();
}
// ??运算符的演示
private static void NullcoalescingOperator()
{
int? nullable = null;
int? nullhasvalue = 1;

// ??和三目运算符的功能差不多的
// 所以下面代码等价于：
// x=nullable.HasValue?b.Value:12;
int x = nullable ?? 12;

// 此时nullhasvalue不能null,所以y的值为nullhasvalue.Value,即输出1
int y = nullhasvalue ?? 123;
Console.WriteLine("可空类型没有值的情况：{0}", x);
Console.WriteLine("可空类型有值的情况：{0}", y);

// 同时??运算符也可以用于引用类型， 下面是引用类型的例子
Console.WriteLine();
string stringnotnull = "123";
string stringisnull = null;

// 下面的代码等价于：
// (stringnotnull ==null)? "456" :stringnotnull
// 也也等价于：
// if(stringnotnull==null)
// {
//      return "456";
// }
// else
// {
//      return stringnotnull;
// }

// 从上面的等价代码可以看出，有了??运算符之后可以省略大量的if—else语句，这样代码少了， 自然可读性就高了
string result = stringnotnull ?? "456";
string result2 = stringisnull ?? "12";
Console.WriteLine("引用类型不为null的情况：{0}", result);
Console.WriteLine("引用类型为null的情况：{0}", result2);
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _12._3
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("可空类型的装箱和拆箱的使用如下：");
BoxedandUnboxed();
Console.Read();
}

// 可空类型装箱和拆箱的演示
private static void BoxedandUnboxed()
{
// 定义一个可空类型对象nullable
Nullable<int> nullable = 5;
int? nullablewithoutvalue = null;

Console.Write(nullablewithoutvalue.Value);
// 获得可空对象的类型，此时返回的是System.Int32,而不是System.Nullable<System.Int32>,这点大家要特别注意下的
Console.WriteLine("获取不为null的可空类型的类型为：{0}", nullable.GetType());

// 对于一个为null的类型调用方法时出现异常，所以一般对于引用类型的调用方法前，最好养成习惯先检测下它是否为null
//Console.WriteLine("获取为null的可空类型的类型为：{0}", nullablewithoutvalue.GetType());

// 将可空类型对象赋给引用类型obj,此时会发生装箱操作，大家可以通过IL中的boxed 来证明
object obj = nullable;

// 获得装箱后引用类型的类型，此时输出的仍然是System.Int32,而不是System.Nullable<System.Int32>
Console.WriteLine("获得装箱后obj 的类型：{0}", obj.GetType());

// 拆箱成非可空变量
int value = (int)obj;
Console.WriteLine("拆箱成非可空变量的情况为：{0}", value);

// 拆箱成可空变量
nullable = (int?)obj;
Console.WriteLine("拆箱成可空变量的情况为：{0}", nullable);

// 装箱一个没有值的可空类型的对象
obj = nullablewithoutvalue;
Console.WriteLine("对null的可空类型装箱后obj 是否为null：{0}", obj == null);

// 拆箱成非可空变量,此时会抛出NullReferenceException异常,因为没有值的可空类型装箱后obj等于null,引用一个空地址
// 相当于拆箱后把null值赋给一个int 类型的变量,此时当然就会出现错误了
//value = (int)obj;
//Console.WriteLine("一个没有值的可空类型装箱后，拆箱成非可空变量的情况为：{0}", value);

// 拆箱成可空变量
nullable = (int?)obj;
Console.WriteLine("一个没有值的可空类型装箱后，拆箱成可空变量是否为null：{0}", nullable == null);
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace _12._9
{
class Program
{
static void Main(string[] args)
{
// 创建一个对象
Friends friendcollection = new Friends();
// Friends实现了IEnumerable所以可以使用foreach语句进行遍历
foreach (Friend f in friendcollection)
{
Console.WriteLine(f.Name);
}

Console.Read();
}

// 朋友类
public class Friend
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public Friend(string name)
{
this.name = name;
}
}

// 朋友集合
public class Friends : IEnumerable
{
private Friend[] friendarray;

public Friends()
{
friendarray = new Friend[]
{
new Friend("张三"),
new Friend("李四"),
new Friend("王五")
};
}

// 索引器
public Friend this[int index]
{
get { return friendarray[index]; }
}

public int Count
{
get { return friendarray.Length; }
}

// 实现IEnumerable<T>接口方法
public IEnumerator GetEnumerator()
{
return new FriendIterator(this);
}
}

//  C#1.0中实现迭代器代码——必须实现 IEnumerator接口
public class FriendIterator : IEnumerator
{
private readonly Friends friends;
private int index;
private Friend current;
internal FriendIterator(Friends friendcollection)
{
this.friends = friendcollection;
index = 0;
}

// 实现IEnumerator接口中的方法
public object Current
{
get
{
return this.current;
}
}

public bool MoveNext()
{
if (index + 1 > friends.Count)
{
return false;
}
else
{
this.current = friends[index];
index++;
return true;
}
}

public void Reset()
{
index = 0;
}
}
}
}

Lambda表达式：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _14._1
{
class Program
{
static void Main(string[] args)
{
// Lambda表达式的演变过程
// 下面是C# 1中创建委托实例的代码
Func<string, int> delegatetest1 = new Func<string, int>(Callbackmethod);

// ↓
// C# 2中用匿名方法来创建委托实例，此时就不需要额外定义回调方法Callbackmethod
Func<string, int> delegatetest2 = delegate(string text)
{
return text.Length;
};
// ↓
// C# 3中使用Lambda表达式来创建委托实例
Func<string, int> delegatetest3 = (string text) => text.Length;

// ↓
// 可以省略参数类型string,把上面代码再简化为：
Func<string, int> delegatetest4 = (text) => text.Length;

// ↓
// 此时可以把圆括号也省略,简化为：
Func<string, int> delegatetest = text => text.Length;

// 调用委托
Console.WriteLine("使用Lambda表达式返回字符串的长度为： " + delegatetest("learning hard"));
Console.Read();
}

// 回调方法
private static int Callbackmethod(string text)
{
return text.Length;
}
}
}

using System;
using System.Windows.Forms;

namespace _14._2
{
class Program
{
static void Main(string[] args)
{
// 新建一个button实例
Button button1 = new Button();
button1.Text = "点击我";

// C# 2中使用匿名方法来订阅事件
button1.Click += delegate(object sender, EventArgs e)
{
ReportEvent("Click事件", sender, e);
};
button1.KeyPress += delegate(object sender, KeyPressEventArgs e)
{
ReportEvent("KeyPress事件，即键盘按下事件", sender, e);
};

// C# 3之前初始化对象时使用下面代码
Form form = new Form();
form.Name = "在控制台中创建的窗体";
form.AutoSize = true;
form.Controls.Add(button1);
// 运行窗体
Application.Run(form);
}

// 记录事件的回调方法
private static void ReportEvent(string title, object sender, EventArgs e)
{
Console.WriteLine("发生的事件为：{0}", title);
Console.WriteLine("发生事件的对象为：{0}", sender);
Console.WriteLine("发生事件参数为： {0}", e.GetType());
Console.WriteLine();
Console.WriteLine();
}
}
}

using System;
// 引入Expression<TDelegate>类的命名空间
using System.Linq.Expressions;

namespace _14._6
{
class Program
{
// 构造a+b表达式树结构
static void Main(string[] args)
{
// 表达式的参数
ParameterExpression a = Expression.Parameter(typeof(int), "a");
ParameterExpression b = Expression.Parameter(typeof(int), "b");

// 表达式树主体部分
BinaryExpression be = Expression.Add(a, b);

// 构造表达式树
Expression<Func<int, int, int>> expressionTree = Expression.Lambda<Func<int, int, int>>(be, a, b);

// 分析树结构，获取表达式树的主体部分
BinaryExpression body = (BinaryExpression)expressionTree.Body;

// 左节点,每个节点本身就是一个表达式对象
ParameterExpression left = (ParameterExpression)body.Left;

// 右节点
ParameterExpression right = (ParameterExpression)body.Right;

// 输出表达式树结构
Console.WriteLine("表达式树结构为："+expressionTree);
// 输出
Console.WriteLine("表达式树主体为：");
Console.WriteLine(expressionTree.Body);
Console.WriteLine("表达式树左节点为：{0}{4} 节点类型为：{1}{4}{4} 表达式树右节点为：{2}{4} 节点类型为：{3}{4}", left.Name, left.Type, right.Name, right.Type, Environment.NewLine);

Console.Read();
}
}
}

using System;
// 引入Expression<TDelegate>类的命名空间
using System.Linq.Expressions;

namespace _14._4
{
class Program
{
static void Main(string[] args)
{
// 将lambda表达式构造成表达式树
Expression<Func<int, int, int>> expressionTree = (a, b) => a + b;

// 获得表达式树参数
Console.WriteLine("参数1：{0},参数2: {1}", expressionTree.Parameters[0], expressionTree.Parameters[1]);
// 获取表达式树的主体部分
BinaryExpression body = (BinaryExpression)expressionTree.Body;

// 左节点,每个节点本身就是一个表达式对象
ParameterExpression left = (ParameterExpression)body.Left;

// 右节点
ParameterExpression right = (ParameterExpression)body.Right;

Console.WriteLine("表达式树主体为：");
Console.WriteLine(expressionTree.Body);
Console.WriteLine("表达式树左节点为：{0}{4} 节点类型为：{1}{4}{4} 表达式树右节点为：{2}{4} 节点类型为：{3}{4}", left.Name, left.Type, right.Name, right.Type, Environment.NewLine);
Console.Read();
}
}
}

using System;
// 引入Expression<TDelegate>类的命名空间
using System.Linq.Expressions;

namespace _14._5
{
class Program
{
static void Main(string[] args)
{
// 将lambda表达式构造成表达式树
Expression<Func<int, int, int>> expressionTree = (a, b) => a + b;
// 通过调用Compile方法来生成Lambda表达式的委托
Func<int,int,int> delinstance =expressionTree.Compile();
// 调用委托实例获得结果
int result = delinstance(2, 3);
Console.WriteLine("2和3的和为：" + result);
Console.Read();
}
}
}

动态类型：
using System;
using System.Dynamic;

namespace _18._1
{
class Program
{
static void Main(string[] args)
{
dynamic expand = new ExpandoObject();
// 动态绑定成员
expand.Name = "Learning Hard";
expand.Age = 24;
expand.Addmethod = (Func<int, int>)(x => x + 1);
// 调用类型成员
Console.WriteLine("expand类型的姓名为：" + expand.Name + " 年龄为： " + expand.Age);
Console.WriteLine("调用expand类型的动态绑定的方法：" + expand.Addmethod(5));
Console.Read();
}
}
}