public DynamicTypeInfo WithType(string typeName)
{
var result = new DynamicTypeInfo(typeName, _moduleBuilder);
_types.Add(result);
return result;
}
private WcfClientProxyTypeFactory()
{
m_ProxyClientChannelType = WcfClientBaseTypeFactory <TServiceInterface, TBaseClass> .GenerateType();
m_ClientChannelPropertyInfo = m_ProxyClientChannelType.Property(WcfClientBaseTypeFactory <TServiceInterface, TBaseClass> .ClientChannelPropertyName, Flags.AllMembers);
m_ClientProxyTypeInfo = IL.NewType(CLIENT_PROXY_TYPE_NAME)
.Implements <TServiceInterface>()
.WithField(SERVICE_CLIENT_CONSTRUCTOR_PARAMETERS_FIELD_NAME, typeof(object[]))
.WithField(BEFORE_OPERATION_CALLBACK_FIELD_NAME, typeof(Action <OperationContext>))
.WithField(AFTER_OPERATION_CALLBACK_FIELD_NAME, typeof(Action <OperationContext>))
.WithMethod(INIT_CALLBACKS_METHOD_NAME, m => m.WithParameter(typeof(Action <OperationContext>))
.WithParameter(typeof(Action <OperationContext>))
.Returns(typeof(void))
.Ldarg(0)
.Ldarg(1)
.Stfld(BEFORE_OPERATION_CALLBACK_FIELD_NAME)
.Ldarg(0)
.Ldarg(2)
.Stfld(AFTER_OPERATION_CALLBACK_FIELD_NAME)
.Ret());
m_ConstructorParameters = new object[] { };
ImplementConstructor(m_ClientProxyTypeInfo, new Type[0]); //implement empty constructor
}
private static DynamicMethodBody EmitMethodSignature(DynamicTypeInfo t, MethodInfo method, IProxyMonitor monitor)
{
var ilmethod = t.WithMethod(method.Name);
var parameters = method.GetParameters();
foreach (var param in parameters)
{
ilmethod.WithParameter(
param.ParameterType,
param.Name
);
}
if (monitor != null)
{
if (method.ReturnType != typeof(void))
{
ilmethod.WithVariable(method.ReturnType);
}
if (parameters.Length > 0)
{
ilmethod.WithVariable(typeof(object[]), "parameters");
}
}
return(ilmethod
.Returns(method.ReturnType));
}
private static void ImplementConstructor(DynamicTypeInfo proxyTypeInfo, Type[] constructorArgs)
{
if (constructorArgs == null)
{
return;
}
if (!constructorArgs.Any())
{
proxyTypeInfo.WithConstructor(c => c.BodyDefinition()
.Ldarg(0)
.Newarr(typeof(object), 0)
.Stfld(SERVICE_CLIENT_CONSTRUCTOR_PARAMETERS_FIELD_NAME)
.Ret());
}
else
{
proxyTypeInfo.WithConstructor(c => c.BodyDefinition()
.Ldarg(0)
.Newarr(typeof(object), constructorArgs.Length)
.Stfld(SERVICE_CLIENT_CONSTRUCTOR_PARAMETERS_FIELD_NAME)
.Repeater(0, constructorArgs.Length - 1, 1, (i, m) =>
m.Ldarg(0)
.Ldfld(SERVICE_CLIENT_CONSTRUCTOR_PARAMETERS_FIELD_NAME)
.LdcI4(i) //load array index to stack
.Ldarg((uint)i + 1)
.Box(constructorArgs[i])
.Stelem_Ref())
.Ret(),
constructorArgs);
}
}
/// <summary>
/// Map game Craftable ID to specific class.
/// </summary>
public void MapCraftable(DynamicTypeInfo dynamicTypeInfo)
{
_dynamicCraftableTypeMap.Add(dynamicTypeInfo.ClassID, dynamicTypeInfo);
if (!_dynamicCraftableCtorCache.ContainsKey(dynamicTypeInfo.BaseType))
{
_dynamicCraftableCtorCache.Add(dynamicTypeInfo.BaseType, new Constructor <int, Object>(dynamicTypeInfo.BaseType));
}
}
public void AsType_ReturnsTypeWithSpecifiedName()
{
// arrange
var dt = new DynamicTypeInfo("Foo");
// act
var t = dt.AsType;
// assert
t.Name.Should().Be("Foo");
}
public void AsDynamicMethod_WithNotNullDynamicTypeInfo_ThrowsInvalidOperationException()
{
// arrange
var dti = new DynamicTypeInfo("Type");
var dmi = new DynamicMethodInfo(dti, "Name");
// act
var result = dmi.AsDynamicMethod;
// assert
}
public void TypeBuilder_InvokedTwoTimes_ReturnsSameValue()
{
// arrange
var dt = new DynamicTypeInfo("Foo");
// act
var t1 = dt.TypeBuilder;
var t2 = dt.TypeBuilder;
// assert
t1.Should().Be(t2);
}
public void AsType_ReturnedTypeShouldBeInstantiableViaActivatorCreateInstance()
{
// arrange
var dt = new DynamicTypeInfo("Foo");
// act
var t = dt.AsType;
var obj = Activator.CreateInstance(t);
// assert
obj.GetType().Should().Be(t);
}
public void Create1()
{
var propNames = new string[] { "LastName", "FirstName", "Age" };
var propTypes = new Type[] { typeof(String), typeof(String), typeof(Int32) };
var t1 = DynamicTypeInfo.FindOrCreate(propNames, propTypes);
var t2 = DynamicTypeInfo.FindOrCreate(propNames, propTypes);
Assert.IsTrue(t1 == t2);
}
public static IQueryable ApplySelect(IQueryable source, Type elementType, SelectClause selectClause)
{
var propSigs = selectClause.Properties;
var dti = DynamicTypeInfo.FindOrCreate(propSigs.Select(ps => ps.Name), propSigs.Select(ps => ps.ReturnType));
var lambdaExpr = CreateNewLambda(dti, propSigs);
var method = TypeFns.GetMethodByExample((IQueryable <String> q) => q.Select(s => s.Length), elementType, dti.DynamicType);
var func = BuildIQueryableFunc(elementType, method, lambdaExpr);
return(func(source));
}
public void AsType_ReturnsTypeWithSpecifiedName()
{
// arrange
var dt = new DynamicTypeInfo("Foo");
// act
var t = dt.AsType;
// assert
t.Name.Should().Be("Foo");
}
private static DynamicTypeInfo EmitMethods <T>(
this DynamicTypeInfo that,
IProxyMonitor monitor
)
{
foreach (var method in typeof(T).GetMethods())
{
EmitMethod(that, method, monitor);
}
return(that);
}
public DynamicFieldInfo(
DynamicTypeInfo dti,
string name,
Type type,
FieldBuilder fieldBuilder = null)
{
DynamicTypeInfo = dti;
Name = name;
Type = type;
FieldBuilder = fieldBuilder;
}
private static void ImplementConstructor(ConstructorInfo constructorInfo, DynamicTypeInfo clientChannelType)
{
clientChannelType.WithConstructor(c => c.BodyDefinition()
.Ldarg(0)
.Repeater(1, constructorInfo.Parameters().Count, 1, (i, m) => m.Ldarg((uint)i))
.Call(constructorInfo)
.Ret(),
constructorInfo.Parameters()
.Select(x => x.ParameterType)
.ToArray());
}
public void TypeBuilder_InvokedTwoTimes_ReturnsSameValue()
{
// arrange
var dt = new DynamicTypeInfo("Foo");
// act
var t1 = dt.TypeBuilder;
var t2 = dt.TypeBuilder;
// assert
t1.Should().Be(t2);
}
public void AsType_ReturnedTypeShouldBeInstantiableViaActivatorCreateInstance()
{
// arrange
var dt = new DynamicTypeInfo("Foo");
// act
var t = dt.AsType;
var obj = Activator.CreateInstance(t);
// assert
obj.GetType().Should().Be(t);
}
private static void EmitMethod(
DynamicTypeInfo t,
MethodInfo method,
IProxyMonitor monitor = null
)
{
var body = EmitMethodSignature(t, method, monitor)
.EmitBeforeExecuteCall(condition: monitor != null, method: method)
.EmitConcreteMethodCall(method)
.EmitAfterExecuteCall(condition: monitor != null, method: method)
.Ret();
}
private static DynamicTypeInfo EmitConcreteInstanceSupport <T>(
this DynamicTypeInfo that)
{
that
.WithField("__concreteinstance", typeof(T))
.WithMethod("__SetConcreteInstance")
.WithParameter(typeof(T))
.Returns(typeof(void))
.Ldarg(0)
.Ldarg(1)
.Stfld("__concreteinstance")
.Ret();
return(that);
}
private static LambdaExpression CreateNewLambda(DynamicTypeInfo dti, IEnumerable <PropertySignature> selectors)
{
var paramExpr = Expression.Parameter(selectors.First().InstanceType, "t");
// cannot create a NewExpression on a dynamic type becasue of EF restrictions
// so we always create a MemberInitExpression with bindings ( i.e. a new Foo() { a=1, b=2 } instead of new Foo(1,2);
var newExpr = Expression.New(dti.DynamicEmptyConstructor);
var propertyExprs = selectors.Select(s => s.BuildMemberExpression(paramExpr));
var dynamicProperties = dti.DynamicType.GetProperties();
var bindings = dynamicProperties.Zip(propertyExprs, (prop, expr) => Expression.Bind(prop, expr));
var memberInitExpr = Expression.MemberInit(newExpr, bindings.Cast <MemberBinding>());
var newLambda = Expression.Lambda(memberInitExpr, paramExpr);
return(newLambda);
}
/// <summary>
/// 根据指定的类型信息，动态创建一个类型。
/// </summary>
/// <param name="info">类型信息。</param>
/// <param name="propertyReadonly">指定一个值，用于确定新创建的类型的属性是否只读。</param>
/// <returns>返回新创建的类型。</returns>
private static Type CreateDynamicTypeByTypeInfo(DynamicTypeInfo info, bool propertyReadonly = false)
{
var interfaces = info.Interfaces.Count > 0 ? new Type[info.Interfaces.Count] : Type.EmptyTypes;
if (info.Interfaces.Count > 0)
{
info.Interfaces.CopyTo(interfaces);
}
var type = DynamicAssemblyHolder.Module.DefineType(GetDynamicTypeName(), TypeAttributes.Public, info.BaseType, interfaces);
var fnCreateProperty = propertyReadonly ? new Action <TypeBuilder, PropInfo>(CreateReadonlyProperty) : CreateProperty;
foreach (var prop in info.Properties)
{
fnCreateProperty(type, prop);
}
return(type.CreateType());
}
private static T CreateInstance <T>(
this DynamicTypeInfo that,
T concreteInstance,
IProxyMonitor monitor = null
)
{
var type = that.AsType;
var result = (T)Activator.CreateInstance(type);
var setupConcreteInstance = type.GetMethod("__SetConcreteInstance");
setupConcreteInstance.Invoke(result, new object[] { concreteInstance });
if (monitor != null)
{
var setupProxyMonitor = type.GetMethod("__SetProxyMonitor");
setupProxyMonitor.Invoke(result, new object[] { monitor });
}
return(result);
}
/// <summary>
/// 根据指定的属性名称和类型，创建一个匿名类型。
/// </summary>
/// <param name="propNames">属性名称。</param>
/// <param name="propTypes">属性类型。</param>
/// <param name="baseType">基类类型。</param>
/// <param name="interfaceTypes">实现的接口类型。</param>
/// <param name="propertyReadonly">指定新创建的类型中的属性是否只读。</param>
/// <returns>返回新创建的类型。</returns>
public static Type CreateDynamicType(string[] propNames, Type[] propTypes, Type baseType = null, Type[] interfaceTypes = null, bool propertyReadonly = false)
{
var info = new DynamicTypeInfo {
BaseType = baseType
};
for (var i = 0; i < propNames.Length; i++)
{
var propInfo = new PropInfo(propNames[i], propTypes[i]);
if (!info.Properties.Contains(propInfo))
{
info.Properties.Add(propInfo);
}
}
if (interfaceTypes != null)
{
info.Interfaces.AddRange(interfaceTypes);
}
return(dynamicTypes[info, key => CreateDynamicTypeByTypeInfo(key, propertyReadonly)]);
}
private static DynamicTypeInfo EmitProxyMonitorSupport(
this DynamicTypeInfo that,
bool condition
)
{
if (!condition)
{
return(that);
}
that
.WithField("__proxymonitor", typeof(IProxyMonitor))
.WithMethod("__SetProxyMonitor")
.WithParameter(typeof(IProxyMonitor))
.Returns(typeof(void))
.Ldarg(0)
.Ldarg(1)
.Stfld("__proxymonitor")
.Ret();
return(that);
}
public PropertyEmitter(DynamicTypeInfo dynamicTypeInfo)
{
_dynamicTypeInfoField = dynamicTypeInfo;
}
public PropertyEmitter(DynamicTypeInfo dynamicTypeInfo)
{
_dynamicTypeInfoField = dynamicTypeInfo;
}
private static void InitializeObjectMapping()
{
ClassMapperService.Instance.MapCraftable <Tank>(Config.Tank.ID);
ClassMapperService.Instance.MapCraftable <FullTank>(Config.Tank.ID + 1);
ClassMapperService.Instance.MapCraftable <Mixer>(Config.Mixer.ID);
ClassMapperService.Instance.MapCraftable <Separator>(Config.Separator.ID);
ClassMapperService.Instance.MapCraftable <Churn>(Config.Churn.ID);
ClassMapperService.Instance.MapCraftable <Fermenter>(Config.Fermenter.ID);
Config.Totems.ForEach(t => ClassMapperService.Instance.MapItem <BigWarpTotem>(t.ID));
Config.Items.ForEach(i => ClassMapperService.Instance.MapItem <SmartObject>(i.ID));
Config.SimpleMachines.ForEach(m => ClassMapperService.Instance.MapCraftable(DynamicTypeInfo.Create <DynamicCustomMachine>(m.ID)));
Config.MachineOverrides.ForEach(m => ClassMapperService.Instance.MapCraftable(DynamicTypeInfo.Create <DynamicOverridedMachine>(m.ID)));
}
public void AsDynamicMethod_WithNotNullDynamicTypeInfo_ThrowsInvalidOperationException()
{
// arrange
var dti = new DynamicTypeInfo("Type");
var dmi = new DynamicMethodInfo(dti, "Name");
// act
var result = dmi.AsDynamicMethod;
// assert
}
