第八章 委托、lambda表达式和事件

最新推荐文章于 2024-05-06 16:44:19 发布
最新推荐文章于 2024-05-06 16:44:19 发布
阅读量112 收藏
点赞数
原文链接：http://www.cnblogs.com/liuslayer/p/7017095.html
版权

GetAStringDemo

using System;

namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    private delegate string GetAString();

    static void Main()
    {
      int x = 40;
      GetAString firstStringMethod = x.ToString;
      Console.WriteLine("String is {0}", firstStringMethod());

      Currency balance = new Currency(34, 50);

      // firstStringMethod references an instance method
      firstStringMethod = balance.ToString;
      Console.WriteLine("String is {0}", firstStringMethod());

      // firstStringMethod references a static method
      firstStringMethod = new GetAString(Currency.GetCurrencyUnit);
      Console.WriteLine("String is {0}", firstStringMethod());

    }
  }
}
View Code 
namespace Wrox.ProCSharp.Delegates
{
    struct Currency
    {
        public uint Dollars;
        public ushort Cents;

        public Currency(uint dollars, ushort cents)
        {
            this.Dollars = dollars;
            this.Cents = cents;
        }

        public override string ToString()
        {
            return string.Format("${0}.{1,-2:00}", Dollars, Cents);
        }

        public static string GetCurrencyUnit()
        {
            return "Dollar";
        }

        public static explicit operator Currency(float value)
        {
            checked
            {
                uint dollars = (uint)value;
                ushort cents = (ushort)((value - dollars) * 100);
                return new Currency(dollars, cents);
            }
        }

        public static implicit operator float(Currency value)
        {
            return value.Dollars + (value.Cents / 100.0f);
        }

        public static implicit operator Currency(uint value)
        {
            return new Currency(value, 0);
        }

        public static implicit operator uint(Currency value)
        {
            return value.Dollars;
        }
    }

}
View Code

SimpleDelegates

namespace Wrox.ProCSharp.Delegates
{
  class MathOperations
  {
    public static double MultiplyByTwo(double value)
    {
      return value * 2;
    }

    public static double Square(double value)
    {
      return value * value;
    }
  }

}
View Code 
using System;

namespace Wrox.ProCSharp.Delegates
{
  delegate double DoubleOp(double x);

  class Program
  {
    static void Main()
    {
      DoubleOp[] operations =
      {
        MathOperations.MultiplyByTwo,
        MathOperations.Square
      };

      for (int i = 0; i < operations.Length; i++)
      {
        Console.WriteLine("Using operations[{0}]:", i);
        ProcessAndDisplayNumber(operations[i], 2.0);
        ProcessAndDisplayNumber(operations[i], 7.94);
        ProcessAndDisplayNumber(operations[i], 1.414);
        Console.WriteLine();
      }
    }

    static void ProcessAndDisplayNumber(DoubleOp action, double value)
    {
      double result = action(value);
      Console.WriteLine(
         "Value is {0}, result of operation is {1}", value, result);
    }
  }

}
View Code

BubbleSorter

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    static void Main()
    {
      Employee[] employees =
      {
        new Employee("Bugs Bunny", 20000),
        new Employee("Elmer Fudd", 10000),
        new Employee("Daffy Duck", 25000),
        new Employee("Wile Coyote", 1000000.38m),
        new Employee("Foghorn Leghorn", 23000),
        new Employee("RoadRunner", 50000)
      };

      BubbleSorter.Sort(employees, Employee.CompareSalary);

      foreach (var employee in employees)
      {
        Console.WriteLine(employee);
      }

    }
  }
}
View Code 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Wrox.ProCSharp.Delegates
{
  class Employee
  {
    public Employee(string name, decimal salary)
    {
      this.Name = name;
      this.Salary = salary;
    }

    public string Name { get; private set; }
    public decimal Salary { get; private set; }

    public override string ToString()
    {
      return string.Format("{0}, {1:C}", Name, Salary);
    }

    public static bool CompareSalary(Employee e1, Employee e2)
    {
      return e1.Salary < e2.Salary;
    }
  }

}
View Code 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Wrox.ProCSharp.Delegates
{
  class BubbleSorter
  {
    static public void Sort<T>(IList<T> sortArray, Func<T, T, bool> comparison)
    {
      bool swapped = true;
      do
      {
        swapped = false;
        for (int i = 0; i < sortArray.Count - 1; i++)
        {
          if (comparison(sortArray[i + 1], sortArray[i]))
          {
            T temp = sortArray[i];
            sortArray[i] = sortArray[i + 1];
            sortArray[i + 1] = temp;
            swapped = true;
          }
        }
      } while (swapped);


    }
  }

}
View Code

MulticastDelegates

using System;

namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    static void Main()
    {
      Action<double> operations = MathOperations.MultiplyByTwo;
      operations += MathOperations.Square;

      ProcessAndDisplayNumber(operations, 2.0);
      ProcessAndDisplayNumber(operations, 7.94);
      ProcessAndDisplayNumber(operations, 1.414);
      Console.WriteLine();
    }

    static void ProcessAndDisplayNumber(Action<double> action, double value)
    {
      Console.WriteLine();
      Console.WriteLine("ProcessAndDisplayNumber called with value = {0}", value);
      action(value);

    }
  }

}
View Code 
using System;

namespace Wrox.ProCSharp.Delegates
{
  class MathOperations
  {
    public static void MultiplyByTwo(double value)
    {
      double result = value * 2;
      Console.WriteLine("Multiplying by 2: {0} gives {1}", value, result);
    }

    public static void Square(double value)
    {
      double result = value * value;
      Console.WriteLine("Squaring: {0} gives {1}", value, result);
    }
  }


}
View Code

MulticastDelegateWithIteration

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    static void One()
    {
      Console.WriteLine("One");
      throw new Exception("Error in one");
    }

    static void Two()
    {
      Console.WriteLine("Two");
    }


    static void Main()
    {
      //Action d1 = One;
      //d1 += Two;

      //try
      //{
      //    d1();
      //}
      //catch (Exception)
      //{
      //    Console.WriteLine("Exception caught");
      //}

      Action d1 = One;
      d1 += Two;

      Delegate[] delegates = d1.GetInvocationList();
      foreach (Action d in delegates)
      {
        try
        {
          d();
        }
        catch (Exception)
        {
          Console.WriteLine("Exception caught");
        }
      }


    }
  }
}
View Code

AnonymousMethods

using System;

namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    static void Main()
    {
      string mid = ", middle part,";

      Func<string, string> anonDel = delegate(string param)
      {
        param += mid;
        param += " and this was added to the string.";
        return param;
      };
      Console.WriteLine(anonDel("Start of string"));

    }
  }

}
View Code

 LambdaExpressions

using System;

namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    static void Main()
    {
      // SimpleDemos();

      int someVal = 5;
      Func<int, int> f = x => x + someVal;

      someVal = 7;

      Console.WriteLine(f(3));
    }


    static void SimpleDemos()
    {
      Func<string, string> oneParam = s => String.Format("change uppercase {0}", s.ToUpper());
      Console.WriteLine(oneParam("test"));

      Func<double, double, double> twoParams = (x, y) => x * y;
      Console.WriteLine(twoParams(3, 2));

      Func<double, double, double> twoParamsWithTypes = (double x, double y) => x * y;
      Console.WriteLine(twoParamsWithTypes(4, 2));

      Func<double, double> operations = x => x * 2;
      operations += x => x * x;

      ProcessAndDisplayNumber(operations, 2.0);
      ProcessAndDisplayNumber(operations, 7.94);
      ProcessAndDisplayNumber(operations, 1.414);
      Console.WriteLine();
    }

    static void ProcessAndDisplayNumber(Func<double, double> action, double value)
    {
      double result = action(value);
      Console.WriteLine(
         "Value is {0}, result of operation is {1}", value, result);

    }

  }
}
View Code

EventsSample

using System;

namespace Wrox.ProCSharp.Delegates
{
  public class CarInfoEventArgs : EventArgs
  {
    public CarInfoEventArgs(string car)
    {
      this.Car = car;
    }

    public string Car { get; private set; }
  }

  public class CarDealer
  {
    public event EventHandler<CarInfoEventArgs> NewCarInfo;

    public void NewCar(string car)
    {
      Console.WriteLine("CarDealer, new car {0}", car);

      RaiseNewCarInfo(car);
    }

    protected virtual void RaiseNewCarInfo(string car)
    {
      EventHandler<CarInfoEventArgs> newCarInfo = NewCarInfo;
      if (newCarInfo != null)
      {
        newCarInfo(this, new CarInfoEventArgs(car));
      }
    }
  }
}
View Code 
using System;

namespace Wrox.ProCSharp.Delegates
{
    public class Consumer
    {
        private string name;

        public Consumer(string name)
        {
            this.name = name;
        }

        public void NewCarIsHere(object sender, CarInfoEventArgs e)
        {
            Console.WriteLine("{0}: car {1} is new", name, e.Car);
        }
    }
}
View Code 
namespace Wrox.ProCSharp.Delegates
{
    class Program
    {
        static void Main()
        {
            var dealer = new CarDealer();

            var michael = new Consumer("Michael");
            dealer.NewCarInfo += michael.NewCarIsHere;

            dealer.NewCar("Ferrari");

            var nick = new Consumer("Sebastian");
            dealer.NewCarInfo += nick.NewCarIsHere;

            dealer.NewCar("Mercedes");

            dealer.NewCarInfo -= michael.NewCarIsHere;

            dealer.NewCar("Red Bull Racing");
        }
    }
}
View Code

WeakEventsSample

using System.Windows;

namespace Wrox.ProCSharp.Delegates
{
  public class WeakCarInfoEventManager : WeakEventManager
  {
    public static void AddListener(object source, IWeakEventListener listener)
    {
      CurrentManager.ProtectedAddListener(source, listener);
    }

    public static void RemoveListener(object source, IWeakEventListener listener)
    {
      CurrentManager.ProtectedRemoveListener(source, listener);
    }

    public static WeakCarInfoEventManager CurrentManager
    {
      get
      {
        WeakCarInfoEventManager manager = GetCurrentManager(typeof(WeakCarInfoEventManager)) as WeakCarInfoEventManager;
        if (manager == null)
        {
          manager = new WeakCarInfoEventManager();
          SetCurrentManager(typeof(WeakCarInfoEventManager), manager);
        }
        return manager;
      }
    }


    protected override void StartListening(object source)
    {
      (source as CarDealer).NewCarInfo += CarDealer_NewCarInfo;
    }

    void CarDealer_NewCarInfo(object sender, CarInfoEventArgs e)
    {
      DeliverEvent(sender, e);
    }
    protected override void StopListening(object source)
    {
      (source as CarDealer).NewCarInfo -= CarDealer_NewCarInfo;
    }
  }
}
View Code 
namespace Wrox.ProCSharp.Delegates
{
  class Program
  {
    static void Main()
    {
      var dealer = new CarDealer();

      var michael = new Consumer("Michael");
      WeakCarInfoEventManager.AddListener(dealer, michael);

      dealer.NewCar("Mercedes");

      var sebastian = new Consumer("Sebastian");
      WeakCarInfoEventManager.AddListener(dealer, sebastian);

      dealer.NewCar("Ferrari");

      WeakCarInfoEventManager.RemoveListener(dealer, michael);

      dealer.NewCar("Red Bull Racing");
    }
  }
}
View Code 
using System;
using System.Windows;

namespace Wrox.ProCSharp.Delegates
{
  public class Consumer : IWeakEventListener
  {
    private string name;

    public Consumer(string name)
    {
      this.name = name;
    }

    public void NewCarIsHere(object sender, CarInfoEventArgs e)
    {
      Console.WriteLine("{0}: car {1} is new", name, e.Car);
    }

    bool IWeakEventListener.ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
    {
      NewCarIsHere(sender, e as CarInfoEventArgs);
      return true;
    }


  }
}
View Code 
using System;

namespace Wrox.ProCSharp.Delegates
{
  public class CarInfoEventArgs : EventArgs
  {
    public CarInfoEventArgs(string car)
    {
      this.Car = car;
    }

    public string Car { get; private set; }
  }

  public class CarDealer
  {
    public event EventHandler<CarInfoEventArgs> NewCarInfo;

    public CarDealer()
    {

    }

    public void NewCar(string car)
    {
      Console.WriteLine("CarDealer, new car {0}", car);
      if (NewCarInfo != null)
      {
        NewCarInfo(this, new CarInfoEventArgs(car));
      }
    }
  }
}
View Code

 

转载于:https://www.cnblogs.com/liuslayer/p/7017095.html

weixin_33953249
关注
Kotlin基础 - 第七章lambda表达式
bencheng06的博客
06-09 667
kotlin中的lambda表达式 #### [kotlin官方文档 https://www.kotlincn.net/docs/reference/](https://www.kotlincn.net/docs/reference/) #### lambda即lambda表达式，简称lambda。本质上是可以传递给其它函数的一小段代码。有了lambda，可以轻松地把通用代码结构抽取成库函数。lambda最常见的用途是和集合一起配合。kotlin甚至还拥有带接收者的lambda，这是一种特殊的la
Java中Lambda表达式和Groovy闭包的相关解析
茅屋
01-24 5159
Lambda名词释义 Lambda表达式表示匿名函数，和匿名类对比，及不需要声明函数的方法名和返回值，用表达式的形式完成函数的参数和相关逻辑。 Lambda表达式应用于Groovy和Kotlin中，作为实现函数式编程的关键（函数式编程是指一个函数能够作为另一个函数的入参）。而在JDK8中支持了对Lambda表达式的应用。 基本使用 java中对lambda表达式的声明不像Kotlin等
委托、 Lambda表达式和事件——事件
weixin_30512043的博客
08-03 135
1 /* 2 * 由SharpDevelop创建。 3 * 用户： David Huang 4 * 日期: 2015/7/31 5 * 时间: 14:21 6 */ 7 using System; 8 9 namespace 事件 10 { 11 public class GameInfoEventArgs:EventArgs 12 ...
委托的Lambda表达式
weixin_30877493的博客
01-21 63
在.NET 3.5的System命名空间中，有5个泛型Func委托类型。Func并无特别之处，只是它提供了一些好用的预定义泛型类型，在很多情况下能帮我们处理问题。最后一个类型用作每种情况下的返回类型。 TResult Func<TResult>() TResult Func<T,TResultl>(T arg) ... Func<string,dou...
委托，事件，lambda表达式
ddd77197的博客
05-06 125
开篇说明三个点： 委托是一种类型 事件是委托的实例 lambda表达式是一个方法（匿名方法） 【未完待续】 转载于:https://www.cnblogs.com/daimajun/p/6818769.html...
委托、lambda表达式
weixin_30786657的博客
06-03 79
委托 当只有一个参数时，大括号可以省略掉。 多个参数时用逗号(,)隔开，参数类型可以省略掉。 方法只有一行代码，叫lambda表达式，大括号可以省略掉，自动将表达式的结果返回。 lambda 语法:用来简化声明方法 使用lambda表达式，可以简化代码，减少多余代码。 转载于:https://www.cnblogs.com/zlwei23/p/1094...
委托、Lambda表达式、事件、观察者设计模式
xmhwjzabc的博客
06-08 147
委托简述：委托简单来说就是一个可以赋值方法的类型（就如int类型可以赋值数字一样）。所有的委托（Delegate）都派生自 System.Delegate 类。委托是一个类型安全的，面向对象的函数指针。 委托定义：例如 delegate void IntMethodInvoker(int x).上述声明了一个可以指向一个带有一个int 类型的形参，返回值为void 的方法。 字段 ...
C#高级编程笔记-委托、lambda表达式和事件
qq_62520130的博客
05-06 798
定义委托基本上是定义一个新类，所以可以在定义类的任何地方定义委托，既可以在另一个类的内部定义，也可以在任何类的外部定义，还可以在命名空间中把委托定义为顶层对象。根据定义的可见性，可以在委托定义上添加一般的访问修饰符：public、private、protected等：委托实现为派生自基类System. MulticastDelegate的类，System.MulticastDelegate又派生自基类System.Delegate。
C# 委托、Lambda表达式和事件
江江的博客
06-15 555
在C#中，首先需要定义委托类型，它定义了委托可以引用的方法的签名。委托的定义类似于一个方法的声明，但没有实现体。委托定义可以放在命名空间、类或结构体内部。// 定义了一个名为 MyDelegate 的委托，它可以引用一个带有一个 int 类型参数并且没有返回值的方法 delegate void MyDelegate(int x);
委托、冒泡排序、lambda表达式、事件
XiaoYaoYao2的博客
12-15 625
一、委托 1、介绍     如果要把方法当做参数来传递的话，就要用到委托，简单来说委托是一个类型     这个类型可以赋值一个方法的引用 2、声明委托     与类一样，经过两个阶段：先定义委托，告诉编译器这个委托指向哪些类型的方法                         创建该委托的实例 定义： delegate void IntMethodInvoker(int
【ASP.NET编程知识】SqlDataReader生成动态Lambda表达式.docx
05-20
通过动态生成Lambda表达式，我们可以仅在第一次转换时进行反射操作，之后的转换只需调用预先生成的委托，显著提高了性能。 5. **示例代码分析**: - `ToList<T>`方法接收一个DataTable，并使用第一行的数据生成...
深入底层原理—带你看透Lambda表达式的本质
weixin_57907028的博客
05-28 1822
前言 嗨咯，大家好，今天给带大家深入底层原理看透Lambda表达式的本质，如果本文对你有帮助，记得一键三连一下！！ 知识点 Lambda的原理 Java 8支持动态语言，看到很酷的Lambda表达式，对一直以静态类型语言自居的Java，让人看到了Java虚拟机可以支持动态语言的目标。 Lambda的案例 import java.util.function.Consumer; public class Lambda { public static void main(String[] args) {
python贪吃蛇代码写好了怎么运行-用python实现贪吃蛇代码
weixin_37988176的博客
10-29 815
import sys, pygamefrom pygame.locals import *from random import randrangeup =lambda x:(x[0]-1,x[1])down = lambda x :(x[0]+1,x[1])left = lambda x : (x[0],x[1]-1)right = lambda x : (x[0],x[1]+1)tl = lam...
输入框事件监听(一)：keydown、keyup、input
热门推荐
甘焕的博客
08-30 9万+
当输入框的值发生变化时，我们可以通过keydown、keyup、input、onchange、blur事件观察到其值的变化，但它们的应用时机与应用场景存在显著的差异
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
最新发布
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
C++11/14/17正则表达式入门与Lambda表达式详解
此外，Lambda表达式和函数对象包装器（如`std::function`和`std::bind`）使得异步编程和回调函数的管理更为方便。 语言运行期强化主要涉及右值引用和移动语义，这些概念对于高效地处理对象传递至关重要。移动语义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值