private void Build(BuildStep step, AbstractTypeBuilderList builders)
{
_context.Step = step;
_context.TypeBuilders.Clear();
foreach (IAbstractTypeBuilder builder in builders)
{
if (builder.IsApplied(_context, builders))
{
_context.TypeBuilders.Add(builder);
}
}
if (_context.IsVirtualMethod || _context.IsVirtualProperty)
{
_context.TypeBuilders.Add(_defaultTypeBuilder);
}
if (_context.TypeBuilders.Count == 0)
{
return;
}
CheckCompatibility(_context, _context.TypeBuilders);
_context.TypeBuilders.Sort(new BuilderComparer(_context));
for (int i = 0; i < _context.TypeBuilders.Count; i++)
{
IAbstractTypeBuilder builder = _context.TypeBuilders[i];
builder.Build(_context);
}
}
private static void CheckCompatibility(BuildContext context, AbstractTypeBuilderList builders)
{
for (int i = 0; i < builders.Count; i++)
{
IAbstractTypeBuilder cur = builders[i];
if (cur == null)
{
continue;
}
for (int j = 0; j < builders.Count; j++)
{
IAbstractTypeBuilder test = builders[j];
if (i == j || test == null)
{
continue;
}
if (cur.IsCompatible(context, test) == false)
{
builders[j] = null;
}
}
}
for (int i = 0; i < builders.Count; i++)
{
if (builders[i] == null)
{
builders.RemoveAt(i--);
}
}
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
if (context.IsBuildStep)
{
return(false);
}
AbstractTypeBuilderList list = new AbstractTypeBuilderList(2);
list.Add(this);
list.Add(typeBuilder);
BuildStep step = context.Step;
try
{
context.Step = BuildStep.Build;
return(typeBuilder.IsApplied(context, list));
}
finally
{
context.Step = step;
}
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
if (typeBuilder is PropertyChangedBuilder)
return false;
return base.IsCompatible(context, typeBuilder);
}
protected bool IsRelative(IAbstractTypeBuilder typeBuilder)
{
if (typeBuilder == null)
{
throw new ArgumentNullException("typeBuilder");
}
return(GetType().IsInstanceOfType(typeBuilder) || typeBuilder.GetType().IsInstanceOfType(this));
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
if (typeBuilder is PropertyChangedBuilder)
{
return(false);
}
return(base.IsCompatible(context, typeBuilder));
}
private static AbstractTypeBuilderList GetBuilders(object[] attributes, object target)
{
AbstractTypeBuilderList builders = new AbstractTypeBuilderList(attributes.Length);
foreach (AbstractTypeBuilderAttribute attr in attributes)
{
IAbstractTypeBuilder builder = attr.TypeBuilder;
builder.TargetElement = target;
builders.Add(builder);
}
return(builders);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
if (context.IsBuildStep)
return false;
var list = new AbstractTypeBuilderList(2) { this, typeBuilder };
var step = context.Step;
try
{
context.Step = BuildStep.Build;
return typeBuilder.IsApplied(context, list);
}
finally
{
context.Step = step;
}
}
private static AbstractTypeBuilderList GetBuilders(ParameterInfo[] parameters)
{
AbstractTypeBuilderList builders = new AbstractTypeBuilderList();
foreach (ParameterInfo pi in parameters)
{
object[] attributes = pi.GetCustomAttributes(typeof(AbstractTypeBuilderAttribute), true);
foreach (AbstractTypeBuilderAttribute attr in attributes)
{
IAbstractTypeBuilder builder = attr.TypeBuilder;
builder.TargetElement = pi;
builders.Add(builder);
}
}
return(builders);
}
private static AbstractTypeBuilderList GetBuilderList(TypeHelper type)
{
object[] attrs = type.GetAttributes(typeof(AbstractTypeBuilderAttribute));
AbstractTypeBuilderList builders = new AbstractTypeBuilderList(attrs.Length);
foreach (AbstractTypeBuilderAttribute attr in attrs)
{
IAbstractTypeBuilder builder = attr.TypeBuilder;
if (builder != null)
{
builder.TargetElement = type;
builders.Add(builder);
}
}
return(builders);
}
private void DefineInterfaces()
{
foreach (KeyValuePair <TypeHelper, IAbstractTypeBuilder> de in _context.InterfaceMap)
{
_context.CurrentInterface = de.Key;
MethodInfo[] interfaceMethods = _context.CurrentInterface.GetMethods();
foreach (MethodInfo m in interfaceMethods)
{
if (_context.TypeBuilder.OverriddenMethods.ContainsKey(m))
{
continue;
}
BeginEmitMethod(m);
// Call builder to build the method.
//
IAbstractTypeBuilder builder = de.Value;
if (builder != null)
{
builder.ID = ++_idCounter;
_context.BuildElement = BuildElement.InterfaceMethod;
_context.Step = BuildStep.Build;
builder.Build(_context);
}
EndEmitMethod();
}
_context.CurrentInterface = null;
}
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
if (context.IsBuildStep)
{
return(false);
}
var list = new List <IAbstractTypeBuilder>(2)
{
this, typeBuilder
};
var step = context.Step;
try
{
context.Step = BuildStep.Build;
return(typeBuilder.IsApplied(context, list));
}
finally
{
context.Step = step;
}
}
public virtual bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return(true);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
var builder = typeBuilder as InterceptorAspectBuilder;
return(builder == null || _interceptorType != builder._interceptorType);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
var builder = typeBuilder as InterceptorAspectBuilder;
return builder == null || _interceptorType != builder._interceptorType;
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return(!(typeBuilder is InterceptorAspectBuilder builder) || _interceptorType != builder._interceptorType);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return(IsRelative(typeBuilder) == false);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return IsRelative(typeBuilder) == false;
}
private bool IsApplied(IAbstractTypeBuilder builder, AbstractTypeBuilderList builders, BuildStep buildStep)
{
_context.Step = buildStep;
return(builder.IsApplied(_context, builders));
}
public virtual bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return true;
}
protected bool IsRelative(IAbstractTypeBuilder typeBuilder)
{
if (typeBuilder == null) throw new ArgumentNullException("typeBuilder");
return GetType().IsInstanceOfType(typeBuilder) || typeBuilder.GetType().IsInstanceOfType(this);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return(true);
}
public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
{
return true;
}
