public void CreateTypeForComplexInterface()
{
Type iClass = DynamicTypeGenerator.GetTypeForInterface(typeof(IComplexInterface));
IComplexInterface instance = (IComplexInterface)Activator.CreateInstance(iClass);
instance.ShouldNotBeNull();
instance.Id = 42;
instance.Foo = new Foo();
instance.NullableInt = 123;
instance.Name = "Lorem ipsum";
instance.Ints = new List <int>();
instance.IntArray = new int[2];
instance.Foos = new List <Foo>();
instance.FooArray = new Foo[2];
instance.Id.ShouldBe(42);
instance.Foo.ShouldNotBeNull();
instance.NullableInt.ShouldBe(123);
instance.Name.ShouldBe("Lorem ipsum");
int i = 0;
string s = null;
Should.Throw <NotImplementedException>(() => instance.BaseMethod(), "Call BaseMethod.");
Should.Throw <NotImplementedException>(() => instance.SimpleMethod(), "Call SimpleMethod.");
Should.Throw <NotImplementedException>(() => instance.ComplexMethod(123, ref i, out s), "Call ComplexMethod.");
}
public void ThrowExceptionWhenInterfaceIsNotVisible()
{
void action() => DynamicTypeGenerator.GetTypeForInterface(typeof(INotVisibleInterface));
var ex = Should.Throw <InvalidOperationException>(action);
ex.Message.ShouldContain("not accessible");
}
public void CreateTypeForSimpleInterface()
{
Type iClass = DynamicTypeGenerator.GetTypeForInterface(typeof(ISimpleInterface));
ISimpleInterface instance = (ISimpleInterface)Activator.CreateInstance(iClass);
instance.ShouldNotBeNull();
instance.Id = 42;
instance.Name = "Lorem ipsum";
instance.Id.ShouldBe(42);
instance.Name.ShouldBe("Lorem ipsum");
}
protected virtual Expression CreateInstantiationExpression(Expression source, Expression?destination, CompileArgument arg)
{
//new TDestination()
//if there is constructUsing, use constructUsing
var constructUsing = arg.GetConstructUsing();
if (constructUsing != null)
{
var args = destination == null ? new[] { source } : new[] { source, destination };
return(constructUsing.Apply(arg.MapType, args)
.TrimConversion(true)
.To(arg.DestinationType));
}
//if there is default constructor, use default constructor
else if (arg.DestinationType.HasDefaultConstructor())
{
return(Expression.New(arg.DestinationType));
}
//if mapToTarget or include derived types, allow mapping & throw exception on runtime
//instantiation is not needed
else if (destination != null || arg.Settings.Includes.Count > 0)
{
return(Expression.Throw(
Expression.New(
// ReSharper disable once AssignNullToNotNullAttribute
typeof(InvalidOperationException).GetConstructor(new[] { typeof(string) }),
Expression.Constant("Cannot instantiate type: " + arg.DestinationType.Name)),
arg.DestinationType));
}
//if mapping to interface, create dynamic type implementing it
else if (arg.DestinationType.GetTypeInfo().IsInterface)
{
return(Expression.New(DynamicTypeGenerator.GetTypeForInterface(arg.DestinationType)));
}
//otherwise throw
else
{
throw new InvalidOperationException($"No default constructor for type '{arg.DestinationType.Name}', please use 'ConstructUsing' or 'MapWith'");
}
}
protected override Expression CreateInstantiationExpression(Expression source, Expression?destination, CompileArgument arg)
{
//new TDestination(src.Prop1, src.Prop2)
if (arg.GetConstructUsing() != null)
{
return(base.CreateInstantiationExpression(source, destination, arg));
}
var destType = arg.DestinationType.GetTypeInfo().IsInterface
? DynamicTypeGenerator.GetTypeForInterface(arg.DestinationType)
: arg.DestinationType;
var ctor = destType.GetConstructors()[0];
var classModel = GetConstructorModel(ctor, false);
var classConverter = CreateClassConverter(source, classModel, arg);
return(CreateInstantiationExpression(source, classConverter, arg));
}
protected override Expression CreateInstantiationExpression(Expression source, Expression?destination, CompileArgument arg)
{
//new TDestination(src.Prop1, src.Prop2)
if (arg.GetConstructUsing() != null || arg.Settings.MapToConstructor == null)
{
return(base.CreateInstantiationExpression(source, destination, arg));
}
ClassMapping?classConverter;
var ctor = arg.Settings.MapToConstructor as ConstructorInfo;
if (ctor == null)
{
var destType = arg.DestinationType.GetTypeInfo().IsInterface
? DynamicTypeGenerator.GetTypeForInterface(arg.DestinationType, arg.Settings.Includes.Count > 0)
: arg.DestinationType;
if (destType == null)
{
return(base.CreateInstantiationExpression(source, destination, arg));
}
classConverter = destType.GetConstructors()
.OrderByDescending(it => it.GetParameters().Length)
.Select(it => GetConstructorModel(it, true))
.Select(it => CreateClassConverter(source, it, arg))
.FirstOrDefault(it => it != null);
}
else
{
var model = GetConstructorModel(ctor, false);
classConverter = CreateClassConverter(source, model, arg);
}
if (classConverter == null)
{
return(base.CreateInstantiationExpression(source, destination, arg));
}
return(CreateInstantiationExpression(source, classConverter, arg));
}