public override ILCoder GetCoder()
{
if (this._isBuild)
{
throw new CodingException("Metodun tanımlandığı tip derlenmiş. Derlenmiş metotların gövdesi yeniden yazılamaz.");
}
if (this._coder == null)
{
this.ConstructorBuilder = base.ILTypeBuilder.TypeBuilder.DefineConstructor(this._methodAttributes, this._conventions, this.GetParameterTypes());
for (int i = 0; i < this._parameters.Count; i++)
{
ILParameterInfo parameter = this._parameters[i];
parameter.Builder = this.ConstructorBuilder.DefineParameter(i + 1, parameter.Attributes, parameter.ParameterName);
if (parameter.OptionalValue != null)
{
parameter.Builder.SetConstant(parameter.OptionalValue);
}
}
return(this._coder = new ILCoder(this, this.ConstructorBuilder.GetILGenerator()));
}
else
{
return(this._coder);
}
}
public void AddParameter(string genericTypeName, Type[] constraints, string name, ParameterAttributes attributes)
{
GenericTypeParameterBuilder parameterBuilder = this.TypeOfGenericArgument(genericTypeName) as GenericTypeParameterBuilder;
this.AddParameter(parameterBuilder, name, attributes, null);
if (constraints != null || constraints.Length > 0)
{
ILParameterInfo parameterInfo = this.GetParameterInfo(this._nameToIndex[name]);
parameterInfo.Constraints = constraints.Clone() as Type[];
if (constraints[0].IsClass)
{
parameterBuilder.SetBaseTypeConstraint(constraints[0]);
Type[] interfaceConsts = new Type[constraints.Length - 1];
Array.Copy(constraints, 1, interfaceConsts, 0, interfaceConsts.Length);
if (interfaceConsts.Length > 0)
{
parameterBuilder.SetInterfaceConstraints(interfaceConsts);
}
}
else
{
parameterBuilder.SetInterfaceConstraints(constraints);
}
}
}
public override ILCoder GetCoder()
{
if (this._isBuild)
{
throw new CodingException("Metot daha önce derlenmiş. Derlenmiş metotların gövdesi yeniden yazılamaz.");
}
if (this._coder == null)
{
this._isImplemented = true;
this._dynMethod = new DynamicMethod(this.Name, this._attributes, this._conventions, this.ReturnType, this.GetParameterTypes(), this.DeclaringType, false);
for (int i = 0; i < this._parameters.Count; i++)
{
ILParameterInfo parameter = this._parameters[i];
parameter.Builder = this.DynamicMethod.DefineParameter(i + 1, parameter.Attributes, parameter.ParameterName);
if (parameter.OptionalValue != null)
{
parameter.Builder.SetConstant(parameter.OptionalValue);
}
}
return(this._coder = new ILCoder(this, this.DynamicMethod.GetILGenerator()));
}
else
{
return(this._coder);
}
}
public override void AddParameter(Type type, string name, ParameterAttributes attributes, object optionalValue)
{
if (this._coder != null)
{
throw new DefinitionException("Metot gövdesi yazılmaya başlandıktan sonra parametre eklemesi yapılamaz.");
}
ILParameterInfo parameter = new ILParameterInfo {
Attributes = attributes, ParameterName = name, ParameterType = type, OptionalValue = optionalValue
};
this._nameToIndex.Add(name, this._parameterTypes.Count);
this._parameterTypes.Add(type);
this._parameters.Add(parameter);
}
internal ILArgument(ILCoder coding, int argNo, Type argumentType)
: base(coding)
{
this._parameterInfo = coding.CurrentMethod.GetParameterInfo(argNo);
this._isByRef = argumentType.IsByRef;
if (coding.CurrentMethod.IsStatic)
{
this._argNo = argNo;
}
else
{
this._argNo = argNo + 1;
}
if (this._isByRef)
{
this._argType = argumentType.GetElementType();
}
else
{
this._argType = argumentType;
}
}
public override ILCoder GetCoder()
{
if (this._isBuild)
{
throw new CodingException("Metodun tanımlandığı tip derlenmiş. Derlenmiş metotların gövdesi yeniden yazılamaz.");
}
if (this.IsAbstract)
{
throw new CodingException("Soyut metotların gövdesi tanımlanamaz.");
}
if (this._coder == null)
{
this.MethodBuilder.SetParameters(this._parameterTypes.ToArray());
this.MethodBuilder.SetReturnType(this.ReturnType);
for (int i = 0; i < this._parameterTypes.Count; i++)
{
ILParameterInfo param = this._parameters[i];
if (this.MethodBuilder.IsStatic)
{
param.Builder = this.MethodBuilder.DefineParameter(i, param.Attributes, param.ParameterName);
}
else
{
param.Builder = this.MethodBuilder.DefineParameter(i + 1, param.Attributes, param.ParameterName);
}
if (param.OptionalValue != null)
{
param.Builder.SetConstant(param.OptionalValue);
}
}
this._coder = new ILCoder(this, this.MethodBuilder.GetILGenerator());
}
return(this._coder);
}
public void CopyParametersFrom(MethodInfo info)
{
if (this._coder != null)
{
throw new DefinitionException("Metot gövdesi yazılmaya başlandıktan sonra parametre eklemesi yapılamaz.");
}
if (this.IsOverride)
{
throw new DefinitionException("Geçersiz kılınmış metotlar üzerine parametre eklemesi yapılamaz.");
}
if (info.IsGenericMethod)
{
Type[] genericArgTypes = info.GetGenericArguments();
string[] genericArgNames = new string[genericArgTypes.Length];
for (int i = 0; i < genericArgTypes.Length; i++)
{
genericArgNames[i] = genericArgTypes[i].Name;
}
this.DefineGenericParameters(genericArgNames);
ParameterInfo[] methodParameters = info.GetParameters();
for (int i = 0; i < methodParameters.Length; i++)
{
ParameterInfo parameter = methodParameters[i];
Type parameterType = parameter.ParameterType;
Type[] constraints = null;
if (parameter.ParameterType.IsGenericParameter)
{
constraints = parameter.ParameterType.GetGenericParameterConstraints();
}
string genericTypeName = null;
if (parameterType.IsArray)
{
Type elementType = parameterType.GetElementType();
int rank = parameterType.GetArrayRank();
if (this.ContainsGenericParameterName(elementType.Name))
{
Type copyParameterType = this.TypeOfGenericArgument(genericTypeName = elementType.Name).MakeArrayType(rank);
if (parameterType.IsByRef)
{
copyParameterType = copyParameterType.MakeByRefType();
}
this.AddParameter(copyParameterType, parameter.Name, parameter.Attributes);
}
else
{
this.AddParameter(parameterType, parameter.Name, parameter.Attributes);
}
}
else
{
if (this.ContainsGenericParameterName(parameterType.Name))
{
Type copyParameterType = this.TypeOfGenericArgument(genericTypeName = parameterType.Name);
if (parameterType.IsByRef)
{
copyParameterType = copyParameterType.MakeByRefType();
}
this.AddParameter(copyParameterType, parameter.Name, parameter.Attributes);
}
else
{
Type copyParameterType = parameterType;
this.AddParameter(copyParameterType, parameter.Name, parameter.Attributes);
}
}
if ((constraints != null && constraints.Length > 0) && genericTypeName != null)
{
ILParameterInfo parameterInfo = this.GetParameterInfo(this._nameToIndex[parameter.Name]);
parameterInfo.Constraints = constraints.Clone() as Type[];
GenericTypeParameterBuilder parameterBuilder = this.TypeOfGenericArgument(genericTypeName) as GenericTypeParameterBuilder;
if (constraints[0].IsClass)
{
parameterBuilder.SetBaseTypeConstraint(constraints[0]);
Type[] interfaceConsts = new Type[constraints.Length - 1];
Array.Copy(constraints, 1, interfaceConsts, 0, interfaceConsts.Length);
if (interfaceConsts.Length > 0)
{
parameterBuilder.SetInterfaceConstraints(interfaceConsts);
}
}
else
{
parameterBuilder.SetInterfaceConstraints(constraints);
}
}
}
Type returnType = info.ReturnType;
Type[] returnConstraints = null;
if (returnType.IsGenericParameter)
{
returnConstraints = returnType.GetGenericParameterConstraints();
}
if (returnType.IsArray)
{
Type elementType = returnType.GetElementType();
int rank = returnType.GetArrayRank();
if (this.ContainsGenericParameterName(elementType.Name))
{
this.SetReturnType(this.TypeOfGenericArgument(elementType.Name).MakeArrayType(rank));
}
else
{
this.SetReturnType(returnType);
}
}
else
{
if (this.ContainsGenericParameterName(returnType.Name))
{
this.SetReturnType(this.TypeOfGenericArgument(returnType.Name));
}
else
{
this.SetReturnType(returnType);
}
}
if (returnConstraints != null && returnConstraints.Length > 0)
{
GenericTypeParameterBuilder parameterBuilder = this.TypeOfGenericArgument(returnType.Name) as GenericTypeParameterBuilder;
if (returnConstraints[0].IsClass)
{
parameterBuilder.SetBaseTypeConstraint(returnConstraints[0]);
Type[] interfaceConsts = new Type[returnConstraints.Length - 1];
Array.Copy(returnConstraints, 1, interfaceConsts, 0, interfaceConsts.Length);
if (interfaceConsts.Length > 0)
{
parameterBuilder.SetInterfaceConstraints(interfaceConsts);
}
}
else
{
parameterBuilder.SetInterfaceConstraints(returnConstraints);
}
}
}
else
{
ParameterInfo[] methodParameters = info.GetParameters();
for (int i = 0; i < methodParameters.Length; i++)
{
ParameterInfo parameter = methodParameters[i];
this.AddParameter(parameter.ParameterType, parameter.Name, parameter.Attributes);
}
Type returnType = info.ReturnType;
this.SetReturnType(returnType);
}
}
