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); }