委托构造函数 委托构造函数定义形参

C# wrm 如何用Thread调用动态生成Label委托，看下面代码~

字符串类型，OBJECT类型，类类型，数组类型，委托类型，接口类型叫引用类型

添加一个委托函数,在委托中调用proBox.

委托构造函数 委托构造函数定义形参

委托构造函数 委托构造函数定义形参

然后调用form的invoke函数来通过放射，可以在运行时获得.NET中每一个类型（包括类、结构、委托、接口和枚举等）的成员，包括方法、属性、，以及构造函数等。还可以获得每个成员的名称、限定符和参数等。有了反射，即可对每一个类型了如指掌。如果获得了构造函数的信息，即可直接创建对象，即使这个对象的类型在编译时还不知道。那么如何注册呢？执行委托函数

在wrm构造函数中

添加 CheckForIllegalCrossThreadCalls=false;

这样就可以跨线程访问变量了

c委托实例

- 远程：控制远程对象的访问

在form1中，布置一个标签label1和一个按钮button1

refEvent(null,null);

partial class form1: Form

{public form1()

}private void button1_Click(object sender, EventArgs e)

{form2 f2 = new form2(this); //用form2的重载构造函数创建实例

}public void SetLabelText(string text)

{label1.Text = text;

}}在form2中，布置一个文本框textBox1， 一个按钮button1

partial class form2: Form

{form1 f1; //引用窗体1

public form2()

}public form2(form1 f): this( ) //重载构造函数，传入窗体1实例

}private void button1_Click(object sender, EventArgs e)

{//调用form1中的方法，修改form1上label1

f1.SetLabelText(this.textBox1.Text);

用VS2010按照你的描述写了个例子，见附件。

c#委托的委托

ntargs

看到这里，是不是有那么点如梦初醒的感觉？于是，你是不是在想：在上面的例子中，我不一定要直接在GreetPeople()方法中给 name参数赋值，我可以像这样使用变量： static void Main(string[] args) {string name1, name2;name1 = "Jimmy Zhang";name2 = "张子阳";GreetPeople(name1, EnglishGreeting);GreetPeople(name2, ChineseGreeting);Console.ReadKey();}而既然委托GreetingDelegate 和 类型 string 的地位一样，都是定义了一种参数类型，那么，我是不是也可以这么使用委托？ static void Main(string[] args) {GreetingDelegate delegate1, delegate2;delegate1 = EnglishGreeting;delegate2 = ChineseGreeting;GreetPeople("Jimmy Zhang", delegate1);GreetPeople("张子阳", delegate2);Console.ReadKey();}如你所料，这样是没有问题的，程序一如预料的那样输出。这里，我想说的是委托不同于string的一个特性：可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。在这个例子中，语法如下： static void Main(string[] args) {GreetingDelegate delegate1;delegate1 = EnglishGreeting; // 先给委托类型的变量赋值delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法// 将先后调用 EnglishGreeting 与 ChineseGreetinfloat area() const; //计算圆面积g 方法GreetPeople("Jimmy Zhang", delegate1);Console.ReadKey();}输出为：

C#与委托，与回调的用法区别

max = new Max(md.Max);//为啥不显示输出结果呢?

关于，我们首要知道的是的发送者必须知道发送什么类型的，以及相关

的参数。而的接收者必须了解其的处理方法必须使用的返回类型和参数

的发送者和的接收者都只关注而不是对方，这样对象就只需考虑自己，而不用

考虑其他对象。

例如：运动员踢球射门时，产生一个击球，但他并不用关心守门员是谁，他

只要关心自己踢球的角度、力度等参数，而守门员也一样，他只需关注如何接球即可。

运动员踢出球，产生一个击球，但是该的可能并不只守门员，其他球员包括己

方和对方球员，甚至包括观众和裁判，他们都应该该，因为球接下来会怎么样是未

知的，他们都应该做出相应的处理方法。

当多个对象同一个时，IDE(Integrated Dlopment Environment)就会把它们的事

件处理程序一个接一个地串起来关联到这个，并按照顺序，先后执行。可以用+=增加事

件处理函数。

在上面中，我们一直讲触发时会调用对应的处理方法。但是，问题是他怎么知道调用

谁的处理方法。任何一个对象只要了，他的是处理程序就会得到调用。然而

这就需要一个新的类型，叫做委托。

通过委托可以创建一个引用变量，但是并不是指向类的实例，而是指向一个类中的某个方法。

设计.NET的5步骤:

1):定义参数类型:从类型EventArgs派生出满足要求的参数类

2):定义处理者委托:与步相关该步一般被泛型委托取代了

3):定义成员:在自定义类中，由处理者委托定义一个或多个成员

4):触发:自定义类的引发方法中，通知所有者

5)::注册处理程序

参数object sender 是产生这个对象的一个引用，例如处理一个按钮的单击，sender就

表示别单击的这个按钮。

如果没有数据，则传递 Empty，而不要传递 null。

可能你会执着于这样的一个问题:既然有了委托，那么干什么用的呢？

显然，委托可以干很多事情，但是他不知道什么时候干，这时候就需要来驱动。

或许你还会纠结于这样的一个问题:那为什么不直接让自己直接去做呢？

这就得回归到面向对象的思想上面了，面向对象讲究专注，就是一个对象只专注

自己的本职工作就可以，其他的事情就由其他相关的对象自己完成。

你想想，如果你是个老板，你可以触发一个(相当于你有某件事情)，但如果处理这个

还要让你自己去做，你会觉得很麻烦，于是你就可以让你的职员(委托)去执行这些处理程序，

你只要在办公室里等待回复就可以了，这样是不是轻松了许多!

可能你没有当老板的命，无法体会，但换个例子，如你想要买一张火车票，在没有委托之前，

毫无疑问，你得自己前晚火车站买票，但有了委托后，你就轻松了，你只要上网点击订票发布

一个，你的委托就会直接帮你买票，而你就不用大老远的自己跑去买票了。

生活中的例子其实很多，我们的父母其实一直充当着委托这个角色，在这里，感激他们一下:你

们辛苦了。

之前，我们说运动员踢球时会产生一个击球，并把这个击球与守门员直接联系

起来，这其实是不准确的，但我只是为了说明的作用而已。

准确的说，击球应该是运动员和球的，而球和守门员之间的应该是球飞出的。

现在我们要讨论的是这个击球:

既然如此，

那么设，球场还有别的球，你可能无意中 帮这些球也订购了由运动员引发的击球，这样

子会造成一个后果，运动员一踢球这些所有的球都飞出去了。

后果把这是Form1的代码：！

下面是关于回调的一些定义:(Callback Mod)

回调:一个对象将一个方法的引用(方法的引用用委托保存)传入另一个对象，使得只有他能返

回信息，这就是一个回调。

回调方法是一种在作或活动完成时由委托自动调用的方法。

回调不同于，回调不能发布，不是类型，是一种设计模式，回调在两个类之间建立一种关系，

其中一个对象会自动对另一个对象做出反应，回调一般是私有的，保存回调的类对于谁能访问这个

回调有所控制，回调通常在对象的构造函数中设置。

本人粗略定义:简单的说就是将委托作为参数传递给某个特定对象。

这样，有了回调我们就可以避免上面非赛场上的球也飞出去的问题了。

c# 为什么说委托是不可变的

有不好的请指正哟！

String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。在需要对字符串执行重复修改的情况下，与创建新的 String 对象相关的系统开销可能会非常昂贵。如果要修改字符串而不创建新的对象，则可以使用 System.Text.StringBu当创建某一具体对象RealSubject开销很大时，应该根据需要进行创建，当真正需要到这个RealSubject对象时在进行创建，此时就需要用到Proxy 。ilder 类。例如，当在一个循环中将许多字符串连接在一起时，使用 StringBuilder 类可以提升性能。

通过用一个重载的构造函数方法初始化变量，可以创建 StringBuilder 类的新实例，正如以下示例中所阐释的那样。

结构型模式-安卓源码实战之的Proxy（）、Delegate（委托）

Proxy和Delegate的设计思想是相同的，可以一起讨论。前面是模式的简要介绍，后面是具体源码实战。

以下基础知识摘抄自《设计模式-可复用面向对象软件的基础》Proxy章节

为其他对象提供一种以控制对这个对象的访问

例如需要在文档中嵌入 图形对象的文档编辑器功能 ，然而 创建图形文档编辑器的开销很大也不是每一个文档都需要用到图形文档编辑器 。所以我们使用另外一个对象（即图像Proxy） 代替 真正的图形文档编辑器。 Proxy可以代替一个图形文档编辑器，并且在真正需要的时候负责实例化这个图形文档编辑器对象。

只有当文档编辑器点击 图形文档编辑器 Proxy的图标以启动功能时，图形Proxy才创建真正的 图形文档编辑器 对象

上面说过，（委托）模式是为了避免直接创建开销大的资源而不使用，采用的一种模式以便于真正使用时在实例化。

在 PhoneWindowMar 中使用 KeyguardServDelegate 来 KeyguardServ 的功能( KeyguardServ 由 KeyguardServWrapper 包装器进行包装)

PhoneWindowMar 需要使用到 KeyguardServ 的功能，但是在创建 PhoneWindowMar 时就实例化 KeyguardServ 没必要且开销大，因为还没用到 KeyguardServ 的功能。直接创建 KeyguardServ 会浪费 binder线程池 资源，所以应该在需要使用的时候再创建，所以引入 KeyguardServDelegate 。

PhoneWindowMar 并没有直接创建 KeyguardServ 对象，而是创建了对象 KeyguardServDelegate 。 后面 PhoneWindowMar 需要使用到 KeyguardServ 的功能时，通过调用 KeyguardServDelegate.bindServ 将 KeyguardServ 的 binder 对象转化为 接口 封装到 KeyguardServWrapper 包装器，将 KeyguardServWrapper 赋值到 KeyguardServDelegate 的成员变量，完成整个模式的架构。

终的方法调用流程：

PhoneWindowMar -> KeyguardServDelegate ->KeyguardServWrapper->KeyguardServ

通过创建KeyguardServDelegate来避免直接创建KeyguardServ而不使用带来不必要的开销。属于延迟加载。

[SystemS穿窗体的静态变量。。。。。类似于单例模式。。。。 public static Main _cmain=null;//窗体初始化的时候 进行new下。。。然后 其他窗体通过引用可以达到效果。。LZ可以试试看。。或者自己google相关信息 做个提示！！erver.ja]

众所周知System用来完成服务的创建和初始化过程。

一：WindowMarServ.main();启动了WMS，可以看到new PhoneWindowMar()传入WMS的main方法中，它将被赋值到成员变量WindowMarPolicy mPolicy;

二：wm.onInitReady();调用WMS的init方法，这里是KeyguardServDelegate的创建流程

[WindowMarServ.ja]

[WindowMarServ.ja]

调用PhoneWindowMar.init方法

[PhoneWindowMar.ja]

这里可以看到，在PhoneWindowMar.init函数中并没有直接创建KeyguardServ对象，而是创建了对象KeyguardServDelegate。在后面需要使用到KeyguardServ的功能时，通过调用KeyguardServDelegate.bindServ将KeyguardServ的binder对象转化为接口封装到KeyguardServWrapper包装器，将包装器赋值给KeyguardServDelegate的成员变量

[KeyguardServDelegate.ja]

[System.ja]

[System.ja]

[WindowMarServ.ja]

mPolicy指的是WindowMarPolicy。而PhoneWindowMar实现了WindowMarPolicy接口。mPolicy的赋值在WMS的构造函数中就已经完成了。而WMS的启动在中。

[PhoneWindowMar.ja]

[PhoneWindowMar.ja]

[PhoneWindowMar.ja]

调用context.bindServAsUser(...)来绑定服务，重点关注以下几点

通过指定ComponentName来绑定服务。可以看到KeyguardServDelegate所在包名为

/frameworks/base/servs/core/ja/com/android/server/policy/keyguard/KeyguardServDelegate.ja

寻找resources.getString(com.android.internal.R.string.config_keyguardComponent)的定义位{InitializeComponent();置

[/frameworks/base/core/res/res/values/config.xml]

可以看到config_keyguardComponent对应启动的就是 KeyguardServ 这个服务。通过 ServConnection 去指定拿到 KeyguardServ 后，将 KeyguardServ 转换为接口对象 IKeyguardServ.Stub.asIntece(serv) 来创建 KeyguardServWrapper 对象。看一看 KeyguardServWrapper 的创建过程

[KeyguardServWrapper.ja]

可以看到将IKeyguardServ serv传递给了成员变量mServ

后续当需要使用到 KeyguardServ 功能是将是以下的调用过程

PhoneWindowMar -> KeyguardServDelegate ->KeyguardServWrapper->KeyguardServ

定义点类,从点类派生矩形类和圆类,主程序实现用同一个方法显示矩形和圆的面积.用多态和委托分别实现）

form1中

老师布置的作业要完成，我现在就后悔大学动脑太少，现在要补充太多东西。代码里我本来用了运算符重载，那样更方便，后来我给注视掉了，你可以自己去掉注释，然后修改主函数试试、、

1. 基类调用派生类时候用

#include

using namespace std;

//声明类Point

class Point

{public:

Point(float x=0,float y=0); //有默认参数的构造函数

void setPoint(float,float); //设置坐标值

float getX( ) const {return x;} //读x坐标

float getY( ) const {return y;} //读y坐标

// friend ostream & operator<<(ostream &,const Point &);//重载运算符“<<”

public: //公用成员

float x,y;

};

//下面定义Point类的成员函数

Point::Point(float a,float b) //Point的构造函数设置x和y的坐标值,

{x=a;y=b;}

void Point::setPoint(float a,float b) //为x,y赋新值

{x=a;y=b;}

//ostream & operator<<(ostream &output,const Point &p)//重载运算符“<<”，使之能输出点的坐标

//{

// output<<"["<

// return output;

//}

//rect是Point类的公用派生类

class Rect:public Point

{public:

Rect(float x=0,float y=0);

float area() const;

// friend ostream &operator<<(ostream &,const Rect &);//重载运算符“<<”

};

//下面定义Rect类的成员函数

Rect::Rect(float a,float b):Point(a,b){}//初始化列表

float Rect::area() const

{return xy;}

//ostream &operator<<(ostream &output,const Rect &r)//重载运算符“<<”，使之按规定的形式输出圆的信息

//{

// output<<"Rect=["<

// return output;

//}

//circle是Point类的公用派生类

class Circle:public Point

{public:

Circle(float x=0,float y=0,float r=0); //构造函数

void setRadius(float); //设置半径值

float getRadius() const; //读取半径值

// friend ostream &operator<<(ostream &,const Circle &);//重载运算符“<<”

private:

float radius;

};

//下面定义Circle类的成员函数

Circle::Circle(float a,float b,float r):Point(a,b),radius(r){}//定义构造函数，对圆心坐标和半径初始化

void Circle::setRadius(float r) //设置半径值

{radius=r;}

float Circle::getRadius( ) const //读取半径值

{return radius;}

float Circle::area( ) const //计算圆面积

{return 3.14159radiusradius;}

//ostream &operator<<(ostream &output,const Circle &c)//重载运算符“<<”，使之按规定的形式输出圆的信息

//{

// output<<"Center=["<

// return output;

//}

int main( )

{Circle m(5.5,5.5,10); //定义Circle类对象m

cout<<"圆心x坐标"<

cout<<"圆心y坐标"<

m.getRadius();

cout<<"圆的面积："<

Point pRef(1,1);

cout<<"点的坐标"<

cout<<"矩形的面积"<

return 0;

}

C#委托在windowsfrom里怎么使用呢,给个例子,谢谢

总之，一个总是由一个对象产生，但是一个可以由多个对象响应。

public delegate void MyDelegate(string name); // 步骤1，声明

public static void MyDelegateFunc(string name){}// 将传递的方法，参数和返回值类型要与声明相同

// 步骤2，创建

MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);

// 步骤3，调用

md("sam1111");

在动态加载时可以这样写：

btn_export.Click+=new EventHandler(btn_export_Click);

public class SampleEventArgs

{public SampleEventArgs(string s) { Text = s; }

public String Text {get; private set;} // readonly

}public class PublisherForm:Form

{public delegate void SampleEventHandler(object sender, SampleEventArgs e);

// 测试

public nt SampleEventHandler SampleEvent;

private void btn_Click( Object sender,EventArgs e ){

// TODO : 按钮触发时，抛出测试

RaiseSampleEvent();

}protected virtual void RaiseSampleEvent()

{if (Samp包括：发送者、接收者和处理程序。leEvent != null){

SampleEvent(this, new SampleEventArgs("Hello"));

/ 在自定参数中，可以加入自己将要交给，接收者的数据 /

}}

}

设计模式——模式

两个中打开了不同的窗口，在buttonshowform_click(object

模式是一种结构型设计模式，它为其他对象提供一个以控制对这个对象的访问。对象充当原始对象的，可以允许或禁止对原始对象的访问，或者在访问时添加一些额外的逻辑。

模式通常用于以下情况：

- 虚拟：控制对实际对象的访问，如延迟加载等

- 保护：控制对对象的访问权限

- 缓存：对频繁访问的对象进行缓存，提高性能

模式的核心思想是将原始对象封装在对象中，客户端无需知道原始对象的真实实现，只需要与对象交互即可。

模式的优点是：

- 增加了对象的间接性，降低了系统的耦合度

- 可以在不改变原始对象的情况下对其进行控制和扩展

- 提高了系统的性能，特别是对频繁的对象访问进行了缓存

常见的模式包括静态和两种。静态需要为每个原始对象定义一个对象}}以上实现的功能，基本与委托（delegate)无关。，而可以在运行时为任意实现了某个接口的对象生成对象。

总之，模式是一种非常常用的设计模式，可以在很多场合中发挥作用，例如、安全、缓存等。