Silverlight中动态数据验证和动态自动计算的Reflection反射实现
Silverlight中动态数据验证和动态自动计算的Reflection反射实现
上周在博客园发了个首页随笔，因为被误认为是广告而被移出首页，这次发首页，特地备足了技术材料，结合FreeForm实际的开发情况，从技术上分析在Silverlight中实现动态数据验证和自动计算的方法。我们知道在.Net 4.0标准类库中，反射的类很全，非常好用，但在Silverlight类库中涉及反射的命名空间虽然也有System.Reflection 和System.Reflection.Emit ，但类和方法大大的缩减了。以前我们在WinForm或者ASP.Net中实现动态验证和动态计算非常容易，可以通过类似如下代码实现：
View Code
//
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;
}
}
View Code
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)：