Silverlight中动态数据验证和动态自动计算的Reflection反射实现

来源:转载

上周在博客园发了个首页随笔,因为被误认为是广告而被移出首页,这次发首页,特地备足了技术材料,结合FreeForm实际的开发情况,从技术上分析在Silverlight中实现动态数据验证和自动计算的方法。我们知道在.Net 4.0标准类库中,反射的类很全,非常好用,但在Silverlight类库中涉及反射的命名空间虽然也有System.Reflection 和System.Reflection.Emit ,但类和方法大大的缩减了。以前我们在WinForm或者ASP.Net中实现动态验证和动态计算非常容易,可以通过类似如下代码实现:// compile string code to create class, generate an intance and mothod
        public Expression(string expression, string fieldID, AppCom appcom)

        {

            this.Com =
appcom;

            if (expression.IndexOf("return") < 0) expression = "return " + expression + ";"
;

            string className = "ExpressionValidate"
;

            string methodName = "Compute"
;

            if (!string
.IsNullOrEmpty(fieldID))

            {

                methodName = ("Validate_" + fieldID).Replace(":", "_"
);

                methodName = methodName.Replace("@", "Att_"
);

            }

            CompilerParameters cp = new
CompilerParameters();

            cp.GenerateInMemory = true
;

            cp.ReferencedAssemblies.Add("System.dll"
);

            cp.ReferencedAssemblies.Add("mscorlib.dll"
);

            cp.ReferencedAssemblies.Add("System.Data.dll"
);

            cp.ReferencedAssemblies.Add("System.Xml.dll"
);

            // cp.ReferencedAssemblies.Add(Com.ClassDir + "ComFun_cs.dll");


            CompilerResults cr = new CSharpCodeProvider()

                .CompileAssemblyFromSource(cp, string
.

              Format(@"
using System;

                       using System.Text.RegularExpressions;

                       using System.Collections.Generic;

                       using System.Data.SqlClient;

                       using System.Xml;

                      sealed class {0}{{

                         XmlDocument xdoc;

                         XmlNamespaceManager nsmgr;

                         public bool {1}(){{

                            {2}

                         }}

                         {3}

                      }}"
,

              className, methodName, expression, appcom.ValidateComFuns) +
Com.GetComFunInfo());

         

            instance =
cr.CompiledAssembly.CreateInstance(className);

            method =
instance.GetType().GetMethod(methodName);



            {

                MethodInfo SFun = instance.GetType().GetMethod("Initial"
);

                if (SFun != null
)

                {

                    SFun.Invoke(instance, new object
[] { AppCom.XDoc, AppCom.nsmgr });

                }

            }

            CLog.Win_ClassExp.AppendText(appcom.ValidateComFuns);

        }



        // validate one validation method


        public bool Compute()

        {

            return (bool)method.Invoke(instance, null
);

        }

其中

sealed class {0}{{

XmlDocument xdoc;

XmlNamespaceManager nsmgr;

public bool {1}(){{

{2}

}}

{3}

}}

就是我们运行时从XML动态生成的类,从XML动态传入的参数,返回一个True 或 False的验证结果。参数分别对应如下:

{0}:className 类名

{1}:methodName 方法名

{2}:expression 动态验证表达式

{3}:动态加入的调用代码

很遗憾,这是在标准类库的快捷方便的写法,但是到了Silverlight微缩类库这里,很多类已不存在了。CodeDomProvider类没有了,Microsoft.VisualBasic

命名空间没有了,CompilerParameters 类没有了,CompilerResults类没有了,Microsoft.CSharp.CSharpCodeProvider类没有了,Microsoft.CSharp

下还有2个类:Microsoft.CSharp.RuntimeBinder. RuntimeBinderException类和Microsoft.CSharp.RuntimeBinder.RuntimeBinderInternalCompilerException,很明显这2个类是处理异常的。真的要绝望了。

经过捣腾System.Reflection.Assembly类,我们发现有4个方法:

System.Reflection.Assembly.GetCallingAssembly();

System.Reflection.Assembly.GetExecutingAssembly();

System.Reflection.Assembly.Load(assemblyName);

System.Reflection.Assembly.LoadFrom(assemblyFile);

发现Silverlight中的反射与.NET FRAMEWORK中的略有不同。以下分三种情况描述:

1:动态创建当前执行的程序集中的类实例。

2:动态创建XAP包中其它SILVERLIGHT程序集中的类实例。

3:动态下载并创建网站上其它SILVERLIGHT程序集中的类实例。

我们可以利用后两种方法来动态加载程序集,CSharpCodeProvider那种方便快捷的写法不可能用了,于是只能用System.Reflection.Emit 命名空间,定义动态程序集,关于这方面,微软有详细介绍:

http://msdn.microsoft.com/zh-cn/library/4xtysk39%28v=VS.95%29.aspx

首先需要了解生成方法体的 MSIL 指令代码,感觉和大学学的汇编差不多,

http://msdn.microsoft.com/zh-cn/library/system.reflection.emit.opcodes%28v=VS.95%29.aspx

贴一个通过Emit动态生成程序集的例子。其实是动态生成了这个类:

public class MyDynamicType

            {

                private int m_number;

                public MyDynamicType() : this(42) {}

                public MyDynamicType(int initNumber)

                {

                    m_number = initNumber;

                }

                public int Number

                {

                    get { return m_number; }

                    set { m_number = value; }

                }

                public int MyMethod(int multiplier)

                {

                    return m_number * multiplier;

                }

            }

 

class Example

{

public static void Demo(System.Windows.Controls.TextBlock outputBlock)

{



AssemblyName aName = new AssemblyName("DynamicAssemblyExample");

AssemblyBuilder ab =

AppDomain.CurrentDomain.DefineDynamicAssembly(

aName,

AssemblyBuilderAccess.Run);



// Create the module.

ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);



TypeBuilder tb = mb.DefineType(

"MyDynamicType",

TypeAttributes.Public);



// Add a private field of type int (Int32).

FieldBuilder fbNumber = tb.DefineField(

"m_number",

typeof(int),

FieldAttributes.Private);



// Define a constructor that takes an integer argument and

// stores it in the private field.

Type[] parameterTypes = { typeof(int) };

ConstructorBuilder ctor1 = tb.DefineConstructor(

MethodAttributes.Public,

CallingConventions.Standard,

parameterTypes);



ILGenerator ctor1IL = ctor1.GetILGenerator();

// For a constructor, argument zero is a reference to the new

// instance. Push it on the stack before calling the base

// class constructor. Specify the default constructor of the

// base class (System.Object) by passing an empty array of

// types (Type.EmptyTypes) to GetConstructor.

ctor1IL.Emit(OpCodes.Ldarg_0);

ctor1IL.Emit(OpCodes.Call,

typeof(object).GetConstructor(Type.EmptyTypes));

// Push the instance on the stack before pushing the argument

// that is to be assigned to the private field m_number.

ctor1IL.Emit(OpCodes.Ldarg_0);

ctor1IL.Emit(OpCodes.Ldarg_1);

ctor1IL.Emit(OpCodes.Stfld, fbNumber);

ctor1IL.Emit(OpCodes.Ret);



// Define a default constructor that supplies a default value

// for the private field. For parameter types, pass the empty

// array of types or pass null.

ConstructorBuilder ctor0 = tb.DefineConstructor(

MethodAttributes.Public,

CallingConventions.Standard,

Type.EmptyTypes);



ILGenerator ctor0IL = ctor0.GetILGenerator();

// For a constructor, argument zero is a reference to the new

// instance. Push it on the stack before pushing the default

// value on the stack, then call constructor ctor1.

ctor0IL.Emit(OpCodes.Ldarg_0);

ctor0IL.Emit(OpCodes.Ldc_I4_S, 42);

ctor0IL.Emit(OpCodes.Call, ctor1);

ctor0IL.Emit(OpCodes.Ret);



// Define a property named Number that gets and sets the private

// field.

//

// The last argument of DefineProperty is null, because the

// property has no parameters. (If you don't specify null, you must

// specify an array of Type objects. For a parameterless property,

// use the built-in array with no elements: Type.EmptyTypes)

PropertyBuilder pbNumber = tb.DefineProperty(

"Number",

PropertyAttributes.HasDefault,

typeof(int),

null);



// The property "set" and property "get" methods require a special

// set of attributes.

MethodAttributes getSetAttr = MethodAttributes.Public |

MethodAttributes.SpecialName | MethodAttributes.HideBySig;



// Define the "get" accessor method for Number. The method returns

// an integer and has no arguments. (Note that null could be

// used instead of Types.EmptyTypes)

MethodBuilder mbNumberGetAccessor = tb.DefineMethod(

"get_Number",

getSetAttr,

typeof(int),

Type.EmptyTypes);



ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();

// For an instance property, argument zero is the instance. Load the

// instance, then load the private field and return, leaving the

// field value on the stack.

numberGetIL.Emit(OpCodes.Ldarg_0);

numberGetIL.Emit(OpCodes.Ldfld, fbNumber);

numberGetIL.Emit(OpCodes.Ret);



// Define the "set" accessor method for Number, which has no return

// type and takes one argument of type int (Int32).

MethodBuilder mbNumberSetAccessor = tb.DefineMethod(

"set_Number",

getSetAttr,

null,

new Type[] { typeof(int) });



ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();

// Load the instance and then the numeric argument, then store the

// argument in the field.

numberSetIL.Emit(OpCodes.Ldarg_0);

numberSetIL.Emit(OpCodes.Ldarg_1);

numberSetIL.Emit(OpCodes.Stfld, fbNumber);

numberSetIL.Emit(OpCodes.Ret);



// Last, map the "get" and "set" accessor methods to the

// PropertyBuilder. The property is now complete.

pbNumber.SetGetMethod(mbNumberGetAccessor);

pbNumber.SetSetMethod(mbNumberSetAccessor);



// Define a method that accepts an integer argument and returns

// the product of that integer and the private field m_number. This

// time, the array of parameter types is created on the fly.

MethodBuilder meth = tb.DefineMethod(

"MyMethod",

MethodAttributes.Public,

typeof(int),

new Type[] { typeof(int) });



ILGenerator methIL = meth.GetILGenerator();

// To retrieve the private instance field, load the instance it

// belongs to (argument zero). After loading the field, load the

// argument one and then multiply. Return from the method with

// the return value (the product of the two numbers) on the

// execution stack.

methIL.Emit(OpCodes.Ldarg_0);

methIL.Emit(OpCodes.Ldfld, fbNumber);

methIL.Emit(OpCodes.Ldarg_1);

methIL.Emit(OpCodes.Mul);

methIL.Emit(OpCodes.Ret);



// Finish the type.

Type t = tb.CreateType();



// The code can be executed immediately. Start by getting reflection

// objects for the method and the property.

MethodInfo mi = t.GetMethod("MyMethod");

PropertyInfo pi = t.GetProperty("Number");



// Create an instance of MyDynamicType using the default

// constructor.

object o1 = Activator.CreateInstance(t);



// Display the value of the property, then change it to 127 and

// display it again. Use null to indicate that the property

// has no index.

outputBlock.Text += String.Format("o1.Number: {0}/n", pi.GetValue(o1, null));

pi.SetValue(o1, 127, null);

outputBlock.Text += String.Format("o1.Number: {0}/n", pi.GetValue(o1, null));



// Call MyMethod, passing 22, and display the return value, 22

// times 127. Arguments must be passed as an array, even when

// there is only one.

object[] arguments = { 22 };

outputBlock.Text += String.Format("o1.MyMethod(22): {0}/n",

mi.Invoke(o1, arguments));



// Create an instance of MyDynamicType using the constructor

// that specifies m_Number. The constructor is identified by

// matching the types in the argument array. In this case,

// the argument array is created on the fly. Display the

// property value.

object o2 = Activator.CreateInstance(t,

new object[] { 5280 });

outputBlock.Text += String.Format("o2.Number: {0}/n", pi.GetValue(o2, null));

}

}


 

好了,原理清晰了,一起看看在Siverlight上实现的例子吧(一定要看最后一节的“动态自定义验证”),感谢大家。

在线演示(ver2011):

http://crmwin.com/FreeForm2011TestPage.html

本文来自昕友的博客,原文地址:http://www.cnblogs.com/starcrm/archive/2011/06/25/2090288.html


分享给朋友:
您可能感兴趣的文章:
随机阅读: