private static IEnumerable <MethodInfo> GetMethodsMissingFromInstance(IEnumerable <MethodInfo> methods, object instance)
{
var instanceSupportsMethod = DynamicInterfaceExtensions.GenerateInstanceSupportsMethod(instance);
var instanceType = instance.GetType();
var instanceMethods = instanceType.GetPublicMethods();
var instanceFields = instanceType.GetPublicDelegateFields();
var instanceProperties = instanceType.GetPublicDelegateProperties();
// later, we can check for a delegate-creation function that can deliver a delegate to us by name and parameter types.
// currently, we don't need that, so we're not going to implement it right away.
return(methods.Where(method =>
!instanceSupportsMethod(method.Name) || (
instanceMethods.FindMethod(method) == null &&
instanceFields.FindDelegate(instance, method) == null &&
instanceProperties.FindDelegate(instance, method) == null
)));
}
private static object CreateProxy(Type tInterface, params object[] instances)
{
var matrix = instances.SelectMany(instance => {
var instanceType = instance.GetType();
// get all the public interfaces for the instances and place them at the top
// and let it try to bind against those.
return(instanceType.GetInterfaces().Where(each => each.IsPublic).Select(each => new {
instance,
SupportsMethod = DynamicInterfaceExtensions.GenerateInstanceSupportsMethod(instance),
Type = each,
Methods = each.GetPublicMethods(),
Fields = each.GetPublicDelegateFields(),
Properties = each.GetPublicDelegateProperties()
}).ConcatSingleItem(new {
instance,
SupportsMethod = DynamicInterfaceExtensions.GenerateInstanceSupportsMethod(instance),
Type = instanceType,
Methods = instanceType.GetPublicMethods(),
Fields = instanceType.GetPublicDelegateFields(),
Properties = instanceType.GetPublicDelegateProperties()
}));
}).ToArray();
var instanceMethods = new OrderedDictionary <Type, List <MethodInfo, MethodInfo> >();
var delegateMethods = new List <Delegate, MethodInfo>();
var stubMethods = new List <MethodInfo>();
var usedInstances = new List <Type, object>();
foreach (var method in tInterface.GetVirtualMethods())
{
// figure out where it's going to get implemented
var found = false;
foreach (var instance in matrix)
{
if (method.Name == "IsMethodImplemented")
{
// skip for now, we'll implement this at the end
found = true;
break;
}
if (instance.SupportsMethod(method.Name))
{
var instanceMethod = instance.Methods.FindMethod(method);
if (instanceMethod != null)
{
instanceMethods.GetOrAdd(instance.Type, () => new List <MethodInfo, MethodInfo>()).Add(method, instanceMethod);
if (!usedInstances.Contains(instance.Type, instance.instance))
{
usedInstances.Add(instance.Type, instance.instance);
}
found = true;
break;
}
var instanceDelegate = instance.Fields.FindDelegate(instance.instance, method) ?? instance.Properties.FindDelegate(instance.instance, method);
if (instanceDelegate != null)
{
delegateMethods.Add(instanceDelegate, method);
found = true;
break;
}
}
}
if (!found && (tInterface.IsInterface || method.IsAbstract))
{
#if xDEEPDEBUG
Console.WriteLine(" Generating stub method for {0} -> {1}".format(tInterface.NiceName(), method.ToSignatureString()));
#endif
stubMethods.Add(method);
}
}
return(DynamicType.Create(tInterface, instanceMethods, delegateMethods, stubMethods, usedInstances));
}
