c#高级语法

构造函数析构函数

class MyClass
{
	public MyClass() //可以添加参数
	{
	
	}
	private MyClass()//如果是私有则无法new 类对象
	{}
	
}
析构函数
class MyClass
{
	~MyClass()
	{}
}

特性

[Obsolete()]//提示过时的方法
[contional(IsTest)]//取消该方法的调用，判断是否被定义，没有被定义就不能被调用。

//1，特性类以Attribute结尾,
//2，需要继承System.Attribute
//3，声明sealed 
//4，一般情况下表示目标结构的状态.一般定义属性不定义方法。
[AttributeUsage(AttributeTarget.Class)]//表示该特性类可以应用道德程序结构有哪些。
sealed class MyTestAttribute：System.Attribute{
public string Description{get;set;}
public int ID{get;set;}
public MyTestAttribute(string des){
this.Description=des;
}
}

[MyTest("easy"，ID=200)]//使用特性，添加描述，通过制定属性的名字给属性赋值叫命名参数
class Program{
}
Type type=typeof(progrem)//
obgect[] array=type.GetCustomAttribute(false);//是否检索父类的特性
MyTestAttribute mytest=array[0] as MyTestAttribute;
mytest.Description;//打印特性类的描述
mytest.ID;//打印特性类的字段值

委托（一）模版

//创建与方法相同参数类型的委托
public delegate void a(string s);
class Program
{
	static void Test1(string str)
	{
		Console.WriteLine("test1");
	}
		static void Test2(string str)
	{
		Console.WriteLine("test2");
	}
}
static void Main()
{
	a D1;          //实例化委托
	D1 +=Test1;    //给委托添加方法
	D1 -=Test1;    //给委托删除方法
	D1("1")；      //通过委托调用方法
}

Delegate[] delegates=a1.GetlnvocationList();//返回委托的集合
foreach(delegate d in delegates){
	d.Dynamiclnvoke(null);
}

委托（二）回调

static void Test3(a d)
{
	id (d!=null)
	{
		d("3")
	}
}
	a D2;          //实例化委托
Test3(D2);

事件

1拥有者
2事件
3事件的响应者
4事件处理器
5事件的订阅

startic void Main()
{
	Customer customer=new Customer ();
	Waiter waiter=new Waiter();
	customer.Order+=Waiter.Action;
	customer.Action();
	customer. PayTheBill()
}

//传递时间消息的类后缀为EventArgs,自定传递参数类型
public class OrderEventArgs：EventArgs
{
	public string DishName{}
	public string Size{}
}

public delegate void OrederEventHandler(Customer customer,OrderEventArgs e);//委托是为了声明事件准备的需要EventHandler作为后缀





//事件拥有者
public class Customer
{
	private OrderEventHandler OrderEventHandler;
	public event OrderEventHandler Order{
		add{
		this.orderEventHandler += value；
	}
	remove
	{
		this.orderEventHandler -= value；
	}
	}
	public double Bill{get;set;}
	public void PayTheBill()
	{
		Console.WriteLine("i will pay ${o}.",this.Bill);
	}
	//事件触发方法
	public	void	 WalkIn()
	{
		Console.WriteLine("Walk into  the restaurant");
	}
	public void SitDown()
	{
		Console.WriteLine("Sit down");
	}
	public void Think()
	{
		for(int i=0;I<5,i++)
		{
			Console.WriteLine("Let me think...");
			Thread.Sleep(1000);
		}
		if(this.orderEventHandler !=null)//判断引用的委托是否为空，是否有人响应事件
		{
			OrderEventArgs e=new OrderEventArgs();
			e.DishName="Kon Chicken";
			e.Size-"Large"
			this.order.EventHandler.Invoke(this,e)
		}
	}
	public void Action()
	{
		Console.ReadLine();//等待执行
		this.WalkIn();
		this.SitDown();
		this.Think();
	}

}

class Waiter
{
	internal void Action(Customer customer,OrderEventArgs e)
	{
		Console.WriteLine("")
		double price=10;
		switch(e.Size)
		{
			case "small":
				price=price*0.5;
				break;
			case "large":
				price=price*1.5;
				break;
			defaule:
				break;
		}
		customer.Bill+=price;
	}
}

//简化声明事件
public event OrderEventHandler Order;

协成

yield return unll 结束这一帧
yield return WaitForSeconds 挂起一个时间
yield return ForEndOfFrame 帧结束的时候挂起一帧
yield return WaitForFixedUpdate 挂起一个间隔
yield return Another coroutione 等待一个协成
yield return WWW 等待网络

c#委托开启多线程

static int Test(int i,string str)
{
	Console.WriteLine("test"+i+str)
	thread.Sleep(100);//暂停0.1s
	return 100;
}
static void Main(string[] args)
{
//通过委托开启线程
	Func<int,string,int>a=Test;
	//开启线程去执行a方法
	a.BeginInvoke(100,"siki",nul,null);
	//IAsyncResul可以获得当前线程状态
	IAsyncResul ar=Counsole.WriteLine("main");
	while（ar.IsCompleted==false）
	{
		Counsole.WriteLine(".");
		thread.Sleep(100);//控制子线程的检测频率
	}
	int res=a.EndInvoke(ar);//去的异步线程返回值
	Console.ReaderKey();
}

获取线程结束

bool isEnd=ar.AsyncWaitHandle.WaiteOne(1000);//1000毫秒表示最大等待时间时间，事件之后会自动返回false，结束立即返回true.
if(isEnd)
{
	int res=a.EndInvoke(ar);
	Console.WriteLine(res);
}
Console.ReaderKey();

异步回调

	Func<int,string,int>a=Test;
	//第一个null是委托类型的参数，表示回调函数，线程结束时调用这个方法
	//最后一个null，用来给回调函数传递数据
	//开启线程去执行a方法
	IAsyncResul ar=a.BeginInvoke(100,"siki",nul,null);//线程结束会调用第一个null

static void OnCallBack(IAsyncResul ar)
{
	Func<int,string,int> a=ar.AsyncState as Func<int,string,int>;
	a.EndInvoke(ar);
	Console.WriteLine("子线程end");
}

a.BeginInvoke(100,"siki",ar=>
{
	int res=a.EndInvoke(ar);
	Console.ReaderKey();
},null);

Thread类

static void DownloadFile()
{
	Thread.Sleep(2000);
}

static void Main()
{
	Thread t=new(DownloadFile);
	t.Start();//开启线程
	
}

lanm 表达式

Thread t=new Thread (()=>
{
	Thread.Sleep(2000);
});
t.Start();

获取线程id
Thread.CurrentThread.ManagedThreadId

//线程传参
t.Start("xxx")

private string filename;

public MyThread(string name)
{
	this.filename=name;
}

后台线程，前台线程
thread创建的线程是前台线程。
前台线程结束则相应的后台线程也结束

Thread t=new(DownloadFile);
t.IsBackground=true;//设置为后台线程
t.Start();

线程优先级
Priorty设置线程优先级
控制线程
线程状态runing unstarted
t.join()

线程池

static void ThreadMethod(object state)
{
console.WriteLine("线程开始"+Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(2000);
console.WriteLine();
}
static void Main()
{//开启多个线程池线程
	ThreadPool.QueueUserWorkItem(ThreadMethod);
	ThreadPool.QueueUserWorkItem(ThreadMethod);
	ThreadPool.QueueUserWorkItem(ThreadMethod);
	ThreadPool.QueueUserWorkItem(ThreadMethod);
}

接口

var user =newPhoneUser(new NokiaPhone){//继承接口类型，降低耦合
	user.UserPhone();
}
class PhoneUser{
public PhoneUser(Iphone phone){//传入接口
	_phone=phone;
}
public void UsePhone(){
	_phone.Dail();
	_phone.PickUp();	
}
interface Iphone{}
class NokiaPhone:Iphone(){}

Linq

var res=from m in masterList
where m.Level>8 select m;//表示把m的结果返回
select m.Name;//返回m的name的集合