regex & async & await

1.regex

Regex re = new Regex("abc");

我的理解是：对“abc”这个字符进行代换或者判断...，即将“abc”当做关注点。

关于正则表达式，有一些code较为常用。

#1忽略大小写的功能RegexOptions.IgnoreCase

 3                 string str1 = "hello";
 4                 string str2 = "HeLLo";
 5                 Regex re = new Regex("hello", RegexOptions.IgnoreCase);
 6                 if(re.IsMatch(str1))
 7                 {
 8                     Console.WriteLine("it is match!");
 9                 }
10                 if (re.IsMatch(str2))
11                 {
12                     Console.WriteLine("it is match,too!");
13                 }

输出为：

#2 替换功能Regex.Replace（）

1                 string str1 = "123abc321AbC123";
2                 Console.WriteLine("before replace:{0}", str1);
3                 Regex re = new Regex("abc", RegexOptions.IgnoreCase);
4                 string newStr = re.Replace(str1, "|");
5                 Console.WriteLine("after replace:{0}",newStr);

输出为：

#3.匹配IP地址

 1 string str1 = "04:09:54 111.13.100.91 www.baidu.com"
 2                            + "05:22:23 112.25.24.135 www.sohu.com "
 3                             + "08:09:11 23.200.221.15 www.apple.com";
 4                 Regex re = new Regex(@"(?<time>(\d|\:)+)\s" +
 5                                      @"(?<ip>(\d|\.)+)\s" +
 6                                      @"(?<site>\S+)");
 7                 MatchCollection matches = re.Matches(str1);
 8                 foreach(Match match in matches)
 9                 {
10                     if(match.Length != 0)
11                     {
12                         Console.WriteLine("\nmatches: {0}", match.ToString());
13                         Console.WriteLine("time: {0}", match.Groups["time"]);
14                         Console.WriteLine("ip: {0}", match.Groups["ip"]);
15                         Console.WriteLine("site: {0}", match.Groups["site"]);
16                     }
17                 }

结果：

2.async & await

这是两个关键字，用于异步编程。像写同步方法一样去写异步方法。async关键字能用在方法、lambda表达式的声明部分，用来标示此方法可能包含await关键字，只有拥有async才能在其内部使用await关键字。当一个async方法，且内部包含await关键字，它就会在编译的时候成为一个异步方法，如果没有await关键字，则它将只会被当成一个同步方法来执行。

下面是从网上查找到，普通同步与用了async & await的异步的比较程序。（自己加了程序运行时间）

先是同步：

 1 static void Main(string[] args)
 2             {
 3                 DateTime d1 = DateTime.Now;
 4                 // 同步方式
 5                 Console.WriteLine("同步方式测试开始！");
 6                 SyncMethod(0);
 7                 Console.WriteLine("同步方式结束！");
 8
 9                 DateTime d2 = DateTime.Now;
10                 Console.WriteLine("花费时间为：{0}",d2-d1);
11
12             }
13             // 同步操作
14             private static void SyncMethod(int input)
15             {
16                 Console.WriteLine("进入同步操作！");
17                 var result = SyancWork(input);
18                 Console.WriteLine("最终结果{0}", result);
19                 Console.WriteLine("退出同步操作！");
20             }
21             // 模拟耗时操作（同步方法）
22             private static int SyancWork(int val)
23             {
24                 for (int i = 0; i < 5; ++i)
25                 {
26                     Console.WriteLine("耗时操作{0}", i);
27                     Thread.Sleep(100);
28                     val++;
29                 }
30                 return val;
31             }

结果：

然后是异步：

 1 static void Main(string[] args)
 2             {
 3                 // 异步方式
 4                 DateTime d1 = DateTime.Now;
 5                 Console.WriteLine("\n异步方式测试开始！");
 6                 AsyncMethod(0);
 7                 Console.WriteLine("异步方式结束！");
 8                 Console.ReadKey();
 9                 DateTime d2 = DateTime.Now;
10                 Console.WriteLine("程序运行时间：{0}",d2-d1);
11             }
12
13             // 异步操作
14             private static async void AsyncMethod(int input)
15             {
16                 Console.WriteLine("进入异步操作！");
17                 var result = await AsyncWork(input);
18                 Console.WriteLine("最终结果{0}", result);
19                 Console.WriteLine("退出异步操作！");
20             }
21
22             // 模拟耗时操作（异步方法）
23             private static async Task<int> AsyncWork(int val)
24             {
25                 for (int i = 0; i < 5; ++i)
26                 {
27                     Console.WriteLine("耗时操作{0}", i);
28                     await Task.Delay(100);
29                     val++;
30                 }
31                 return val;
32             }

结果为：

由结果可知，耗时操作此事已变成异步进行了，即并不会等待下面的AsyncWork完成其耗时操作，先返回main函数，然后再进行耗时操作。经过比较可知，二者程序结构一样，只是异步的多了两个关键字async & await，就可以用写同步的方法来写异步程序了。

over