/// <summary>
/// Creates an instance of an ImplicitInterceptor which can intercept
/// interface calls and route them to the implicit instance implementations
/// of the specific methods.
/// </summary>
/// <param name="instance">The instance being wrapped by this interceptor
/// which does not implement the specific interface.</param>
/// <param name="methodsCache">A supplied cache that will help increase
/// performance when fetching for an implementation of a Method.</param>
/// <param name="proxyWrapperFactory">The proxy factory that will be used
/// recursively to get any children implicit implementations.</param>
public ImplicitInterceptor(object instance,
IDictionary <MethodInfo, MethodInfo> methodsCache,
IProxyWrapperFactory proxyWrapperFactory)
{
_instance = instance;
_methodsCache = methodsCache;
_proxyWrapperFactory = proxyWrapperFactory;
}
/// <summary>
/// Wraps the current instance as the specific interface by implementing it
/// implicitly. However, a NotImplementedException exception is thrown if the
/// interface method is not implemented by the instance.
/// </summary>
/// <typeparam name="TInterface">The interface type to</typeparam>
/// <param name="instance">The instance to wrap.</param>
/// <param name="factory">The factory engine that generates the
/// wrapped instance.</param>
/// <returns>The wrapped instance as the specific interface.</returns>
public static TInterface As <TInterface>(this object instance,
IProxyWrapperFactory factory) where TInterface : class
{
if (instance == null)
{
throw new ArgumentNullException(nameof(instance));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (!typeof(TInterface).IsInterface)
{
throw new InvalidOperationException(
$"{typeof(TInterface).Name} is not an interface!");
}
return(factory.Wrap(typeof(TInterface), instance) as TInterface);
}
