019 委托

最新推荐文章于 2024-07-14 09:26:19 发布
最新推荐文章于 2024-07-14 09:26:19 发布
阅读量102 收藏
点赞数
文章标签： c# c/c++ java
原文链接：http://www.cnblogs.com/YiShen/p/9889380.html
版权

实例:C/C++中的函数指针

#include <stdio.h>
#include <stdlib.h>

typedef int(*Calc)(int a, int b);

int Add(int a, int b)
{
    return a+b;
}

int Sub(int a, int b)
{
    return a-b;
}

int main()
{
    int x = 100;
    int y = 200;
    int z;

    Calc funPiont1 = &Add;
    Calc funPoint2 = &Sub;

    z = funPiont1(x,y);
    printf("%d+%d=%d\n",x,y,z);

    z=funPoint2(x,y);
    printf("%d-%d=%d\n",x,y,z);

    system("pause");
    return 0;
}

C#中的委托:

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

namespace demo2
{
    class Program
    {
        static void Main(string[] args)
        {
            Calcculator calculator = new Calcculator();
            Action action = new Action(calculator.Report);
            calculator.Report();
            action.Invoke();
            action();

            Func<int, int, int> func1 = new Func<int, int, int>(calculator.Add);
            Func<int, int, int> func2 = new Func<int, int, int>(calculator.Sub);
            int x = 20;
            int y = 12;
            int z = func1(x, y);
            Console.WriteLine(z);
            z = func2(x, y);
            Console.WriteLine(z);
        }
    }

    class Calcculator
    {
        public void Report()//报告
        {
            Console.WriteLine("I have 3 methods.");//我有三种方法
        }

        public int Add(int a,int b)
        {
            int result = a + b;
            return result;
        }

        public int Sub(int a,int b)
        {
            int result = a - b;
            return result;
        }
    }
}

C#委托声明(自定义委托)

检测委托是否是一个类(返回结果表示 委托是一个类):

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

namespace demo2
{
    class Program
    {
        static void Main(string[] args)
        {
            Type t = typeof(Action);
            Console.WriteLine(t.IsClass);
        }
    }
}

自己声明一个委托:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Calculator calculator = new Calculator();
            Calc calc1 = new Calc(calculator.Add);
            Calc calc2 = new Calc(calculator.Sub);
            Calc calc3 = new Calc(calculator.Mul);
            Calc calc4 = new Calc(calculator.Div);

            double a = 100;
            double b = 200;
            double c = 0;
            Console.WriteLine(calc1.Invoke(a,b));
            Console.WriteLine(calc2.Invoke(a,b));
            Console.WriteLine(calc3(a,b));
            Console.WriteLine(calc4(a,b));

        }
    }

    class Calculator
    {
        public double Add(double x, double y)
        {
            return x + y;
        }

        public double Sub(double x, double y)
        {
            return x - y;
        }

        public double Mul(double x, double y)
        {
            return x * y;
        }

        public double Div(double x, double y)
        {
            return x / y;
        }

    }
}

 

委托的一般使用

实例:把方法当做参数传给另一个方法

正确使用1:模板方法

  • 相当于填空题
  • 常常位于代码中部
  • 委托有返回值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            ProductFactory productFactory = new ProductFactory();
            WrapFactory wrapFactory = new WrapFactory();

            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
            Func<Product> func2 = new Func<Product>(productFactory.MakeToCar);

            Box box1 = wrapFactory.WraProduct(func1);
            Box box2 = wrapFactory.WraProduct(func2);

            Console.WriteLine(box1.product.Name);
            Console.WriteLine(box2.product.Name);
        }
    }
    
    class Product//产品
    {
        public string Name { get; set; }
    }

    class Box//包装
    {
        public Product product { get; set; }
    }

    class WrapFactory//包装工厂
    {
        public Box WraProduct(Func<Product>getProduct)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            box.product = product;
            return box;
        }
    }

    class ProductFactory//产品工厂
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }

        public Product MakeToCar()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            return product;
        }
    }
}

 

正确使用2:回调(callback)

  • 相当于流水线
  • 常常位于代码末尾
  • 委托无返回值
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            ProductFactory productFactory = new ProductFactory();
            WrapFactory wrapFactory = new WrapFactory();

            Func<Product> func1 = new Func<Product>(productFactory.MakePizza);
            Func<Product> func2 = new Func<Product>(productFactory.MakeToCar);

            Logger logger = new Logger();
            Action<Product> log = new Action<Product>(logger.Log);

            Box box1 = wrapFactory.WraProduct(func1,log);
            Box box2 = wrapFactory.WraProduct(func2,log);

            Console.WriteLine(box1.product.Name);
            Console.WriteLine(box2.product.Name);
        }
    }

    class Logger
    {
        public void Log(Product product)
        {
            Console.WriteLine("Product'{0}' Create at'{1}'.Price is '{2}'.",product.Name,DateTime.UtcNow,product.Price);
        }
    }

    class Product//产品
    {
        public string Name { get; set; }
        public double Price { get; set; }
    }

    class Box//包装
    {
        public Product product { get; set; }
    }

    class WrapFactory//包装工厂
    {
        public Box WraProduct(Func<Product>getProduct,Action<Product>logCallback)
        {
            Box box = new Box();
            Product product = getProduct.Invoke();
            if (product.Price >= 50)
            {
                logCallback(product);
            }
            box.product = product;
            return box;
        }
    }

    class ProductFactory//产品工厂
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            product.Price = 12;
            return product;
        }

        public Product MakeToCar()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            product.Price = 100;
            return product;
        }
    }
}

 

注意:难精通+易使用+功能强大的东西,一旦被滥用则后果非常严重

  • 缺点1:这种方法是一种方法级别的紧耦合,现实工作中要慎之又慎.
  • 缺点2:使可读性下降,debug难度增大.
  • 缺点3:把委托回调,异步回调和多线程纠缠在一起,会让代码变得难以阅读和维护.
  • 缺点4:委托使用不当有可能造成内存泄漏和程序性能下降.

下面是一段滥用委托的例子:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Operation op1 = new Operation();
            Operation op2 = new Operation();
            Operation op3 = new Operation();

            op3.InnerOperation = op2;
            op2.InnerOperation = op1;

            op3.Operate(new object, null, null);
            //问题1:如果传入的两个参数都为null,失败返回的结果是什么?答:内层操作会调用外层的回调!
            //问题2:如果传入的两个参数不为null,会出现什么情况?答:所有默认callback都被"穿透性"屏蔽!
        }
    }

    class Operation
    {
        public Action DefaultSuccessCallback { get; set; }
        public Action DefaultFailureCallback { get; set; }
        public Operation InnerOperation { get; set; }

        public object Operate(object input,Action successCallback,Action failureCallback)
        {
            if (successCallback == null)
            {
                successCallback = this.DefaultSuccessCallback;
            }

            if (failureCallback == null)
            {
                failureCallback = this.DefaultFailureCallback;
            }

            object result = null;
            try
            {
                result = this.InnerOperation(input, successCallback, failureCallback);
            }
            catch
            {

                failureCallback.Invoke();
            }

            successCallback.Invoke();
            return result;
        }
    }
}

 

委托的高级使用

  • 多播委托

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            //单播委托
            //action1.Invoke();
            //action2.Invoke();
            //action3.Invoke();

            //多播委托
            action1 += action2;
            action1 += action3;

            action1.Invoke();
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)",this.ID,i);
                Thread.Sleep(1000);
            }
        }
    }
}

  • 隐式异步调用

    • 同步与异步简介
      • 中英文语言差异
      • 同步:你做完了我(在你的基础上)接着做.
      • 异步:咱们两个同时做(相当于汉语中的"同步进行")
    • 同步调用与异步调用的对比
      • 每一个运行的程序是一个进程(process)
      • 每一个进程都可以有一个或多个线程(thread)
      • 同步调用实在同个线程内
      • 异步调用的底层机理是多线程
      • 串行==同步==单线程, 并行==异步==多线程
    • 隐式多线程VS显示多线程
      • 直接同步调用:使用方法名
      • 简介同步调用:使用单播/多播委托的invoke方法
      • 隐式异步调用:使用委托begininvoke
      • 显示异步调用:使用thread或task

同步直接调用实例:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            stu1.DoHomework();
            stu2.DoHomework();
            stu3.DoHomework();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}.", i);
                Thread.Sleep(1000);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)", this.ID, i);
                Thread.Sleep(1000);
            }
        }
    }
}

同步单播间接调用实例:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1.Invoke();
            action2.Invoke();
            action3.Invoke();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}.", i);
                Thread.Sleep(1000);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)", this.ID, i);
                Thread.Sleep(100);
            }
        }
    }
}

同步多播间接调用:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1 += action2;
            action1 += action3;

            action1.Invoke();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}.", i);
                Thread.Sleep(1000);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)", this.ID, i);
                Thread.Sleep(100);
            }
        }
    }
}

隐式异步调用例子:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Action action1 = new Action(stu1.DoHomework);
            Action action2 = new Action(stu2.DoHomework);
            Action action3 = new Action(stu3.DoHomework);

            action1.BeginInvoke(null, null);
            action2.BeginInvoke(null, null);
            action3.BeginInvoke(null, null);

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}.", i);
                Thread.Sleep(100);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)", this.ID, i);
                Thread.Sleep(100);
            }
        }
    }
}

显示异步调用1:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            //古老的方式
            Thread thread1 = new Thread(new ThreadStart(stu1.DoHomework));
            Thread thread2 = new Thread(new ThreadStart(stu2.DoHomework));
            Thread thread3 = new Thread(new ThreadStart(stu3.DoHomework));

            thread1.Start();
            thread2.Start();
            thread3.Start();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}.", i);
                Thread.Sleep(100);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)", this.ID, i);
                Thread.Sleep(100);
            }
        }
    }
}

显示异步调用2:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            Student stu1 = new Student() { ID = 1, PenColor = ConsoleColor.Yellow };
            Student stu2 = new Student() { ID = 2, PenColor = ConsoleColor.Green };
            Student stu3 = new Student() { ID = 3, PenColor = ConsoleColor.Red };

            Task task1 = new Task(new Action(stu1.DoHomework));
            Task task2 = new Task(new Action(stu2.DoHomework));
            Task task3 = new Task(new Action(stu3.DoHomework));

            task1.Start();
            task2.Start();
            task3.Start();

            for (int i = 0; i < 10; i++)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("Main thread{0}.", i);
                Thread.Sleep(100);
            }
        }
    }

    class Student
    {
        public int ID { get; set; }
        public ConsoleColor PenColor { get; set; }

        public void DoHomework()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homeword {1} hour(s)", this.ID, i);
                Thread.Sleep(100);
            }
        }
    }
}
  •  应该适时地使用接口(interface)取代一些委托的操作
    • java完全地使用接口取代了委托的功能.

使用接口取代委托的例子:

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

namespace demo2
{
    public delegate double Calc(double x, double y);

    class Program
    {
        static void Main(string[] args)
        {
            IProductFactory pizzaFactory = new PizzaFactory();
            IProductFactory toycarFactory = new ToCarFactory();
            WrapFactory wrapFactory = new WrapFactory();
 
            Box box1 = wrapFactory.WraProduct(pizzaFactory);
            Box box2 = wrapFactory.WraProduct(toycarFactory);

            Console.WriteLine(box1.product.Name);
            Console.WriteLine(box2.product.Name);
        }
    }

    interface IProductFactory
    {
        Product Make();
    }

    class PizzaFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }
    }

    class ToCarFactory : IProductFactory
    {
        public Product Make()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            return product;
        }
    }

    class Product//产品
    {
        public string Name { get; set; }
    }

    class Box//包装
    {
        public Product product { get; set; }
    }

    class WrapFactory//包装工厂
    {
        public Box WraProduct(IProductFactory productFactory)
        {
            Box box = new Box();
            Product product = productFactory.Make();
            box.product = product;
            return box;
        }
    }

    class ProductFactory//产品工厂
    {
        public Product MakePizza()
        {
            Product product = new Product();
            product.Name = "Pizza";
            return product;
        }

        public Product MakeToCar()
        {
            Product product = new Product();
            product.Name = "Toy Car";
            return product;
        }
    }
}

 

转载于:https://www.cnblogs.com/YiShen/p/9889380.html

aishizhuang1602
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#学习八：委托
qq_43042445的博客
04-06 110
目录什么是委托委托的声明（自定义委托）委托的一般使用 什么是委托 委托（delegate）是函数指针的“升级版” 实例：C/C++中的函数指针 一切皆地址 变量（数据）是以某个地址为起点的一段内存中所储存的值 函数（算法）是以某个地址为起点的一段内存中所储存的一组机器语言指令 直接调用与间接调用 直接调用：通过函数名来调用函数，CPU通过函数名直接获得函数所在地址并开始执行—返回 间接调用：通过...
C#学习笔记 委托
Mr_Tfos的博客
03-25 136
什么是委托 委托（delegate）是函数指针的“升级版” 实例：C/C++中的函数指针 一切皆地址 变量（数据）是以某个地址为起点的一段内存中所存储的值 函数（算法）是以某个地址为起点的一段内存中所存储的一组机器语言指令 直接调用与间接调用 直接调用：通过函数名来调用函数，CPU通过函数名直接获得函数所在地址并开始执行→返回 间接调用：通过函数指针来调用函数，CPU通过读取函数指针存储的值获得函数所在地址并开始执行→返回 Java中没有与委托相对应的功能实体 委托的简单使用 Acti
C#学习笔记（十三）委托——一切皆地址
xiaoyaolangwj的博客
04-06 546
委托（delegate）是函数指针的“升级版”。C/C++中的函数指针。 C语言中的函数指针： #include<stdio.h> // 声明函数指针,定义为一种数据类型。 typedef int (*Calc)(int a, int b); int Add(int a, int b) { int result = a + b; return result; } int Sub(int a, int b) { int result = a - b; return resu
刘铁猛《C#语言入门详解》019 委托详解 模板方法案例
weixin_41758001的博客
06-25 220
函数的本质：以函数名所对应的内存地址为起点的一段内存，在这段内存中存储的是一组机器语言的指令，CPU按照这组指令一条一条完成。解释：数据存储在变量中，变量的本质：以变量名所对应的内存地址为起点的一段内存[存储着变量的数据]，内存的大小由数据类型决定。2）间接调用：通过函数指针调用函数，CPU通过读取函数指针中存储的值获得函数的地址并开始执行 返回。2）函数（算法）是以某个地址为起点的一段内存中所存储的一组机器语言指令。1）变量（数据）是以某个地址为起点的一段内存中所存储的值。3）直接调用&间接调用。
QT019-循序渐进学C#
01-29
《QT019-循序渐进学C#》是一本专门为编程初学者设计的教程，旨在引导读者逐步掌握C#编程语言的核心概念和技术。这本书的PDF格式使得读者可以方便地在电子设备上阅读和查阅，同时其详细的目录和清晰的结构确保了学习...
004-如何把教程配套的代码运行起来.avi
03-20
019-滚动区域阻尼系数实现回弹.avi 020-双webview模式实现卡头卡尾代码重用.avi 021-加载子页面.avi 022-同时加载多个子页面.avi 023-底部选项卡切换.avi 024-点击底部选项卡切换标题栏文本.avi 025-商品列表页面....
005-创建项目.avi
03-20
019-滚动区域阻尼系数实现回弹.avi 020-双webview模式实现卡头卡尾代码重用.avi 021-加载子页面.avi 022-同时加载多个子页面.avi 023-底部选项卡切换.avi 024-点击底部选项卡切换标题栏文本.avi 025-商品列表页面....
久立特材：首次公开发行股票招股说明书.PDF
05-15
控股股东久立集团股份有限公司和实际控制人周志江先生承诺，自股票上市起36个月内不转让或委托他人管理其所持有的股份，也不由公司回购。同时，其他法人股东和自然人股东承诺，股票上市交易后12个月内不转让所持股份...
大药房有限公司质量管理制度.doc
09-18
19. **设施设备管理制度** (WDK-ZD-019)：规定了药品储存、展示和处理设施设备的维护和使用标准。 20. **计算机系统管理制度** (WDK-ZD-020)：确保计算机系统的稳定运行，支持药品经营和质量管理的各项功能。 21. ...
软件开发面试题C#，.NET知识点（续）
房东的猫的博客
07-10 1061
定义扩展方法：扩展方法是一个静态方法，它必须定义在一个静态类中。第一个参数指定要扩展的类型，并且必须使用this关键字修饰。在这个例子中，WordCount方法是一个扩展方法，它扩展了string类型，计算字符串中的单词数量。使用扩展方法：扩展方法可以像实例方法一样调用。// 输出：Word count: 4内存分配：值类型分配在堆栈上，引用类型分配在堆上。数据存储：值类型直接存储数据，引用类型存储数据的引用。赋值操作：值类型赋值复制数据，引用类型赋值复制引用。生命周期管理。
PE文件（九）导出表
2301_78838647的博客
07-10 958
解析此图：该PE文件以.def的方式自定义序号导出函数，定义了序号13、14、16、17、19的导出函数，那么Base的值应为13，那么序号为13的函数相对相对下标就是0，序号14的导出函数相对下标就是1，序号为15的导出函数虽然没有，但是会把位置空出来，定义地址值为NULL，即0x00000000，序号16的导出函数相对下标就是3…导出函数名称表RVA我们在硬盘数据找该表地址时要先转成FOA，这个地址指向的表记录了导出函数的名称字符串RVA首地址，而不是导出函数名称。//导出函数名称表RVA *
线程安全（二）synchronized 的底层实现原理、锁升级、对象的内存结构
ACGkaka的博客
07-11 1700
线程安全（二）synchronized 的底层实现原理、锁升级、对象的内存结构
Spire.PDF for .NET【文档操作】演示：C#/VB.NET：压缩 PDF 文档
励志做最业余的专业博主，控件产品可以私我~
07-11 741
在本文中，您将学习如何使用Spire.PDF for .NET在 C# 和 VB.NET 中压缩 PDF 文档。
C# 多态性
最新发布
07-14 224
多态性是面向对象编程（OOP）的一个核心概念，它允许不同类的对象对同一消息做出响应，并产生不同的结果。在C#中，多态性主要通过继承、接口和虚方法来实现。本文将深入探讨C#中的多态性，包括其原理、实现方式以及在实际编程中的应用。
C# 根据日期对mysql数据库数据筛选的一些操作函数
sunyao1314的博客
07-11 274
在C#中，根据日期筛选MySQL数据库中的数据是一个常见的操作。
C#绘制阻抗圆图初步
bcbobo21cn的专栏
07-12 265
C#画圆需要画笔参数，还要传递圆的外接矩形的坐标和大小；
NLP入门之中文分词
m0_57922605的博客
07-09 369
分词是一个被长期研究的任务，通过了解分词算法的发展，可以看到NLP的研究历程,分词是NLP中一类问题的代表,分词很常用，很多NLP任务建立在分词之上。目前分词切分的难点主要有歧义切分、新词、专有名词、改造词等。
C#中简单Socket编程
weixin_45144862的博客
07-09 444
TCP通信服务端的通信过程是：第一步调用Socket创建套接字。第二步：调用Bind()函数将套接字绑定到指定的IP地址和端口号。第三步：调用Listen()函数监听套接字。Socket分为面向连接的套接字(TCP套接字)和面向消息的套接字(UDP 套接字)。客户端套接字通信过程是：第一步:调用Socket类创建套接字。第一步：创建套接字。第一步：创建套接字。第二步：将套接字绑定到指定IP地址和端口号。UDP通信是面向消息的通信方式。接下来，我用C#语言来进行简单的TCP通信和UDP通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值