‘ .NET开发 ’ category archive

扩展方法使用小结

272 views 九月 28, 09 by Timothy

随着.Net Framework一路走来，已经让广大开发人员体验到快速开发的甜头，这得益于.Net Framework为我们提供了更高层次的封装，开发人员不必关心底层的Win32 API及其繁琐的调用参数，而可以把大部分的经历放在对业务的分析和实现。随着.Net的不断革新，也引入了更多的特性，例如C# 2.0，就增加了匿名方法和迭代器，这些特性让我们的编码效率更高。随着C# 3.0的推出，引入了更多的新特性，包括：隐式类型局部变量、对象初始化器、Lambda表达式、扩展方法、匿名类型。

而这些特性，都为LINQ的推出，构建好了基础。其中一个比较不错的特性，就是扩展方法。扩展方法，顾名思义，就是在类型定义完成之后，再继续为其添加新的方法。这是相当方便的，比如对于一个已经封装好的Assembly来说，我们不用改动Assembly的代码，而通过扩展方法就能实现对其功能的扩展，而且在调用的时候，仅仅通过代码，你几乎判断不出这是扩展方法，还是Assembly本身的方法。

扩展方法在.Net 3.5中的应用也是非常普遍的，如果你仔细观察，就会发现我们常用的Linq to Object中的Where,Select,Average,Sum等方法，以及Linq to SQL中的Where,Select,Average,Sum等方法，其实都是扩展方法，他们分别定义于System.Linq.Enumerable类和System.Linq.Queryable类之中。

就扩展方法本身而言，也存在一些限制之处。对于编译器来说，如果扩展方法和被扩展类型的方法发生冲突的时候，在调用此方法的时候，究竟是调用被扩展类型的方法，还是扩展方法呢？通过一个例子，我们就能发现其中的区别。

   1:    class Program
   2:      {
   3:          static void Main(string[] args)
   4:          {
   5:              new TestClassA().Display("Test");
   6:              new TestClassB().Display("Test");
   7:              Console.ReadLine();
   8:          }
   9:      }
  10:  
  11:      class TestClassA
  12:      {
  13:          public void Display(int b)
  14:          {
  15:              Console.WriteLine("This is TestClassA.Display() ...");
  16:          }
  17:      }
  18:  
  19:      class TestClassB
  20:      {
  21:          public void Display(string s)
  22:          {
  23:              Console.WriteLine("This is TestClassB.Display() ...");
  24:          }
  25:      }
  26:  
  27:      static class TestClassExtention
  28:      {
  29:          static public void Display(this object o, string s)
  30:          {
  31:              Console.WriteLine("This is TestClassExtention.Display() ...");
  32:          }
  33:      }

程序输出：

ExtentionMethod

可以看出,TestClassA的方法和扩展方法并没有冲突，因为他们的方法签名是不一样的，而TestClassB的方法和扩展方法有冲突，因为他们的都是接受一个string类型的输入参数。从结果可以看到，程序对Display的方法调用，TestClassB本身的Display方法，要“优先”于扩展方法Display被调用。因此，类本身的方法如果满足调用条件，那么这个方法会被优先执行，只有在类当中无法找到同样参数的方法时，扩展方法才有机会被执行。所以，我们可以得出这样的结论：扩展方法的优先级较低，也即扩展方法不会覆盖同名的类本身的方法。

另外，还有一个比较明显的区别，就是扩展方法要远远弱于类本身的方法，比如，在一个类中，类的方法可以访问自己的非公有成员，而扩展方法做不到这一点。

IIS7中Host WCF遇到的问题

204 views 九月 03, 09 by Timothy

最近重装了系统，用上了Windows 7，在IIS7中Host WCF Service的时候，遇到一个比较奇怪的问题，当在站点下面添加应用，指向WCF的目录后，访问.svc文件，浏览器提示以下错误：

 

The page you are requesting cannot be served because of the extension configuration.
If the page is a script, add a handler. If the file should be downloaded, add a MIME map.

 

这种错误应该是.svc文件没有映射到相关的handler上，因此IIS不知道怎么处理该请求。带着错误信息，在网上搜索了一把，终于找到了解决方法，看来搜索引擎很强大。

解决方法如下：

1.用管理员身份运行cmd命令行

2.切换到目录C:\Windows\Microsoft.NET\Framework\v3.0\Windows Communication Foundation

3.运行命令： servicemodelreg –i

这样，工具会自动把WCF相关的注册项安装到IIS7中，再打开浏览器访问WCF Service，一切正常。

细想了一下自己的装机过程，先装了VSTS和.net framework，后来发现IIS7没有在windows7里面默认安装，要到部署WCF的时候，才装好IIS7。这样在安装.net framework 3.0的时候，因为没有安装IIS7，所以一些注册项就没有起到作用。此方法可以将WCF的配置项重新配置到IIS7中，供同学们参考。

C# IDE Mobile – Write your C# code anywhere!

250 views 五月 29, 09 by Timothy

最近败了个QWERTY全键盘的HTC Touch pro，全键盘的感觉不错，输入速度比以前靠触摸笔点屏幕快多了。装了个Python的Windows mobile版本，没事学着写Python玩玩。一日突发奇想，要是能在PPC手机上写C#的程序并能运行起来，那就太棒了。果然不出我所料，国外已经有大侠已经做好了这个东东，一个运行在Windows Mobile手机上的简单的C# IDE，让你可以随时在你的PPC手机上写C#的程序。这是作者自己实现的一个简单IDE，现在已经支持的功能如下：

* 可以创建基于图形用户界面的程序

* 可创建方法和类

* 可以调用所有的.NET Compact Framework的类。

* 执行文件操作

* 运行进程

* 使用.NET 2.0中的范型

* 支持C#的控制语句，包括循环、条件判断……

IDE的使用非常简单，写入你的代码，然后可以立即运行，看到结果。

简单的例子，如下：

   1:  using System.Windows.Forms;
   2:  namespace TestNS
   3:  {
   4:      class TestCL
   5:      {
   6:         public static void Main()
   7:         {
   8:              MessageBox.Show("Hello Timothy!");
   9:         }
  10:      }
  11:  }

 

点击菜单下面的Debug->Run,运行结果截图如下：

1

 

IDE自带一些简单的功能， 包括插入代码模板，编辑(复制、粘贴、剪切)功能，还支持插件功能。

2

 

软件下载地址： http://www.geocities.com/hrowson/wm5_software/cs_ide_mobile.zip

Code Sample: http://www.geocities.com/hrowson/wm5_software/cs_ide_mobile_samples.zip

用户手册、帮助文档地址： http://www.geocities.com/hrowson/wm5_software/cs_ide_mobile_manual/index.htm

作者主页：http://www.geocities.com/hrowson/wm5_software/index.htm

赶紧下载吧，write your C# code anywhere! 活活~~

Unity 学习笔记(3) — 生命周期管理

182 views 四月 28, 09 by Timothy

Unity根据我们在注册类型的时候所指定的生命周期来管理注册类型的创建和解析。当我们在向容器中注册类型的时候，如果我们没有显式的指明该类型的生命周期管理器(下称:Lifetime Manager)，默认的情况下，容器会为我们注册的类型创建一个生命周期短暂的管理器。这样一来，当我们每次调用容器的Resolve方法或者ResolveAll方法，或者采用依赖机制注入实例到其他的类中的时候，容器都会为我们创建新的实例，并且容器不会保存对实例的引用。

容器的RegisterType函数包含多个支持泛型的重载，同时还包含了一一对应的非泛型重载。其中的重载函数，我们可以看到类似下面的声明：

   1:  RegisterType<TFrom, TTo>(LifetimeManager lifetime)

参数中的LifetimeManager类型，就是用来控制注册类型生命周期的。Unity中提供了几个继承自LifetimeManager的类作为注册类型的生命周期管理器。在目前的Unity 1.2版本中，共提供了3个LifetimeManager供我们直接在代码中调用。此外，我们也可以实现自己的LifetimeManager，不过必须实现LifetimeManager所必须的一些方法。

1.ContainerControlledLifetimeManager:

容器负责管理注册类型的生命周期，并且注册类型的生命周期和容器一致。当离开容器的作用域范围时，容器会被销毁，同时其中的注册类型也会被销毁。或者，当容器被显式销毁时，其中的注册类型也同样被销毁。但是在容器有效的作用域范围中，当我们使用Resolve方法，或者使用ResolveAll方法获取我们的注册类型的时候，容器会在第一次调用时，创建实例，但是在后面的调用中，我们始终只会得到相同的实例。我们可以利用这种Manager来实现Singleton模式。

2.ExternallyControlledLifetimeManager:

和上一种方式类似，不过容器在不会保留对注册类型的强引用，而只是保留弱引用。也就是说，如果这个注册类型没有在其他地方被强引用的时候，那么这个注册类型可能会被GC给干掉。

3.PerThreadLifetimeManager:

容器保证在每个线程中返回同一个对象实例，那么在不同的线程中，得到的实例是不同的。

下面我们可以试验一下不同的LifetimeManager的效果

a. 默认的情况，不显示的指明LifetimeManager

代码：

   1:  namespace UnityDemo
   2:  {
   3:      class Program
   4:      {
   5:          static void Main(string[] args)
   6:          {
   7:              IUnityContainer container = new UnityContainer();
   8:              container.RegisterType<INotify, EmailNotify>();
   9:  
  10:              INotify notify1 = container.Resolve<INotify>();
  11:  
  12:              INotify notify2 = container.Resolve<INotify>();
  13:  
  14:              Console.WriteLine("notify1:" + notify1.GetHashCode());
  15:              Console.WriteLine("notify2:" + notify2.GetHashCode());
  16:  
  17:              Console.ReadLine();
  18:          }
  19:      }
  20:  }

运行结果：

4

从结果我们可以看到，默认情况下不指定LifetimeManager的时候，每次我们获得的Instance其实不是同一个Instance.

b.使用ContainerControlledLifetimeManager

代码：

   1:  namespace UnityDemo
   2:  {
   3:      class Program
   4:      {
   5:          static void Main(string[] args)
   6:          {
   7:              IUnityContainer container = new UnityContainer();
   8:              container.RegisterType<INotify, EmailNotify>(new ContainerControlledLifetimeManager());
   9:  
  10:              INotify notify1 = container.Resolve<INotify>();
  11:  
  12:              INotify notify2 = container.Resolve<INotify>();
  13:  
  14:              Console.WriteLine("notify1:" + notify1.GetHashCode());
  15:              Console.WriteLine("notify2:" + notify2.GetHashCode());
  16:  
  17:              Console.ReadLine();
  18:          }
  19:      }
  20:  }

运行结果:

5
使用ContainerControlledLifetimeManager，在Container生命中期内，我们得到的Instance是同一个。

c.使用PerThreadLifetimeManager

代码：

   1:  namespace UnityDemo
   2:  {
   3:      class Program
   4:      {
   5:          static void Main(string[] args)
   6:          {
   7:              IUnityContainer container = new UnityContainer();
   8:              container.RegisterType<INotify, EmailNotify>(new PerThreadLifetimeManager());
   9:  
  10:              Thread thread1 = new Thread(new ParameterizedThreadStart(ThreadProc1));
  11:              Thread thread2 = new Thread(new ParameterizedThreadStart(ThreadProc2));
  12:  
  13:              thread1.Start(container);
  14:              thread2.Start(container);
  15:  
  16:              Console.ReadLine();
  17:          }
  18:  
  19:          static void ThreadProc1(object obj)
  20:          {
  21:              INotify notify1 = (obj as IUnityContainer).Resolve<INotify>();
  22:              INotify notify2 = (obj as IUnityContainer).Resolve<INotify>();
  23:  
  24:              Console.WriteLine("ThreadProc1 --- notify1:" + notify1.GetHashCode());
  25:              Console.WriteLine("ThreadProc1 --- notify2:" + notify2.GetHashCode());
  26:  
  27:          }
  28:  
  29:          static void ThreadProc2(object obj)
  30:          {
  31:              INotify notify1 = (obj as IUnityContainer).Resolve<INotify>();
  32:              INotify notify2 = (obj as IUnityContainer).Resolve<INotify>();
  33:  
  34:              Console.WriteLine("ThreadProc2 --- notify1:" + notify1.GetHashCode());
  35:              Console.WriteLine("ThreadProc2 --- notify2:" + notify2.GetHashCode());
  36:          }
  37:      }
  38:  }
运行结果：
6
 在结果中可以看到，同一个线程中连续两次获取到的是同一个Instance，而不同的线程中获取到的Instance不一样。

Unity 学习笔记(2) — 配置文件的使用

318 views 四月 25, 09 by Timothy

在Unity的配置中，使用配置文件也是一种非常灵活的方式，毕竟能够通过修改配置文件的文本就能达到改动的目的，而不需要对源码进行改动、重新编译。使用配置文件对Unity进行配置，需要增加两个程序集的引用：System.Configuration和Microsoft.Practices.Unity.Configration，并且在代码中用相应的两个命名空间：

   1:  using System.Configuration;
   2:  using Microsoft.Practices.Unity.Configuration;

此外，需要修改应用程序的配置文件：

在configSections节点中，加入Unity的section配置信息



<configSections>


...


<section name="unity"


type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>


</configSections>


<configSections>


...


<section name="unity"


type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>


</configSections>


其中name是section的名称，type就是处理该section的程序类型，Unity提供了UnityConfigurationSection，负责处理配置文件信息，它包含在程序集Microsoft.Practices.Unity.Configuration中

接下来，需要在configuration节点中增加Unity配置节点，格式如下：

   1:  <unity>
   2:      <typeAliases>
   3:        <typeAlias alias="" type="" />
   4:      <typeAliases />
   5:      <containers  >
   6:        <container>
   7:           <types>
   8:             <type type="" mapTo="" />
   9:           </types>
  10:           <instances>
  11:             <add name="" type="" value="" />
  12:           </instances>
  13:        </container>
  14:      </containers>
  16:  </unity>

unity的子元素，包含节点大致如上，其宗typeAliases是type别名，能够简化下面types中type的配置。containers节点中可以包含多个container的配置。container主要包含的子元素有types元素，instance元素，types元素可以包含多个type元素，用以添加注册类型，instance主要用来添加实例到容器中。type元素，主要包含四个属性：

name：表示注册类型的名称，此属性在配置中可选。

type:注册的源类型

mapto:注册的目标类型

lifetime:设置注册类型的生命周期

此外，还有instances元素，包括name,type,value,typeConverter四个属性。value表示注册实例的初始值，typeConverter是用以转换提供的值到实例的匹配类型的类型转换器。

具体的元素含义，可以参考Unity的帮助文档。

下面我们还是采用Monitor的例子，来实现用配置文件注册类型，配置文件示例：

   1:  <?xml version="1.0" encoding="utf-8" ?>
   2:  <configuration>
   3:    <configSections>
   4:      <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration" />
   5:    </configSections>
   6:  
   7:    <unity>
   8:      <containers>
   9:        <container>
  10:          <types>
  11:            <type type="UnityDemo.IMonitor,UnityDemo" mapTo="UnityDemo.Monitor,UnityDemo" />
  12:            <type type="UnityDemo.INotify,UnityDemo" mapTo="UnityDemo.EmailNotify,UnityDemo" />
  13:          </types>
  14:        </container>
  15:      </containers>
  16:    </unity>
  17:  
  18:  </configuration>

程序代码修改如下：

   1:  using System;
   2:  
   3:  using Microsoft.Practices.Unity;
   4:  using Microsoft.Practices.Unity.Configuration;
   5:  using System.Configuration;
   6:  
   7:  namespace UnityDemo
   8:  {
   9:      class Program
  10:      {
  11:          static void Main(string[] args)
  12:          {
  13:              IUnityContainer container = new UnityContainer();
  14:              UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
  15:              section.Containers.Default.Configure(container);
  16:  
  17:              IMonitor monitor = container.Resolve<IMonitor>();
  18:              monitor.Alarm();
  19:  
  20:              Console.ReadLine();
  21:          }
  22:      }
  23:  }

编译运行结果：

使用配置文件，还有许多方便的地方，比如对于程序的扩展而言，新增的模块不再需要修改已编译好的程序，而只需要修改配置文件就可以方便的实现新模块的注册，对于系统的稳定性和可维护性都非常有好处。

Page 2 of 512345