public void Init()
{
_MemberInfo = A.Fake<IMemberInfo>();
_Builder = new PropertyBuilder<ReferencedTargetClass, TargetClass>(_MemberInfo);
A.CallTo(() => _MemberInfo.Name).Returns("OneToReferencedTarget");
_AppearanceBuilder = _Builder.UsingAppearance();
}
void LockSignature()
{
if (_pb == null)
{
_indexParameters.Lock();
_pb = _owner.TypeBuilder.DefineProperty(ImplementedInterface == null ? Name : ImplementedInterface.FullName + "." + Name, PropertyAttributes.None, _type, _indexParameters.TypeArray);
_owner.RegisterForCompletion(this);
}
}
// Create the callee transient dynamic assembly.
private static Type CreateCallee(AppDomain myAppDomain, AssemblyBuilderAccess access)
{
// Create a simple name for the callee assembly.
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "EmittedAssembly";
// Create the callee dynamic assembly.
AssemblyBuilder myAssemblyBuilder =
myAppDomain.DefineDynamicAssembly(myAssemblyName, access);
// Create a dynamic module named "EmittedModule" in the callee assembly.
ModuleBuilder myModule;
if (access == AssemblyBuilderAccess.Run)
{
myModule = myAssemblyBuilder.DefineDynamicModule("EmittedModule");
}
else
{
myModule = myAssemblyBuilder.DefineDynamicModule("EmittedModule", "EmittedModule.mod");
}
// <Snippet2>
// Define a public class named "HelloWorld" in the assembly.
TypeBuilder helloWorldTypeBuilder = myModule.DefineType("HelloWorld", TypeAttributes.Public);
// Define a private String field named "m_greeting" in "HelloWorld" class.
FieldBuilder greetingFieldBuilder = helloWorldTypeBuilder.DefineField("m_greeting",
typeof(String), FieldAttributes.Private);
// Create constructor args and define constructor.
Type[] constructorArgs = { typeof(String) };
ConstructorBuilder constructor = helloWorldTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.Standard, constructorArgs);
// Generate IL code for the method.The constructor stores its argument in the private field.
ILGenerator constructorIL = constructor.GetILGenerator();
constructorIL.Emit(OpCodes.Ldarg_0);
constructorIL.Emit(OpCodes.Ldarg_1);
constructorIL.Emit(OpCodes.Stfld, greetingFieldBuilder);
constructorIL.Emit(OpCodes.Ret);
// <Snippet1>
// Define property Greeting.
PropertyBuilder greetingPropertyBuilder = helloWorldTypeBuilder.DefineProperty(
"Greeting",PropertyAttributes.None,typeof(string),null);
// Define the 'get_Greeting' method.
MethodBuilder getGreetingMethod = helloWorldTypeBuilder.DefineMethod("get_Greeting",
MethodAttributes.Public|MethodAttributes.HideBySig|MethodAttributes.SpecialName,
typeof(String),null);
// Generate IL code for 'get_Greeting' method.
ILGenerator methodIL = getGreetingMethod.GetILGenerator();
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Ldfld, greetingFieldBuilder);
methodIL.Emit(OpCodes.Ret);
greetingPropertyBuilder.SetGetMethod(getGreetingMethod);
// </Snippet1>
// Define the set_Greeting method.
Type[] methodArgs = {typeof(string)};
MethodBuilder setGreetingMethod = helloWorldTypeBuilder.DefineMethod("set_Greeting",
MethodAttributes.Public|MethodAttributes.HideBySig|MethodAttributes.SpecialName,
typeof(void), methodArgs);
// Generate IL code for set_Greeting method.
methodIL = setGreetingMethod.GetILGenerator();
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Ldarg_1);
methodIL.Emit(OpCodes.Stfld,greetingFieldBuilder);
methodIL.Emit(OpCodes.Ret);
greetingPropertyBuilder.SetSetMethod(setGreetingMethod);
// </Snippet2>
// <Snippet3>
// Define the reset_Greeting method.
MethodBuilder otherGreetingMethod = helloWorldTypeBuilder.DefineMethod("reset_Greeting",
MethodAttributes.Public|MethodAttributes.HideBySig,
typeof(void), null);
// Generate IL code for reset_Greeting method.
methodIL = otherGreetingMethod.GetILGenerator();
methodIL.Emit(OpCodes.Ldarg_0);
methodIL.Emit(OpCodes.Ldstr,"Default String.");
methodIL.Emit(OpCodes.Stfld, greetingFieldBuilder);
methodIL.Emit(OpCodes.Ret);
greetingPropertyBuilder.AddOtherMethod(otherGreetingMethod);
// </Snippet3>
// Create the class HelloWorld.
return(helloWorldTypeBuilder.CreateType());
}
public static PropertyBuilder <T> HasAggregateIdConversion <T>(this PropertyBuilder <T> builder) => builder.HasConversion(new AggregateIdValueConverter());
/// <summary>
/// 创建 TCP 客户端
/// </summary>
/// <param name="type"></param>
/// <param name="attribute"></param>
/// <param name="methods"></param>
/// <param name="getCommandMethod"></param>
/// <returns></returns>
internal Type Build(Type type, ServerBaseAttribute attribute, Method <attributeType, methodAttributeType, serverSocketSenderType>[] methods, MethodInfo getCommandMethod)
{
TypeBuilder typeBuilder = AutoCSer.Emit.Builder.Module.Builder.DefineType(Metadata.ClientTypeName + ".Emit." + type.FullName, TypeAttributes.Class | TypeAttributes.Sealed, Metadata.MethodClientType, new Type[] { type });
typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
ConstructorBuilder staticConstructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, null);
ILGenerator staticConstructorGenerator = staticConstructorBuilder.GetILGenerator();
Commands = new CommandInfo[methods.Length];
int parameterIndex;
foreach (Method <attributeType, methodAttributeType, serverSocketSenderType> nextMethod in methods)
{
if (nextMethod != null)
{
Method <attributeType, methodAttributeType, serverSocketSenderType> method = nextMethod;
METHOD:
FieldBuilder commandInfoFieldBuilder;
if (method.Attribute.IsExpired)
{
commandInfoFieldBuilder = null;
}
else
{
commandInfoFieldBuilder = typeBuilder.DefineField("_c" + method.Attribute.CommandIdentity.toString(), typeof(CommandInfo), FieldAttributes.Private | FieldAttributes.InitOnly | FieldAttributes.Static);
CommandInfo commandInfo = new CommandInfo {
Command = method.Attribute.CommandIdentity + TcpServer.Server.CommandStartIndex, TaskType = method.IsAsynchronousCallback ? method.Attribute.ClientTaskType : AutoCSer.Net.TcpServer.ClientTaskType.Synchronous, IsVerifyMethod = method.Attribute.IsVerifyMethod
};
Commands[method.Attribute.CommandIdentity] = commandInfo;
if (method.IsClientSendOnly)
{
commandInfo.IsSendOnly = 1;
}
if (method.IsJsonSerialize)
{
commandInfo.CommandFlags = CommandFlags.JsonSerialize;
}
if (method.ParameterType != null)
{
commandInfo.InputParameterIndex = method.ParameterType.Index;
if (attribute.IsSimpleSerialize)
{
commandInfo.IsSimpleSerializeInputParamter = method.ParameterType.IsSimpleSerialize;
}
}
if (attribute.IsSimpleSerialize && method.OutputParameterType != null)
{
commandInfo.IsSimpleSerializeOutputParamter = method.OutputParameterType.IsSimpleSerialize && SimpleSerialize.Serializer.IsType(method.ReturnType);
}
#region private static readonly AutoCSer.Net.TcpServer.CommandInfo @MethodIdentityCommand = AutoCSer.Net.TcpInternalServer.Emit.Client<interfaceType>.commands[method.Attribute.CommandIdentity];
staticConstructorGenerator.int32(method.Attribute.CommandIdentity);
staticConstructorGenerator.call(getCommandMethod);
staticConstructorGenerator.Emit(OpCodes.Stsfld, commandInfoFieldBuilder);
#endregion
}
if (method.PropertyInfo == null)
{
ParameterInfo[] parameters = method.MethodInfo.GetParameters();
MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.MethodInfo.Name, MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, method.MethodInfo.ReturnType, parameters.getArray(parameter => parameter.ParameterType));
typeBuilder.DefineMethodOverride(methodBuilder, method.MethodInfo);
ILGenerator methodGenerator = methodBuilder.GetILGenerator();
if (method.Attribute.IsExpired)
{
if (method.ReturnValueType == null)
{
#region throw new Exception(AutoCSer.Net.TcpServer.ReturnType.VersionExpired.ToString());
methodGenerator.throwString(AutoCSer.Net.TcpServer.ReturnType.VersionExpired.ToString());
#endregion
}
else
{
#region @ParameterName = default(@ParameterType.FullName);
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (parameter.IsOut)
{
methodGenerator.outParameterDefault(parameter, parameterIndex, method.Attribute.IsInitobj);
}
}
#endregion
#region return new AutoCSer.Net.TcpServer.ReturnValue<@MethodReturnType.FullName> { Type = AutoCSer.Net.TcpServer.ReturnType.VersionExpired };
LocalBuilder returnReturnValueLocalBuilder = methodGenerator.DeclareLocal(method.ReturnValueType);
if (method.ReturnType != typeof(void) && (method.Attribute.IsInitobj || method.ReturnType.isInitobj()))
{
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Initobj, method.ReturnValueType);
}
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.int32((byte)AutoCSer.Net.TcpServer.ReturnType.VersionExpired);
methodGenerator.Emit(OpCodes.Stfld, method.ReturnType == typeof(void) ? TcpServer.Emit.ClientMetadata.ReturnValueTypeField : method.ReturnValueType.GetField(TcpServer.Emit.ClientMetadata.ReturnValueTypeField.Name, BindingFlags.Instance | BindingFlags.Public));
methodGenerator.Emit(OpCodes.Ldloc_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Ret);
#endregion
}
}
else if (method.IsClientSendOnly)
{
LocalBuilder inputParameterLocalBuilder;
if (method.ParameterType == null)
{
inputParameterLocalBuilder = null;
}
else
{
#region TcpInternalServer.@InputParameterTypeName _inputParameter_ = new TcpInternalServer.@InputParameterTypeName { @ParameterName = @ParameterName };
inputParameterLocalBuilder = methodGenerator.DeclareLocal(method.ParameterType.Type);
LocalBuilder newInputParameterLocalBuilder = methodGenerator.DeclareLocal(method.ParameterType.Type);
if (method.Attribute.IsInitobj || method.ParameterType.IsInitobj)
{
methodGenerator.Emit(OpCodes.Ldloca_S, newInputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Initobj, method.ParameterType.Type);
}
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (StreamParameterType.IsInputParameter(parameter))
{
methodGenerator.parameterToStructField(parameter, parameterIndex, newInputParameterLocalBuilder, method.ParameterType.GetField(parameter.Name));
}
}
methodGenerator.Emit(OpCodes.Ldloc_S, newInputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Stloc_S, inputParameterLocalBuilder);
#endregion
}
#region _TcpClient_.Sender.CallOnly(@MethodIdentityCommand, ref _inputParameter_);
methodGenerator.Emit(OpCodes.Ldarg_0);
methodGenerator.call(Metadata.MethodClientGetTcpClientMethod);
methodGenerator.call(Metadata.ClientGetSenderMethod);
methodGenerator.Emit(OpCodes.Ldsfld, commandInfoFieldBuilder);
if (method.ParameterType == null)
{
methodGenerator.call(Metadata.ClientSocketSenderCallOnlyMethod);
}
else
{
methodGenerator.Emit(OpCodes.Ldloca_S, inputParameterLocalBuilder);
//methodGenerator.call(Metadata.ClientSocketSenderCallOnlyInputMethod.MakeGenericMethod(method.ParameterType.Type));
methodGenerator.call(Metadata.GetParameterGenericType(method.ParameterType.Type).ClientSocketSenderCallOnlyMethod);
}
#endregion
methodGenerator.Emit(OpCodes.Ret);
}
else
{
Label clientExceptionLabel = methodGenerator.DefineLabel(), returnLable = methodGenerator.DefineLabel(), returnReturnValueLable, returnValueLable;
LocalBuilder returnReturnValueLocalBuilder, returnValueLocalBuilder;
if (method.ReturnValueType == null)
{
returnReturnValueLocalBuilder = null;
returnReturnValueLable = default(Label);
}
else
{
returnReturnValueLocalBuilder = methodGenerator.DeclareLocal(method.ReturnValueType);
returnReturnValueLable = methodGenerator.DefineLabel();
}
if (method.ReturnValueType == null && method.ReturnType != typeof(void))
{
returnValueLocalBuilder = methodGenerator.DeclareLocal(method.ReturnType);
returnValueLable = methodGenerator.DefineLabel();
}
else
{
returnValueLocalBuilder = null;
returnValueLable = default(Label);
}
#region AutoCSer.Net.TcpServer.AutoWaitReturnValue<TcpInternalServer.@OutputParameterTypeName> _wait_ = _TcpClient_.GetAutoWait<TcpInternalServer.@OutputParameterTypeName>();
Type waitType = method.OutputParameterType == null ? typeof(AutoCSer.Net.TcpServer.AutoWaitReturnValue) : typeof(AutoCSer.Net.TcpServer.AutoWaitReturnValue <>).MakeGenericType(method.OutputParameterType.Type);
LocalBuilder waitLocalBuilder = methodGenerator.DeclareLocal(waitType);
methodGenerator.call(method.OutputParameterType == null ? TcpServer.Emit.ClientMetadata.AutoWaitReturnValuePopMethod : waitType.GetMethod("Pop", BindingFlags.Static | BindingFlags.Public));
methodGenerator.Emit(OpCodes.Stloc_S, waitLocalBuilder);
#endregion
#region try
methodGenerator.BeginExceptionBlock();
#endregion
Label leaveTryLabel = methodGenerator.DefineLabel();
LocalBuilder senderLocalBuilder = methodGenerator.DeclareLocal(Metadata.SenderType);
parameterIndex = 0;
if (method.Attribute.IsVerifyMethod)
{
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (parameter.ParameterType == Metadata.SenderType)
{
#region AutoCSer.Net.TcpInternalServer.ClientSocketSender _socket_ = _sender_;
methodGenerator.ldarg(parameterIndex);
methodGenerator.Emit(OpCodes.Stloc_S, senderLocalBuilder);
#endregion
parameterIndex = int.MinValue;
break;
}
}
}
if (parameterIndex != int.MinValue)
{
#region AutoCSer.Net.TcpInternalServer.ClientSocketSender _socket_ = _TcpClient_.Sender;
methodGenerator.Emit(OpCodes.Ldarg_0);
methodGenerator.call(Metadata.MethodClientGetTcpClientMethod);
methodGenerator.call(Metadata.ClientGetSenderMethod);
methodGenerator.Emit(OpCodes.Stloc_S, senderLocalBuilder);
#endregion
}
#region if (_socket_ != null)
methodGenerator.Emit(OpCodes.Ldloc_S, senderLocalBuilder);
methodGenerator.Emit(method.ParameterType == null ? OpCodes.Brfalse_S : OpCodes.Brfalse, leaveTryLabel);
#endregion
LocalBuilder inputParameterLocalBuilder;
if (method.ParameterType == null)
{
inputParameterLocalBuilder = null;
}
else
{
#region TcpInternalServer.@InputParameterTypeName _inputParameter_ = new TcpInternalServer.@InputParameterTypeName { @ParameterName = @ParameterName };
inputParameterLocalBuilder = methodGenerator.DeclareLocal(method.ParameterType.Type);
LocalBuilder newInputParameterLocalBuilder = methodGenerator.DeclareLocal(method.ParameterType.Type);
if (method.Attribute.IsInitobj || method.ParameterType.IsInitobj)
{
methodGenerator.Emit(OpCodes.Ldloca_S, newInputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Initobj, method.ParameterType.Type);
}
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (StreamParameterType.IsInputParameter(parameter))
{
methodGenerator.parameterToStructField(parameter, parameterIndex, newInputParameterLocalBuilder, method.ParameterType.GetField(parameter.Name));
}
}
methodGenerator.Emit(OpCodes.Ldloc_S, newInputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Stloc_S, inputParameterLocalBuilder);
#endregion
}
if (method.OutputParameterType == null)
{
#region AutoCSer.Net.TcpServer.ReturnType _returnType_ = _socket_.WaitCall(@MethodIdentityCommand, ref _wait_, ref _inputParameter_);
LocalBuilder returnTypeLocalBuilder = methodGenerator.DeclareLocal(typeof(AutoCSer.Net.TcpServer.ReturnType));
methodGenerator.Emit(OpCodes.Ldloc_S, senderLocalBuilder);
methodGenerator.Emit(OpCodes.Ldsfld, commandInfoFieldBuilder);
methodGenerator.Emit(OpCodes.Ldloca_S, waitLocalBuilder);
if (method.ParameterType == null)
{
methodGenerator.call(Metadata.ClientSocketSenderWaitCallMethod);
}
else
{
methodGenerator.Emit(OpCodes.Ldloca_S, inputParameterLocalBuilder);
//methodGenerator.call(Metadata.ClientSocketSenderWaitCallInputMethod.MakeGenericMethod(method.ParameterType.Type));
methodGenerator.call(Metadata.GetParameterGenericType(method.ParameterType.Type).ClientSocketSenderWaitCallMethod);
}
methodGenerator.Emit(OpCodes.Stloc_S, returnTypeLocalBuilder);
#endregion
if (method.ReturnValueType == null)
{
Label throwReturnTypeLabel = methodGenerator.DefineLabel();
#region if (_returnType_ == AutoCSer.Net.TcpServer.ReturnType.Success) return;
methodGenerator.Emit(OpCodes.Ldloc_S, returnTypeLocalBuilder);
methodGenerator.int32((byte)AutoCSer.Net.TcpServer.ReturnType.Success);
methodGenerator.Emit(OpCodes.Bne_Un_S, throwReturnTypeLabel);
methodGenerator.Emit(OpCodes.Leave_S, returnLable);
#endregion
methodGenerator.MarkLabel(throwReturnTypeLabel);
#region throw new Exception(AutoCSer.Net.TcpInternalServer.Emit.Client.ReturnTypeStrings[(byte)_returnType_]);
methodGenerator.Emit(OpCodes.Ldsfld, TcpServer.Emit.ClientMetadata.ReturnTypeStringsField);
methodGenerator.Emit(OpCodes.Ldloc_S, returnTypeLocalBuilder);
methodGenerator.Emit(OpCodes.Ldelem_Ref);
methodGenerator.Emit(OpCodes.Newobj, AutoCSer.Extension.EmitGenerator.StringExceptionConstructor);
methodGenerator.Emit(OpCodes.Throw);
#endregion
}
else
{
#region return new AutoCSer.Net.TcpServer.ReturnValue { Type = _returnType_ };
//methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
//methodGenerator.Emit(OpCodes.Initobj, method.ReturnValueType);
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Ldloc_S, returnTypeLocalBuilder);
methodGenerator.Emit(OpCodes.Stfld, TcpServer.Emit.ClientMetadata.ReturnValueTypeField);
methodGenerator.Emit(OpCodes.Leave, returnReturnValueLable);
#endregion
}
}
else
{
#region TcpInternalServer.@OutputParameterTypeName _outputParameter_ = new TcpInternalServer.@OutputParameterTypeName { @ParameterName = @ParameterName };
LocalBuilder outputParameterLocalBuilder = methodGenerator.DeclareLocal(method.OutputParameterType.Type);
if (method.Attribute.IsInitobj || method.OutputParameterType.IsInitobj)
{
methodGenerator.Emit(OpCodes.Ldloca_S, outputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Initobj, method.OutputParameterType.Type);
}
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (parameter.ParameterType.IsByRef)
{
methodGenerator.parameterToStructField(parameter, parameterIndex, outputParameterLocalBuilder, method.OutputParameterType.GetField(parameter.Name));
}
}
//if (method.ReturnInputParameter != null)
//{
//}
#endregion
#region AutoCSer.Net.TcpServer.ReturnType _returnType_ = _socket_.WaitGet<TcpInternalServer.@InputParameterTypeName, TcpInternalServer.@OutputParameterTypeName>(@MethodIdentityCommand, ref _wait_, ref _inputParameter_, ref _outputParameter_);
LocalBuilder returnTypeLocalBuilder = methodGenerator.DeclareLocal(typeof(AutoCSer.Net.TcpServer.ReturnType));
methodGenerator.Emit(OpCodes.Ldloc_S, senderLocalBuilder);
methodGenerator.Emit(OpCodes.Ldsfld, commandInfoFieldBuilder);
methodGenerator.Emit(OpCodes.Ldloca_S, waitLocalBuilder);
if (method.ParameterType == null)
{
methodGenerator.Emit(OpCodes.Ldloca_S, outputParameterLocalBuilder);
//methodGenerator.call(Metadata.ClientSocketSenderWaitGetMethod.MakeGenericMethod(method.OutputParameterType.Type));
methodGenerator.call(Metadata.GetParameterGenericType(method.OutputParameterType.Type).ClientSocketSenderWaitGetMethod);
}
else
{
methodGenerator.Emit(OpCodes.Ldloca_S, inputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Ldloca_S, outputParameterLocalBuilder);
//methodGenerator.call(Metadata.ClientSocketSenderWaitGetInputMethod.MakeGenericMethod(method.ParameterType.Type, method.OutputParameterType.Type));
methodGenerator.call(Metadata.GetParameterGenericType2(method.ParameterType.Type, method.OutputParameterType.Type).ClientSocketSenderWaitGetMethod);
}
methodGenerator.Emit(OpCodes.Stloc_S, returnTypeLocalBuilder);
#endregion
if (method.ReturnValueType == null)
{
Label throwReturnTypeLabel = methodGenerator.DefineLabel();
#region if (_returnType_ == AutoCSer.Net.TcpServer.ReturnType.Success)
methodGenerator.Emit(OpCodes.Ldloc_S, returnTypeLocalBuilder);
methodGenerator.int32((byte)AutoCSer.Net.TcpServer.ReturnType.Success);
methodGenerator.Emit(OpCodes.Bne_Un, throwReturnTypeLabel);
#endregion
#region @ParameterName = _outputParameter_.@ParameterName;
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (parameter.ParameterType.IsByRef)
{
methodGenerator.outParameterFromValueField(parameter, parameterIndex, outputParameterLocalBuilder, method.OutputParameterType.GetField(parameter.Name));
}
}
#endregion
if (method.ReturnType == typeof(void))
{
#region return;
methodGenerator.Emit(OpCodes.Leave_S, returnLable);
#endregion
}
else
{
#region return _outputParameter_.Ret;
methodGenerator.Emit(OpCodes.Ldloca_S, outputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Ldfld, method.OutputParameterType.GetField(TcpServer.ReturnValue.RetParameterName));
methodGenerator.Emit(OpCodes.Stloc_S, returnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Leave_S, returnValueLable);
#endregion
}
methodGenerator.MarkLabel(throwReturnTypeLabel);
#region throw new Exception(AutoCSer.Net.TcpServer.Emit.Client.ReturnTypeStrings[(byte)_returnType_]);
methodGenerator.Emit(OpCodes.Ldsfld, TcpServer.Emit.ClientMetadata.ReturnTypeStringsField);
methodGenerator.Emit(OpCodes.Ldloc_S, returnTypeLocalBuilder);
methodGenerator.Emit(OpCodes.Ldelem_Ref);
methodGenerator.Emit(OpCodes.Newobj, AutoCSer.Extension.EmitGenerator.StringExceptionConstructor);
methodGenerator.Emit(OpCodes.Throw);
#endregion
}
else
{
#region @ParameterName = _outputParameter_.@ParameterName;
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (parameter.ParameterType.IsByRef)
{
methodGenerator.outParameterFromValueField(parameter, parameterIndex, outputParameterLocalBuilder, method.OutputParameterType.GetField(parameter.Name));
}
}
#endregion
#region return new AutoCSer.Net.TcpServer.ReturnValue<@MethodReturnType.FullName> { Type = _returnType_, Value = _outputParameter_.Return };
if (method.ReturnType != typeof(void) && (method.Attribute.IsInitobj || method.ReturnType.isInitobj()))
{
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Initobj, method.ReturnValueType);
}
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Ldloc_S, returnTypeLocalBuilder);
methodGenerator.Emit(OpCodes.Stfld, method.ReturnType == typeof(void) ? TcpServer.Emit.ClientMetadata.ReturnValueTypeField : method.ReturnValueType.GetField(TcpServer.Emit.ClientMetadata.ReturnValueTypeField.Name, BindingFlags.Instance | BindingFlags.Public));
if (method.ReturnType != typeof(void))
{
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Ldloca_S, outputParameterLocalBuilder);
methodGenerator.Emit(OpCodes.Ldfld, method.OutputParameterType.GetField(ReturnValue.RetParameterName));
methodGenerator.Emit(OpCodes.Stfld, method.ReturnValueType.GetField("Value", BindingFlags.Instance | BindingFlags.Public));
}
methodGenerator.Emit(OpCodes.Leave, returnReturnValueLable);
#endregion
}
}
methodGenerator.MarkLabel(leaveTryLabel);
methodGenerator.Emit(OpCodes.Leave_S, clientExceptionLabel);
#region finally
methodGenerator.BeginFinallyBlock();
#endregion
Label endfinallyLabel = methodGenerator.DefineLabel();
#region if (_wait_ != null)
methodGenerator.Emit(OpCodes.Ldloc_S, waitLocalBuilder);
methodGenerator.Emit(OpCodes.Brfalse_S, endfinallyLabel);
#endregion
#region AutoCSer.Net.TcpServer.AutoWaitReturnValue<TcpInternalServer.@OutputParameterTypeName>.PushNotNull(_wait_);
methodGenerator.Emit(OpCodes.Ldloc_S, waitLocalBuilder);
if (method.OutputParameterType == null)
{
methodGenerator.call(TcpServer.Emit.ClientMetadata.AutoWaitReturnValuePushNotNullMethod);
}
else
{
Type autoWaitReturnValueType = typeof(AutoCSer.Net.TcpServer.AutoWaitReturnValue <>).MakeGenericType(method.OutputParameterType.Type);
methodGenerator.call(autoWaitReturnValueType.GetMethod(TcpServer.Emit.ClientMetadata.AutoWaitReturnValuePushNotNullMethod.Name, BindingFlags.Static | BindingFlags.Public, null, new Type[] { autoWaitReturnValueType }, null));
}
#endregion
methodGenerator.MarkLabel(endfinallyLabel);
methodGenerator.Emit(OpCodes.Endfinally);
#region try end
methodGenerator.EndExceptionBlock();
#endregion
methodGenerator.MarkLabel(clientExceptionLabel);
if (method.ReturnValueType == null)
{
#region throw new Exception(AutoCSer.Net.TcpServer.ReturnType.ClientException.ToString());
methodGenerator.throwString(AutoCSer.Net.TcpServer.ReturnType.ClientException.ToString());
#endregion
methodGenerator.MarkLabel(returnLable);
methodGenerator.Emit(OpCodes.Ret);
if (method.ReturnType != typeof(void))
{
methodGenerator.MarkLabel(returnValueLable);
#region @MethodReturnType.FullName
methodGenerator.Emit(OpCodes.Ldloc_S, returnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Ret);
#endregion
}
}
else
{
#region @ParameterName = default(@ParameterType.FullName);
parameterIndex = 0;
foreach (ParameterInfo parameter in parameters)
{
++parameterIndex;
if (parameter.IsOut)
{
methodGenerator.outParameterDefault(parameter, parameterIndex, method.Attribute.IsInitobj);
}
}
#endregion
#region return new AutoCSer.Net.TcpServer.ReturnValue<@MethodReturnType.FullName> { Type = AutoCSer.Net.TcpServer.ReturnType.ClientException };
if (method.ReturnType != typeof(void) && (method.Attribute.IsInitobj || method.ReturnType.isInitobj()))
{
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.Emit(OpCodes.Initobj, method.ReturnValueType);
}
methodGenerator.Emit(OpCodes.Ldloca_S, returnReturnValueLocalBuilder);
methodGenerator.int32((byte)AutoCSer.Net.TcpServer.ReturnType.ClientException);
methodGenerator.Emit(OpCodes.Stfld, method.ReturnType == typeof(void) ? TcpServer.Emit.ClientMetadata.ReturnValueTypeField : method.ReturnValueType.GetField(TcpServer.Emit.ClientMetadata.ReturnValueTypeField.Name, BindingFlags.Instance | BindingFlags.Public));
methodGenerator.MarkLabel(returnReturnValueLable);
methodGenerator.Emit(OpCodes.Ldloc_S, returnReturnValueLocalBuilder);
methodGenerator.MarkLabel(returnLable);
methodGenerator.Emit(OpCodes.Ret);
#endregion
}
}
}
else if (method.IsPropertySetMethod)
{
if (method.PropertyBuilder != null || method.PropertyGetMethod == null)
{
ParameterInfo[] parameters = method.MethodInfo.GetParameters();
PropertyBuilder propertyBuilder = method.PropertyBuilder ?? typeBuilder.DefineProperty(method.PropertyInfo.Name, PropertyAttributes.HasDefault, parameters[parameters.Length - 1].ParameterType, new LeftArray <ParameterInfo> {
Array = parameters, Length = parameters.Length - 1
}.GetArray(parameter => parameter.ParameterType));
MethodBuilder setMethodBuilder = typeBuilder.DefineMethod(method.MethodInfo.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual, method.MethodInfo.ReturnType, parameters.getArray(parameter => parameter.ParameterType));
ILGenerator methodGenerator = setMethodBuilder.GetILGenerator();
//XXX
propertyBuilder.SetSetMethod(setMethodBuilder);
method.PropertyBuilder = null;
}
}
else
{
Type[] parameterTypes = method.MethodInfo.GetParameters().getArray(parameter => parameter.ParameterType);
PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(method.PropertyInfo.Name, PropertyAttributes.HasDefault, method.MethodInfo.ReturnType, parameterTypes);
MethodBuilder getMethodBuilder = typeBuilder.DefineMethod(method.MethodInfo.Name, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual, method.MethodInfo.ReturnType, parameterTypes);
ILGenerator methodGenerator = getMethodBuilder.GetILGenerator();
//XXX
propertyBuilder.SetGetMethod(getMethodBuilder);
if (method.PropertySetMethod != null)
{
method = method.PropertySetMethod;
method.PropertyBuilder = propertyBuilder;
goto METHOD;
}
}
}
}
staticConstructorGenerator.Emit(OpCodes.Ret);
return(typeBuilder.CreateType());
}
private void GeneratePropertySetter
(
[NotNull] IntrospectivePropertyInfo property,
[NotNull] FieldInfo propertyFieldBuilder,
[NotNull] PropertyBuilder propertyBuilder
)
{
var wrappedProperty = property.GetWrappedMember();
var actualSetMethod = wrappedProperty.GetSetMethod();
var setterMethod = TargetType.DefineMethod
(
actualSetMethod.Name,
PropertyMethodAttributes,
actualSetMethod.CallingConvention,
typeof(void),
actualSetMethod.GetParameters().Select(p => p.ParameterType).ToArray()
);
MethodInfo underlyingMethod;
if (property.PropertyType.IsPointer)
{
underlyingMethod = typeof(Marshal).GetMethods().First
(
m =>
m.Name == nameof(Marshal.WriteIntPtr) &&
m.GetParameters().Length == 3
);
}
else if (property.PropertyType.IsValueType)
{
underlyingMethod = typeof(Marshal).GetMethods().First
(
m =>
m.Name == nameof(Marshal.StructureToPtr) &&
m.GetParameters().Length == 3 &&
m.IsGenericMethod
)
.MakeGenericMethod(property.PropertyType);
}
else
{
throw new NotSupportedException
(
$"The type \"{property.PropertyType.FullName}\" is not supported. Only value types or pointers are supported."
);
}
var setterIL = setterMethod.GetILGenerator();
if (Options.HasFlagFast(GenerateDisposalChecks))
{
EmitDisposalCheck(setterIL);
}
if (property.PropertyType.IsPointer)
{
var explicitConvertToIntPtrFunc = typeof(IntPtr).GetMethods().First
(
m =>
m.Name == "op_Explicit"
);
GenerateSymbolPush(setterIL, propertyFieldBuilder); // Push Symbol address to stack
setterIL.Emit(OpCodes.Ldc_I4, 0); // Push 0 offset to stack
setterIL.Emit(OpCodes.Ldarg_1); // Push value to stack
setterIL.EmitCall(OpCodes.Call, explicitConvertToIntPtrFunc, null); // Explicit Convert Pointer to IntPtr object
}
else
{
setterIL.Emit(OpCodes.Ldarg_1);
GenerateSymbolPush(setterIL, propertyFieldBuilder);
setterIL.Emit(OpCodes.Ldc_I4, 0); // false for deleting structure that is already stored in pointer
}
setterIL.EmitCall
(
OpCodes.Call,
underlyingMethod,
null
);
setterIL.Emit(OpCodes.Ret);
propertyBuilder.SetSetMethod(setterMethod);
TargetType.DefineMethodOverride(setterMethod, actualSetMethod);
}
private void AssertIsGeneric(PropertyBuilder<string> _)
{
}
private void VisitComputedValue(PropertyBuilder propertyBuilder, ColumnModel column)
{
if (column.ComputedValue != null)
{
((Property)propertyBuilder.Metadata).SetValueGenerated(null, ConfigurationSource.Explicit);
propertyBuilder.Metadata.Relational().ComputedColumnSql = null;
var computedExpression = ConvertSqlServerDefaultValue(column.ComputedValue);
if (computedExpression != null)
{
if (!(computedExpression == "NULL"
&& propertyBuilder.Metadata.ClrType.IsNullableType()))
{
propertyBuilder.HasComputedColumnSql(computedExpression);
}
}
else
{
Logger.LogWarning(
SqlServerDesignStrings.CannotInterpretComputedValue(
column.DisplayName,
column.ComputedValue,
propertyBuilder.Metadata.Name,
propertyBuilder.Metadata.DeclaringEntityType.Name));
}
}
}
public NonGenericTestPropertyBuilder(PropertyBuilder propertyBuilder)
{
PropertyBuilder = propertyBuilder;
}
private void AssertIsGeneric(PropertyBuilder <string> _)
{
}
private static SqlServerPropertyBuilderAnnotations GetSqlServerInternalBuilder(PropertyBuilder propertyBuilder) => propertyBuilder.GetInfrastructure <InternalPropertyBuilder>().SqlServer(ConfigurationSource.Explicit);
/// <summary>
/// Configures the column that the property maps to when targeting a relational database.
/// </summary>
/// <typeparam name="TProperty"> The type of the property being configured. </typeparam>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <param name="name"> The name of the column. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static PropertyBuilder <TProperty> HasColumnName <TProperty>(
this PropertyBuilder <TProperty> propertyBuilder,
string?name)
=> (PropertyBuilder <TProperty>)HasColumnName((PropertyBuilder)propertyBuilder, name);
public static Type BuildDynamicTypeWithProperties()
{
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "MyDynamicAssembly";
// To generate a persistable assembly, specify AssemblyBuilderAccess.RunAndSave.
AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.RunAndSave);
// Generate a persistable single-module assembly.
ModuleBuilder myModBuilder = myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");
TypeBuilder myTypeBuilder = myModBuilder.DefineType("CustomerData", TypeAttributes.Public);
FieldBuilder customerNameBldr = myTypeBuilder.DefineField("customerName", typeof(string), FieldAttributes.Private);
// 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 an array with no elements: new Type[] {})
PropertyBuilder custNamePropBldr = myTypeBuilder.DefineProperty("CustomerName",
PropertyAttributes.HasDefault,
typeof(string),
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 CustomerName.
MethodBuilder custNameGetPropMthdBldr =
myTypeBuilder.DefineMethod("get_CustomerName",
getSetAttr,
typeof(string),
Type.EmptyTypes);
ILGenerator custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();
custNameGetIL.Emit(OpCodes.Ldarg_0);
custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);
custNameGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for CustomerName.
MethodBuilder custNameSetPropMthdBldr =
myTypeBuilder.DefineMethod("set_CustomerName",
getSetAttr,
null,
new Type[] { typeof(string) });
ILGenerator custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();
custNameSetIL.Emit(OpCodes.Ldarg_0);
custNameSetIL.Emit(OpCodes.Ldarg_1);
custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);
custNameSetIL.Emit(OpCodes.Ret);
// Last, we must map the two methods created above to our PropertyBuilder to
// their corresponding behaviors, "get" and "set" respectively.
custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);
custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);
Type retval = myTypeBuilder.CreateType();
// Save the assembly so it can be examined with Ildasm.exe,
// or referenced by a test program.
myAsmBuilder.Save(myAsmName.Name + ".dll");
return(retval);
}
private void GeneratePropertyGetter
(
[NotNull] IntrospectivePropertyInfo property,
[NotNull] FieldInfo propertyFieldBuilder,
[NotNull] PropertyBuilder propertyBuilder
)
{
var wrappedProperty = property.GetWrappedMember();
var actualGetMethod = wrappedProperty.GetGetMethod();
var getterMethod = TargetType.DefineMethod
(
actualGetMethod.Name,
PropertyMethodAttributes,
actualGetMethod.CallingConvention,
actualGetMethod.ReturnType,
Type.EmptyTypes
);
MethodInfo underlyingMethod;
if (property.PropertyType.IsPointer)
{
underlyingMethod = typeof(Marshal).GetMethods().First
(
m =>
m.Name == nameof(Marshal.ReadIntPtr) &&
m.GetParameters().Length == 1
);
}
else if (property.PropertyType.IsValueType)
{
underlyingMethod = typeof(Marshal).GetMethods().First
(
m =>
m.Name == nameof(Marshal.PtrToStructure) &&
m.GetParameters().Length == 1 &&
m.IsGenericMethod
)
.MakeGenericMethod(property.PropertyType);
}
else
{
throw new NotSupportedException
(
$"The type \"{property.PropertyType.FullName}\" is not supported. Only value types or pointers are supported."
);
}
var getterIL = getterMethod.GetILGenerator();
if (Options.HasFlagFast(GenerateDisposalChecks))
{
EmitDisposalCheck(getterIL);
}
GenerateSymbolPush(getterIL, propertyFieldBuilder);
getterIL.EmitCall
(
OpCodes.Call,
underlyingMethod,
null
);
getterIL.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getterMethod);
TargetType.DefineMethodOverride(getterMethod, actualGetMethod);
}
private PropertyBuilder VisitTypeMapping(PropertyBuilder propertyBuilder, ColumnModel column)
{
if (column.IsIdentity == true)
{
if (typeof(byte) == propertyBuilder.Metadata.ClrType)
{
Logger.LogWarning(
SqlServerDesignStrings.DataTypeDoesNotAllowSqlServerIdentityStrategy(
column.DisplayName, column.DataType));
}
else
{
propertyBuilder
.ValueGeneratedOnAdd()
.UseSqlServerIdentityColumn();
}
}
if (_dateTimePrecisionTypes.Contains(column.DataType)
&& column.Scale.HasValue
&& column.Scale != DefaultDateTimePrecision)
{
propertyBuilder.Metadata.SetMaxLength(null);
propertyBuilder.HasColumnType($"{column.DataType}({column.Scale})"); //not a typo: .Scale is the right property for datetime precision
}
// undo quirk in reverse type mapping to litters code with unnecessary nvarchar annotations
if (typeof(string) == propertyBuilder.Metadata.ClrType
&& propertyBuilder.Metadata.Relational().ColumnType == "nvarchar")
{
propertyBuilder.Metadata.Relational().ColumnType = null;
}
return propertyBuilder;
}
public PropertyGeneratedBuilder(PropertyBuilder parent, Action<string> setter)
{
this.parent = parent;
this.setter = setter;
}
static ConstructorInfo DefineIgnoresAccessChecksToAttribute(ModuleBuilder mb)
{
TypeBuilder attributeTypeBuilder =
mb.DefineType("System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute",
TypeAttributes.Public | TypeAttributes.Class,
typeof(Attribute));
// Create backing field as:
// private string assemblyName;
FieldBuilder assemblyNameField =
attributeTypeBuilder.DefineField("assemblyName", typeof(string), FieldAttributes.Private);
// Create ctor as:
// public IgnoresAccessChecksToAttribute(string)
ConstructorBuilder constructorBuilder = attributeTypeBuilder.DefineConstructor(MethodAttributes.Public,
CallingConventions.HasThis,
new Type[] { assemblyNameField.FieldType });
ILGenerator il = constructorBuilder.GetILGenerator();
// Create ctor body as:
// this.assemblyName = {ctor parameter 0}
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg, 1);
il.Emit(OpCodes.Stfld, assemblyNameField);
// return
il.Emit(OpCodes.Ret);
// Define property as:
// public string AssemblyName {get { return this.assemblyName; } }
PropertyBuilder propertyBuilder = attributeTypeBuilder.DefineProperty(
"AssemblyName",
PropertyAttributes.None,
CallingConventions.HasThis,
returnType: typeof(string),
parameterTypes: null);
MethodBuilder getterMethodBuilder = attributeTypeBuilder.DefineMethod(
"get_AssemblyName",
MethodAttributes.Public,
CallingConventions.HasThis,
returnType: typeof(string),
parameterTypes: null);
propertyBuilder.SetGetMethod(getterMethodBuilder);
// Generate body:
// return this.assemblyName;
il = getterMethodBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, assemblyNameField);
il.Emit(OpCodes.Ret);
// Generate the AttributeUsage attribute for this attribute type:
// [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
TypeInfo attributeUsageTypeInfo = typeof(AttributeUsageAttribute).GetTypeInfo();
// Find the ctor that takes only AttributeTargets
ConstructorInfo attributeUsageConstructorInfo =
attributeUsageTypeInfo.DeclaredConstructors
.Single(c => c.GetParameters().Length == 1 &&
c.GetParameters()[0].ParameterType == typeof(AttributeTargets));
// Find the property to set AllowMultiple
PropertyInfo allowMultipleProperty =
attributeUsageTypeInfo.DeclaredProperties
.Single(f => string.Equals(f.Name, "AllowMultiple"));
// Create a builder to construct the instance via the ctor and property
CustomAttributeBuilder customAttributeBuilder =
new CustomAttributeBuilder(attributeUsageConstructorInfo,
new object[] { AttributeTargets.Assembly },
new PropertyInfo[] { allowMultipleProperty },
new object[] { true });
// Attach this attribute instance to the newly defined attribute type
attributeTypeBuilder.SetCustomAttribute(customAttributeBuilder);
// Make the TypeInfo real so the constructor can be used.
return(attributeTypeBuilder.CreateTypeInfo().DeclaredConstructors.Single());
}
public void Init()
{
_MemberInfo = A.Fake<IMemberInfo>();
_Builder = new PropertyBuilder<string, object>(_MemberInfo);
}
/// <summary>
/// Configures the key property to use the SQL Server IDENTITY feature to generate values for new entities,
/// when targeting SQL Server. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
/// </summary>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <param name="seed"> The value that is used for the very first row loaded into the table. </param>
/// <param name="increment"> The incremental value that is added to the identity value of the previous row that was loaded. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static PropertyBuilder UseIdentityColumn(
this PropertyBuilder propertyBuilder,
int seed,
int increment = 1)
=> propertyBuilder.UseIdentityColumn((long)seed, increment);
internal override void Apply(ClassLoaderWrapper loader, PropertyBuilder pb, object annotation)
{
Annotation annot = type.Annotation;
foreach (object ann in UnwrapArray(annotation))
{
annot.Apply(loader, pb, ann);
}
}
/// <summary>
/// Configures the key property to use the SQL Server IDENTITY feature to generate values for new entities,
/// when targeting SQL Server. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
/// </summary>
/// <typeparam name="TProperty"> The type of the property being configured. </typeparam>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <param name="seed"> The value that is used for the very first row loaded into the table. </param>
/// <param name="increment"> The incremental value that is added to the identity value of the previous row that was loaded. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static PropertyBuilder <TProperty> UseIdentityColumn <TProperty>(
this PropertyBuilder <TProperty> propertyBuilder,
int seed,
int increment = 1)
=> (PropertyBuilder <TProperty>)UseIdentityColumn((PropertyBuilder)propertyBuilder, (long)seed, increment);
protected void DefineBuilders (MemberKind kind, ParametersCompiled parameters)
{
PropertyBuilder = Parent.TypeBuilder.DefineProperty (
GetFullName (MemberName), PropertyAttributes.None,
#if !BOOTSTRAP_BASIC // Requires trunk version mscorlib
IsStatic ? 0 : CallingConventions.HasThis,
#endif
MemberType.GetMetaInfo (), null, null,
parameters.GetMetaInfo (), null, null);
PropertySpec spec;
if (kind == MemberKind.Indexer)
spec = new IndexerSpec (Parent.Definition, this, MemberType, parameters, PropertyBuilder, ModFlags);
else
spec = new PropertySpec (kind, Parent.Definition, this, MemberType, PropertyBuilder, ModFlags);
if (Get != null) {
spec.Get = Get.Spec;
var method = Get.Spec.GetMetaInfo () as MethodBuilder;
if (method != null) {
PropertyBuilder.SetGetMethod (method);
Parent.MemberCache.AddMember (this, method.Name, Get.Spec);
}
} else {
CheckMissingAccessor (kind, parameters, true);
}
if (Set != null) {
spec.Set = Set.Spec;
var method = Set.Spec.GetMetaInfo () as MethodBuilder;
if (method != null) {
PropertyBuilder.SetSetMethod (method);
Parent.MemberCache.AddMember (this, method.Name, Set.Spec);
}
} else {
CheckMissingAccessor (kind, parameters, false);
}
Parent.MemberCache.AddMember (this, PropertyBuilder.Name, spec);
}
/// <summary>
/// Configures whether the property's column is created as sparse when targeting SQL Server.
/// </summary>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <param name="sparse"> A value indicating whether the property's column is created as sparse. </param>
/// <returns> A builder to further configure the property. </returns>
/// <remarks> See https://docs.microsoft.com/sql/relational-databases/tables/use-sparse-columns. </remarks>
public static PropertyBuilder <TProperty> IsSparse <TProperty>(
this PropertyBuilder <TProperty> propertyBuilder,
bool sparse = true)
=> (PropertyBuilder <TProperty>)IsSparse((PropertyBuilder)propertyBuilder, sparse);
private static void AttachAssociationAttribute(Relationship relationship, string propertyName, PropertyBuilder propertyBuilder)
{
////[Association(Member = "Orders", KeyMembers = "CustomerID", RelatedEntityID = "Orders", RelatedKeyMembers = "CustomerID")]
//PropertyInfo memberInfo = typeof(AssociationAttribute).GetProperty("Member");
//PropertyInfo keyMembersInfo = typeof(AssociationAttribute).GetProperty("KeyMembers");
//PropertyInfo relatedEntityIDInfo = typeof(AssociationAttribute).GetProperty("RelatedEntityID");
//PropertyInfo relatedKeyMembers = typeof(AssociationAttribute).GetProperty("RelatedKeyMembers");
//CustomAttributeBuilder associationBuilder = new CustomAttributeBuilder(
// typeof(AssociationAttribute).GetConstructor(Type.EmptyTypes),
// new object[0], new[] { memberInfo, keyMembersInfo, relatedEntityIDInfo, relatedKeyMembers },
// new object[]
// {
// propertyName, relationship.ReferencingAttribute.PhysicalName,
// relationship.ReferencedEntity.PhysicalName, relationship.ReferencedAttribute.PhysicalName
// });
//propertyBuilder.SetCustomAttribute(associationBuilder);
}
/// <summary>
/// Configures the key property to use a sequence-based hi-lo pattern to generate values for new entities,
/// when targeting SQL Server. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
/// </summary>
/// <typeparam name="TProperty"> The type of the property being configured. </typeparam>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <param name="name"> The name of the sequence. </param>
/// <param name="schema"> The schema of the sequence. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static PropertyBuilder <TProperty> UseHiLo <TProperty>(
this PropertyBuilder <TProperty> propertyBuilder,
string?name = null,
string?schema = null)
=> (PropertyBuilder <TProperty>)UseHiLo((PropertyBuilder)propertyBuilder, name, schema);
public bool EmitMember(
TypeBuilder typeBuilder, EdmMember member, PropertyBuilder propertyBuilder, PropertyInfo baseProperty,
BaseProxyImplementor baseImplementor)
{
if (_members.Contains(member))
{
var baseGetter = baseProperty.GetGetMethod(true);
const MethodAttributes getterAttributes =
MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.Virtual;
var getterAccess = baseGetter.Attributes & MethodAttributes.MemberAccessMask;
// Define field to store interceptor Func
// Signature of interceptor Func delegate is as follows:
//
// bool intercept(ProxyType proxy, PropertyType propertyValue)
//
// where
// PropertyType is the type of the Property, such as ICollection<Customer>,
// ProxyType is the type of the proxy object,
// propertyValue is the value returned from the proxied type's property getter.
var interceptorType = typeof(Func <, ,>).MakeGenericType(typeBuilder, baseProperty.PropertyType, typeof(bool));
var interceptorInvoke = TypeBuilder.GetMethod(interceptorType, typeof(Func <, ,>).GetMethod("Invoke"));
var interceptorField = typeBuilder.DefineField(
GetInterceptorFieldName(baseProperty.Name), interceptorType, FieldAttributes.Private | FieldAttributes.Static);
// Define a property getter override in the proxy type
var getterBuilder = typeBuilder.DefineMethod(
"get_" + baseProperty.Name, getterAccess | getterAttributes, baseProperty.PropertyType, Type.EmptyTypes);
var generator = getterBuilder.GetILGenerator();
// Emit instructions for the following call:
// T value = base.SomeProperty;
// if(this._interceptorForSomeProperty(this, value))
// { return value; }
// return base.SomeProperty;
// where _interceptorForSomeProperty represents the interceptor Func field.
var lableTrue = generator.DefineLabel();
generator.DeclareLocal(baseProperty.PropertyType); // T value
generator.Emit(OpCodes.Ldarg_0); // call base.SomeProperty
generator.Emit(OpCodes.Call, baseGetter); // call to base property getter
generator.Emit(OpCodes.Stloc_0); // value = result
generator.Emit(OpCodes.Ldarg_0); // load this
generator.Emit(OpCodes.Ldfld, interceptorField); // load this._interceptor
generator.Emit(OpCodes.Ldarg_0); // load this
generator.Emit(OpCodes.Ldloc_0); // load value
generator.Emit(OpCodes.Callvirt, interceptorInvoke); // call to interceptor delegate with (this, value)
generator.Emit(OpCodes.Brtrue_S, lableTrue); // if true, just return
generator.Emit(OpCodes.Ldarg_0); // else, call the base propertty getter again
generator.Emit(OpCodes.Call, baseGetter); // call to base property getter
generator.Emit(OpCodes.Ret);
generator.MarkLabel(lableTrue);
generator.Emit(OpCodes.Ldloc_0);
generator.Emit(OpCodes.Ret);
propertyBuilder.SetGetMethod(getterBuilder);
baseImplementor.AddBasePropertyGetter(baseProperty);
return(true);
}
return(false);
}
internal void GenerateSerializerContract(string className, XmlMapping[] xmlMappings, Type[] types, string readerType, string[] readMethods, string writerType, string[] writerMethods, Dictionary <string, string> serializers)
{
TypeBuilder serializerContractTypeBuilder = CodeGenerator.CreateTypeBuilder(
_moduleBuilder,
"XmlSerializerContract",
TypeAttributes.Public | TypeAttributes.BeforeFieldInit,
typeof(XmlSerializerImplementation),
Array.Empty <Type>()
);
ilg = new CodeGenerator(serializerContractTypeBuilder);
PropertyBuilder propertyBuilder = serializerContractTypeBuilder.DefineProperty(
"Reader",
PropertyAttributes.None,
typeof(XmlSerializationReader),
null, null, null, null, null);
ilg.BeginMethod(
typeof(XmlSerializationReader),
"get_Reader",
Array.Empty <Type>(),
Array.Empty <string>(),
CodeGenerator.PublicOverrideMethodAttributes | MethodAttributes.SpecialName);
propertyBuilder.SetGetMethod(ilg.MethodBuilder);
ConstructorInfo ctor = CreatedTypes[readerType].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
ilg.New(ctor);
ilg.EndMethod();
ilg = new CodeGenerator(serializerContractTypeBuilder);
propertyBuilder = serializerContractTypeBuilder.DefineProperty(
"Writer",
PropertyAttributes.None,
typeof(XmlSerializationWriter),
null, null, null, null, null);
ilg.BeginMethod(
typeof(XmlSerializationWriter),
"get_Writer",
Array.Empty <Type>(),
Array.Empty <string>(),
CodeGenerator.PublicOverrideMethodAttributes | MethodAttributes.SpecialName);
propertyBuilder.SetGetMethod(ilg.MethodBuilder);
ctor = CreatedTypes[writerType].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
ilg.New(ctor);
ilg.EndMethod();
FieldBuilder readMethodsField = GeneratePublicMethods("readMethods", "ReadMethods", readMethods, xmlMappings, serializerContractTypeBuilder);
FieldBuilder writeMethodsField = GeneratePublicMethods("writeMethods", "WriteMethods", writerMethods, xmlMappings, serializerContractTypeBuilder);
FieldBuilder typedSerializersField = GenerateTypedSerializers(serializers, serializerContractTypeBuilder);
GenerateSupportedTypes(types, serializerContractTypeBuilder);
GenerateGetSerializer(serializers, xmlMappings, serializerContractTypeBuilder);
// Default ctor
ConstructorInfo baseCtor = typeof(XmlSerializerImplementation).GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty <Type>()
);
ilg = new CodeGenerator(serializerContractTypeBuilder);
ilg.BeginMethod(
typeof(void),
".ctor",
Array.Empty <Type>(),
Array.Empty <string>(),
CodeGenerator.PublicMethodAttributes | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName
);
ilg.Ldarg(0);
ilg.Load(null);
ilg.StoreMember(readMethodsField);
ilg.Ldarg(0);
ilg.Load(null);
ilg.StoreMember(writeMethodsField);
ilg.Ldarg(0);
ilg.Load(null);
ilg.StoreMember(typedSerializersField);
ilg.Ldarg(0);
ilg.Call(baseCtor);
ilg.EndMethod();
// Instantiate type
Type serializerContractType = serializerContractTypeBuilder.CreateTypeInfo().AsType();
CreatedTypes.Add(serializerContractType.Name, serializerContractType);
}
public Type EmitInterfaceImpl(Type to_be_impl)
{
if (!to_be_impl.IsInterface)
{
throw new InvalidOperationException("interface expected, but got " + to_be_impl);
}
if (!gen_interfaces.Contains(to_be_impl))
{
throw new InvalidCastException("This interface must add to CSharpCallLua: " + to_be_impl);
}
TypeBuilder impl_type_builder = CodeEmitModule.DefineType("XLuaGenInterfaceImpl" + (genID++), TypeAttributes.Public | TypeAttributes.Class, typeof(LuaBase), new Type[] { to_be_impl });
foreach (var member in to_be_impl.GetMembers())
{
if (member.MemberType == MemberTypes.Method)
{
MethodInfo method = member as MethodInfo;
if (method.Name.StartsWith("get_") || method.Name.StartsWith("set_") ||
method.Name.StartsWith("add_") || method.Name.StartsWith("remove_"))
{
continue;
}
var parameters = method.GetParameters();
Type[] param_types = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; ++i)
{
param_types[i] = parameters[i].ParameterType;
}
var method_builder = impl_type_builder.DefineMethod(method.Name,
MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, method.ReturnType, param_types);
for (int i = 0; i < parameters.Length; ++i)
{
method_builder.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
}
ILGenerator g = method_builder.GetILGenerator();
g.DeclareLocal(typeof(RealStatePtr)); //RealStatePtr L; 0
g.DeclareLocal(typeof(int)); //int err_func; 1
g.DeclareLocal(typeof(ObjectTranslator)); //ObjectTranslator translator; 2
bool has_return = method.ReturnType != typeof(void);
if (has_return)
{
g.DeclareLocal(method.ReturnType); //ReturnType ret; 3
}
// L = LuaBase.L;
g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Callvirt, LuaBase_L_getter);
g.Emit(OpCodes.Stloc_0);
//err_func =LuaAPI.load_error_func(L, errorFuncRef);
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Callvirt, DelegateBridgeBase_errorFuncRef_getter);
g.Emit(OpCodes.Call, LuaAPI_load_error_func);
g.Emit(OpCodes.Stloc_1);
//translator = LuaBase.translator;
g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Callvirt, LuaBase_translator_getter);
g.Emit(OpCodes.Stloc_2);
//LuaAPI.lua_getref(L, luaReference);
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Ldfld, LuaBase_luaReference);
g.Emit(OpCodes.Call, LuaAPI_lua_getref);
//LuaAPI.lua_pushstring(L, "xxx");
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldstr, method.Name);
g.Emit(OpCodes.Call, LuaAPI_lua_pushstring);
//LuaAPI.xlua_pgettable(L, -2)
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldc_I4_S, (sbyte)-2);
g.Emit(OpCodes.Call, LuaAPI_xlua_pgettable);
Label gettable_no_exception = g.DefineLabel();
g.Emit(OpCodes.Brfalse, gettable_no_exception);
g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Ldfld, LuaBase_luaEnv);
g.Emit(OpCodes.Ldloc_1);
g.Emit(OpCodes.Ldc_I4_1);
g.Emit(OpCodes.Sub);
g.Emit(OpCodes.Callvirt, LuaEnv_ThrowExceptionFromError);
g.MarkLabel(gettable_no_exception);
//LuaAPI.lua_pushvalue(L, -2);
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldc_I4_S, (sbyte)-2);
g.Emit(OpCodes.Call, LuaAPI_lua_pushvalue);
//LuaAPI.lua_remove(L, -3);
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldc_I4_S, (sbyte)-3);
g.Emit(OpCodes.Call, LuaAPI_lua_remove);
int in_param_count = 0;
int out_param_count = 0;
bool has_params = false;
//translator.PushAny(L, param_in)
for (int i = 0; i < parameters.Length; ++i)
{
var pinfo = parameters[i];
if (!pinfo.IsOut)
{
var ptype = pinfo.ParameterType;
var pelemtype = ptype.IsByRef ? ptype.GetElementType() : ptype;
g.Emit(OpCodes.Ldloc_2);
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldarg, (short)(i + 1));
if (ptype.IsByRef)
{
if (pelemtype.IsValueType)
{
g.Emit(OpCodes.Ldobj, pelemtype);
g.Emit(OpCodes.Box, pelemtype);
}
else
{
g.Emit(OpCodes.Ldind_Ref);
}
}
else if (ptype.IsValueType)
{
g.Emit(OpCodes.Box, ptype);
}
if (pinfo.IsDefined(typeof(System.ParamArrayAttribute), false))
{
g.Emit(OpCodes.Callvirt, ObjectTranslator_PushParams);
has_params = true;
}
else
{
g.Emit(OpCodes.Callvirt, ObjectTranslator_PushAny);
++in_param_count;
}
}
if (pinfo.ParameterType.IsByRef)
{
++out_param_count;
}
}
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldc_I4, in_param_count + 1);
if (has_params)
{
Label l1 = g.DefineLabel();
g.Emit(OpCodes.Ldarg, (short)parameters.Length);
g.Emit(OpCodes.Brfalse, l1);
g.Emit(OpCodes.Ldarg, (short)parameters.Length);
g.Emit(OpCodes.Ldlen);
g.Emit(OpCodes.Add);
g.MarkLabel(l1);
}
g.Emit(OpCodes.Ldc_I4, out_param_count + (has_return ? 1 : 0));
g.Emit(OpCodes.Ldloc_1);
g.Emit(OpCodes.Call, LuaAPI_lua_pcall);
Label no_exception = g.DefineLabel();
g.Emit(OpCodes.Brfalse, no_exception);
g.Emit(OpCodes.Ldarg_0);
g.Emit(OpCodes.Ldfld, LuaBase_luaEnv);
g.Emit(OpCodes.Ldloc_1);
g.Emit(OpCodes.Ldc_I4_1);
g.Emit(OpCodes.Sub);
g.Emit(OpCodes.Callvirt, LuaEnv_ThrowExceptionFromError);
g.MarkLabel(no_exception);
int offset = 1;
if (has_return)
{
genGetObjectCall(g, offset++, method.ReturnType);
g.Emit(OpCodes.Stloc_3);
}
for (int i = 0; i < parameters.Length; ++i)
{
var pinfo = parameters[i];
var ptype = pinfo.ParameterType;
if (ptype.IsByRef)
{
g.Emit(OpCodes.Ldarg, (short)(i + 1));
var pelemtype = ptype.GetElementType();
genGetObjectCall(g, offset++, pelemtype);
if (pelemtype.IsValueType)
{
g.Emit(OpCodes.Stobj, pelemtype);
}
else
{
g.Emit(OpCodes.Stind_Ref);
}
}
}
if (has_return)
{
g.Emit(OpCodes.Ldloc_3);
}
//LuaAPI.lua_settop(L, err_func - 1);
g.Emit(OpCodes.Ldloc_0);
g.Emit(OpCodes.Ldloc_1);
g.Emit(OpCodes.Ldc_I4_1);
g.Emit(OpCodes.Sub);
g.Emit(OpCodes.Call, LuaAPI_lua_settop);
g.Emit(OpCodes.Ret);
}
else if (member.MemberType == MemberTypes.Property)
{
PropertyInfo property = member as PropertyInfo;
PropertyBuilder prop_builder = impl_type_builder.DefineProperty(property.Name, property.Attributes, property.PropertyType, Type.EmptyTypes);
if (property.Name == "Item")
{
if (property.CanRead)
{
var getter_buildler = defineImplementMethod(impl_type_builder, property.GetGetMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(getter_buildler.GetILGenerator(), property.PropertyType);
prop_builder.SetGetMethod(getter_buildler);
}
if (property.CanWrite)
{
var setter_buildler = defineImplementMethod(impl_type_builder, property.GetSetMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(setter_buildler.GetILGenerator(), property.PropertyType);
prop_builder.SetSetMethod(setter_buildler);
}
continue;
}
if (property.CanRead)
{
MethodBuilder getter_buildler = impl_type_builder.DefineMethod("get_" + property.Name,
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
property.PropertyType, Type.EmptyTypes);
ILGenerator il = getter_buildler.GetILGenerator();
LocalBuilder L = il.DeclareLocal(typeof(RealStatePtr));
LocalBuilder oldTop = il.DeclareLocal(typeof(int));
LocalBuilder translator = il.DeclareLocal(typeof(ObjectTranslator));
LocalBuilder ret = il.DeclareLocal(property.PropertyType);
// L = LuaBase.L;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_L_getter);
il.Emit(OpCodes.Stloc, L);
//oldTop = LuaAPI.lua_gettop(L);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Call, LuaAPI_lua_gettop);
il.Emit(OpCodes.Stloc, oldTop);
//translator = LuaBase.translator;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_translator_getter);
il.Emit(OpCodes.Stloc, translator);
//LuaAPI.lua_getref(L, luaReference);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaReference);
il.Emit(OpCodes.Call, LuaAPI_lua_getref);
//LuaAPI.lua_pushstring(L, "xxx");
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldstr, property.Name);
il.Emit(OpCodes.Call, LuaAPI_lua_pushstring);
//LuaAPI.xlua_pgettable(L, -2)
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)-2);
il.Emit(OpCodes.Call, LuaAPI_xlua_pgettable);
Label gettable_no_exception = il.DefineLabel();
il.Emit(OpCodes.Brfalse, gettable_no_exception);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaEnv);
il.Emit(OpCodes.Ldloc, oldTop);
il.Emit(OpCodes.Callvirt, LuaEnv_ThrowExceptionFromError);
il.MarkLabel(gettable_no_exception);
il.Emit(OpCodes.Ldloc, translator);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)-1);
il.Emit(OpCodes.Ldtoken, property.PropertyType);
il.Emit(OpCodes.Call, Type_GetTypeFromHandle); // typeof(type)
il.Emit(OpCodes.Callvirt, ObjectTranslator_GetObject);
if (property.PropertyType.IsValueType)
{
Label not_null = il.DefineLabel();
Label null_done = il.DefineLabel();
LocalBuilder local_new = il.DeclareLocal(property.PropertyType);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Brtrue_S, not_null);
il.Emit(OpCodes.Pop);
il.Emit(OpCodes.Ldloca, local_new);
il.Emit(OpCodes.Initobj, property.PropertyType);
il.Emit(OpCodes.Ldloc, local_new);
il.Emit(OpCodes.Br_S, null_done);
il.MarkLabel(not_null);
il.Emit(OpCodes.Unbox_Any, property.PropertyType);
il.MarkLabel(null_done);
}
else if (property.PropertyType != typeof(object))
{
il.Emit(OpCodes.Castclass, property.PropertyType);
}
il.Emit(OpCodes.Stloc, ret);
//LuaAPI.lua_pop(L, 2);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)2);
il.Emit(OpCodes.Call, LuaAPI_lua_pop);
il.Emit(OpCodes.Ldloc, ret);
il.Emit(OpCodes.Ret);
prop_builder.SetGetMethod(getter_buildler);
}
if (property.CanWrite)
{
MethodBuilder setter_builder = impl_type_builder.DefineMethod("set_" + property.Name,
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig,
null, new Type[] { property.PropertyType });
ILGenerator il = setter_builder.GetILGenerator();
LocalBuilder L = il.DeclareLocal(typeof(RealStatePtr));
LocalBuilder oldTop = il.DeclareLocal(typeof(int));
LocalBuilder translator = il.DeclareLocal(typeof(ObjectTranslator));
// L = LuaBase.L;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_L_getter);
il.Emit(OpCodes.Stloc, L);
//oldTop = LuaAPI.lua_gettop(L);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Call, LuaAPI_lua_gettop);
il.Emit(OpCodes.Stloc, oldTop);
//translator = LuaBase.translator;
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, LuaBase_translator_getter);
il.Emit(OpCodes.Stloc, translator);
//LuaAPI.lua_getref(L, luaReference);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaReference);
il.Emit(OpCodes.Call, LuaAPI_lua_getref);
//LuaAPI.lua_pushstring(L, "xxx");
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldstr, property.Name);
il.Emit(OpCodes.Call, LuaAPI_lua_pushstring);
//translator.Push(L, value);
il.Emit(OpCodes.Ldloc, translator);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldarg_1);
if (property.PropertyType.IsValueType)
{
il.Emit(OpCodes.Box, property.PropertyType);
}
il.Emit(OpCodes.Callvirt, ObjectTranslator_PushAny);
//LuaAPI.xlua_psettable(L, -2)
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)-3);
il.Emit(OpCodes.Call, LuaAPI_xlua_psettable);
Label settable_no_exception = il.DefineLabel();
il.Emit(OpCodes.Brfalse, settable_no_exception);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, LuaBase_luaEnv);
il.Emit(OpCodes.Ldloc, oldTop);
il.Emit(OpCodes.Callvirt, LuaEnv_ThrowExceptionFromError);
il.MarkLabel(settable_no_exception);
//LuaAPI.lua_pop(L, 1);
il.Emit(OpCodes.Ldloc, L);
il.Emit(OpCodes.Ldc_I4_S, (sbyte)1);
il.Emit(OpCodes.Call, LuaAPI_lua_pop);
il.Emit(OpCodes.Ret);
prop_builder.SetSetMethod(setter_builder);
}
}
else if (member.MemberType == MemberTypes.Event)
{
EventInfo event_info = member as EventInfo;
EventBuilder event_builder = impl_type_builder.DefineEvent(event_info.Name, event_info.Attributes, event_info.EventHandlerType);
if (event_info.GetAddMethod() != null)
{
var add_buildler = defineImplementMethod(impl_type_builder, event_info.GetAddMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(add_buildler.GetILGenerator(), typeof(void));
event_builder.SetAddOnMethod(add_buildler);
}
if (event_info.GetRemoveMethod() != null)
{
var remove_buildler = defineImplementMethod(impl_type_builder, event_info.GetRemoveMethod(),
MethodAttributes.Virtual | MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig);
genEmptyMethod(remove_buildler.GetILGenerator(), typeof(void));
event_builder.SetRemoveOnMethod(remove_buildler);
}
}
}
// Constructor
var ctor_param_types = new Type[] { typeof(int), typeof(LuaEnv) };
ConstructorInfo parent_ctor = typeof(LuaBase).GetConstructor(ctor_param_types);
var ctor_builder = impl_type_builder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctor_param_types);
var cg = ctor_builder.GetILGenerator();
cg.Emit(OpCodes.Ldarg_0);
cg.Emit(OpCodes.Ldarg_1);
cg.Emit(OpCodes.Ldarg_2);
cg.Emit(OpCodes.Call, parent_ctor);
cg.Emit(OpCodes.Ret);
return(impl_type_builder.CreateType());
}
public static PropertyBuilder <TProperty> SetDefaultShortMaxLength <TProperty>(
this PropertyBuilder <TProperty> builder)
=> builder.HasMaxLength(Consts.ShortStringMaxLength);
public BuildCustomValidationAttributesEventArgs(string objectTypeAlias, Type fieldType, string fieldName, PropertyBuilder propertyBuilder)
{
ObjectTypeAlias = objectTypeAlias;
FieldType = fieldType;
FieldName = fieldName;
PropertyBuilder = propertyBuilder;
}
/// <summary>
/// Configures the key property to use a sequence-based hi-lo pattern to generate values for new entities,
/// when targeting Oracle. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
/// </summary>
/// <typeparam name="TProperty"> The type of the property being configured. </typeparam>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <param name="name"> The name of the sequence. </param>
/// <param name="schema"> The schema of the sequence. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static PropertyBuilder <TProperty> ForOracleUseSequenceHiLo <TProperty>(
[NotNull] this PropertyBuilder <TProperty> propertyBuilder,
[CanBeNull] string name = null,
[CanBeNull] string schema = null)
=> (PropertyBuilder <TProperty>)ForOracleUseSequenceHiLo((PropertyBuilder)propertyBuilder, name, schema);
private PropertyBuilder VisitDefaultValue(ColumnModel column, PropertyBuilder propertyBuilder)
{
if (column.DefaultValue != null)
{
// unset default
propertyBuilder.Metadata.ValueGenerated = null;
propertyBuilder.Metadata.Relational().GeneratedValueSql = null;
var property = propertyBuilder.Metadata;
var defaultExpressionOrValue =
_sqlServerLiteralUtilities
.ConvertSqlServerDefaultValue(
property.ClrType, column.DefaultValue);
if (defaultExpressionOrValue?.DefaultExpression != null)
{
propertyBuilder.HasDefaultValueSql(defaultExpressionOrValue.DefaultExpression);
}
else if (defaultExpressionOrValue != null)
{
// Note: defaultExpressionOrValue.DefaultValue == null is valid
propertyBuilder.HasDefaultValue(defaultExpressionOrValue.DefaultValue);
}
else
{
Logger.LogWarning(
SqlServerDesignStrings.UnableToConvertDefaultValue(
column.DisplayName, column.DefaultValue,
property.ClrType, property.Name, property.DeclaringEntityType.Name));
}
}
return propertyBuilder;
}
/// <summary>
/// Configures the key property to use the Oracle IDENTITY feature to generate values for new entities,
/// when targeting Oracle. This method sets the property to be <see cref="ValueGenerated.OnAdd" />.
/// </summary>
/// <typeparam name="TProperty"> The type of the property being configured. </typeparam>
/// <param name="propertyBuilder"> The builder for the property being configured. </param>
/// <returns> The same builder instance so that multiple calls can be chained. </returns>
public static PropertyBuilder <TProperty> UseOracleIdentityColumn <TProperty>(
[NotNull] this PropertyBuilder <TProperty> propertyBuilder)
=> (PropertyBuilder <TProperty>)UseOracleIdentityColumn((PropertyBuilder)propertyBuilder);
private void VisitTypeMapping(PropertyBuilder propertyBuilder, ColumnModel column)
{
if (column.SqlServer().IsIdentity)
{
if (typeof(byte) == propertyBuilder.Metadata.ClrType)
{
Logger.LogWarning(
SqlServerDesignStrings.DataTypeDoesNotAllowSqlServerIdentityStrategy(
column.DisplayName, column.DataType));
}
else
{
propertyBuilder
.ValueGeneratedOnAdd()
.UseSqlServerIdentityColumn();
}
}
var dateTimePrecision = column.SqlServer().DateTimePrecision;
if (dateTimePrecision.HasValue
&& dateTimePrecision.Value != DefaultTimeTimePrecision)
{
propertyBuilder.Metadata.SetMaxLength(null);
propertyBuilder.HasColumnType($"{column.DataType}({dateTimePrecision.Value})");
}
else if (!HasTypeAlias(column))
{
var qualifiedColumnTypeAndMaxLength =
MaxLengthQualifiedDataType(column.DataType, column.MaxLength);
if (qualifiedColumnTypeAndMaxLength != null)
{
propertyBuilder.HasColumnType(qualifiedColumnTypeAndMaxLength.Item1);
propertyBuilder.Metadata.SetMaxLength(qualifiedColumnTypeAndMaxLength.Item2);
}
}
var columnType = propertyBuilder.Metadata.SqlServer().ColumnType;
if (columnType != null)
{
TypeMapper.ValidateTypeName(columnType);
}
}
private static OraclePropertyBuilderAnnotations GetOracleInternalBuilder(PropertyBuilder propertyBuilder) => propertyBuilder.GetInfrastructure <InternalPropertyBuilder>().Oracle(ConfigurationSource.Explicit);
void GenerateInterfaceMethod(TypeBuilder tb,
TypeInfo.MethodDescriptor desc)
{
if (desc == null || !desc.IsVisible())
return;
MethodAttributes methodAttrs = METHOD_ATTRS;
String methodName = desc.name;
if (desc.IsGetter()) {
methodName = "get_" + desc.name;
methodAttrs |= MethodAttributes.SpecialName;
} else if (desc.IsSetter()) {
methodName = "set_" + desc.name;
methodAttrs |= MethodAttributes.SpecialName;
}
// Fix up interface types in parameters
Type ret = desc.resultType;
if (ret == typeof(object))
ret = FixupInterfaceType(desc.args[desc.args.Length - 1]);
Type[] argTypes = (Type[])desc.argTypes.Clone();
for (int i = 0; i < argTypes.Length; i++) {
if (argTypes[i] == typeof(object))
argTypes[i] = FixupInterfaceType(desc.args[i]);
}
MethodBuilder meth = tb.DefineMethod(methodName, methodAttrs, ret,
argTypes);
if (desc.IsSetter()) {
if (lastProperty != null && lastProperty.Name == desc.name) {
lastProperty.SetSetMethod(meth);
} else {
tb.DefineProperty(desc.name, PROPERTY_ATTRS, ret, new Type[0])
.SetSetMethod(meth);
}
lastProperty = null;
} else if (desc.IsGetter()) {
lastProperty = tb.DefineProperty(desc.name, PROPERTY_ATTRS, ret,
new Type[0]);
lastProperty.SetGetMethod(meth);
} else {
lastProperty = null;
}
}
/// <summary>Called by the emitter after the proxy property is emitted.</summary>
/// <param name="interfaceProperty">Interfact property.</param>
/// <param name="builder">Property builder for the emitted property. </param>
public virtual void OnPropertyEmitted(PropertyInfo interfaceProperty, PropertyBuilder builder)
{
}
public void Init()
{
_MemberInfo = A.Fake<IMemberInfo>();
_Builder = new PropertyBuilder<ReferencedTargetClass, TargetClass>(_MemberInfo);
}
public Type EmitCustomType7(ModuleBuilder moduleBuilder, string typeName)
{
TypeBuilder tb = moduleBuilder.DefineType(typeName, TypeAttributes.Public);
FieldBuilder fbNumber = tb.DefineField("m_number", typeof(int), FieldAttributes.Private);
Type[] ctorParameterTypes = new Type[] { typeof(int) };
ConstructorBuilder ctor1 = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ctorParameterTypes);
ILGenerator ctorIL1 = ctor1.GetILGenerator();
ctorIL1.Emit(OpCodes.Ldarg_0);
ctorIL1.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
ctorIL1.Emit(OpCodes.Ldarg_0);
ctorIL1.Emit(OpCodes.Ldarg_1);
ctorIL1.Emit(OpCodes.Stfld, fbNumber);
ctorIL1.Emit(OpCodes.Ret);
ConstructorBuilder ctor2 = tb.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
ILGenerator ctorIL2 = ctor2.GetILGenerator();
ctorIL2.Emit(OpCodes.Ldarg_0);
ctorIL2.Emit(OpCodes.Ldc_I4_S, 23);
ctorIL2.Emit(OpCodes.Call, ctor1);
ctorIL1.Emit(OpCodes.Ret);
PropertyBuilder pbNumber = tb.DefineProperty("Number", PropertyAttributes.HasDefault, typeof(int), null);
MethodAttributes getSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
MethodBuilder mbNumberGetAccessor = tb.DefineMethod("get_Number", getSetAttr, typeof(int), null);
ILGenerator numberGetIL = mbNumberGetAccessor.GetILGenerator();
numberGetIL.Emit(OpCodes.Ldarg_0);
numberGetIL.Emit(OpCodes.Ldfld, fbNumber);
numberGetIL.Emit(OpCodes.Ret);
MethodBuilder mbNumberSetAccessor = tb.DefineMethod("set_Number", getSetAttr, typeof(void), new Type[] { typeof(int) });
ILGenerator numberSetIL = mbNumberSetAccessor.GetILGenerator();
numberSetIL.Emit(OpCodes.Ldarg_0);
numberSetIL.Emit(OpCodes.Ldarg_1);
numberSetIL.Emit(OpCodes.Stfld, fbNumber);
numberSetIL.Emit(OpCodes.Ret);
pbNumber.SetGetMethod(mbNumberGetAccessor);
pbNumber.SetSetMethod(mbNumberSetAccessor);
MethodBuilder mbMyMethod = tb.DefineMethod("MyMethod", MethodAttributes.Public, typeof(int), new Type[] { typeof(int) });
ILGenerator myMethodGetIL = mbMyMethod.GetILGenerator();
myMethodGetIL.Emit(OpCodes.Ldarg_0);
myMethodGetIL.Emit(OpCodes.Ldfld, fbNumber);
myMethodGetIL.Emit(OpCodes.Ldarg_1);
myMethodGetIL.Emit(OpCodes.Mul);
myMethodGetIL.Emit(OpCodes.Ret);
return(tb.CreateType());
}
internal override void Apply(ClassLoaderWrapper loader, PropertyBuilder pb, object annotation)
{
}
public void Init()
{
_MemberInfo = A.Fake <IMemberInfo>();
_Builder = new PropertyBuilder <string, object>(_MemberInfo);
}
internal override void Apply(ClassLoaderWrapper loader, PropertyBuilder pb, object annotation)
{
if (type.IsSubclassOf(Types.SecurityAttribute))
{
// you can't add declarative security to a property
}
else
{
pb.SetCustomAttribute(MakeCustomAttributeBuilder(loader, annotation));
}
}
internal void AddInterfaceImpl(Type iface)
{
// If necessary, generate an attribute to permit visibility
// to internal types.
_assembly.EnsureTypeIsVisible(iface);
_tb.AddInterfaceImplementation(iface);
// AccessorMethods -> Metadata mappings.
var propertyMap = new Dictionary <MethodInfo, PropertyAccessorInfo>(MethodInfoEqualityComparer.Instance);
foreach (PropertyInfo pi in iface.GetRuntimeProperties())
{
var ai = new PropertyAccessorInfo(pi.GetMethod, pi.SetMethod);
if (pi.GetMethod != null)
{
propertyMap[pi.GetMethod] = ai;
}
if (pi.SetMethod != null)
{
propertyMap[pi.SetMethod] = ai;
}
}
var eventMap = new Dictionary <MethodInfo, EventAccessorInfo>(MethodInfoEqualityComparer.Instance);
foreach (EventInfo ei in iface.GetRuntimeEvents())
{
var ai = new EventAccessorInfo(ei.AddMethod, ei.RemoveMethod, ei.RaiseMethod);
if (ei.AddMethod != null)
{
eventMap[ei.AddMethod] = ai;
}
if (ei.RemoveMethod != null)
{
eventMap[ei.RemoveMethod] = ai;
}
if (ei.RaiseMethod != null)
{
eventMap[ei.RaiseMethod] = ai;
}
}
foreach (MethodInfo mi in iface.GetRuntimeMethods())
{
// Skip regular/non-virtual instance methods, static methods, and methods that cannot be overriden
// ("methods that cannot be overriden" includes default implementation of other interface methods).
if (!mi.IsVirtual || mi.IsFinal)
{
continue;
}
MethodBuilder mdb = AddMethodImpl(mi);
PropertyAccessorInfo associatedProperty;
if (propertyMap.TryGetValue(mi, out associatedProperty))
{
if (MethodInfoEqualityComparer.Instance.Equals(associatedProperty.InterfaceGetMethod, mi))
{
associatedProperty.GetMethodBuilder = mdb;
}
else
{
associatedProperty.SetMethodBuilder = mdb;
}
}
EventAccessorInfo associatedEvent;
if (eventMap.TryGetValue(mi, out associatedEvent))
{
if (MethodInfoEqualityComparer.Instance.Equals(associatedEvent.InterfaceAddMethod, mi))
{
associatedEvent.AddMethodBuilder = mdb;
}
else if (MethodInfoEqualityComparer.Instance.Equals(associatedEvent.InterfaceRemoveMethod, mi))
{
associatedEvent.RemoveMethodBuilder = mdb;
}
else
{
associatedEvent.RaiseMethodBuilder = mdb;
}
}
}
foreach (PropertyInfo pi in iface.GetRuntimeProperties())
{
PropertyAccessorInfo ai = propertyMap[pi.GetMethod ?? pi.SetMethod];
// If we didn't make an overriden accessor above, this was a static property, non-virtual property,
// or a default implementation of a property of a different interface. In any case, we don't need
// to redeclare it.
if (ai.GetMethodBuilder == null && ai.SetMethodBuilder == null)
{
continue;
}
PropertyBuilder pb = _tb.DefineProperty(pi.Name, pi.Attributes, pi.PropertyType, pi.GetIndexParameters().Select(p => p.ParameterType).ToArray());
if (ai.GetMethodBuilder != null)
{
pb.SetGetMethod(ai.GetMethodBuilder);
}
if (ai.SetMethodBuilder != null)
{
pb.SetSetMethod(ai.SetMethodBuilder);
}
}
foreach (EventInfo ei in iface.GetRuntimeEvents())
{
EventAccessorInfo ai = eventMap[ei.AddMethod ?? ei.RemoveMethod];
// If we didn't make an overriden accessor above, this was a static event, non-virtual event,
// or a default implementation of an event of a different interface. In any case, we don't
// need to redeclare it.
if (ai.AddMethodBuilder == null && ai.RemoveMethodBuilder == null && ai.RaiseMethodBuilder == null)
{
continue;
}
EventBuilder eb = _tb.DefineEvent(ei.Name, ei.Attributes, ei.EventHandlerType);
if (ai.AddMethodBuilder != null)
{
eb.SetAddOnMethod(ai.AddMethodBuilder);
}
if (ai.RemoveMethodBuilder != null)
{
eb.SetRemoveOnMethod(ai.RemoveMethodBuilder);
}
if (ai.RaiseMethodBuilder != null)
{
eb.SetRaiseMethod(ai.RaiseMethodBuilder);
}
}
}
private void AssertIsGeneric(PropertyBuilder<int> _)
{
}
private Type GetObjectType(List <DataSourceVariable> vars)
{
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "tmpAssembly";
AssemblyBuilder assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder module = assemblyBuilder.DefineDynamicModule("tmpModule");
int varnameidx = 0;
// create a new type builder
TypeBuilder typeBuilder = module.DefineType("BindableRowCellCollection", TypeAttributes.Public | TypeAttributes.Class);
foreach (DataSourceVariable var in vars)
{
Type type = (var.DataClass.Equals("POSIXct") || var.DataClass.Equals("Date")) ? typeof(string) : typeof(string);//28Aug2017 Date as string in grid
string propertyName = var.Name.Replace(".", "_").Replace("(", "_").Replace(")", "_");
// Generate a private field
FieldBuilder field = typeBuilder.DefineField("_" + propertyName, typeof(string), FieldAttributes.Private);
// Generate a public property
PropertyBuilder property =
typeBuilder.DefineProperty(propertyName,
PropertyAttributes.None,
type,
new Type[] { type });
// The property set and property get methods require a special set of attributes:
MethodAttributes GetSetAttr =
MethodAttributes.Public |
MethodAttributes.HideBySig;
// Define the "get" accessor method for current private field.
MethodBuilder currGetPropMthdBldr =
typeBuilder.DefineMethod("get_value",
GetSetAttr,
type,
Type.EmptyTypes);
// Intermediate Language stuff...
ILGenerator currGetIL = currGetPropMthdBldr.GetILGenerator();
currGetIL.Emit(OpCodes.Ldarg_0);
currGetIL.Emit(OpCodes.Ldfld, field);
currGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for current private field.
MethodBuilder currSetPropMthdBldr =
typeBuilder.DefineMethod("set_value",
GetSetAttr,
null,
new Type[] { type });
// Again some Intermediate Language stuff...
ILGenerator currSetIL = currSetPropMthdBldr.GetILGenerator();
currSetIL.Emit(OpCodes.Ldarg_0);
currSetIL.Emit(OpCodes.Ldarg_1);
currSetIL.Emit(OpCodes.Stfld, field);
currSetIL.Emit(OpCodes.Ret);
property.SetGetMethod(currGetPropMthdBldr);
property.SetSetMethod(currSetPropMthdBldr);
}
Type generetedType = typeBuilder.CreateType();
return(generetedType);
}
internal void DoLink(TypeBuilder tb)
{
if(getter != null)
{
getter.Link();
}
if(setter != null)
{
setter.Link();
}
pb = tb.DefineProperty(this.Name, PropertyAttributes.None, this.FieldTypeWrapper.TypeAsSignatureType, Type.EmptyTypes);
if(getter != null)
{
pb.SetGetMethod((MethodBuilder)getter.GetMethod());
}
if(setter != null)
{
pb.SetSetMethod((MethodBuilder)setter.GetMethod());
}
#if STATIC_COMPILER
AttributeHelper.SetModifiers(pb, this.Modifiers, this.IsInternal);
#endif
}
public static PropertyBuilder <TProperty> IsUtc <TProperty>(this PropertyBuilder <TProperty> builder, Boolean isUtc = true) => builder.HasAnnotation(IsUtcAnnotation, isUtc);
