public void Mapper_CreateMap_NotExist_ContainerCount1()
{
Clean();
ExpressionMapper.CreateMap <ClassSource, ClassDest>().ForMember(s => s.PropString1, d => d.PropString2);
Assert.Equal(1, MapperConfigurationCollectionContainer.Instance.Count);
}
public void Not_Support_Enumerable_Test()
{
Assert.Throws <NotSupportedException>(() =>
{
ExpressionMapper.Map <IEnumerable <POCO>, IEnumerable <POCO> >(new List <POCO>()
{
new POCO()
{
Hello = "World"
}
});
});
Assert.Throws <NotSupportedException>(() =>
{
ExpressionMapper.Map <List <POCO>, List <POCO> >(new List <POCO>()
{
new POCO()
{
Hello = "World"
}
});
});
Assert.Throws <NotSupportedException>(() =>
{
ExpressionMapper.Map <POCO[], POCO[]>(new[] { new POCO()
{
Hello = "World"
} });
});
}
/// <summary>
/// 访问子表达式树
/// </summary>
/// <param name="node">访问表达式树</param>
/// <returns>
/// 改变表达式，如果它或它的任何子表达式被修改; 否则，返回原始表达式。
/// </returns>
protected override Expression VisitMember(MemberExpression node)
{
var expr = Visit(node.Expression);
if (expr != null && expr.Type != node.Type)
{
if (_mapper == null)
{
_mapper = ExpressionMapper.GetMapper(node.Member.DeclaringType, _destinationType);
}
Expression expDest;
// 认为原始类是简单属性（不是子对象）。
if (!expr.Type.IsValueType && expr.Type != typeof(string) && expr.NodeType != ExpressionType.Parameter && expr.NodeType != ExpressionType.Constant)
{
var subExp = ExpressionMapper.GetMapper(node.Member.DeclaringType, expr.Type);
expDest = subExp.GetLambdaDest(node.Member.Name);
return(AnalyseDestExpression(expr, expDest));
}
expDest = _mapper.GetLambdaDest(node.Member.Name);
if (expDest != null)
{
return(AnalyseDestExpression(expr, expDest));
}
}
return(base.VisitMember(node));
}
public void Map_NoActionException_Exception()
{
ExpressionMapper.GetMapper <ClassSource, ClassDest>().AfterMap(null);
ExpressionMapper.Initialize();
new ClassSource().Map <ClassSource, ClassDest>();
Clean();
}
public void ExpressionMapTest()
{
var date = DateTime.Now;
var clonnedClass = new MappedClass
{
DateTimeProp = date,
IntProp = 5,
StringProp = "qwe"
};
var destClass = new DestClass
{
DateTimeProp = date,
IntProp = 5,
StringProp = "qwe"
};
var mapper = new ExpressionMapper();
mapper.Register <MappedClass, DestClass>();
var mapped = mapper.Map <MappedClass, DestClass>(clonnedClass);
mapped.Should().BeEquivalentTo(destClass);
Assert.Pass();
}
public void ExpressionMapper_WorksWithJustDefaultMappings()
{
var foo = new Foo()
{
A = 5,
B = 10
};
var mapper = new ExpressionMapper <Foo, Bar>(
new ExpressionMappingComponents <Foo, Bar>(
defaultMappings: (Foo source) => new Bar()
{
A = source.A,
B = source.B,
}));
var @new = mapper.Map(foo);
Assert.AreEqual(@new.A, 5);
Assert.AreEqual(@new.B, 10);
Assert.AreEqual(@new.C, 0);
Assert.AreEqual(@new.E, null);
var existing = new Bar();
mapper.Map(foo, existing);
Assert.AreEqual(existing.A, 5);
Assert.AreEqual(existing.B, 10);
Assert.AreEqual(existing.C, 0);
Assert.AreEqual(existing.E, null);
}
/// <summary>
/// 匹配映射比较
/// 2个实体类做映射，将一个实体类的数据复制到另一个实体类上
/// 在领域模型中BO与DTO的映射
/// 可以使用：
/// 1.硬编码
/// 2.泛型+反射
/// 3.泛型+表达式树
/// </summary>
public static void MapperCompare()
{
People p = new People()
{
Id = 1001,
Number = 10,
Name = "VesNing",
Age = 28
};
var result1 = HardCodingMapper.Mapper(p);
result1.ToString();
var result2 = ReflectionMapper.Mapper <People, PeopleCopy>(p);
result2.ToString();
var result3 = SerializeMapper.Mapper(p);
result3.ToString();
var result4 = ExpressionMapper.Mapper <People, PeopleCopy>(p);
StopWatchRun((m) => { HardCodingMapper.Mapper(m); }, p, "硬编码");
StopWatchRun((m) => { ReflectionMapper.Mapper <People, PeopleCopy>(m); }, p, "泛型+反射");
StopWatchRun((m) => { SerializeMapper.Mapper(m); }, p, "NewtoneSoft序列化");
StopWatchRun((m) => { ExpressionMapper.Mapper <People, PeopleCopy>(m); }, p, "表达式树+字典缓存");
}
private static void Init()
{
Clean();
ExpressionMapper.CreateMap <ClassSource, ClassDest>().ForMember(s => s.PropString1, d => d.PropString2).ReverseMap();
ExpressionMapper.CreateMap <ClassDest2, ClassSource2>().ForMember(s => s.PropString2, d => d.PropString1).ReverseMap();
ExpressionMapper.Initialize();
}
public void GetPropertiesNotMapped_ReturnProperties_Success()
{
ExpressionMapper.Initialize();
PropertiesNotMapped actual = ExpressionMapper.GetPropertiesNotMapped <ClassSource, ClassDest>();
Assert.True(actual.SourceProperties.Count > 0);
Assert.True(actual.TargetProperties.Count > 0);
}
private static IQueryable <TDest> GetSelect <TSource, TDest>(IQueryable <TSource> query, string mapperName) where TSource : class where TDest : class
{
// 不需要mapper
if (typeof(TSource) == typeof(TDest))
{
return((IQueryable <TDest>)query);
}
return(query.Select(ExpressionMapper.GetMapper <TSource, TDest>(mapperName).GetLambdaExpression()));
}
public void ReverseMap_Success()
{
ExpressionMapper.Reset();
MapperConfigurationTestContainer expected = new MapperConfigurationTestContainer();
var actual = expected.ReverseMap();
Assert.IsType <MapperConfiguration <ClassDest, ClassSource> >(actual);
}
public void ReverseMap_Success()
{
ExpressionMapper.Reset();
MapperConfigurationTestContainer expected = new MapperConfigurationTestContainer();
var actual = expected.ReverseMap();
Assert.IsInstanceOfType(actual, typeof(MapperConfiguration <ClassDest, ClassSource>));
}
public void GetQuery_ReturnFunc()
{
Init(null);
ExpressionMapper.Initialize();
var actual = ExpressionMapper.GetQuery <ClassSource, ClassDest>();
Assert.IsNotNull(actual);
}
public void GetQuery_ReturnFunc()
{
Init();
ExpressionMapper.Initialize();
System.Func <ClassSource, ClassDest> actual = ExpressionMapper.GetQuery <ClassSource, ClassDest>();
Assert.Null(actual);
}
private static void Import(int time)
{
string curDir = Environment.CurrentDirectory;
string fileUrl = Path.Combine(curDir, "files", "CarImport.xlsx");
Stopwatch sw = new Stopwatch();
sw.Start();
var rows = ExcelImportService.Validate <ImportCar>(fileUrl, DBExist);
Console.WriteLine($"------------第{time}次导入，处理{rows.Where(e=>e.IsValid).Count()}条数据------------");
sw.Stop();
Console.WriteLine($"Exel读取以及校验耗时：{sw.ElapsedMilliseconds}");
List <ImportCar> list = new List <ImportCar>();
sw.Restart();
foreach (var item in rows.Where(e => e.IsValid))
{
//反射转换 - 5000条 6秒
item.ConvertByRefelection <ImportCar>();
}
sw.Stop();
Console.WriteLine($"直接反射转换耗时：{sw.ElapsedMilliseconds}");
sw.Restart();
foreach (var item in rows.Where(e => e.IsValid))
{
//反射转换 - 5000条 6秒
item.Convert <ImportCar>();
}
sw.Stop();
Console.WriteLine($"反射+委托转换耗时：{sw.ElapsedMilliseconds}");
sw.Restart();
foreach (var item in rows.Where(e => e.IsValid))
{
//Expression + 缓存转换 - 5000条3.5秒
list.Add(ExpressionMapper.FastConvert <ImportCar>(item));
}
sw.Stop();
Console.WriteLine($"表达式树转换耗时：{sw.ElapsedMilliseconds}");
sw.Restart();
foreach (var item in rows.Where(e => e.IsValid))
{
//Expression + 缓存转换 - 5000条3.5秒
list.Add(HardCode(item));
}
sw.Stop();
Console.WriteLine($"硬编码转换耗时：{sw.ElapsedMilliseconds}");
Console.WriteLine("\r\n");
}
public T GetByPredicate(Expression <Func <T, bool> > predicate)
{
if (predicate != null)
{
Expression <Func <U, T> > mapper = ExpressionMapper.ToDal((dynamic)context.Set <U>());
return(context.Set <U>().Select(mapper).FirstOrDefault(predicate));
}
throw new ArgumentNullException(nameof(predicate), "Predicate is null");
}
public IEnumerable <T> GetManyByPredicate(Expression <Func <T, bool> > predicate)
{
if (predicate != null)
{
Expression <Func <U, T> > mapper = ExpressionMapper.ToDal((dynamic)context.Set <U>());
return(context.Set <U>().Select(mapper).Where(predicate));
}
throw new ArgumentNullException(nameof(predicate), "Predicate is null");
}
public void GetQueryExpression_ReturnExpression()
{
Clean();
ExpressionMapper.CreateMap <ClassSource, ClassDest>().ForMember(s => s.PropString1, d => d.PropString2);
ExpressionMapper.Initialize();
var actual = ExpressionMapper.GetQueryExpression <ClassSource, ClassDest>();
Assert.IsNotNull(actual);
}
public void TestPropertyToPropertyBinary()
{
var sut = new ExpressionMapper(new FooBarMap());
var exp = sut.Map <Bar, Foo, bool>(_ => _.Id > 3 || _.Id < -1);
exp.Should().NotBeNull();
exp.Compile()(new Foo()).Should().BeFalse();
}
public void TestEmptyFilter()
{
var sut = new ExpressionMapper(new FooBarMap());
var exp = sut.Map <Bar, Foo, bool>(_ => true);
exp.Should().NotBeNull();
exp.Compile()(new Foo()).Should().BeTrue();
}
public void GetQueryExpression_ReturnExpression()
{
Clean();
ExpressionMapper.CreateMap <ClassSource, ClassDest>().ForMember(s => s.PropString1, d => d.PropString2);
ExpressionMapper.Initialize();
System.Linq.Expressions.Expression <System.Func <ClassSource, ClassDest> > actual = ExpressionMapper.GetQueryExpression <ClassSource, ClassDest>();
Assert.Null(actual);
}
public void Map_NoActionException_Exception()
{
Assert.Throws <NoActionAfterMappingException>(() =>
{
ExpressionMapper.GetMapper <ClassSource, ClassDest>().AfterMap(null);
ExpressionMapper.Initialize();
new ClassSource().Map <ClassSource, ClassDest>();
Clean();
});
}
public void TestPropertyToPropertyAccess()
{
var sut = new ExpressionMapper(new FooBarMap());
var exp = sut.Map <Bar, Foo, int>(_ => _.Id);
exp.Compile()(new Foo
{
Id = 10
}).Should().Be(10);
}
/// <summary>
/// 获取转换函数
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="row">单元行</param>
private static Func <IList <ICell>, T> GetFunc <T>(IRow row)
{
var propertyNames = string.Empty;
row.Cells.ForEach(cell => propertyNames += cell.PropertyName + "_");
var key = typeof(T).FullName + "_" + propertyNames.Trim('_');
var props = typeof(T).GetProperties().Where(x => x.CanWrite && x.CanRead && !x.HasIgnore());
var func = ExpressionMapper.GetFunc <T>(key, props);
return(func);
}
public void ThenBy_Success()
{
ExpressionMapper.CreateMap <ClassSource, ClassDest>().ForMember(s => s.PropString1, d => d.PropString2);
ExpressionMapper.Initialize();
QueryableImplTest <ClassSource> expected = new QueryableImplTest <ClassSource>();
IQueryable <ClassSource> actual = expected.OrderByDescending <ClassSource, ClassDest>("PropInt1").ThenBy <ClassSource, ClassDest>("PropInt1");
Assert.IsTrue(CheckExpressionMethod(actual.Expression, nameof(QueryableExtentions.ThenBy)));
}
public void CreateMemberAssignementForExisting_Succes()
{
MapperConfigurationTestContainer expected = new MapperConfigurationTestContainer();
MapperConfigurationCollectionContainer.Instance.Add(expected);
ExpressionMapper.CreateMap <ClassSource2, ClassDest2>();
expected.CreateMappingExpression(null);
Assert.Null(expected.GetDelegateForExistingTargetTest());
}
public void TestPropertyToPropertyExtensionMethodCall()
{
var sut = new ExpressionMapper(new FooBarMap());
var exp = sut.Map <Bar, Foo, bool>(_ => _.Ids.Any(id => id > 5));
exp.Should().NotBeNull();
exp.Compile()(new Foo {
Ids = new[] { 1, 2, 10 }
}).Should().BeTrue();
}
public void GetDestinationType_WithServiceConstructor()
{
ExpressionMapper.ConstructServicesUsing((x) => new ClassDest2());
var mapper = ExpressionMapper.CreateMap <ClassSource2, IClassDest2>().ConstructUsingServiceLocator();
ExpressionMapper.Initialize();
var actual = mapper.GetDestinationType();
Assert.AreEqual(actual, typeof(ClassDest2));
ExpressionMapper.Reset();
}
public void GetDestinationType_WithServiceConstructor()
{
ExpressionMapper.ConstructServicesUsing((x) => new ClassDest2());
MapperConfiguration <ClassSource2, IClassDest2> mapper = ExpressionMapper.CreateMap <ClassSource2, IClassDest2>().ConstructUsingServiceLocator();
ExpressionMapper.Initialize();
Type actual = mapper.GetDestinationType();
Assert.IsType <ClassDest2>(actual);
ExpressionMapper.Reset();
}
public void TestPropertyToPropertyWithConversionExtensionMethodCall()
{
var sut = new ExpressionMapper(new FooBarConversionMap());
var exp = sut.Map <Bar, Foo, bool>(_ => _.Names.Any());
exp.Should().NotBeNull();
exp.Compile()(new Foo {
Ids = new[] { 0 }
}).Should().BeTrue();
}
public void TestFromAtoB()
{
var mapper = new ExpressionMapper<TestA, TestB>()
.Map(x => x.AValue1, x => x.BValue1)
.Map(x => x.AValue2, x => x.BValue2);
var testA = new TestA()
{
AValue1 = "TestValue",
AValue2 = 42
};
var testB = mapper.MapAtoB(testA);
Assert.AreEqual("TestValue", testB.BValue1);
Assert.AreEqual(42, testB.BValue2);
}
public void TestFromBtoA()
{
var mapper = new ExpressionMapper<TestA, TestB>()
.Map(x => x.AValue1, x => x.BValue1)
.Map(x => x.AValue2, x => x.BValue2);
var testB = new TestB()
{
BValue1 = "TestValue",
BValue2 = 42
};
var testA = mapper.MapBtoA(testB);
Assert.AreEqual("TestValue", testA.AValue1);
Assert.AreEqual(42, testA.AValue2);
}
public void TestExpressionMapper_Int()
{
//Arrange
var em = new ExpressionMapper<TestRecord, Test_Int>();
var tr = new TestRecord { Steps = new List<TestStepRecord> { new TestStepRecord {Step = "Test" } } };
//Act
var t = em.GetMapper()(tr);
//Assert
Assert.IsTrue(t.Steps.Count == 1);
Assert.IsTrue(t.NotNullSetterCalled);
}
public void NoCrossRef()
{
var mapper = new ExpressionMapper<Class20,Class21> { HandleBackReferences = false }.GetMapper();
var source = new Class20();
source.Class2 = source.Class1;
var dest = mapper(source);
Assert.IsNotNull (dest.Class1);
Assert.IsNotNull (dest.Class2);
Assert.AreNotSame(dest.Class1, dest.Class2);
}
