Func和Action委托的区别和简单使用

最新推荐文章于 2025-09-11 18:43:17 发布

转载最新推荐文章于 2025-09-11 18:43:17 发布 · 56 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/jeffwongishandsome/archive/2010/04/08/1512556.html

文章标签：

#c# #javascript #操作系统 #ViewUI

本文详细对比了C#中Func和Action委托的区别，并提供了使用实例。此外，还深入介绍了正则表达式的多种应用场景及其高级用法。

前言：下面几条都是根据自己开发经验和网上资料整理总结的，初学者可适当入门学习，加深印象，高手请54.
Func和Action委托的区别和简单使用
1、两种委托的常见形式和区别
（1）、Func委托有5个重载形式,区别仅在于它所指向的方法的签名的参数个数，分别如下：

Func<TResult>

Func<T,TResult>

Func<T1,T2,TResult>

unc<T1,T2,T3,TResult>

Func<T1,T2,T3,T4,TResult>
其中T,T1,..T4是委托指向的方法的参数的类型，TResult为方法的返回类型。
（2）、Action委托也有5个重载形式，分别如下：
Action

Action<T>

Action<T1,T2>

Action<T1,T2,T3>

Action<T1,T2,T3,T4>
其中T,T1,..T4是委托指向的方法的参数的类型。
从上面的委托形式我们就可以分析出来，Func和Action委托的唯一区别在于Func要有返回值， Action没有返回值。
2、简单示例代码

代码

   class Program
    {
         static void Main( string [] args)
        {
             int num = 5 ;
             /*   Func和Action委托的唯一区别在于Func要有返回值， Action没有返回值 */
            FirstCalcSquare calFirst = Square; // delegate
            Console.WriteLine( " The square of {0} is {1}. " , num, calFirst(num));

            Func < int , int > funcTest = Program.Square; // Func
            Console.WriteLine( " The square of {0} is {1}. " , num, funcTest(num));

            SecondCalcSquare calSecond = GetSquere;
            calSecond(num); // delegate

            Action < int > actionTest = Program.GetSquere;
            actionTest(num); // Action

            Console.ReadLine();
        }
         private delegate int FirstCalcSquare( int input);
         private static int Square( int input)
        {
             return input * input;
        }

         private delegate void SecondCalcSquare( int input);
         private static void GetSquere( int input)
        {
            Console.WriteLine( " The square of {0} is {1}. " , input, input * input);
        }

    }

附1：通过命令行保存webservice为本地的类
经常用到这个功能，通过如下的vs命令行：
wsdl http://www.xxx.com/TesterWebService.asmx /l:cs /n:Test
说明：wsdl url /l:cs(指定语言) /n:(命名空间)

附2：c#正则表达式使用小结
一、正则表达式概述
1、正则表达式可以看作是一种有特定功能的小型编程语言：在大的字符串表达式中定位一个子字符串。它不是一种新技术，最初是在unix环境中开发的，与perl一起使用的较多。ms把它移植到windows中，System.Text.RegularExpression命名空间中的许多.net类都支持正则表达式。
2、主要包含的两个功能
（1）一组用于标识字符类型的转义字符。您可能熟悉dos表达式中的*字符表示任意字符串(例如，dos命令dir pro*会列出所有名称以pro开头的文件)。
（2）一个系统。在搜索操作中，它把字符串和中间结果的各个部分组合起来。
二、示例
1、常见的特定字符或转义序列

符号        含义        示例              匹配的示例
^     输入文本的开头    ^a       a,但只能是文本的第一个字符
$     输入文本的结尾    z$         z,但只能是文本的最后一个字符
.     除了换行符（\n）  a.c       abc,azc,

外所有单个字符
* >=0次的前导字符 ab*c ac,abc,abbc,

+ >=1次的前导字符 ab+c abc,abbc,abbbc,

?     可以重复0次或1次  ab?c       ac或者abc
       的前导字符
\s    任意空白字符      \sa     [space]a,\ta,\na
\S    \s的补集          \Sa     aa,ba

不能是\ta,\na等
\d 0-9的数字 \da 1a,2a,

9a
\D    \d的补集          \Da      aa,+a..不会是数字和a的组合
\b    字边界             abc\b   以abc结尾的任何文本
\B    不是字边界的位置   \Babc\B 字中间的任何abc

\w    单词字符，指大小写字母、0-9的数字、下划线
\W    \w的补集

简单示例代码：

Code
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace MyCsStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.^和$
            string strSource = "think in c# deeply";
            Regex myReg = new Regex("think in c# deeply");
            Console.WriteLine(myReg.IsMatch(strSource)); //true
            myReg = new Regex("^think in c# deeply$");
            Console.WriteLine(myReg.IsMatch(strSource)); //true
            myReg = new Regex("^think in c# deep$");
            Console.WriteLine(myReg.IsMatch(strSource)); //false
            myReg = new Regex("^Think in c# deeply$");
            Console.WriteLine(myReg.IsMatch(strSource));//false

            //带换行的情况
            strSource = @"think in
c# deeply";
            myReg = new Regex("think in \r\nc# deeply");
            Console.WriteLine(myReg.IsMatch(strSource)); //true
            myReg = new Regex("^think in \r\nc# deeply$");
            Console.WriteLine(myReg.IsMatch(strSource)); //true
            myReg = new Regex("^think in c# deeply$");
            Console.WriteLine(myReg.IsMatch(strSource)); //false
            myReg = new Regex("^think in c# deeply$");
            Console.WriteLine(myReg.IsMatch(strSource));//false

            //2..,*,+,?
            strSource = "abc xybzac acbab";
            myReg = new Regex(".b");
            Console.WriteLine(myReg.Matches(strSource).Count); //4处匹配
            strSource = "abcdefg asdfghjkbedk aabccd";
            myReg = new Regex("a*b");
            Console.WriteLine(myReg.Matches(strSource).Count); //3处匹配
            myReg = new Regex("a+b");
            Console.WriteLine(myReg.Matches(strSource).Count); //2处匹配
            myReg = new Regex("a?b");
            Console.WriteLine(myReg.Matches(strSource).Count); //3处匹配

            //3.\s和\S
            strSource = "aoe iuv abc uvaw abcxyz";
            myReg = new Regex(@"\sa");
            Console.WriteLine(myReg.Matches(strSource).Count); //2处匹配
            myReg = new Regex(@"\Sa");
            Console.WriteLine(myReg.Matches(strSource).Count); //1处匹配

            //4.\d和\D
            strSource = "123aoe iuv abc uv789aw abcxyz";
            myReg = new Regex(@"\da");
            Console.WriteLine(myReg.Matches(strSource).Count); //2处匹配
            myReg = new Regex(@"\Da");
            Console.WriteLine(myReg.Matches(strSource).Count); //2处匹配

            //5.\b和\B
            strSource = "aoe iuv abc uv789aw abcxyz";
            myReg = new Regex(@"\ba");
            Console.WriteLine(myReg.Matches(strSource).Count); //3处匹配
            myReg = new Regex(@"\Ba");
            Console.WriteLine(myReg.Matches(strSource).Count); //1处匹配
            myReg = new Regex(@"\Ba\B");
            Console.WriteLine(myReg.Matches(strSource).Count); //1处匹配

            //6.\w和\W
            strSource = "abc123_()*&$";
            myReg = new Regex(@"\w");
            Console.WriteLine(myReg.Matches(strSource).Count); //7处匹配
            myReg = new Regex(@"\W");
            Console.WriteLine(myReg.Matches(strSource).Count); //5处匹配

            Console.ReadLine();
        }
    }
}

2、特殊字符的匹配

3、常见重复描述字符
{n} 匹配前面的字符n次
{n,} 匹配前面的字符n次或多于n次
{n,m} 匹配前面的字符n到m次
示例：

4、表示匹配“或者”的|

5、组与非捕获组

Code
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace MyCsStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            string strSource = "think in c# deeply,and think in javascript deeply";
            Regex myReg = new Regex(@"^think ([a-z]{2}) c# ([a-z]{4,}),and think \1 javascript \2$");
            //正则表达式引擎会记忆()中匹配到的内容,作为一个"组",并且可以通过索引的方式进行引用.
            //表达式中的"\1",用于反向引用表达式中出现的第一个组,\2则依此类推。

            Console.WriteLine(myReg.IsMatch(strSource)); //true
            Console.WriteLine(myReg.Matches(strSource).Count);//1

            if (myReg.IsMatch(strSource))
            {
                int i = 1;
                foreach (Group group in myReg.Match(strSource).Groups)
                {
                    Console.WriteLine("group"+i.ToString()+" value:" + group.Value);//输出组中的内容，第二组是in，第三组是deeply
                    i++;
                }
            }
            //获取组中的内容，注意，第一组是整个变量strSource的值，从第二、三组才匹配我们想要的in和deeply

            Console.WriteLine("--------------------------------");

            myReg = new Regex(@"^think (?<g1>[a-z]{2}) c# (?<g2>[a-z]{4,}),and think \1 javascript \2$");
            if (myReg.IsMatch(strSource))
            {
                Console.WriteLine("group1 value:" + myReg.Match(strSource).Groups["g1"].Value);//输出：in
                Console.WriteLine("group2 value:" + myReg.Match(strSource).Groups["g2"].Value);//输出：deeply
            }
            //根据组名进行索引.使用以下格式为标识一个组的名称(?<groupname>…)。

            Console.WriteLine("--------------------------------");

            strSource = "think in c# deeply deeply";
             myReg = new Regex(@"([a-z]{4,}) \1");
             if (myReg.IsMatch(strSource))
             {
                 string tmpStr = myReg.Replace(strSource, "$1");
                 Console.WriteLine("result:" + tmpStr);//输出：deeply
             }
            //删除原字符串中重复出现的“deeply”。在表达式之外，使用“$1”来引用第一个组，下面通过组名来引用:

             myReg = new Regex(@"(?<g1>[a-z]{4,}) \1");
             if (myReg.IsMatch(strSource))
             {
                 string tmpStr = myReg.Replace(strSource, "${g1}");
                 Console.WriteLine("result:" + tmpStr);//输出：deeply
             }

             Console.WriteLine("--------------------------------");

             myReg = new Regex(@"^think in c# (?:[a-z]{4,})$");
             if (myReg.IsMatch(strSource))
             {
                 Console.WriteLine("group1 value:" + myReg.Match(strSource).Groups[1].Value);//输出：空
             }
            //在组前加上“?:”表示这是个“非捕获组”，即引擎将不保存该组的内容。

            Console.ReadLine();
        }
    }
}

6、贪婪与非贪婪
正则表达式的引擎是贪婪的，只要模式允许，它将匹配尽可能多的字符。通过在“重复描述字符”（*,+）后面添加“?”，可以将匹配模式改成非贪婪。

7、正向预搜索、反向预搜索
正向预搜索声明格式：正声明 “(?=…)”，负声明 “(?!...)” ，声明本身不作为最终匹配结果的一部分。

Code
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace MyCsStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            string strSource = "think in javascript deeply";
            //myReg中的正声明表示必须保证在至少5个字母的后面必须紧跟着“ in”（in前有一个空格）
            Regex myReg = new Regex(@"[a-z]{5,}(?= in)");

            Console.WriteLine(myReg.IsMatch(strSource)); //true
            Console.WriteLine(myReg.Matches(strSource).Count);//1

            if (myReg.IsMatch(strSource))
            {
                Console.WriteLine("match:" + myReg.Match(strSource).Value);
            }

            Console.WriteLine("--------------------------------");

            //myReg中的负声明表示必须保证在至少5个字母的后面不能跟有“ in”（in前有一个空格）
            myReg = new Regex(@"[a-z]{5,}(?! in)");

            Console.WriteLine(myReg.IsMatch(strSource)); //true
            Console.WriteLine(myReg.Matches(strSource).Count);//2

            if (myReg.IsMatch(strSource))
            {
                Console.WriteLine("match:" + myReg.Match(strSource).Value);
            }

            Console.ReadLine();
        }
    }
}

反向预搜索声明格式：正声明“(?<=)”，负声明“(?<!)”，声明本身不作为最终匹配结果的一部分。

Code
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace MyCsStudy
{
    class Program
    {
        static void Main(string[] args)
        {

            string strSource = "think in c# bright,think in javascript deeply";
            //myReg中的反向正声明表示必须保证在6个字母组合的前面必须紧跟着至少5个字母的组合
            Regex myReg = new Regex(@"(?<=[a-z]{5,})(\s[a-z]{6})");

            Console.WriteLine(myReg.IsMatch(strSource)); //true
            Console.WriteLine(myReg.Matches(strSource).Count);//1

            if (myReg.IsMatch(strSource))
            {
                Console.WriteLine("match:" + myReg.Match(strSource).Value);
            }

            Console.WriteLine("--------------------------------");

            //myReg中的反向负声明表示必须保证在6个字母组合的前面必须紧跟着处至少5个字母的组合
            myReg = new Regex(@"(?<![a-z]{5,})(\s[a-z]{6})");

            Console.WriteLine(myReg.IsMatch(strSource)); //true
            Console.WriteLine(myReg.Matches(strSource).Count);//1

            if (myReg.IsMatch(strSource))
            {
                Console.WriteLine("match:" + myReg.Match(strSource).Value);
            }
        }
    }
}

8、回溯与非回溯
使用“(?>…)”方式进行非回溯声明。由于正则表达式引擎的贪婪特性，导致它在某些情况下，将进行回溯以获得匹配。

Code
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace MyCsStudy
{
    class Program
    {
        static void Main(string[] args)
        {
            string strSource = "think in c# deeply,think in javascript deeply";
            //由于"*"的贪婪特性，将一直匹配到字符串的最后，随后匹配“ly,”，但在匹配“,”时失败，此时引擎将回溯，并在“ly,”处匹配成功
            Regex myReg = new Regex(@".*ly,");

            Console.WriteLine(myReg.IsMatch(strSource)); //true
            Console.WriteLine(myReg.Matches(strSource).Count);//1

            if (myReg.IsMatch(strSource))
            {
                Console.WriteLine("match:" + myReg.Match(strSource).Value);
            }

            Console.WriteLine("--------------------------------");

            //非回溯，无匹配项
            myReg = new Regex(@"(?>.*)ly,");

            Console.WriteLine(myReg.IsMatch(strSource)); //false
            Console.WriteLine(myReg.Matches(strSource).Count);//0

            if (myReg.IsMatch(strSource))//不匹配
            {
                Console.WriteLine("match:" + myReg.Match(strSource).Value);
            }
            else Console.WriteLine("no match result");

            Console.ReadLine();
        }
    }
}

9、小结
关于正则表达式有很多书籍专门讲解它的高级应用，比如在搜索引擎，词库等方面的应用。读者可按需要自己去买来看看。按照笔者的经验，这个东西学起来不难，用起来也很灵活，当然忘得也很快。关于正则表达式还有很多高级应用这里没有也不可能一一列举，需要注意的是，有些需求要做到精确匹配比较困难，只能退而求其次，保证比较精确的匹配。比如url的验证，这里就不举例了。

转载于:https://www.cnblogs.com/jeffwongishandsome/archive/2010/04/08/1512556.html