大学IT网 - 最懂大学生的IT学习网站! QQ资料交流群:367606806
当前位置:大学IT网 > C#技巧 > 委托的三种实现方式

委托的三种实现方式

关键词:三种委托方式  阅读(765) 赞(12)

[摘要]委托是封装方法的类型,委托的类型由委托的名称定义。既然它是是一种类型,那么它就可以像int、string一样去使用,好像也没有我们想象的那么神秘。

一. 委托的定义 委托是封装方法的类型,委托的类型由委托的名称定义。既然它是是一种类型,那么它就可以像int、string一样去使用,好像也没有我们想象的那么神秘。 在Entity Framework 3.5之前,在使用委托时需要先显示的声明委托,格式如下:

public delegate void DelegateName(string message);

在Entity Framework 3.5之后,新增了两种实现方式,格式如下:

1. 不带返回值的委托定义:

public delegate void Action<in T1, in T2>(
    T1 arg1,
    T2 arg2
)
2. 代返回值的委托定义:
publicdelegate TResult Func<in T, out TResult>(
    T arg
)

二. 委托的具体实现

首先,显示声明委托的实现方式:

1. 声明委托

        //显式定义一个没有返回值,有两个参数的方法的委托
        public delegate void CommonDelegateForAction(string string1, string string2); 

2. 实例化委托的实例,并将方法的引用分配给委托实例

//实例化一个CommonDelegate的实例,并将对UpperString 方法的引用分配给委托实例
            CommonDelegateForAction commDelegate = Concat;

3.引用委托的实例,调用引用委托的方法

//引用CommonDelegateForAction的实例,调用UpperString方法
            commDelegate(source1, source2);

4. 完整的代码实现

public class CommonDelegateSample
    {
        //显式定义一个没有返回值,有两个参数的方法的委托
        public delegate void CommonDelegateForAction(string string1, string string2);

        public void SampleForAction()
        {
            //实例化一个CommonDelegate的实例,并将对UpperString 方法的引用分配给委托实例
            CommonDelegateForAction commDelegate = Concat;
                        
            string source1 = "I deeply love my country,";
            string source2 = "But she didn't love me.";

            //引用CommonDelegateForAction的实例,调用UpperString方法
            commDelegate(source1, source2);
        }

        /// <summary>
        /// 连接两个字符串
        /// </summary>
        /// <param name="str1">字符串</param>
        /// <param name="str2">字符串</param>
        private void Concat(string str1, string str2)
        {
            Console.WriteLine(str1+str2);
        }
    }

其次,Action<T1, T2>委托实现方式

Action<...>委托最多可以有16个参数,并且Action<...>委托使用前不需要提前声明。

1.实例化委托的实例,并将方法的引用分配给委托实例

            //定义一个委托变量,并赋值为Concat
            Action<string, string> actionDelegate = Concat;

2.引用委托的实例,调用方法

            //引用委托的实例,调用方法
            actionDelegate(str1, str2);

3. 完整的代码实现

        public void Sample()
        {
            //定义一个委托变量,并赋值为Concat
            Action<string, string> actionDelegate = Concat;

            string str1 = "I deeply love my country,";
            string str2 = "But she didn't love me.";

            //引用委托的实例,调用方法
            actionDelegate(str1, str2);
        }

        /// <summary>
        /// 输出两个字符串的连接
        /// </summary>
        /// <param name="str1">字符串</param>
        /// <param name="str2">字符串</param>
        private void Concat(string str1,string str2)
        {
            Console.WriteLine(str1+str2);
        }
    }

最后,Func<T, TResult>委托的实现方式
Func<...>委托最多可以有16个输入参数,一个返回值,并且Func<...>委托使用前不需要提前声明。

1.实例化委托的实例,并将方法的引用分配给委托实例

//定义一个委托变量,并赋值为UpperString
            Func<string, string> convert = UpperString;

2. 引用委托的实例,调用方法

            //用委托实例,调用方法
            string target = convert(source);

3.Func<T, TResult> 委托,与Lambda表达式

        public void SampleForLambda()
        {
            Func<string, string> convert = str => str.ToUpper();

            string source = "delegate";
            string target = convert(source);

            Console.WriteLine(target);  
        }

4.Func<T, TResult> 委托,作为变量

        /// <summary>
        /// Func<T, TResult> 委托,作为变量
        /// </summary>
        public void SampleForVariable()
        {
            //声明一个Func变量,并给这个变量赋值一个Lambda表达式
            Func<string, string> selector = str => str.ToUpper();

            string[] words = { "china", "america", "england", "germany" };

            //Select方法的定义:IEnumerable<string> IEnumerable<string>.Select<string, string>(Func<string, string> selector);
            //Select方法需要一个Func<string, string>类型的参数,所以传递一个Func<string, string>类型的参数selector。
            IEnumerable<String> aWords = words.Select(selector);

            foreach (String word in aWords)
                Console.WriteLine(word);
        }

5. 完整的代码实现

public class FuncDelegateSample
    {
        /// <summary>
        /// 实例化 Func<T, TResult> 委托
        /// </summary>
        public void Sample()
        {
            //定义一个委托变量,并赋值为UpperString
            Func<string, string> convert = UpperString;

            string source = "I deeply love my country,But she didn't love me.";

            //用委托实例,调用方法
            string target = convert(source);

            Console.WriteLine(target);
        }

        /// <summary>
        /// Func<T, TResult> 委托,与Lambda表达式
        /// </summary>
        public void SampleForLambda()
        {
            Func<string, string> convert = str => str.ToUpper();

            string source = "delegate";
            string target = convert(source);

            Console.WriteLine(target);  
        }

        /// <summary>
        /// Func<T, TResult> 委托,作为变量
        /// </summary>
        public void SampleForVariable()
        {
            //声明一个Func变量,并给这个变量赋值一个Lambda表达式
            Func<string, string> selector = str => str.ToUpper();

            string[] words = { "china", "america", "england", "germany" };

            //Select方法的定义:IEnumerable<string> IEnumerable<string>.Select<string, string>(Func<string, string> selector);
            //Select方法需要一个Func<string, string>类型的参数,所以传递一个Func<string, string>类型的参数selector。
            IEnumerable<String> aWords = words.Select(selector);

            foreach (String word in aWords)
                Console.WriteLine(word);
        }

        /// <summary>
        /// 将输入字符串的字符转化为大写
        /// </summary>
        /// <param name="str">输入参数</param>
        /// <returns>返回值</returns>
        private string UpperString(string str)
        {
            return str.ToUpper();
        }
    }


相关评论