public void MapperInstance()
{
var customer = GetCustomer();
var mapper1 = new MapperInstance();
var mapper2 = new MapperInstance();
mapper1.AddMap <Customer, CustomerInput>((from) =>
{
var input = new CustomerInput();
input.InjectFrom(from);
return(input);
});
mapper2.AddMap <Customer, CustomerInput>((from) =>
{
var input = new CustomerInput();
input.FirstName = from.FirstName;
return(input);
});
var input1 = mapper1.Map <CustomerInput>(customer);
var input2 = mapper2.Map <CustomerInput>(customer);
Assert.AreEqual(customer.LastName, input1.LastName);
Assert.AreEqual(null, input2.LastName);
}
public void ShouldMapDifferentlyUsingMultipleMapperInstances()
{
var mapper1 = new MapperInstance();
var mapper2 = new MapperInstance();
Mapper.AddMap <Customer, Customer>(o => (Customer) new Customer().InjectFrom(o));
mapper1.AddMap <Customer, Customer>(o => new Customer {
Id = 1, FirstName = "mapper1"
});
mapper2.AddMap <Customer, Customer>(o => new Customer {
Id = 2, FirstName = "mapper2"
});
var customer = GetCustomer();
var m1 = mapper1.Map <Customer>(customer);
var m2 = mapper2.Map <Customer>(customer);
var m = Mapper.Map <Customer>(customer);
Assert.AreEqual(customer.Id, m.Id);
Assert.AreEqual(1, m1.Id);
Assert.AreEqual("mapper1", m1.FirstName);
Assert.AreEqual(2, m2.Id);
Assert.AreEqual("mapper2", m2.FirstName);
}
public static void Configure()
{
// tag is being used here to pass in the existing Entity ( pulled from the Db )
CrudMapper.DefaultMap = (src, resType, tag) =>
{
var res = tag != null && tag.GetType().IsSubclassOf(typeof(Entity)) ? tag : Activator.CreateInstance(resType);
// handle basic properties
res.InjectFrom(src);
var srcType = src.GetType();
// handle the rest Country.Id <-> CountryId; int <-> int?
if (srcType.IsSubclassOf(typeof(Entity)) && resType.IsSubclassOf(typeof(Input)))
{
res.InjectFrom <NormalToNullables>(src)
.InjectFrom <EntitiesToInts>(src);
}
else if (srcType.IsSubclassOf(typeof(Input)) && resType.IsSubclassOf(typeof(Entity)))
{
res.InjectFrom(new IntsToEntities(), src);
res.InjectFrom <IntsToEntities>(src)
.InjectFrom <NullablesToNormal>(src);
}
return(res);
};
CrudMapper.AddMap <Dinner, DinnerInput>((dinner, tag) =>
{
var res = CrudMapper.MapDefault <DinnerInput>(dinner, tag);
res.Time = dinner.Start;
res.Duration = (int)dinner.End.Subtract(dinner.Start).TotalMinutes;
return(res);
});
CrudMapper.AddMap <DinnerInput, Dinner>((input, tag) =>
{
var res = CrudMapper.MapDefault <Dinner>(input, tag);
res.Start = res.Start.Date + input.Time.Value.TimeOfDay;
res.End = res.Start.AddMinutes(input.Duration);
return(res);
});
}
/// <summary>
/// 数据传输对象测试
/// </summary>
public void DtoTest()
{
Console.WriteLine("******************************使用ValueInjecter实现值注入*******************************************");
Omu.ValueInjecter.Mapper.AddMap <Student, StudentDto>(src =>
{
var name = "test";
var dto = new StudentDto
{
id = src.id,
name = $"{src.fname}{src.lname}"
};
return(dto);
});
var users1 = Omu.ValueInjecter.Mapper.Map <Student, StudentDto>(new Students().stus.First());
Omu.ValueInjecter.Mapper.AddMap <Student, StudentDto>((src, tag) =>
{
var par = (Nametest)tag;
var res = new StudentDto {
name = par.Name
};
return(res);
});
var users2 = Omu.ValueInjecter.Mapper.Map <StudentDto>(new Students().stus.First(), new Nametest {
Name = "help"
});
var mapper1 = new MapperInstance();
mapper1.AddMap <Student, Student>(o => new Student {
fname = "mapper1"
});
var users3 = mapper1.Map <Student>(new Students().stus.First());
TextMessage msg = new TextMessage();
var s = msg.InjectFrom <XmlStrInjection>(MsgDemo1);
}
public void ShouldMapDifferentlyUsingMultipleMapperInstances()
{
var mapper1 = new MapperInstance();
var mapper2 = new MapperInstance();
Mapper.AddMap<Customer, Customer>(o => (Customer)new Customer().InjectFrom(o));
mapper1.AddMap<Customer, Customer>(o => new Customer { Id = 1, FirstName = "mapper1" });
mapper2.AddMap<Customer, Customer>(o => new Customer { Id = 2, FirstName = "mapper2" });
var customer = GetCustomer();
var m1 = mapper1.Map<Customer>(customer);
var m2 = mapper2.Map<Customer>(customer);
var m = Mapper.Map<Customer>(customer);
Assert.AreEqual(customer.Id, m.Id);
Assert.AreEqual(1, m1.Id);
Assert.AreEqual("mapper1", m1.FirstName);
Assert.AreEqual(2, m2.Id);
Assert.AreEqual("mapper2", m2.FirstName);
}
public static void AddMap <TSource, TResult>(Func <TSource, TResult> func)
{
Instance.AddMap <TSource, TResult>(func);
}
private void MapperConfigure(MapperInstance cfd)
{
cfd.AddMap<Person, PersonInfoDto>(src =>
{
PersonInfoDto dst = new PersonInfoDto();
dst.InjectFrom(src);
dst.EmployeeBrithDate = src.Employee?.BirthDate;
return dst;
});
cfd.AddMap<EmailAddress, EmailDto>(src =>
{
EmailDto dst = new EmailDto();
dst.InjectFrom(src);
dst.EmailAddress = src.EmailAddress1;
return dst;
});
cfd.AddMap<ShipMethod, ShipMethodDto>(src =>
{
ShipMethodDto dst = new ShipMethodDto();
dst.InjectFrom(src);
return dst;
});
cfd.AddMap<ProductListPriceHistory, ProductListPriceHistoryDto>(src =>
{
ProductListPriceHistoryDto dst = new ProductListPriceHistoryDto();
dst.InjectFrom(src);
return dst;
});
cfd.AddMap<Product, ProductDto>(src =>
{
ProductDto dst = new ProductDto();
dst.InjectFrom(src);
dst.ProductListPriceHistories = new List<ProductListPriceHistoryDto>();
foreach (ProductListPriceHistory item in src.ProductListPriceHistories)
{
ProductListPriceHistoryDto itemDto = new ProductListPriceHistoryDto();
itemDto.InjectFrom(item);
dst.ProductListPriceHistories.Add(itemDto);
}
return dst;
});
cfd.AddMap<ProductModel, ProductModelDto>(src =>
{
ProductModelDto dst = new ProductModelDto();
dst.InjectFrom(src);
return dst;
});
cfd.AddMap<Product, Product2Dto>(src =>
{
Product2Dto dst = new Product2Dto();
dst.InjectFrom(src);
dst.ProductModel = new ProductModelDto();
dst.ProductModel.InjectFrom(src.ProductModel);
dst.ProductModelID = src.ProductModel?.ProductModelID;
return dst;
});
}
private void MapperConfigure(MapperInstance cfd)
{
cfd.AddMap <Person, PersonInfoDto>(src =>
{
PersonInfoDto dst = new PersonInfoDto();
dst.InjectFrom(src);
dst.EmployeeBrithDate = src.Employee?.BirthDate;
return(dst);
});
cfd.AddMap <EmailAddress, EmailDto>(src =>
{
EmailDto dst = new EmailDto();
dst.InjectFrom(src);
dst.EmailAddress = src.EmailAddress1;
return(dst);
});
cfd.AddMap <ShipMethod, ShipMethodDto>(src =>
{
ShipMethodDto dst = new ShipMethodDto();
dst.InjectFrom(src);
return(dst);
});
cfd.AddMap <ProductListPriceHistory, ProductListPriceHistoryDto>(src =>
{
ProductListPriceHistoryDto dst = new ProductListPriceHistoryDto();
dst.InjectFrom(src);
return(dst);
});
cfd.AddMap <Product, ProductDto>(src =>
{
ProductDto dst = new ProductDto();
dst.InjectFrom(src);
dst.ProductListPriceHistories = new List <ProductListPriceHistoryDto>();
foreach (ProductListPriceHistory item in src.ProductListPriceHistories)
{
ProductListPriceHistoryDto itemDto = new ProductListPriceHistoryDto();
itemDto.InjectFrom(item);
dst.ProductListPriceHistories.Add(itemDto);
}
return(dst);
});
cfd.AddMap <ProductModel, ProductModelDto>(src =>
{
ProductModelDto dst = new ProductModelDto();
dst.InjectFrom(src);
return(dst);
});
cfd.AddMap <Product, Product2Dto>(src =>
{
Product2Dto dst = new Product2Dto();
dst.InjectFrom(src);
dst.ProductModel = new ProductModelDto();
dst.ProductModel.InjectFrom(src.ProductModel);
dst.ProductModelID = src.ProductModel?.ProductModelID;
return(dst);
});
}
private static void DefineApplicationToApplicationModelMapping()
{
MapperObject.AddMap <Application, ApplicationModel>(src =>
{
var res = new ApplicationModel();
res.InjectFrom(src);
res.TenantDomain = src.DomainId;
if (src.ToolRelationships != null)
{
var tools = from t in src.ToolRelationships where t.ApplicationId == src.ApplicationId select new Tool()
{
ToolId = t.ToolId
};
res.Tools = tools.Select(x => MapperObject.Map <Tool, ToolModel>(x)).ToList();
}
if (src.AccessoryRelationships != null)
{
var accessories = from a in src.AccessoryRelationships where a.ApplicationId == src.ApplicationId select new Accessory()
{
AccessoryId = a.AccessoryId
};
res.Accessories = accessories.Select(x => MapperObject.Map <Accessory, AccessoryModel>(x)).ToList();
}
return(res);
});
}
