c# 工厂模式 类名 转对象

方式一：通过类名来生成对象（优势：方便；劣势：不能以递增方式增加需转化成对象的类文件，即每次发布需整个项目重新编译）经测试正确

public class FruitFactory
{
　public IFruit MakeFruit(string Name)
　{
　　IFruit MyFruit = null;
　　try
　　{
　　　Type type = Type.GetType(Name,true);
　　　MyFruit = (IFruit)Activator.CreateInstance(type);
　　}
　　catch (TypeLoadException e)
　　　Console.WriteLine("I dont know this kind of fruit,exception caught - {0}" ,e.Message);
　　　return MyFruit;
　}
}


方式二：通过反射（需提供文件路径，类名；优势：可以以递增文件的方式发布程序；劣势：生成文件麻烦）未测试
/// <summary>
        /// 创建对象(外部程序集)
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="typeName">类型名</param>
        /// <returns>创建的对象，失败返回 null</returns>
        public static object CreateObject(string path, string typeName)
        {
            object obj = null;
            try
            {

                obj = Assembly.Load(path).CreateInstance(typeName);
            }
            catch (Exception ex)
            {
                Debug.Write(ex);
            }


另外参见：http://blog.hetaoos.com/archives/40
C# 中反射获取某类的子类和根据类型名动态创建对象
2010/10/11 于 23:35 Null 已有 7 条评论

有时候，为了快速批量处理已经实现某个基类或者某个接口的子类，需要通过反射的方式获取到他们的类类型(Type),然后再通过
1 Activator.CreateInstance(objType);

或者
1 Assembly.Load(path).CreateInstance(typeName);

或者
1 Assembly.LoadFile(filePath).CreateInstance(typeName);

创建对象实例。

以下通过一个简单的示例来展示：
1，获取当前程序集中的全部类型；
2，判断某一类型是否是继承与另一类型；
3，根据类型名动态创建对象。

目前还有个疑问，不知道谁能解答：
1，如何判断某个类是否实现了某个接口，目前只能先 new 一个对象，然后再 用 is 判断。
001 using System;
002 using System.Collections.Generic;
003 using System.Text;
004 using System.Reflection;
005 using System.Diagnostics;
006
007 namespace com.hetaoos
008 {
009
010     class Test
011     {
012         public Test()
013         {
014             var types = Assembly.GetExecutingAssembly().GetTypes();
015             var baseType = typeof(BaseProcessor);
016             List<BaseProcessor> processors = new List<BaseProcessor>();
017             foreach (var t in types)
018             {
019                 var tmp = t.BaseType;
020                 while (tmp != null)
021                 {
022                     if (tmp == baseType)
023                     {
024                         BaseProcessor obj = MethodMaker.CreateObject(t.FullName) as BaseProcessor;
025                         if (obj != null)
026                         {
027                             processors.Add(obj);
028                         }
029                         break;
030                     }
031                     else
032                     {
033                         tmp = tmp.BaseType;
034                     }
035                 }
036             }
037
038             Debug.Print("Processor Count:{0}", processors.Count);
039             foreach (var p in processors)
040             {
041                 Debug.Print("{0}\t:{1}", p, p.Calc(2, 5));
042             }
043         }
044     }
045
046     public class MethodMaker
047     {
048
049         /// <summary>
050         /// 创建对象（当前程序集）
051         /// </summary>
052         /// <param name="typeName">类型名</param>
053         /// <returns>创建的对象，失败返回 null</returns>
054         public static object CreateObject(string typeName)
055         {
056             object obj = null;
057             try
058             {
059                 Type objType = Type.GetType(typeName, true);
060                 obj = Activator.CreateInstance(objType);
061             }
062             catch (Exception ex)
063             {
064                 Debug.Write(ex);
065             }
066             return obj;
067         }
068
069         /// <summary>
070         /// 创建对象(外部程序集)
071         /// </summary>
072         /// <param name="path"></param>
073         /// <param name="typeName">类型名</param>
074         /// <returns>创建的对象，失败返回 null</returns>
075         public static object CreateObject(string path, string typeName)
076         {
077             object obj = null;
078             try
079             {
080
081                 obj = Assembly.Load(path).CreateInstance(typeName);
082             }
083             catch (Exception ex)
084             {
085                 Debug.Write(ex);
086             }
087
088             return obj;
089         }
090     }
091
092     public abstract class BaseProcessor
093     {
094         public abstract int Calc(int a, int b);
095     }
096
097     public class Adder : BaseProcessor
098     {
099         public override int Calc(int a, int b)
100         {
101             return a + b;
102         }
103     }
104
105     public class Multiplier : BaseProcessor
106     {
107         public override int Calc(int a, int b)
108         {
109             return a * b;
110         }
111     }
112 }

输出结果为：
1 Processor Count:2
2 com.hetaoos.Adder   :7
3 com.hetaoos.Multiplier  :10

PS:
判断某个类是否继承自某个接口、类的方法：
01 public static bool IsParent(Type test, Type parent)
02 {
03     if (test == null || parent == null || test == parent || test.BaseType == null)
04     {
05         return false;
06     }
07     if (parent.IsInterface)
08     {
09         foreach (var t in test.GetInterfaces())
10         {
11             if (t == parent)
12             {
13                 return true;
14             }
15         }
16     }
17     else
18     {
19         do
20         {
21             if (test.BaseType == parent)
22             {
23                 return true;
24             }
25             test = test.BaseType;
26         } while (test != null);
27
28     }
29     return false;

            return obj;
        }