public EasyProperty CreateProperty(string name, Type returnType)
{
EasyProperty property = new EasyProperty(this, name, returnType);
this._properties.Add(property);
return(property);
}
public EasyProperty CreateProperty(String name, Type returnType)
{
EasyProperty prop = new EasyProperty(this, name, returnType);
_properties.Add(prop);
return(prop);
}
private void GenerateTargetProperty()
{
EasyProperty property = CreateProperty("Target", typeof(object));
EasyMethod getMethod = property.CreateGetMethod();
MethodInfo baseMethod = typeof(MulticastDelegate).GetMethod("get_Target");
getMethod.CodeBuilder.AddStatement(
new ReturnStatement(new MethodInvocationExpression(baseMethod)));
// PropertyAttributes patts = PropertyAttributes.None;
// PropertyBuilder pbuilder = _delegateBuilder.DefineProperty("Target", patts, typeof(Object), null);
//
// MethodAttributes atts = MethodAttributes.Public|MethodAttributes.Virtual|MethodAttributes.SpecialName;
// MethodBuilder methodBuilder = _delegateBuilder.DefineMethod("get_Target",
// atts, CallingConventions.Standard, typeof(object), new Type[0]);
//
// ILGenerator gen = methodBuilder.GetILGenerator();
//
// gen.DeclareLocal( typeof(object) );
// gen.Emit(OpCodes.Ldarg_0);
// gen.Emit(OpCodes.Call, typeof(MulticastDelegate).GetMethod("get_Target"));
// gen.Emit(OpCodes.Stloc_0);
// gen.Emit(OpCodes.Ldloc_0);
// gen.Emit(OpCodes.Ret);
//
// pbuilder.SetGetMethod(methodBuilder);
}
public EasyProperty CreateProperty(PropertyInfo property)
{
EasyProperty property2 = new EasyProperty(this, property.Name, property.PropertyType);
property2.IndexParameters = property.GetIndexParameters();
this._properties.Add(property2);
return(property2);
}
public void Add(EasyProperty property)
{
InnerList.Add(property);
}
public EasyProperty CreateProperty( PropertyInfo property )
{
EasyProperty prop = new EasyProperty( this, property.Name, property.PropertyType );
prop.IndexParameters = property.GetIndexParameters();
_properties.Add(prop);
return prop;
}
public EasyProperty CreateProperty( String name, Type returnType )
{
EasyProperty prop = new EasyProperty( this, name, returnType );
_properties.Add(prop);
return prop;
}
protected virtual EasyProperty[] GenerateProperties(Type inter)
{
PropertyInfo[] properties = inter.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
EasyProperty[] propertiesBuilder = new EasyProperty[properties.Length];
for(int i = 0; i < properties.Length; i++)
{
propertiesBuilder[i] = CreateProperty(properties[i]);
}
return propertiesBuilder;
}
protected virtual void GenerateMethods(Type inter, EasyProperty[] properties)
{
MethodInfo[] methods = inter.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach(MethodInfo method in methods)
{
if (method.IsFinal)
{
Context.AddMethodToGenerateNewSlot(method);
}
if (method.IsPrivate || !method.IsVirtual || method.IsFinal)
{
continue;
}
#if DOTNET2
if (method.IsAssembly && !IsInternalToDynamicProxy(method.Module.Assembly))
#else
if (method.IsAssembly && !IsInternalToDynamicProxy(inter.Assembly))
#endif
{
continue;
}
if (method.DeclaringType.Equals(typeof(Object)) && !method.IsVirtual)
{
continue;
}
if (method.DeclaringType.Equals(typeof(Object)) && "Finalize".Equals(method.Name))
{
continue;
}
GenerateMethodImplementation(method, properties);
}
}
/// <summary>
/// Generates implementation for each method.
/// </summary>
/// <param name="method"></param>
/// <param name="properties"></param>
protected void GenerateMethodImplementation(MethodInfo method, EasyProperty[] properties)
{
if (Context.ShouldSkip(method)) return;
ParameterInfo[] parametersInfo = method.GetParameters();
Type[] parameters = new Type[parametersInfo.Length];
for(int i = 0; i < parametersInfo.Length; i++)
{
parameters[i] = parametersInfo[i].ParameterType;
}
MethodAttributes atts = ObtainMethodAttributes(method);
PreProcessMethod(method);
EasyMethod easyMethod = null;
bool isSetMethod = method.IsSpecialName && method.Name.StartsWith("set_");
bool isGetMethod = method.IsSpecialName && method.Name.StartsWith("get_");
if (!isSetMethod && !isGetMethod)
{
easyMethod = _typeBuilder.CreateMethod(method.Name,
atts, new ReturnReferenceExpression(method.ReturnType), parameters);
}
else
{
if (isSetMethod || isGetMethod)
{
foreach(EasyProperty property in properties)
{
if (property == null)
{
break;
}
if (!property.Name.Equals(method.Name.Substring(4)))
{
continue;
}
if (property.IndexParameters != null)
{
bool signatureMatches = true;
int numOfIndexes = parametersInfo.Length;
//A set method already has a value parameter, and everything after
//that is an indexer.
if (isSetMethod)
numOfIndexes--;
if (numOfIndexes != property.IndexParameters.Length)
continue;
for(int i = 0; i < property.IndexParameters.Length; i++)
{
if (property.IndexParameters[i].ParameterType != parametersInfo[i].ParameterType)
{
signatureMatches = false;
break;
}
}
if (!signatureMatches) continue;
}
if (isSetMethod)
{
easyMethod = property.CreateSetMethod(atts, parameters);
break;
}
else
{
easyMethod = property.CreateGetMethod(atts, parameters);
break;
}
}
}
}
easyMethod.DefineParameters(parametersInfo);
WriteInterceptorInvocationMethod(method, easyMethod);
PostProcessMethod(method);
}
public void Add(EasyProperty property)
{
base.InnerList.Add(property);
}
