c#扩展方法奇思妙用高级篇四：对扩展进行分组管理

核心提示： 首先定义一个接口IConvertableString，它继承泛型接口IExtension<T>（我定义的一个接口，c#扩展方法奇思妙用高级篇四：对扩展进行分组管理(5)，稍后给出），因为是对string类作扩展，将方法扩展在空接口上，有一点注意一下，所以泛型参数为string，ICo

首先定义一个接口IConvertableString，它继承泛型接口IExtension<T>（我定义的一个接口，稍后给出），因为是对string类作扩展，所以泛型参数为string。IConvertableString只需要一个空架子。然后再编写一个扩展类，所有的方法扩展在IConvertableString接口上。

再来看右图IRegexableString的代码：

1　　　　 public static class RegexableString
2　　　　 {
3　　　　　　　　 public static bool IsMatch(this IRegexableString s, string pattern)
4　　　　　　　　 { throw new NotImplementedException(); }
5　　　　　　　　 public static string Match(this IRegexableString s, string pattern)
6　　　　　　　　 { throw new NotImplementedException(); }
7　　　　　　　　 public static string Relplace(this IRegexableString s, string pattern, MatchEvaluator evaluator)
8　　　　　　　　 { throw new NotImplementedException(); }
9　　　　 }

与上一个一样，也是先定义一个空接口，再定义一个扩展类，将方法扩展在空接口上。

有一点注意一下，扩展的实现中都要使用GetValue获取原始字符串的值。

最后给出IExtension<T>接口及As<T>扩展的实现：　

　1　　　 public interface IExtension<V>
　2　　　 {
　3　　　　　　　 V GetValue();
　4　　　 }
　5
　6　　　 public static class ExtensionGroup
　7　　　 {
　8　　　　　　　 private static Dictionary<Type, Type> cache = new Dictionary<Type, Type>();
　9
10　　　　　　　 public static T As<T>(this string v) where T : IExtension<string>
11　　　　　　　 {
12　　　　　　　　　　　 return As<T, string>(v);
13　　　　　　　 }
14
15　　　　　　　 public static T As<T, V>(this V v) where T : IExtension<V>
16　　　　　　　 {
17　　　　　　　　　　　 Type t;
18　　　　　　　　　　　 Type valueType = typeof(V);
19　　　　　　　　　　　 if (cache.ContainsKey(valueType))
20　　　　　　　　　　　 {
21　　　　　　　　　　　　　　　 t = cache[valueType];
22　　　　　　　　　　　 }
23　　　　　　　　　　　 else
24　　　　　　　　　　　 {
25　　　　　　　　　　　　　　　 t = CreateType<T, V>();
26　　　　　　　　　　　　　　　 cache.Add(valueType, t);
27　　　　　　　　　　　 }
28　　　　　　　　　　　 object result = Activator.CreateInstance(t, v);
29　　　　　　　　　　　 return (T)result;
30　　　　　　　 }
31　　　　　　　 // 通过反射发出动态实现接口T
32　　　　　　　 private static Type CreateType<T, V>() where T : IExtension<V>
33　　　　　　　 {
34　　　　　　　　　　　 Type targetInterfaceType = typeof(T);
35　　　　　　　　　　　 string generatedClassName = targetInterfaceType.Name.Remove(0, 1);
36　　　　　　　　　　　 //
37　　　　　　　　　　　 AssemblyName aName = new AssemblyName("ExtensionDynamicAssembly");
38　　　　　　　　　　　 AssemblyBuilder ab =
39　　　　　　　　　　　　　　　 AppDomain.CurrentDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Run);
40　　　　　　　　　　　 ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
41　　　　　　　　　　　 TypeBuilder tb = mb.DefineType(generatedClassName, TypeAttributes.Public);
42　　　　　　　　　　　 //实现接口
43　　　　　　　　　　　 tb.AddInterfaceImplementation(typeof(T));
44　　　　　　　　　　　 //value字段
45　　　　　　　　　　　 FieldBuilder valueFiled = tb.DefineField("value", typeof(V), FieldAttributes.Private);
46　　　　　　　　　　　 //构造函数
47　　　　　　　　　　　 ConstructorBuilder ctor = tb.DefineConstructor(MethodAttributes.Public,
48　　　　　　　　　　　　　　　 CallingConventions.Standard, new Type[] { typeof(V) });
49　　　　　　　　　　　 ILGenerator ctor1IL = ctor.GetILGenerator();
50　　　　　　　　　　　 ctor1IL.Emit(OpCodes.Ldarg_0);
51　　　　　　　　　　　 ctor1IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
52　　　　　　　　　　　 ctor1IL.Emit(OpCodes.Ldarg_0);
53　　　　　　　　　　　 ctor1IL.Emit(OpCodes.Ldarg_1);
54　　　　　　　　　　　 ctor1IL.Emit(OpCodes.Stfld, valueFiled);
55　　　　　　　　　　　 ctor1IL.Emit(OpCodes.Ret);
56　　　　　　　　　　　 //GetValue方法
57　　　　　　　　　　　 MethodBuilder getValueMethod = tb.DefineMethod("GetValue",
58　　　　　　　　　　　　　　　 MethodAttributes.Public | MethodAttributes.Virtual, typeof(V), Type.EmptyTypes);
59　　　　　　　　　　　 ILGenerator numberGetIL = getValueMethod.GetILGenerator();
60　　　　　　　　　　　 numberGetIL.Emit(OpCodes.Ldarg_0);
61　　　　　　　　　　　 numberGetIL.Emit(OpCodes.Ldfld, valueFiled);
62　　　　　　　　　　　 numberGetIL.Emit(OpCodes.Ret);
63　　　　　　　　　　　 //接口实现
64　　　　　　　　　　　 MethodInfo getValueInfo = targetInterfaceType.GetInterfaces()[0].GetMethod("GetValue");
65　　　　　　　　　　　 tb.DefineMethodOverride(getValueMethod, getValueInfo);
66　　　　　　　　　　　 //
67　　　　　　　　　　　 Type t = tb.CreateType();
68　　　　　　　　　　　 return t;
69　　　　　　　 }
70　　　 }