嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：78630559
本次赞助数额为： 20 元微信扫码支付：20 元
请留下您的邮箱，我们将在2小时内将文件发到您的邮箱
【实例1】
namespace AyncDemo
{
public partial class FrmAync : Form
{
public FrmAync()
{
InitializeComponent();
}
//同步
private void btnTest1_Click(object sender, EventArgs e)
{ this.lblInfo2.Text = ExecuteTask2(20).ToString();
this.lblInfo1.Text = ExecuteTask1(10).ToString();
}
//【2】 委托方法
int ExecuteTask1(int num)
{
Thread.Sleep(5000);
return num * num;
}
int ExecuteTask2(int num)
{
return num * num;
}
//异步
private void btnTest2_Click(object sender, EventArgs e)
{
//【3】关联
MyCalculator myCalculator = ExecuteTask1;
IAsyncResult result = myCalculator.BeginInvoke(10, null, null);
lblInfo2.Text = ExecuteTask2(20).ToString();
this.lblInfo1.Text = "正在计算请稍等...";
int r = myCalculator.EndInvoke(result);
lblInfo1.Text=r.ToString();
}
//【1】创建委托
public delegate int MyCalculator(int num);
}
}
【实例2】
namespace AsyncCallBackDemo
{
public partial class FrmAsynCallBack : Form
{
//【1】 声明委托
public delegate int MyCalculator(int num, int ms);
public FrmAsynCallBack()
{
InitializeComponent();
//【3】初始化委托变量
// this.objMyCal = new MyCalculator(ExecuteTask);
//Lambda表达式
this.objMyCal = (num, ms) =>
{
System.Threading.Thread.Sleep(ms);
return num * num;
};
}
//【4】同时执行多个任务
private void btnExec_Click(object sender, EventArgs e)
{
for (int i = 1; i < 11; i )//产生10个任务
{
//开始异步执行，并封装回调函数 objMyCal.BeginInvoke(10 * i, 1000 * i, null, i);
objMyCal.BeginInvoke(10 * i, 1000 * i, MyCallBack, i);
//最后一个参数 i 给回调函数的字段AsyncState赋值，如果数据很多可以定义成类或结构
IAsyncResult result= objMyCal.BeginInvoke(10 * i, 1000 * i, MyCallBack, i);
}
}
//【5】回调函数
private void MyCallBack(IAsyncResult result)
{
int res = objMyCal.EndInvoke(result);
//异步显示结果：result.AsyncState字段用来封装回调时自定义的参数，object类型
Console.WriteLine("第{0}个计算结果为：{1}", result.AsyncState.ToString(), res);
}
/// <summary>
/// 【2】根据委托定义一个方法：返回一个数的平方
/// </summary>
/// <param name="num">基数</param>
/// <param name="ms">延迟的时间：秒</param>
/// <returns></returns>
private int ExecuteTask(int num, int ms)
{
System.Threading.Thread.Sleep(ms);
return num * num;
}
//【3】创建委托变量（因为异步函数和回调函数都要用，所以定义成员变量）
private MyCalculator objMyCal = null;
}
}
【实例3】
namespace ThreadTest
{
public partial class FrmThreadText : Form
{
public delegate void Deleage(int a);
public FrmThreadText()
{
InitializeComponent();
Task task = new Task(new Action<object>((s) => { textBox1.Text = s.ToString(); }), 1);
task.Start();
Task task1 = new Task(delegate (object s) { textBox1.Text = s.ToString(); }, 10);
task1.Start();
Action<int> action = new Action<int>(test1);
action(1);
Action<int> action1 = delegate (int a) { this.textBox1.Text = a.ToString(); };
action1(10);
Action<int> action2 = (a) =>
{
this.textBox1.Text = a.ToString();
};
action2.Invoke(10);
textBox1.Invoke(new Action<int>(s => textBox1.Text = s.ToString()), 10);
textBox1.Invoke(new Action<int>((s) => { textBox1.Text = s.ToString(); }), 10);
textBox1.Invoke(new Action<int>((s) => { textBox1.Text = s.ToString(); }), 10);
textBox1.Invoke(new Action<int>(s=> { textBox1.Text = s.ToString(); } ),10);
textBox1.Invoke((WaitCallback)delegate(object s){ textBox1.Text = s.ToString(); },10);
Deleage deleage1 = new Deleage(test1);
Deleage deleage2 = delegate (int s) { this.textBox1.Text = s.ToString(); };
Deleage deleage3 = (s) => { this.textBox1.Text = s.ToString(); };
Deleage deleage4 = s => this.textBox1.Text = s.ToString();
void test1(int a)
{
this.textBox1.Text = a.ToString();
}
}
private void btnExecute1_Click(object sender, EventArgs e)
{
Thread objThread1 = new Thread(delegate()
{
for (int i = 1; i <= 20; i )
{
Console.WriteLine(i " ");
Thread.Sleep(500);
}
});
objThread1.IsBackground = true;
objThread1.Start();
}
private void btnExecute2_Click(object sender, EventArgs e)
{
Thread objThread2 = new Thread(()=>
{
for (int i = 0; i <= 50; i )
{
Console.WriteLine("-----------------a" i "----------------");
Thread.Sleep(100);
}
});
objThread2.IsBackground = true;
objThread2.Start();
}
}
}
【实例4】
namespace _04_CrossThreadVistControl
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void btnExecute1_Click(object sender, EventArgs e)
{
int a = 0;
Thread thread1 = new Thread(() =>
{
for (int i = 1; i <= 100; i )
{
a = i;
if (lblResult1.InvokeRequired)
{
//this.lblResult1.Invoke(new Action<int>((s) => { lblResult1.Text = s.ToString(); }), a);
this.lblResult1.Invoke((ParameterizedThreadStart)delegate (object s) { lblResult1.Text = s.ToString(); }, a);
Thread.Sleep(200);
/*
public delegate void ThreadStart();
public delegate void MethodInvoker();
public delegate void WaitCallback(object state);
public delegate void ParameterizedThreadStart(object obj);
public delegate void AsyncCallback(IAsyncResult ar);
*/
}
}
});
thread1.IsBackground = true;
thread1.Start();
}
private void btnExecute2_Click(object sender, EventArgs e)
{
int a=0;
Thread thread2 = new Thread(delegate() {
for (int i = 1; i <= 100; i )
{
a = i;
if (btnExecute2.InvokeRequired)
{
lblResult2.Invoke(new Action<int>((s)=> { lblResult2.Text = s.ToString(); }),a);
}
Thread.Sleep(500);
}
});
thread2.IsBackground = true;
thread2.Start();
}
}
}
【5】
namespace _05_CrossThreadVistDataBase
{
public partial class FrmDataBase : Form
{
public FrmDataBase()
{
InitializeComponent();
}
private void btnExecute1_Click(object sender, EventArgs e)
{
//Thread objThread1 = new Thread(() =>
//{
// Thread.Sleep(3000);
// string classCount = _05_CrossThreadVistDataBase.SQLHelper.GetSingleResult("select count(*) from StudentClass").ToString();
// this.lblResult1.Invoke(new Action<string>(c => { this.lblResult1.Text = c; }), classCount);
//});
//objThread1.IsBackground = true;
//objThread1.Start();
Thread objThread1 = new Thread(()=>
{
Thread.Sleep(300);
string classCount= _05_CrossThreadVistDataBase.SQLHelper.GetSingleResult("select count(*) from StudentClass").ToString();
this.lblResult1.Invoke(new Action<string>((c) => { this.lblResult1.Text = c; }), classCount);
});
objThread1.IsBackground = true;
objThread1.Start();
}
private void btnExecute2_Click(object sender, EventArgs e)
{
Thread objThread2 = new Thread(() =>
{
Thread.Sleep(300);
string stuCount = _05_CrossThreadVistDataBase.SQLHelper.GetSingleResult("select count(*) from Students").ToString();
this.lblResult2.Invoke(new Action<string>(s => { this.lblResult2.Text = s; }), stuCount);
});
objThread2.IsBackground = true;
objThread2.Start();
}
private void btnGetData_Click(object sender, EventArgs e)
{
Thread objThread3 = new Thread(() =>
{
Thread.Sleep(200);
//string stuCount = DBUtility.SQLHelper.GetSingleResult("select count(*) from Students").ToString();
//this.lblResult2.Invoke(new Action<string>(s => { this.lblResult2.Text = s; }), stuCount);
//访问数据库
DataSet ds = _05_CrossThreadVistDataBase.SQLHelper.GetDataSet("select * from StudentClass;select StudentName,Gender,PhoneNumber from Students");
DataTable dt1 = ds.Tables[0];
DataTable dt2 = ds.Tables[1];
this.dgv1.Invoke(new Action<DataTable>(c => { this.dgv1.DataSource = c; }), dt1);
Thread.Sleep(200);
this.dgv2.Invoke(new Action<DataTable>(s => { this.dgv2.DataSource = s; }), dt2);
});
objThread3.IsBackground = true;
objThread3.Start();
}
}
}
【实例6】
namespace _06_ProcessDemo
{
public partial class FrmProcess : Form
{
public FrmProcess()
{
InitializeComponent();
}
//进程：每一个独立运行的程序都是进程。操作系统有《进程管理模块》管理同时运行的多个程序。
//进程和线程：一个进程可以包含若干线程。
//句柄：（Handle）句柄是一个标识符，用于代表操作系统中的各种资源。比如各种窗体、CDI绘制的对象、进程和线程对象、文件等都拥有句柄。
//句柄使用1：即使进程退出，有很多时候操作系统仍然保持进程句柄。操作系统句柄有限，使用中要节省，比如打开文件后，使用完毕要及时关掉。
//句柄使用2：句柄可以通过Process对象的Handle属性访问，比如进程退出的代码、时间等。
//总结提高：拥有图形界面的程序都有一个主窗体，此窗体也对应一个句柄。当主窗体关闭的时候进程也关闭。主窗体一般由主线程负责创建。
#region 获取本机所有进程
private System.Diagnostics.Process[] allProcesses = null;
private void btnGetProcessess_Click(object sender, EventArgs e)
{
allProcesses = System.Diagnostics.Process.GetProcesses();//获取本机的所有进程
this.lbProcess.Items.Clear();
foreach (System.Diagnostics.Process item in allProcesses)
{
this.lbProcess.Items.Add(item.ProcessName);
}
}
#endregion
private void lbProcess_Click(object sender, EventArgs e)
{
if (this.lbProcess.Items.Count == 0)
{
return;
}
else
{
this.lbModels.Items.Clear();
}
System.Diagnostics.Process currentProcess = allProcesses[this.lbProcess.SelectedIndex];
try
{
//获取当前进程所调用的模块（有些进程会拒绝访问）
ProcessModuleCollection models = currentProcess.Modules;
foreach (ProcessModule item in models)
{
this.lbModels.Items.Add(item.FileName);
}
//for (int i = 0; i < models.Count; i )
//{
// this.lbModels.Items.Add(models[i].FileName);
//}
//显示当前进程的基本信息
string info = @"进程的唯一标识符（Id）：" currentProcess.Id "\r\n\r\n";
info = "关联进程的本机句柄（Handle）：" currentProcess.Handle "\r\n\r\n";
info = "打开的句柄数（HandleCount）：" currentProcess.HandleCount "\r\n\r\n";
info = "关联进程的基本优先级：" currentProcess.BasePriority "\r\n\r\n";
info = "进程启动的时间：" currentProcess.StartTime;
this.txtProcessInfo.Text = info;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnKill_Click(object sender, EventArgs e)
{
if (this.lbProcess.Items.Count == 0 || this.lbProcess.SelectedIndex == -1) return;
System.Diagnostics.Process currentProcess = allProcesses[this.lbProcess.SelectedIndex];//获取当前选中的进程
currentProcess.Kill();//立即停止关联的进程
currentProcess.Close();//释放进程资源
this.lbProcess.Items.RemoveAt(this.lbProcess.SelectedIndex);
this.lbModels.Items.Clear();
this.txtProcessInfo.Clear();
}
//开启一个新的进程（如：iexplore.exe；notepad.exe；D:\abc.pptx）
//在windows环境变量里面没有注册的，需要使用路径
private void btnStartnew_Click(object sender, EventArgs e)
{
System.Diagnostics.Process.Start(this.txtProcessName.Text.Trim());
}
}
}
【实例7】
namespace _07_ThreadLock
{
class Program
{
static void Main(string[] args)
{
Thread.CurrentThread.Name = "------------------主线程";
Program objDemo = new Program();
Thread objNewThread = new Thread(new ThreadStart(objDemo.ActionMethod));
objNewThread.Name = "子线程";
objNewThread.Start();//开始子线程，并为该线程执行ActionMethod
objDemo.ActionMethod();//让主线程执行ActionMethod
Console.ReadLine();
}
private int counter = 0;
////被线程调用的方法【未使用线程安全措施】
//private void ActionMethod()
//{
// for (int count = 1; count <= 100; count )
// {
// counter = count;
// Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
// //Thread.Sleep(80);
// }
//}
//// //使用线程安全方法
//private void ActionMethod()
//{
// // //lock关键字可以确保一次只有一个线程调用它。
// // //lock关键字可以简单理解成代码块的“锁”。
// lock (this)
// {
// for (int count = 1; count <= 100; count )
// {
// counter = count;
// Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
// //Thread.Sleep(80);
// }
// }
//private void ActionMethod()
//{
// // //lock关键字可以确保一次只有一个线程调用它。
// // //lock关键字可以简单理解成代码块的“锁”。
// lock (this)
// {
// for (int count = 1; count <= 100; count )
// {
// counter = count;
// Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
// //Thread.Sleep(80);
// }
// }
//}
//为了方便日常使用，提供了一个方法属性来实现同样的功能。
// [MethodImpl(MethodImplOptions.Synchronized)]
private void ActionMethod()
{
for (int count = 1; count <= 10; count )
{
counter = count;
Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
Thread.Sleep(80);
}
}
}
}
【8】
namespace _08_ThreadSafetyDemo
{
public partial class FrmThreadSafety : Form
{
public FrmThreadSafety()
{
InitializeComponent();
//设置属性
this.backgroundWorker1.WorkerReportsProgress = true;
this.backgroundWorker1.WorkerSupportsCancellation = true;
}
//【1】开始后台要执行的任务
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker bw = sender as BackgroundWorker;
int result = 0;
for (int i = 0; i <= 100; i )
{
if (bw.CancellationPending)
{
e.Cancel = true;//该结果会被传送到RunWorkerCompleted事件中
return;
}
result = i;//累加
//报告进度(同时触发ProgressChanged事件)
//报告操作进度。调用该方法后，将触发BackgroundWorker. ProgressChanged事件。
//另外，该方法包含了一个int类型的参数percentProgress，用来表示当前异步操作所执行的进度百分比。
bw.ReportProgress(i, "已完成了" i.ToString() "%");
Thread.Sleep((int)e.Argument);//外部传入的参数:200，休眠特定的时间
e.Result = result;//向外界返回1 2 ...100的值
}
}
//【2】汇报后台工作进展情况
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
this.progressBar1.Value = e.ProgressPercentage;//显示百分比
lblInfo.Text = e.UserState.ToString();//显示文字信息。
}
//【3】后台任务完成
private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Cancelled)
{
toolStripStatusLabel1.Text = "用户取消了操作";
btnStart.Enabled = true;
return;
}
if (e.Error != null)
{
toolStripStatusLabel1.Text = e.Error.Message;
return;
}
lblResult.Text = e.Result.ToString();//显示计算结果
btnStart.Enabled = true;
toolStripStatusLabel1.Text = "计算完成";
}
//开始任务
private void btnStart_Click(object sender, EventArgs e)
{
lblResult.Text = "?";
lblResult.Refresh();
//启动线程（参数：200代表线程休眠的时间）
backgroundWorker1.RunWorkerAsync(200);
btnStart.Enabled = false;
toolStripStatusLabel1.Text = "正在工作……";
}
//取消任务
private void btnCancel_Click(object sender, EventArgs e)
{
backgroundWorker1.CancelAsync();
}
//关闭
private void btnClose_Click(object sender, EventArgs e)
{
this.Close();
}
}
}
【实例9】
namespace Async
{
class Program
{
// class Rectangle
// {
// // 成员变量
// protected double length;
// protected double width;
// public Rectangle(double l, double w)
// {
// length = l;
// width = w;
// }
// public double GetArea()
// {
// return length * width;
// }
// public void Display()
// {
// Console.WriteLine("长度： {0}", length);
// Console.WriteLine("宽度： {0}", width);
// Console.WriteLine("面积： {0}", GetArea());
// }
// }//end class Rectangle
// class Tabletop : Rectangle
// {
// private double cost;
// public Tabletop(double l, double w) : base(l, w)
// { }
// public double GetCost()
// {
// double cost;
// cost = GetArea() * 70;
// return cost;
// }
// public void Display()
// {
// base.Display();
// Console.WriteLine("成本： {0}", GetCost());
// }
// }
// class ExecuteRectangle
// {
// static void Main(string[] args)
// {
// Tabletop t = new Tabletop(4.5, 7.5);
// t.Display();
// Console.ReadLine();
// }
// }
//}
//class Shape
//{
// public void setWidth(int w)
// {
// width = w;
// }
// public void setHeight(int h)
// {
// height = h;
// }
// protected int width;
// protected int height;
//}
//// 派生类
//class Rectangle : Shape
//{
// public int getArea()
// {
// return (width * height);
// }
//}
//class RectangleTester
//{
// static void Main(string[] args)
// {
// Rectangle Rect = new Rectangle();
// Rect.setWidth(5);
// Rect.setHeight(7);
// // 打印对象的面积
// Console.WriteLine("总面积： {0}", Rect.getArea());
// Console.ReadKey();
// }
//}
//声明CancellationTokenSource对象
static CancellationTokenSource cts = new CancellationTokenSource();
static void Main(string[] args)
{
Console.WriteLine("==========取消单个任务==========");
//将cts.Token传入任务中，在外部通过控制cts实现对任务的控制
Task.Factory.StartNew(MyTask, cts.Token);
Console.WriteLine("请按回车键停止");
Console.ReadLine();
cts.Cancel();//传达取消请求
Console.WriteLine("已停止");
Console.ReadLine();
}
static void MyTask()
{
//判断任务是否取消，如果取消则跳出本次循环
while (!cts.IsCancellationRequested)
{
Console.WriteLine("当前时间:" DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
Thread.Sleep(1000);
}
}
}
public sealed class Singleton
{
public static volatile Singleton instance = null;
public static readonly object padlock = new object();
Singleton()
{
}
public static Singleton Instance
{
get
{
if (instance == null)
{
lock (padlock)
{
if (instance == null)
{
instance = new Singleton();
}
}
}
return instance;
}
}
}
}