CAD工具之家

点击下载此文件

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/06/1687017.html

应用程序配置文件的文件名是可以任意更改的。比如：

1. 向当前的可执行项目中添加一个XML文件，取名abc.config，输入以下代码
    
   view plaincopy to clipboardprint?

   1. <?xml version=“1.0” encoding=“utf-8” ?>  
   2. <configuration>  
   3.   <appSettings>  
   4.     <add key=“k” value=“v”/>  
   5.   </appSettings>  
   6. </configuration>  
   7.  
2. 设置abc.config文件的Copy To Output Directory属性为Copy always
3. 可以使用下面的代码来读取abc.config文件中的配置信息，就好像读取App.config那样
    
   view plaincopy to clipboardprint?

   1. static void Main(string[] args)   
   2. {   
   3.     ExeConfigurationFileMap map = 
   4.         new ExeConfigurationFileMap();   
   5.     
   6.     map.ExeConfigFilename = “abc.config”;   
   7.     
   8.     Configuration config = 
   9.       ConfigurationManager.OpenMappedExeConfiguration(
   10.         map, ConfigurationUserLevel.None);   
   11.     
   12.     string s = config.AppSettings.Settings[“k”].Value;   
   13. }   
   14.  

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/06/1687016.html

在C#中，ref的意思是按引用传递。可以参考C++：

如果简单的调用这个swap，比如：swap(a, b)，那么你根本没办法交换这两个变量的值，因为x和y都是形参，在swap返回的时候，x和y都被释放了。但如果是这样定义swap：

也就相当于x与a，y与b指向同一个内存地址，那么对x的操作也就相当于对a的操作。那么在C#里面，这种效果对于值类型是很明显的。

此时的输出是2，也就是Test方法中的b与Main中的b指向同一个内存地址，那么对Test.b的操作也就是对Main.b的操作。你如果把程序改成：

那么输出的还是1，因为Test.b不是Main.b的引用，也就是一个单独的形参。现在再看对于引用类型，会是什么效果：

上面的代码，输出的是2，因为b是引用类型，在只需修改b的成员的时候，加不加ref关键字都一样。引用类型本身并不包含数据，仅仅维持了对数据的引用。

因此，使用ref参数，对值类型对象的作用显而易见，而对于引用类型，如需修改引用类型内部的数据，则无需使用ref关键字；否则，当被调用函数内部需要更改引用本身时，比如在函数内部重新定位对象的引用，则需要使用ref关键字。

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/07/1687015.html

委托是C#中最为常见的内容。与类、枚举、结构、接口一样，委托也是一种类型。类是对象的抽象，而委托则可以看成是函数的抽象。一个委托代表了具有相同参数列表和返回值的所有函数。比如：

在上面的定义中，我们定义了一个委托，这个委托代表着一类函数，这些函数的第一个参数是整数型的x，第二个参数是整数型的y，而函数的返回值则是一个整数。在这里，为了描述方便，我们把这一类的函数称为具有相同签名（signature）的函数（注意：这个签名并不是数字签名中的概念，而只是表示这类函数具有相同的参数列表和返回值）。

既然委托是一种类型，那么它就能被用来定义参数、变量以及返回值。由委托定义的变量用于保存具有相同签名的函数实体。需要注意的是，C#和C++不同，C++中的函数指针只能保存全局的或者静态的函数，而C#中的委托实体则可以指代任何函数。

现在我们来看一个例子，在这个例子中，我们使用了上面定义的那个委托，并创建了一个委托实体，使其指代程序中的AddCalculator函数，接下来就可以直接像使用函数本身一样，使用这个委托实体来获得计算的结果。

到这里也就能基本上明白“委托”的意义了，针对上面的Main函数，本来需要调用AddCalculator函数的，却通过d来调用了，也就是，后续对AddCalculator的操作由d代为效劳。本来是要小明去老师办公室拿粉笔盒的，由于小明和小文是好朋友，因此小明就要小文代他去拿，于是小文成了小明的代理，小明委托小文去拿粉笔盒。

现在我们来考虑委托作为参数的情形。将委托作为参数，可以把函数本身的处理逻辑抽象出来，而让调用者决定最终使用什么样的逻辑去处理。请看下面的例子：

在上面的例子中，Calculator函数的第一个参数就是一个委托。事实上，Calculator对x和y将会做什么处理，它本身并不知道，如何处理x和y由GetCalculatedValueDelegate来决定。那么在Main方法里，我们将AddCalculator方法作为参数传递给Calculator，表示让Calculator用AddCalculator的逻辑去处理x和y。这也很形象：Calculator说：“我不知道要怎么处理x和y，让del去处理好了！”于是就把x和y扔给了del。

这种做法其实跟“模板方法模式”有点点类似。在模板方法模式中，可以将可变的部分留给子类去重写，而将不变的部分由父类实现。那么在委托作为参数的情况下，Calculator可以自己处理不变的逻辑，而将“具体怎么做”的事情委托给他人去办理。

委托作为参数，在C#中非常常见。比如线程的创建，需要给一个ThreadStart或者ParameterizedThreadStart委托作为参数，而在线程执行的时候，将这个参数所指代的函数用作线程执行体。再比如：List<T>类型的Find方法的参数也是一个委托，它把“怎么去查找”或者说“怎么样才算找到”这个问题留给了开发人员。开发人员只需要定义一个参数为T，返回值为布尔型的函数，实现函数体，并将函数作为参数传给Find方法，就可以完成集合中元素的查找。

委托作为返回值一般会用在“根据不同情况决定使用不同的委托”这样的情形下。这有点像工厂模式，不过委托用作返回值还是用的没有用作参数这样频繁。

与委托相关的概念还有很多，比如异步调用、泛型委托、匿名方法、Lambda表达式、事件、协变与逆变等。我会在后续的文章中陆续介绍。

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/08/1687014.html

首先来看一个简单的例子：

1. 小明在烧水，等水烧开以后，将开水灌入热水瓶，然后开始整理家务
2. 小文在烧水，在烧水的过程中整理家务，等水烧开以后，放下手中的家务活，将开水灌入热水瓶，然后继续整理家务

这也是日常生活中很常见的情形，小文的办事效率明显要高于小明。从C#程序执行的角度考虑，小明使用的同步处理方式，而小文则使用的异步处理方式。

同步处理方式下，事务是按顺序一件一件处理的；而异步方式则是，将子操作从主操作中分离出来，主操作继续进行，子操作在完成处理的时候通知主操作。

在C#中，异步通过委托来完成。请看下面的例子：

上面的例子是一个最简单的异步调用的例子，没有对异步调用函数做任何参数传递以及返回值校验。这个例子反映了小文烧水的流程，首先小文将水壶放在炉子上，在定义好委托以后，就使用BeginInvoke方法开始异步调用，即让水壶开始烧水，于是小文便开始整理家务。水烧开后，C#的异步模型会触发由BeginInvoke方法所指定的回调函数，也就是水烧开后的处理逻辑由这个回调函数定义，此时小文将水灌入热水瓶并继续整理家务。

由此可见，在C#中实现异步调用其实并不复杂，首先创建一个异步处理函数，并针对其定义一个委托；然后在调用函数的时候，使用委托的BeginInvoke方法，指定在函数处理完成时的回调函数（如果不需要对完成事件做处理，可以给null值），并指定所需的参数（如果没有参数，也可以给null值）；最后在回调函数中处理完成事件。

请注意上例回调函数中的EndInvoke调用，EndInvoke会使得调用线程阻塞，直到异步函数处理完成。显然，紧接在BeginInvoke后面的EndInvoke使用方式与同步调用等价。

 EndInvoke调用的返回值也就是异步处理函数的返回值。我们把程序稍作修改，将Boil方法改成下面的形式：

然后将BoilingFinishedCallback改成下面的形式：

那么我们就可以在EndInvoke的时候，获得由Boil异步处理函数返回的时间值。事实上，如果定义的BoilingDelegate委托存在参数列表，那么我们也可以在BeginInvoke的时候，将所需的参数传给异步处理函数。BeginInvoke/EndInvoke函数的签名与定义它们的委托签名有关。

注意：在修改后的BoilingFinishedCallback方法中，为了得到委托实例以便获取异步处理函数的返回值，我们采用了下面的转换：

这样才能获得调用异步处理函数的委托的实体。

.NET处理异步函数调用，事实上是通过线程来完成的。这个过程有以下几个特点：

• 异步函数由线程完成，这个线程是.NET线程池中的线程
• 通常情况下，.NET线程池拥有500个线程（当然这个数量可以设置），每当调用BeginInvoke开始异步处理时，异步处理函数就由线程池中的某个线程负责执行，而用户无法控制具体是由哪个线程负责执行
• 由于线程池中线程数量有限，因此当池中线程被完全占用时，新的调用请求将使函数不得不等待空余线程的出现。此时，程序的效率会有所影响

为了验证这些特点，请看下面的程序：

这个程序在起始的时候将线程池中最大线程个数设置为10个，然后做15次异步调用，每个异步调用中都停留10秒钟当作处理本身所要消耗的时间。从程序的执行我们可以看到，当前10个异步调用完全开始以后，新的异步调用就会等待（注意：不是主线程在等待），直到线程池中有线程空闲出来。

参考资料：异步方法调用

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/10/1687013.html

泛型委托是委托的一种特殊形式，感觉看上去比较怪异，其实在使用的时候跟委托差不多，不过泛型委托更具有类型通用性。

就拿C#里最常见的委托EventHandler打比方。在.NET 2.0以前，也就是泛型出现以前，普通的事件处理函数都由EventHandler定义，如下：

EventHandler指代了这样一类函数，这些函数没有返回值，并且有两个参数，第一个参数是object类型，而第二个参数是EventArgs类型。

而.NET 2.0及其以后的版本，由于泛型的引入，所以一些内建（Built-in）的类、接口、委托都有了各自的泛型版本。EventHandler也不例外，它有了自己的泛型版本：EventHandler<T>，它的定义如下：

您应该可以发现，第二个参数的类型由EventArgs变成了TEventArgs，而TEventArgs具体是什么，则由调用方决定。假设IntEventArgs和StringEventArgs都继承于System.EventArgs，那么：

• EventHandler<IntEventArgs>指代这样一类函数：这些函数没有返回值，有两个参数，第一个参数是object类型，第二个参数是IntEventArgs类型
• EventHandler<StringEventArgs>指代这样一类函数：这些函数没有返回值，有两个参数，第一个参数是object类型，第二个参数是StringEventArgs类型

其实EventHandler<IntEventArgs>和EventHandler<StringEventArgs>是两个完全不同的委托，它们所指代的函数都分别有着不同的签名形式。请参见下面的示例：

有关泛型的具体特性与其在面向对象思想中的应用，将在后续与泛型相关的文章中重点阐述。

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/11/1687012.html

匿名方法是C# 2.0的语言新特性。首先看个最简单的例子：

这段代码在开始的时候初始化了一个字符串列表（string list），然后通过列表的FindAll方法来查找以“sunny”起始的字符串，最后将所查找到的所有结果输出。

我们需要着重介绍List<T>的FindAll方法。这个方法是一个参数为Predicate<T>类型、返回值为List<T>类型的函数。注意，Predicate<T>是一个泛型委托，它指代这样一些函数：这些函数仅有一个T类型的参数，并且返回值是布尔类型。通过reflector等工具，我们可以看到Predicate<T>的定义如下：

至此我们也多少能够猜到FindAll方法的具体实现。即针对List<T>中的每个元素，调用Predicate<T>所指代的函数，如果函数返回为true，则将其加入新建的列表中。遍历完所有的元素后，将新建的列表返回给调用者。如下：

因此，针对上面的例子，要调用FindAll方法，我们必须先定义一个参数为string类型，返回值为布尔类型的函数，在这个函数中，对参数进行条件判断，如果符合条件（也就是以“sunny”作为起始字符串），那么就返回true，否则返回false。最后再将这个函数作为参数传递给FindAll。于是也就得到了最上面的代码。

在上面的例子中，为了调用FindAll方法，我们不得不新定义一个函数，其实这个函数除了FindAll方法要用外，别的地方都几乎很少使用到它，你还不得不给它起个名字。如果程序中有多处需要调用FindAll方法，或者类似的情况，那么整个程序也就会出现一大批“只有一个地方使用”的函数，使得代码难于阅读和维护。

由于存在这样的问题，C# 2.0引入了匿名方法。开发人员在实现方法的时候，只需要给出方法的参数列表（甚至也可以不给）以及方法具体实现，而不需要关心方法的返回值，更不必给方法起名字。最关键的是，只在需要的地方定义匿名方法，保证了代码的简洁。

匿名方法只在需要的地方定义，定义的时候，使用delegate关键字，后接参数列表，然后跟上用一对花括号包括起来的函数体即可。上面的代码可以重构成下面的形式：

此时，我们完全不需要NameMatches方法了，直接将匿名方法作为参数传递给FindAll方法。其实匿名方法本身还是有名字的，只是我们并不关心它究竟该取什么名字，因而.NET帮我们随便取了个名字罢了。

匿名方法在C#中应用十分广泛，因为委托作为函数参数是件非常平常的事情。在定义简单的事件处理过程时，我们同样可以使用匿名方法。比如：

匿名方法可以很方便地使用本地变量，这与单独定义的命名方法相比，能够简化编程。比如上文的例子中，假如Main函数里面定义了一个整型本地变量（局部变量）number，那么可以在delegate (string name)这一匿名方法定义中使用number变量。

上文提到，在定义匿名方法的时候，连参数列表都可以省略。因为编译器可以根据委托的签名来确定函数的签名，然后只要再给函数起个名字就可以了。下面的代码演示了这种使用方式：

在使用不带参数和返回值的匿名方法定义时，需要注意以下两点：

1. 如果在你的匿名方法中需要对参数进行处理，那么你不能使用不定义参数列表的声明方式。也就是在定义匿名方法的时候，需要给出参数列表
2. 不带参数和返回值的匿名方法，可以被具有任何形式签名的委托所指代

上述第一点显而易见，因为你没有定义参数列表，也就没有办法使用参数；要说明第二点，我们可以看下面的代码：

上面的代码没法编译通过，因为编译器不知道应该将delegate { }这一匿名方法还原为由IntDelegate指代的函数，还是还原为由StringDelegate指代的函数。此时只能显式给定参数列表，以便让编译器知道，我们究竟是想调用哪个Output函数。

转载至:http://www.cnblogs.com/daxnet/archive/2008/11/12/1687011.html