传送门

  入门:《开始接触 async/await
异步编程》

  上篇:《走进异步编程的世界 –
剖析异步方法(上)》

  下篇:《走进异步编程的世界 – 在 GUI
中执行异步操作》

 


 【原文链接】

【参考】《Illustrated C# 2012》

student st1 = new student();//可以多次初始化类,注意不同的变量名
st1.name = “李四”;
st1.nianling = 22;
st1.sex = “女”;
#endregion
}

2.补充(以下均为原创):

  1. opencv python中的rows
    cols分别为img.shape[0](height)和img.shape[1](width)
  2. opencv c++中的图像对象访问像素可使用.at :cv::mat的成员函数:
    .at(int y, int
    x),可以用来存取图像中对应坐标为(x,y)的元素坐标。但是在使用它时要注意,在编译期必须要已知图像的数据类型.但在opencv-python中访问像素可直接使用例如img[x][y]
    的方法进行实现

  原因:和opencv不同,目前opencv-python中的数组均为numpy array形式。

目录

  • 异常处理
  • 在调用方法中同步等待任务
  • 在异步方法中异步等待任务
  • Task.Delay()
    暂停执行

  

上课内容:
public struct
student//如果想让其他添加出来的类也能够使用此结构体,需要在前面加上public
{
public int nianling;//想让其他的类可以访问到其中的变量需要加上public
public string name;
public string sex;
public One qq;//可以结构体中包含另一个结构体
public string[] shuzu;//可以直接定义一个数组,但是没有开辟空间
}
public struct One
{
public string nb;
public string abc;
}
static void Main(string[] args)
{

使用opencv-python一段时间了,因为之前没有大量接触过c++下的opencv,在网上看c++的一些程序想改成python遇到了不少坑,正好在这里总结一下。

一、异常处理

  await 表达式也可以使用 try…catch…finally 结构。

 1     internal class Program
 2     {
 3         private static void Main(string[] args)
 4         {
 5             var t = DoExceptionAsync();
 6             t.Wait();
 7 
 8             Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任务状态
 9             Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任务完成状态标识
10             Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任务是否有未处理的异常标识
11 
12             Console.Read();
13         }
14 
15         /// <summary>
16         /// 异常操作
17         /// </summary>
18         /// <returns></returns>
19         private static async Task DoExceptionAsync()
20         {
21             try
22             {
23                 await Task.Run(() => { throw new Exception(); });
24             }
25             catch (Exception)
26             {
27                 Console.WriteLine($"{nameof(DoExceptionAsync)} 出现异常!");
28             }
29         }
30     }

图片 1

图1-1

  【分析】await
表达式位于 try
块中,按普通的方式处理异常。但是,为什么图中的状态(Status)、是否完成标识(IsCompleted)和是否失败标识(IsFaulted)分别显示:运行完成(RanToCompletion)
、已完成(True) 和 未失败(False)
呢?因为:任务没有被取消,并且异常都已经处理完成!

 

struct student

3.函数上的应用的不同处

  在opencv-python中,有很多函数的应用方法都与opencv中不同,下面简单的分析一下最不同的地方

   1)python中使用cv2.方法名或变量名来调用方法/变量

   2)对于具有同样作用的函数的不同调用方法,例如

 

//c++
cvtColor(srcImg, binaryImg, COLOR_BGR2GRAY);

 

#python
binaryImg = cv2.cvtColor(srcImg,cv2.COLOR_BGR2GRAY)

    当然对于每个具体的函数的具体用法,可以自行上网搜索

   3)python中对于变量的类型是不需要声明的,所以将c++中代码修改为python时需要注意很多(缩进虽然很便于查看,但是还是感觉写{}的感觉很爽233)

   4)python中函数参数可以为array形式,所以c++
opencv中的很多类型都是不存在的,切记使用cv2.类型名()去使用,例如

//c++
circle(srcImg, Point(x, y), 3, Scalar(255, 0, 255), 2, 8, 0);

#python
cv2.circle(srcImg, (x, y), 3, (255, 100, 255), 1, 8, 0)

   其他的小坑估计还很多,多Google吧。

走进异步编程的世界 – 剖析异步方法(下)

 

下面开始为里面的每个元素赋值:(结构体名+点+结构体里面的变量名称=值)

1.opencv 中x,y,height, width,rows,cols 的关系(转自

    opencv中图像的x,y 坐标以及 height, width,rows,cols
他们的关系经常混淆。

    rows 其实就是行,一行一行也就是y 啦。height高度也就是y啦。

    cols  也就是列,一列一列也就是x啦。width宽度也就是x啦。   

三、在异步方法中异步等待任务

  上节说的是如何使用 WaitAll() 和 WaitAny() 同步地等待 Task
完成。这次我们使用 Task.WhenAll() 和 Task.WhenAny()
 在异步方法中异步等待任务。

 1     internal class Program
 2     {
 3         private static int time = 0;
 4 
 5         private static void Main(string[] args)
 6         {
 7             var t = GetRandomAsync();
 8 
 9             Console.WriteLine($"t.{nameof(t.IsCompleted)}: {t.IsCompleted}");
10             Console.WriteLine($"Result: {t.Result}");
11 
12             Console.Read();
13         }
14 
15         /// <summary>
16         /// 获取一个随机数
17         /// </summary>
18         /// <param name="id"></param>
19         /// <returns></returns>
20         private static async Task<int> GetRandomAsync()
21         {
22             time++;
23             var t1 = Task.Run(() =>
24             {
25                 Thread.Sleep(time * 100);
26                 return new Random().Next();
27             });
28 
29             time++;
30             var t2 = Task.Run(() =>
31             {
32                 Thread.Sleep(time * 100);
33                 return new Random().Next();
34             });
35 
36             //异步等待集合内的 Task 都完成,才进行下一步操作
37             await Task.WhenAll(new List<Task<int>>() { t1, t2 });
38 
39             Console.WriteLine($"    t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
40             Console.WriteLine($"    t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
41 
42             return t1.Result + t2.Result;
43         }
44     }

图片 2

图3-1 调用 WhenAll()  方法

  【注意】WhenAll() 异步等待集合内的
Task 都完成,不会占用主线程的时间。

 

   现在,我们把 GetRandomAsync() 方法内的 WhenAll() 方法替换成
WhenAny(),并且增大一下线程挂起时间,最终改动如下:

 1         private static async Task<int> GetRandomAsync()
 2         {
 3             time++;
 4             var t1 = Task.Run(() =>
 5             {
 6                 Thread.Sleep(time * 100);
 7                 return new Random().Next();
 8             });
 9 
10             time++;
11             var t2 = Task.Run(() =>
12             {
13                 Thread.Sleep(time * 500);   //这里由 100 改为 500,不然看不到效果
14                 return new Random().Next();
15             });
16 
17             //异步等待集合内的 Task 都完成,才进行下一步操作
18             //await Task.WhenAll(new List<Task<int>>() { t1, t2 });
19             await Task.WhenAny(new List<Task<int>>() { t1, t2 });
20 
21             Console.WriteLine($"    t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");
22             Console.WriteLine($"    t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
23 
24             return t1.Result + t2.Result;
25         }

图片 3

图3-2 调用 WhenAny() 方法

 

 

  感谢大家的支持,这是昨天发布《走进异步编程的世界 –
剖析异步方法(上)》的补充篇。

 

结构体:就是一个自定义的集合,里面可以放各种类型的元素,用法大体跟集合一样。

四、Task.Delay() 暂停执行

  Task.Delay() 方法会创建一个 Task
对象,该对象将暂停其在线程中的处理,并在一定时间之后完成。和
Thread.Sleep 不同的是,它不会阻塞线程,意味着线程可以继续处理其它工作。

 1     internal class Program
 2     {
 3         private static void Main(string[] args)
 4         {
 5             Console.WriteLine($"{nameof(Main)} - start.");
 6             DoAsync();
 7             Console.WriteLine($"{nameof(Main)} - end.");
 8 
 9             Console.Read();
10         }
11 
12         private static async void DoAsync()
13         {
14             Console.WriteLine($"    {nameof(DoAsync)} - start.");
15 
16             await Task.Delay(500);
17 
18             Console.WriteLine($"    {nameof(DoAsync)} - end.");
19         }
20     }

图片 4

图4-1

 

三、结构体类型里面包含结构体类型:

二、在调用方法中同步等待任务

  调用方法可能在某个时间点上需要等待某个特殊的 Task
对象完成,才执行后面的代码。此时,可以采用实例方法 Wait 。

 1     internal class Program
 2     {
 3         private static void Main(string[] args)
 4         {
 5             var t = CountCharactersAsync("http://www.cnblogs.com/liqingwen/");
 6 
 7             t.Wait();   //等待任务结束
 8             Console.WriteLine($"Result is {t.Result}");
 9 
10             Console.Read();
11         }
12 
13         /// <summary>
14         /// 统计字符数量
15         /// </summary>
16         /// <param name="address"></param>
17         /// <returns></returns>
18         private static async Task<int> CountCharactersAsync(string address)
19         {
20             var result = await Task.Run(() => new WebClient().DownloadStringTaskAsync(address));
21             return result.Length;
22         }
23     }

图片 5

图2-1

 

  Wait() 适合用于单一 Task 对象,如果想操作一组对象,可采用 Task
的两个静态方法 WaitAll() 和 WaitAny() 。

 1     internal class Program
 2     {
 3         private static int time = 0;
 4         private static void Main(string[] args)
 5         {
 6             var t1 = GetRandomAsync(1);
 7             var t2 = GetRandomAsync(2);
 8 
 9             //IsCompleted 任务完成标识
10             Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");    
11             Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
12 
13             Console.Read();
14         }
15 
16         /// <summary>
17         /// 获取一个随机数
18         /// </summary>
19         /// <param name="id"></param>
20         /// <returns></returns>
21         private static async Task<int> GetRandomAsync(int id)
22         {
23             var num = await Task.Run(() =>
24             {
25                 time++;
26                 Thread.Sleep(time * 100);
27                 return new Random().Next();
28             });
29 
30             Console.WriteLine($"{id} 已经调用完成");
31             return num;
32         }
33     }

图片 6

图2-2 两个任务的 IsCompleted 属性都显示未完成

 

  现在,在 Main() 方法中新增两行代码(6 和 7 两行),尝试调用
WaitAll() 方法。

 1         private static void Main(string[] args)
 2         {
 3             var t1 = GetRandomAsync(1);
 4             var t2 = GetRandomAsync(2);
 5 
 6             Task<int>[] tasks = new Task<int>[] { t1, t2 };
 7             Task.WaitAll(tasks);    //等待任务全部完成,才继续执行
 8 
 9             //IsCompleted 任务完成标识
10             Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");    
11             Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
12 
13             Console.Read();
14         }

图片 7

图2-3 两个任务的 IsCompleted 属性都显示 True

 

  现在,再次将第 7 行改动一下,调用 WaitAny() 方法试试。 

 1         private static void Main(string[] args)
 2         {
 3             var t1 = GetRandomAsync(1);
 4             var t2 = GetRandomAsync(2);
 5 
 6             Task<int>[] tasks = new Task<int>[] { t1, t2 };
 7             Task.WaitAny(tasks);    //等待任一 Task 完成,才继续执行
 8 
 9             //IsCompleted 任务完成标识
10             Console.WriteLine($"t1.{nameof(t1.IsCompleted)}: {t1.IsCompleted}");    
11             Console.WriteLine($"t2.{nameof(t2.IsCompleted)}: {t2.IsCompleted}");
12 
13             Console.Read();
14         }

图片 8

图2-4 有一个任务的 IsCompleted 属性显示 True (完成) 就继续执行

 

在main主函数外面定义了一个名称为student的结构体,以便于main函数之中使用。

{

//20人投票 switch case 枚举
//投票的时候输入1,2,3,4,5
//利用12345来确定是哪一个候选人得票
//计算得票数
//得票最高的胜出
Console.WriteLine(“投票选班长!请输入1、2、3、4、5来分别代表张三、李四、王五、赵六、冯七”);
int[] shuzu = new int[20];
for (int i = 1; i <= 20; i++)
{
Console.Write(“请第” + i + “位同学来进行投票:”);
shuzu[i – 1] = int.Parse(Console.ReadLine());
}
Console.WriteLine(“投票结束!按下回车开始统计票数!”);
Console.ReadLine();
int zhangsan = 0, lisi = 0, wangwu = 0, zhaoliu = 0, fengqi = 0, zuofei
= 0;
for (int i = 0; i < 20; i++)
{
switch (shuzu[i])
{
case (int)Houxuanren.one:
zhangsan++;
break;
case (int)Houxuanren.two:
lisi++;
break;
case (int)Houxuanren.three:
wangwu++;
break;
case (int)Houxuanren.four:
zhaoliu++;
break;
case (int)Houxuanren.five:
fengqi++;
break;
default:
zuofei++;
break;
}
}
if (zhangsan > lisi && zhangsan > wangwu && zhangsan > zhaoliu
&& zhangsan > fengqi)
{
Console.WriteLine(“张三胜出!票数为” + zhangsan);
}
else if (lisi > zhangsan && lisi > wangwu && lisi > zhaoliu &&
lisi > fengqi)
{
Console.WriteLine(“李四胜出!票数为” + lisi);
}
else if (wangwu > lisi && wangwu > zhangsan && wangwu > zhaoliu
&& wangwu > fengqi)
{
Console.WriteLine(“王五胜出!票数为” + wangwu);
}
else if (zhaoliu > lisi && zhaoliu > wangwu && zhaoliu >
zhangsan && zhaoliu > fengqi)
{
Console.WriteLine(“赵六胜出!票数为” + zhaoliu);
}
else if (fengqi > lisi && fengqi > wangwu && fengqi > zhaoliu
&& fengqi > zhangsan)
{
Console.WriteLine(“冯七胜出!票数为” + fengqi);
}
Console.WriteLine(“作废的票数为:” + zuofei);
Console.ReadLine();

这样就可以在用的时候省下再次初始化结构体。

#region
//为里面的每个元素赋值:(结构体名+点+结构体里面的变量名称=值)
student st = new student();//使用之前需要先初始化一下
st.name = “张三”;//初始化出来的变量名可以看做一个类对象
st.nianling = 21;//类对象的名称是不能相同的
st.sex = “男”;
st.name = “王五”;
//使用的时候利用变量名点出来其中的变量进行使用
Console.WriteLine(st.name);
st.qq.abc=”qsqs”;//结构体中包含另一个结构体类型,可以直接点出来一以下的变量
st.shuzu = new string [9];//使用之前需要先开辟空间
st.shuzu[0] = “赵六”;//数组元素赋值方式

public int sum;

发表评论

电子邮件地址不会被公开。 必填项已用*标注