class Program
{
static void Main(string[] args)
{
init();
System.Console.ReadKey();
}
#region 接口
/// <summary>
/// 接口成员是公共的，不能加其他修饰符,如static,public,virtual等
/// </summary>
public interface IA
{
string IStr { get; set; }
void IMethod();
}
public interface IB
{
string IStr { get; set; }
void IMethod();
}
#endregion
#region B
public class B
{
public virtual void Do()
{
System.Console.WriteLine("B -Do");
}
public virtual void Go()
{
System.Console.WriteLine("B -Go");
}
public void Say()
{
System.Console.WriteLine("B -Say");
}
}
#endregion
#region C
public abstract class C : B
{
#region 私有成员
private int i = 0;
#endregion
#region 构造函数
public C()
{
System.Console.WriteLine("C()");
}
public C(int i)
{
this.i = i;
System.Console.WriteLine("C(int i)");
}
#endregion
/// <summary>
/// 覆盖
/// </summary>
public override void Do()
{
System.Console.WriteLine("C -Do");
}
/// <summary>
/// 隐藏
/// </summary>
public new void Say()
{
System.Console.WriteLine("C -Say");
}
/// <summary>
/// 覆盖和密封，sealed必须和override一起使用
/// </summary>
public override sealed void Go()
{
System.Console.WriteLine("C -Go");
}
/// <summary>
/// 只读抽象属性,虚方法和抽象方法不能为private,抽象成员所属类只能是抽象类
/// </summary>
public abstract string AbStr { get; }
public abstract string AbMethod();
protected abstract void AbProtected();
}
#endregion
#region D
/// <summary>
/// 类单继承，接口多实现
/// </summary>
public class D : C, IA, IB, IComparable, IComparer
{
#region 私有成员
private int i = 0;
private int timeCount = 0;
/*默认是私有的*/
System.Timers.Timer aTimer;
#endregion
#region 构造函数 this base
/*
* 在一开始掉用该类时，初始化一次
*/
/// <summary>
/// 静态构造函数,只能为私有的,不能有参数,不能被外部所更改
/// </summary>
static D()
{
System.Console.WriteLine("Static D()");
}
/*
* 实例化是:从之类到父类传递值，并从父类到之类的实例化过程
*/
public D()
: this(1)
{
System.Console.WriteLine("D()");
}
public D(int i)
: base(i)
{
//this关键字指向本类实例
this.i = i;
System.Console.WriteLine("D(int i)");
}
#endregion
#region 方法的覆盖、隐藏、密封 sealed new
public override void Do()
{
System.Console.WriteLine("D -do");
}
public new void Say()
{
System.Console.WriteLine("D -Say");
}
#endregion
#region 实现父类抽象成员 override
/// <summary>
/// 基础父类抽象成员
/// </summary>
public override string AbStr
{
get
{
return "AbStr";
}
}
/// <summary>
/// 基础父类抽象成员
/// </summary>
public override string AbMethod()
{
return "AbMethod";
}
/// <summary>
/// 访问级别只能小于等于保护级别，不能高于基类的访问级别
/// </summary>
protected override void AbProtected()
{
}
#endregion
#region 索引器
/// <summary>
/// 索引器
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public string this[int i]
{
get
{
return "this[int i] " + i;
}
}
/// <summary>
/// 索引器2
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public string this[string i]
{
get
{
string r = string.Empty;
switch (i)
{
case "A":
r = "this[string i] A";
break;
case "B":
r = "this[string i] B";
break;
default:
break;
}
return r;
}
}
#endregion
#region IA IB 接口成员
/// <summary>
/// 隐式调用，多个接口同名成员可用一个成员实现,访问级别必须为public
/// </summary>
public string IStr
{
get
{
return "";
}
set
{
}
}
/*接口二义性 分开实现同名接口成员,显示实现，不能用public等修饰符，通过实例转换为接口类型来调用相应的私用方法
例如：D d = new D();
((IA)d).IMethod();
((IB)d).IMethod();
*/
/// <summary>
/// 显示实现IA接口，
/// </summary>
void IA.IMethod()
{
System.Console.WriteLine("IA.IMethod()");
}
/// <summary>
/// 显示实现IB接口，分开实现同名接口成员
/// </summary>
void IB.IMethod()
{
System.Console.WriteLine("IB.IMethod()");
}
#endregion
#region 委托和事件 delegate event
//使用委托和事件比较典型的例子是：观察者模式
/*1.单独使用委托，代码封装性易用性较差。
*2.委托返回一般为void,根据委托链，返回最后一个方法执行的返回值
*/
public delegate string DgNoEvent(string str);
public DgNoEvent dgNoEvent;
/*2.将委托与事件结合
* 一方面是为了封装性、易用性
* 另外一方面是防止通过调用委托变量,在外部调用该委托方法。方法应该在封装的方法内被触发
*/
public delegate string DgEventHandler(string str);
public event DgEventHandler dgEvent;
public void DgGo()
{
if (dgEvent != null)
{
//同步调用
dgEvent("dgEvent");
//异步调用,部分代码执行时间过长，可能会影响程序执行。观察者用异步，这样就不影响发布者。
AsyncCallback callBack = new AsyncCallback(OnAddComplete);
//IAsyncResult iAsyncResult = dgEvent.BeginInvoke("AsyncdgEvent", callBack, null);
}
if (dgNoEvent != null)
dgNoEvent("dgNoEvent");
}
void OnAddComplete(IAsyncResult asyncResult)
{
IAsyncResult result = (IAsyncResult)asyncResult;
string data = (string)asyncResult.AsyncState;
System.Console.WriteLine(data);
}
#endregion
#region 多线程互斥锁 lock
/*
* 多线程的资源争用情况，使用互斥锁，让线程等待
*/
public void OnStart()
{
try
{
aTimer = new System.Timers.Timer();
//同步调用
aTimer.Elapsed += OnTimedEvent;
aTimer.Interval = 1000;
aTimer.Enabled = true;
}
catch (Exception ex)
{
System.Console.WriteLine("异常");
}
}
void OnTimedEvent(object source, ElapsedEventArgs e)
{
lock (this)
{
//只循环两次
if (timeCount >= 2)
{
aTimer.Enabled = false;
aTimer.Elapsed -= OnTimedEvent;
return;
}
timeCount++;
for (int i = 0; i < 5; i++)
{
Thread.Sleep(2000);
System.Console.WriteLine("线程" + Thread.CurrentThread.ManagedThreadId + "停止" + i + "秒");
}
}
}
#endregion
#region lambda表达式、匿名方法
/*
* lambda 表达式是一个可用于创建委托对象或表达式树类型的匿名函数
(input parameters) => {statement;}
*/
delegate bool Lambda1NoEventHandler(string str);
delegate string Lambda2NoEventHandler(string str, int i);
delegate void Lambda0NoEventHandler();
public void LambdaAndAnonmous()
{
//lambda方式
Lambda0NoEventHandler l0 = () => System.Console.WriteLine("Lambda0");
Lambda1NoEventHandler l1 = (str) => str.Equals("A");
Lambda2NoEventHandler l2 = (str, i) => { System.Console.WriteLine(str); return ""; };
l0();
l1("A");
l2("lambda2", 0);
//匿名方法，匿名类型
/*
* var变量，编译器会去判断该类型
*/
var a = new { s = "", d = "" };
l2 = delegate(string str, int i)
{
System.Console.WriteLine(str);
return "";
};
l2("anonmous", 0);
}
#endregion
#region 迭代器 GetEnumerator
/*实现该迭代器之后，可对该对象进行foreach遍历*/
public IEnumerator GetEnumerator()
{
yield return "1";
yield return "2";
yield return "3";
}
#endregion
#region 比较 IComparer is typeof
#region IComparer Members
public int Compare(object x, object y)
{
D d1 = (D)x;
D d2 = (D)y;
if (d1.i > d2.i)
return 1;
if (d1.i == d2.i)
return 0;
return -1;
}
#endregion
#region IComparable Members
public int CompareTo(object obj)
{
D d1 = (D)obj;
if (i > d1.i)
return 1;
if (i == d1.i)
return 0;
return -1;
}
#endregion
/*类型比较*/
public void CompareType()
{
D d = new D();
/*类型需完全一致*/
if (d.GetType() == typeof(C))
{
System.Console.WriteLine("d.GetType() == typeof(C)");
}
/*is 判断是否可以转换为指定类型*/
if (d is B)
{
System.Console.WriteLine("d is B");
}
}
#endregion
#region 运算符重载
/*加号两边参数要按顺序调用*/
public static string operator +(D d1, D d2)
{
string str = d1.GetType().ToString() + d2.GetType().ToString();
System.Console.WriteLine("operator +(D d1, D d2)");
return "str";
}
public static string operator +(D d, C c)
{
string str = c.GetType().ToString() + d.GetType().ToString();
System.Console.WriteLine("operator +(D d, C c)");
return "str";
}
public static string operator +(C c, D d)
{
string str = c.GetType().ToString() + d.GetType().ToString();
System.Console.WriteLine("operator +(C c, D d)");
return "str";
}
/*隐式的转换运算符 D d=0; */
public static implicit operator D(int i)
{
D d = new D();
d.i = i;
return d;
}
/*显示的转换运算符 D d=(D)"0";*/
public static explicit operator D(string str)
{
D d = new D();
d.IStr = str;
return d;
}
#endregion
#region 可空类型和??空接合运算符
public void Nullable()
{
int? i = null;
int j = i ?? 0;
}
#endregion
#region 泛型default和各种约束
/*
* T:有一个无参数构造函数
* K:必须是值类型
* L:必须是引用类型
* M1-M2:M1和M2必须类型相同，或者M1继承至M2
* N:N和C必须类型相同，或者继承至C
* N2:N2必须实现IA接口
*/
public T Tnew<T, K, L, M1, M2, N, N2>()
where T : new()
where K : struct
where L : class
where M1 : M2
where N : C
where N2 : IA
{
/*赋予默认值，数值型为0,类为null等*/
return default(T);
}
#endregion
#region 变体：协变(out)和抗变(in)
/*
* 协变和抗变只能用在引用类型上面，不能用在值类型上面。
* 协变和抗变只能用在泛型委托和泛型接口上面。
*/
public interface IIndex<out T>
{
T this[int index] { get; }
int Count { get; }
}
public class RectangleBase { public int ID { get; set; } }
public class Rectangle : RectangleBase { public string Name { get; set; } }
public class RectangleCollection : IIndex<Rectangle>
{
List<Rectangle> list = new List<Rectangle>();
public Rectangle this[int index]
{
get
{
if (index < 0 || index > Count)
throw new ArgumentOutOfRangeException("index");
return list[index];
}
}
public int Count { get { return list.Count; } }
public void Add(Rectangle value) { list.Add(value); }
}
public void Variance()
{
D d = new D();
var list = new RectangleCollection();
list.Add(new Rectangle { ID = 1, Name = "111" });
list.Add(new Rectangle { ID = 2, Name = "222" });
list.Add(new Rectangle { ID = 3, Name = "33" });
//使用了out关键字，可以转换为base类型
IIndex<RectangleBase> Bas = list;
IIndex<Rectangle> Basa = list;
for (int i = 0; i < Bas.Count; i++)
{
System.Console.WriteLine(Bas[i].ID);
}
System.Console.Read();
}
#endregion
#region 初始化器、匿名类型、类型查找Var
/*
* 不用新建一个多个参数的构造函数
*/
public void InitMethod()
{
/*类初始化器*/
D d = new D()
{
i = 0,
IStr = "a"
};
/*集合*/
//普通方法
int[] s3 = new int[2];
s3[0] = 1;
s3[1] = 0;
//集合初始化器
int[] s = new int[] {
1,0,1,2,2,3
};
int[] s2 = {
1,0,1,2,2,3
};
/*匿名类型*/
var a = new { s = "", d = "" };
var ass = new[] { new { s = "", d = "" }, new { s = "", d = "" } };
string str = a.s;
}
#endregion
#region 动态查找 dynamic
public dynamic Getdynamic()
{
if (i == 0)
return new B();
else
return new D();
}
#endregion
#region 高级方法参数：可选参数、参数不固定、传递值类型的引用 out ref
//可选值只能位于方法的末尾，不能放置于没有默认值的参数之前
void HightlevelArg(int i, bool b = true, bool c = false)
{
HightlevelArg(1);
HightlevelArg(1, false);
//也可以这么调用，跳过中间参数
HightlevelArg(1, c: true);
}
/*参数数组，可变个数的参数*/
void Args(params int[] i)
{
int length = i.Count();
//这么调用
Args(1, 1, 1, 1);
}
/*
* out:必须在方法体内初始化
* ref:必须在外部初始化
*/
void ArgsOutIn(out int i, ref int j)
{
//out 在方法体内初始化
i = 0;
}
#endregion
#region 扩展方法,表达式树
/*静态类 静态方法 第一个参数 this string obj */
public void Expression()
{
Expression<Func<int, int, int>> expression = (a, b) => a * b + 2;
dynamic f = Getdynamic();
}
#endregion
}
#endregion
#region init()
public static void init()
{
/*1.抽象，继承，封装，覆盖，隐藏，密封，实例化，静态构造函数，实现*/
B b = new B();
b.Do();
b.Say();
b.Go();
D d = new D();
d.Do();
d.Say();
d.Go();
b = d;
b.Do();
b.Say();
b.Go();
/*2.调用私有的显示实现接口的成员*/
((IA)d).IMethod();
string abStr = d.AbStr;
/*3.索引器*/
System.Console.WriteLine(d["A"]);
System.Console.WriteLine(d["B"]);
System.Console.WriteLine(d[0]);
/*4.委托和事件*/
d.dgNoEvent = new D.DgNoEvent(GGG);
//可以直接调用，失去了委托意义，是不符合正道的。
d.dgNoEvent("dgNoEvent outSide the Delegate");
//这样才是正道
d.dgEvent += GGG;
/*5.lambda表达式建立对象
() => SomeMethod()
*/
d.dgEvent += strParam =>
{
System.Console.WriteLine(strParam + " by lambda ");
return "";
};
/*6.匿名方法，建立委托对象 */
// 通过使用匿名方法，由于您不必创建单独的方法，因此减少了实例化委托所需的编码系统开销。
var a = new { s = "", d = "" };
d.dgEvent += delegate(string str)
{
System.Console.WriteLine(str + " by 匿名委托对象 ");
return "";
};
d.DgGo();
/*7.多进程互斥锁*/
d.OnStart();
}
private static string GGG(string str)
{
System.Console.WriteLine(str);
return "";
}
#endregion
}
