目录
委托的使用
委托的概念，简单匿名函数与lamda表达式使用
委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用语句，同时使得程序具有更好的可扩展性。
把一个方法作为参数传给另一个方法
委托内部由三部分：1，_methodPtr，是一个方法指针，指向当前委托指向的方法的内存地址；
2，_target，目标对象，如下
Program p=new Program();
del += p.AddStaticFunc1;
中，方法指针指向的是AddStaticFunc1方法，目标对象就是p
3、委托链，就是一个委托数组，定义委托实例AddDel del = new AddDel(AddStaticFunc);的背后就是创建这三个部分，当指向的方法为静态方法的时候，_target为null。
执行的时候，从委托链的第0个索引到最后一个索引，因此多播委托返回的是最后一个方法的执行结果。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 委托概念
{
internal class Program
{
//声明一个委托指向一个函数
//委托指向的参数必须跟委托具有相同的签名
public delegate void DelSayHi(string name);
static void Main(string[] args)
{
//DelSayHi del = English;//new DelSayHi(English);
//del("张三");
//test("张三",Chinese);
//test("李四", English);
/*DelSayHi del=delegate (string s)
{
Console.WriteLine("中文" + s);
};*/
DelSayHi del = (string s)=>
{
Console.WriteLine("中文" + s);
};
//lamda表达式，匿名函数的简写形式 => goes to
del("张三");
Console.ReadKey();
}
public static void test(string name, DelSayHi del)
{
del(name);
}
public static void Chinese(string name)
{
Console.WriteLine("中文"+name);
}
public static void English(string name)
{
Console.WriteLine("英文" + name);
}
}
}
委托的定义与使用
委托的定义与使用：
代码1：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp1
{
//定义一个委托类型
delegate int AddDel(int a, int b);
internal class Program
{
static void Main(string[] args)
{
//定义一个委托的实例
AddDel del = new AddDel(AddStaticFunc);
//触发实例
int r = del(3, 4);
Console.WriteLine(r);
Console.ReadKey();
}
//定义一个符合委托规范的方法
public static int AddStaticFunc(int a,int b)
{
return a + b;
}
}
}
结果输出：7
代码2：
匿名函数使用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 委托
{
internal class Program
{
public delegate string DelProStr(string name);
static void Main(string[] args)
{// ProStrSYH(names);
string[] names = { "abcdEFG", "HIjklMn" };
ProStr(names, delegate(string name)
{
return name.ToUpper();
});
//匿名函数，用delegate代替，只执行一次用
for (int i = 0; i < names.Length; i++)
{
Console.WriteLine(names[i]);
}
Console.ReadKey();
}
public static void ProStr(string[] name,DelProStr del)
{
for (int i = 0; i < name.Length; i++)
{
name[i] = del(name[i]);
}
}
/* public static string StrToUpper(string n)
{
return n.ToUpper();
}
public static string StrToLower(string n)
{
return n.ToLower();
}
public static string StrSYH(string name)
{
return "\"" + name + "\"";
}*/
/* public static void ProStrToUpper(string[] name)
{
for(int i = 0; i < name.Length; i++)
{
name[i] = name[i].ToUpper();
}
}
public static void ProStrToLower(string[] name)
{
for (int i = 0; i < name.Length; i++)
{
name[i] = name[i].ToLower();
}
}
public static void ProStrSYH(string[] name)
{
for (int i = 0; i < name.Length; i++)
{
name[i] = "\"" + name[i]+ "\"";
}
}*/
}
}
输出：
ABCDEFG
HIJKLMN
多播委托
多播委托1：
Program p=new Program();
del += p.AddStaticFunc1;
public int AddStaticFunc1(int a, int b)
{
return a + b+1;
}
执行结果：8
使用多播委托时，拿到的委托返回值是最后一个委托指向的方法的执行结果。
多播委托2：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 委托
{
//可以指向多个函数
public delegate void DelTest();
internal class Program
{
static void Main(string[] args)
{
DelTest del = T1;
del += T2;
del -= T1;
del();
Console.ReadKey();
}
public static void T1()
{
Console.WriteLine("T1");
}
public static void T2()
{
Console.WriteLine("T2");
}
public static void T3()
{
Console.WriteLine("T3");
}
public static void T4()
{
Console.WriteLine("T4");
}
}
}
执行结果：T2 T3 T4
泛型委托
简单例子：
Func<int, int,int> funcDemo = new Func<int, int,int>(AddStaticFunc);
int result=funcDemo(1,2);
Console.WriteLine(result);
public static int AddStaticFunc(int a,int b)
{
return a + b;
}
结果是3。
Func原构造函数：
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
可以有很多个int，但是要有一个out，最后一项是用来约束返回值的。
匿名方法
Func<int, int,int> funcDemo = delegate(int a,int b) { return a + b; };
Lamda表达式
Func<int, int,int> funcDemo = (int a,int b)=> { return a + b; };
或
Func<int, int,int> funcDemo = (int a,int b)=> a + b;
例子：
public delegate void DelOne();
public delegate void DelTwo(string name);
public delegate string DelThree(string name);
static void Main(string[] args)
{
//DelOne del = delegate () { };
DelOne del = () => { };
//DelTwo del2 = delegate(string name) { };
DelTwo del2 = (string name) =>{};
/*DelThree del3 = (string name) =>{
return name;
};*/
DelThree del3 = delegate (string name)
{
return name;
};
List<int> list=new List<int> { 1, 2, 3 };
list.RemoveAll(n => n > 4);
//lamda表达式
}
举例
List<string> list = new List<string>()
{
"3","9","32","7","2"
};
var temp = list.Where(delegate (string a)
{
return a.CompareTo("6") < 0;
});
foreach (var v in temp)
{
Console.WriteLine(v);
}
Console.ReadKey();
where是扩展方法，内部会遍历list集合，把每个元素传到委托里执行，如果返回true，就把元素选择出来，最后把所有满足条件的元素一起返回
扩展方法
三要素：静态类、静态方法、this关键字
重新定义where方法
定义：
public static class Class1
{
public static List<T> myWhere<T>(this List<T> list,Func<T,bool> funcWhere)
{
List<T> result = new List<T>();
foreach (var item in list)
{
if (funcWhere(item))
{//调用委托，如果满足条件，加到集合中
result.Add(item);
}
}
return result;
}
}
调用：
List<string> list = new List<string>(){ "3","9","32","7","2"};
匿名方法：
var temp = list.myWhere(delegate (string a)
{
return a.CompareTo("6") < 0;
});
lamda表达式
var temp = list.myWhere<string>(a => a.CompareTo("6") < 0);
方法泛型的约束可以省略，但是如果是显式的约束就必须满足约束。
即<string>可以省略不写，就像var demo = "sss";一样，编译器会自动推断类型
foreach (var v in temp)
{
Console.WriteLine(v);
}
Console.ReadKey();
winform间窗体传值
传统方法
form1和form2两个类之间传值，在from1定义一个form2的对象，并将form2中文本框设置为外部可访问，如下所示。
form1:
public Form2 myForm2 { get; set; }
private void button2_Click(object sender, EventArgs e)
{
myForm2.textBox2.Text = this.textBox1.Text;
}
form2的designer中：
public System.Windows.Forms.TextBox textBox2;
但是，对象内部的字段或者元素最好不要直接让外部访问，最好通过设置的方法控制一下。
例如，设置为私有后，在子窗体定义函数，父窗体中的子窗体对象调用函数：
public void SetText(string txt)
{
textBox2.Text = txt;
}
myForm2.SetText(this.textBox1.Text);
使用委托
主窗体发送消息：点击按钮执行委托，给委托传递参数（当前文本框的内容），子窗体想接收就注册主窗体的委托，把子窗体的方法注册到委托中，执行时，委托执行每个子窗体的方法
主窗体发布，子窗体订阅
主窗体：点击按钮，执行委托
public Action<string> AfterMsgSend { get; set; }
public Form2 myForm2 { get; set; }
private void button2_Click(object sender, EventArgs e)
{
if(AfterMsgSend == null)
{
return;
}
AfterMsgSend(this.textBox1.Text);
}
private void Form1_Load(object sender, EventArgs e)
{
Form2 frm = new Form2();
myForm2 = frm;
//关注主窗体消息的变化
AfterMsgSend+= frm.SetText;
frm.Show();
}
SetText是Form2的一个方法
public void SetText(string txt)
{
textBox2.Text = txt;
}
事件方式实现
//定义消息发布的事件
public event EventHandler AfterMsgEvent;
//EventHandler 是最常见的事件委托类型，子窗体需要符合它的规范
事件触发：
private void button2_Click(object sender, EventArgs e)
{
AfterMsgEvent(this, new TextChangeEvent()
{
Text = this.textBox1.Text
});
}
TextChangeEvent是一个类，继承事件，含有属性Text
public class TextChangeEvent:EventArgs
{
public string Text { get; set; }
}
//加载父窗体时的事件
AfterMsgEvent += frm.AfterParentFrmChange;
Form2中函数：
public void AfterParentFrmChange(object sender, EventArgs e)
{
//拿到父窗体传过来的值
TextChangeEvent text=e as TextChangeEvent;
this.SetText(text.Text);
}
**区别：**委托是类型，事件是委托类型的一个特殊实例，事件只能在类的内部触发执行，安全
发布订阅模式的实现
发布订阅模式
观察者模式
指的是一个
发布订阅：子窗体的个数和类型对主窗体没有影响
如果不使用委托，在主窗体点击按钮，遍历集合，集合存放所有关心此主窗体消息变化的所有子窗体，这个集合相当于注册委托或事件方法
定义一个接口类型：
public interface Interface1
{
void SetText(string text);
}
子窗体：
public partial class ChildFrm : Form,Interface1
{//继承基类，实现接口
public ChildFrm()
{
InitializeComponent();
}
public void SetText(string text)
{//实现接口的方法
this.textBox1.Text = text;
}
}
父窗体：
public partial class ParentFrm : Form
{
public List<Interface1> ChildFrmList { get; set; }
public ParentFrm()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
//遍历所有关注主窗体消息变化的子窗体集合
//调用集合中每个元素的方法
if(ChildFrmList==null) return;
//减少括号的层次，比先判断不是空再循环要好一些
foreach(var item in ChildFrmList)
{
item.SetText(this.textBox1.Text);
}
}
private void ParentFrm_Load(object sender, EventArgs e)
{
ChildFrm frm=new ChildFrm();
this.ChildFrmList=new List<Interface1>();
this.ChildFrmList.Add(frm);
frm.Show();
}
}
如果再多加一个管理窗体，加载时的执行代码为：
//弹出主窗体
ParentFrm parentForm = new ParentFrm();
parentForm.Show();
ChildFrm childForm = new ChildFrm();
parentForm.ChildFrmList = new List<Interface1>();
parentForm.ChildFrmList.Add(childForm);
childForm.Show();
这样，就实现了主窗体和子窗体的分离解耦。
文件流复习
选择文件并读取
using(OpenFileDialog ofd=new OpenFileDialog())
{
if(ofd.ShowDialog() != DialogResult.OK)
{
return;
}
//选中文件后，读取文件
//1、
//string x=File.ReadAllText(ofd.FileName, Encoding.Default);
//直接写，如果文件太大会卡死
//2、使用文件流
using(FileStream fs=new FileStream(ofd.FileName, FileMode.Open, FileAccess.Read))
{
textBox1.Text = ofd.FileName;
using(StreamReader sr=new StreamReader(fs))
{
while (!sr.EndOfStream)
{
string line=sr.ReadLine();
this.textBox2.Text += line;
}
}
}
}
写入文件
using(SaveFileDialog save=new SaveFileDialog())
{
if(save.ShowDialog() != DialogResult.OK)
{
return;
}
//1、
//File.WriteAllText(save.FileName,textBox2.Text,Encoding.Default);
//2、
/*using(StreamWriter sw=new StreamWriter(save.FileName,false,Encoding.Default,1024*1024))
{//第二个参数是是否追加的意思，最后一个参数为缓冲区大小
sw.Write(textBox2.Text);
sw.Flush();//一举写入
}*/
//3、文件流写入
using(FileStream fs=new FileStream(save.FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
string x=textBox2.Text.Replace("\n","\r\n");
byte[]data=Encoding.Default.GetBytes(x);
//不读取换行，一行行的读写，因为x没有\r
//fs.Write(data,0,data.Length);
}
}
多线程
一个线程就是一个进程里的代码执行流，每个线程都要指向一个方法体，方法执行完成之后，线程就释放。
例如：
Thread thread = new Thread
(delegate ()
{
Console.WriteLine(DateTime.Now);
Thread.Sleep(1000);
});
相当于
Thread thread = new Thread(ThreadMethod);
static void ThreadMethod()
{
Console.WriteLine(DateTime.Now);
Thread.Sleep(1000);
}
进程执行是调用Start()方法，线程默认是前台线程。尽量设置为true
thread.IsBackground = true;
thread.Start();
进程退出的标志：所有的前台线程都结束之后，后台线程不会阻塞进程的退出。
程序执行时，Main函数是程序的入口，CLR一开始就默认创建一个主线程，主线程也是一个前台线程。
Thread thread = new Thread(ThreadMethod);
thread.IsBackground = true;
thread.Start();
while (true)
{
Console.WriteLine("from 主线程-----");
Thread.Sleep(1000);
}
Console.ReadKey();
执行结果：
主线程与创建的线程不停的执行，类似于俩个线程同时在执行。
线程的其它属性：1、 IsAlive表示当前线程的状态，2、ManagedThreadId表示线程id
如下：
Console.WriteLine(thread.ManagedThreadId);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
3、优先级
设置为最高都是建议操作系统设置为最高，不一定为最高；线程执行是告诉操作系统可以执行，自己准备好了。
thread.Priority = ThreadPriority.Highest;
4、挂起：thread.Suspend();
5、继续挂起的线程：thread.Resume();
6、终止Abort，不得已才能用，直接终结：thread.Abort();
7、等待thread线程执行完成：thread.Join();，执行代码的线程等待thread执行完成，参数为超时时间。
例如：thread.Join(5000);后的代码执行结果为：
WinFrm与多线程
创建一个Windows窗体，设置为控制台输出
如果不使用线程，显示窗体线程就是前台线程，卡死；
如果设置了线程，使用lamda表达式输出内容，设置为前台线程，既可以控制台输出，主窗体也不卡死，关掉窗体，线程关闭。
如果不设置线程为前台线程，那么关闭主窗体，控制台仍然执行。
Thread thread = new Thread(() =>
{
while(true)
Console.WriteLine(DateTime.Now.ToString());
});
thread.IsBackground = true;
thread.Start();
跨线程访问控件
线程访问主线程（主窗体）控件，设置非法跨线程为false；但是这个属性只是演示，真正项目不可以使用。
Control.CheckForIllegalCrossThreadCalls = false;
正确访问方法：
Thread thread = new Thread(() =>
{
if (button1.InvokeRequired)
{//检查是否为别的线程创建的子控件，为true
//找到创建控件的线程，执行方法
button1.Invoke(new Action<string>(s => {
this.button1.Text = s;
}), DateTime.Now.ToString());
}else this.button1.Text = DateTime.Now.ToString();
while(true)
Console.WriteLine(DateTime.Now.ToString());
});
thread.IsBackground = true;
thread.Start();
进程与线程
操作系统分配的资源最小单位是进程，进程与进程之间互不影响，可以理解为一个程序的基本边界。
进程是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。进程之间是相对独立的，一个进程无法直接访问另 一个进程的数据（除非利用分布式计算方式），一个进程运行的失败也不会影响其他进程的运行，Windows系统就是利用进程把工作划分为多个独立的区域 的。进程可以理解为一个程序的基本边界。
CPU的其中一个核心，同一时间只能执行一个指令。
一个线程就是一个进程里面的代码的执行流。每个线程都要指向一个方法体，方法执行完成后线程就释放。
输出所有进程：
var allPro = Process.GetProcesses();
foreach (var pro in allPro)
{
Console.WriteLine(pro.ProcessName + "\t" + pro.Id);
}
打开某个进程：
Process.Start("notepad", "aaa.txt");
第二个参数是文件名，如果打开浏览器，是网站地址