regex & async & await

1.regex

Regex re = new Regex("abc");

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

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

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

                string str1 = "hello";
                string str2 = "HeLLo";
                Regex re = new Regex("hello", RegexOptions.IgnoreCase);
                if(re.IsMatch(str1))
                {
                    Console.WriteLine("it is match!");
                }
                if (re.IsMatch(str2))
                {
                    Console.WriteLine("it is match,too!");
                }

输出为：

#2 替换功能Regex.Replace（）

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

输出为：

#3.匹配IP地址

string str1 = "04:09:54 111.13.100.91 www.baidu.com" 
                           + "05:22:23 112.25.24.135 www.sohu.com "
                            + "08:09:11 23.200.221.15 www.apple.com";
                Regex re = new Regex(@"(?<time>(d|:)+)s" +
                                     @"(?<ip>(d|.)+)s" +
                                     @"(?<site>S+)");
                MatchCollection matches = re.Matches(str1);
                foreach(Match match in matches)
                {
                    if(match.Length != 0)
                    {
                        Console.WriteLine("
matches: {0}", match.ToString());
                        Console.WriteLine("time: {0}", match.Groups["time"]);
                        Console.WriteLine("ip: {0}", match.Groups["ip"]);
                        Console.WriteLine("site: {0}", match.Groups["site"]);
                    }
                }

结果：

2.async & await

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

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

先是同步：

static void Main(string[] args)
            {                                                              
                DateTime d1 = DateTime.Now;
                // 同步方式
                Console.WriteLine("同步方式测试开始！");
                SyncMethod(0);
                Console.WriteLine("同步方式结束！");
               
                DateTime d2 = DateTime.Now;
                Console.WriteLine("花费时间为：{0}",d2-d1);
            
            }
            // 同步操作
            private static void SyncMethod(int input)
            {
                Console.WriteLine("进入同步操作！");
                var result = SyancWork(input);
                Console.WriteLine("最终结果{0}", result);
                Console.WriteLine("退出同步操作！");
            }
            // 模拟耗时操作（同步方法）
            private static int SyancWork(int val)
            {
                for (int i = 0; i < 5; ++i)
                {
                    Console.WriteLine("耗时操作{0}", i);
                    Thread.Sleep(100);
                    val++;
                }
                return val;
            }

结果：

然后是异步：

static void Main(string[] args)
            {
                // 异步方式
                DateTime d1 = DateTime.Now;
                Console.WriteLine("
异步方式测试开始！");
                AsyncMethod(0);
                Console.WriteLine("异步方式结束！");
                Console.ReadKey();
                DateTime d2 = DateTime.Now;
                Console.WriteLine("程序运行时间：{0}",d2-d1);
            }

            // 异步操作
            private static async void AsyncMethod(int input)
            {
                Console.WriteLine("进入异步操作！");
                var result = await AsyncWork(input);
                Console.WriteLine("最终结果{0}", result);
                Console.WriteLine("退出异步操作！");
            }

            // 模拟耗时操作（异步方法）
            private static async Task<int> AsyncWork(int val)
            {
                for (int i = 0; i < 5; ++i)
                {
                    Console.WriteLine("耗时操作{0}", i);
                    await Task.Delay(100);
                    val++;
                }
                return val;
            }

结果为：

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

over