public Type CreateClassProxyType(Type classToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
{
AssertValidType(classToProxy);
AssertValidTypes(additionalInterfacesToProxy);
var generator = new ClassProxyGenerator(scope, classToProxy) { Logger = logger };
return generator.GenerateCode(additionalInterfacesToProxy, options);
}
public Type CreateInterfaceProxyTypeWithTarget(Type interfaceToProxy, Type[] additionalInterfacesToProxy,
Type targetType,
ProxyGenerationOptions options)
{
AssertValidType(interfaceToProxy);
AssertValidTypes(additionalInterfacesToProxy);
var generator = new InterfaceProxyWithTargetGenerator(scope, interfaceToProxy) { Logger = logger };
return generator.GenerateCode(targetType, additionalInterfacesToProxy, options);
}
public object Create(Type type, MocksRepository repository, IMockMixin mockMixinImpl, MockCreationSettings settings, bool createTransparentProxy)
{
var options = new ProxyGenerationOptions();
options.AddMixinInstance(mockMixinImpl);
foreach (var mixin in settings.Mixins)
options.AddMixinInstance(mixin);
if (settings.AdditionalProxyTypeAttributes != null)
{
foreach (var attr in settings.AdditionalProxyTypeAttributes)
{
options.AdditionalAttributes.Add(attr);
}
}
var interceptor = repository.Interceptor;
#if SILVERLIGHT
options.Hook = new ProxyGenerationHook(false, settings.InterceptorFilter);
#else
options.Hook = new ProxyGenerationHook(settings.MockConstructorCall, settings.InterceptorFilter);
#endif
object instance = null;
Exception proxyFailure = null;
if (type.IsInterface)
{
if (settings.Args != null && settings.Args.Length > 0)
throw new ArgumentException("Do not supply contructor arguments when mocking an interface or delegate.");
try
{
instance = generator.CreateInterfaceProxyWithoutTarget(type, settings.AdditionalMockedInterfaces, options, interceptor);
}
catch (TypeLoadException ex)
{
proxyFailure = ex;
}
catch (GeneratorException ex)
{
proxyFailure = ex;
}
}
else
{
try
{
#if SILVERLIGHT
if (settings.Args == null || settings.Args.Length == 0)
{
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (!constructors.Any(constr => constr.GetParameters().Length == 0))
{
var constructorToCall = constructors.FirstOrDefault();
if (constructorToCall != null)
{
var @params = constructorToCall.GetParameters();
settings.Args = new object[@params.Length];
for (int i = 0; i < @params.Length; ++i)
{
var p = @params[i];
settings.Args[i] = Convert.IsDBNull(p.DefaultValue)
? p.ParameterType.GetDefaultValue()
: p.DefaultValue;
}
}
}
}
#endif
instance = generator.CreateClassProxy(type, settings.AdditionalMockedInterfaces, options, settings.Args, interceptor);
}
catch (TypeLoadException ex)
{
proxyFailure = ex;
}
catch (GeneratorException ex)
{
proxyFailure = ex;
}
catch (InvalidProxyConstructorArgumentsException ex)
{
proxyFailure = ex;
if (!settings.MockConstructorCall)
throw new MockException(ex.Message);
}
}
if (proxyFailure != null)
{
throw new ProxyFailureException(proxyFailure);
}
return instance;
}
private ProxyGenerationOptions CreateProxyGenerationOptions(Type type, MockCreationSettings settings, MockMixin mockMixinImpl = null)
{
var options = new ProxyGenerationOptions();
if (mockMixinImpl != null)
options.AddMixinInstance(mockMixinImpl);
foreach (var mixin in settings.Mixins)
options.AddMixinInstance(mixin);
if (settings.AdditionalProxyTypeAttributes != null)
{
foreach (var attr in settings.AdditionalProxyTypeAttributes)
{
options.AdditionalAttributes.Add(attr);
}
}
return options;
}
public IMockMixin CreateExternalMockMixin(IMockMixin mockMixin, IEnumerable<object> mixins)
{
var options = new ProxyGenerationOptions();
options.AddMixinInstance(mockMixin);
foreach (var mixin in mixins)
options.AddMixinInstance(mixin);
var compoundMockMixin = (IMockMixin)generator.CreateClassProxy(typeof(MocksRepository.ExternalMockMixin), options);
return compoundMockMixin;
}
