public IEnumerable <DetailsModel> GetAllArticle()
{
// return new string[] { "value1", "value2" };
var artCollection = MapperTools.MapToCollection <ArticleBl, DetailsModel>(_articleService.GetAll());
return(artCollection);
}
//added of the gpk, leaving the game files untouched
private void AddCompsite(GpkPackage package, string savepath, string tmpPath, string compositeFile)
{
var patchDataSize = new FileInfo(tmpPath).Length;
//patch mappings
if (package.CompositeEntry != null)
{
//remove from old
CompositeMap[Path.GetFileNameWithoutExtension(package.Path)].Remove(package.CompositeEntry);
//modify our entry
package.CompositeEntry.FileLength = (int)patchDataSize;
package.CompositeEntry.FileOffset = 0;
package.CompositeEntry.SubGPKName = compositeFile;
if (!CompositeMap.ContainsKey(compositeFile))
{
CompositeMap[compositeFile] = new List <CompositeMapEntry>();
}
CompositeMap[compositeFile].Add(package.CompositeEntry);
MapperTools.WriteMappings(savepath, this, true, false);
}
}
//in-sito patch of a composite gpk file, as in modifing the actual game files
private void PatchComposite(GpkPackage package, string savepath, string tmpPath)
{
//ugly and quick, replace with direct memory save
//patch, move entries
var compositeData = File.ReadAllBytes(package.Path);
var patchData = File.ReadAllBytes(tmpPath);
var patchDiff = patchData.Length - package.CompositeEntry.FileLength;
var compositeSize = compositeData.Length;
var compsiteFileEnd = package.CompositeEntry.FileOffset + package.CompositeEntry.FileLength;
if (patchDiff >= 0)
{
//enlarge
Array.Resize(ref compositeData, compositeSize + patchDiff);
}
//move data up/down
var upperData = new byte[compositeSize - compsiteFileEnd];
Array.ConstrainedCopy(compositeData, compsiteFileEnd, upperData, 0, upperData.Length);
//patchdiff could be negative, so data can be moved down
Array.ConstrainedCopy(upperData, 0, compositeData, compsiteFileEnd + patchDiff, upperData.Length);
//copy it in
Array.ConstrainedCopy(patchData, 0, compositeData, package.CompositeEntry.FileOffset, patchData.Length);
if (patchDiff < 0)
{
//shrink
Array.Resize(ref compositeData, compositeSize + patchDiff);
}
File.WriteAllBytes(savepath, compositeData);
//patch mappings
if (package.CompositeEntry != null && package.CompositeEntry.FileLength != patchData.Length)
{
//modify entries accordingly
foreach (var entry in CompositeMap[Path.GetFileNameWithoutExtension(package.Path)])
{
if (entry.FileOffset > package.CompositeEntry.FileOffset)
{
entry.FileOffset += patchDiff;
}
}
//modify our entry
package.CompositeEntry.FileLength = patchData.Length;
MapperTools.WriteMappings(CoreSettings.Default.CookedPCPath, this, true, false);
}
}
public ActionResult Edit(int id, DetailsModel model)
{
try
{
// TODO: Add update logic here
if (ModelState.IsValid)
{
_articleService.Update(MapperTools.MapTo <DetailsModel, ArticleBl>(model));
return(RedirectToAction("ListArticle"));
}
return(View(model));
}
catch
{
return(View());
}
}
/// <summary>
/// 拷贝数组
/// </summary>
/// <typeparam name="TElement">源数组元素类型</typeparam>
/// <param name="source">源List</param>
/// <returns>深拷贝完成的数组</returns>
public static TElement[] CopyArray <TElement>(TElement[] source) where TElement : class
{
TElement[] result = new TElement[source.Length];
if (MapperTools.IsRefTypeExceptString(typeof(TElement)))
{
for (int i = 0; i < source.Length; i++)
{
result[i] = ExpressionGenericMapper <TElement, TElement> .Copy(source[i]);
}
}
else
{
for (int i = 0; i < source.Length; i++)
{
result[i] = source[i];
}
}
return(result);
}
/// <summary>
/// 拷贝List
/// </summary>
/// <typeparam name="T">源ICollection实现类类型</typeparam>
/// <typeparam name="TElement">源ICollection元素类型</typeparam>
/// <param name="source">源ICollection对象</param>
/// <returns>深拷贝完成的ICollection对象</returns>
public static T CopyICollection <T, TElement>(T source) where T : ICollection <TElement> where TElement : class
{
T result = (T)MapperTools.CreateNewInstance(source.GetType());
if (MapperTools.IsRefTypeExceptString(typeof(TElement)))
{
foreach (TElement item in source)
{
result.Add(ExpressionGenericMapper <TElement, TElement> .Copy(item));
}
}
else
{
foreach (TElement item in source)
{
result.Add(item);
}
}
return(result);
}
//patch pkgmapper to not include the modified entrys
public void MultiPatchObjectMapper(GpkPackage package, string savepath)
{
int count = 0;
foreach (var export in package.ExportList)
{
//generate name
//S1UI_SelectServer.SelectServer_I4
var fullUID = $"{package.Filename.Split('.')[0]}.{export.Value.UID}";
var compositeUID = FindObjectMapperEntryForObjectname(fullUID);
if (compositeUID != null)
{
ObjectMapperList.Remove(compositeUID);
logger.Debug("ObjectMapperList: removing uid " + fullUID);
count++;
}
}
logger.Info("Removed the mappings for {0} entries. For details see debug log.", count);
MapperTools.WriteMappings(savepath, this, false, true);
}
public ActionResult Create(DetailsModel model)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
model.DateTime = DateTime.Now;
model.AuthorId = 1;
_articleService.Add(MapperTools.MapTo <DetailsModel, ArticleBl>(model));
string subject = "Creatr Article";
string to = "*****@*****.**";
string from = "*****@*****.**";
string body = model.Title;
_emailService.SendSmpt(subject, body, from, to);
return(RedirectToAction("ListArticle"));
}
return(View(model));
}
catch
{
return(View());
}
}
private static Func <TSource, TDest> GetMapFunc()
{
var sourceType = typeof(TSource);
var targetType = typeof(TDest);
if (MapperTools.IsEnumerable(sourceType) || MapperTools.IsEnumerable(targetType))
{
throw new NotSupportedException("数组类型暂不支持对象映射，请使用List类型");
}
//Func委托传入变量
var parameter = Expression.Parameter(sourceType, "p");
var memberBindings = new List <MemberBinding>();
var targetTypes = targetType.GetProperties().Where(x => x.PropertyType.IsPublic && x.CanWrite);
foreach (var targetItem in targetTypes)
{
var sourceItem = sourceType.GetProperty(targetItem.Name);
//判断对象的读写权限
if (sourceItem == null || !sourceItem.CanRead || sourceItem.PropertyType.IsNotPublic)
{
continue;
}
//标注NotMapped特性的属性忽略转换
if (sourceItem.GetCustomAttribute <NotMappedAttribute>() != null)
{
continue;
}
var sourceProperty = Expression.Property(parameter, sourceItem);
//当非值类型且类型不相同时
if (!sourceItem.PropertyType.IsValueType && sourceItem.PropertyType != targetItem.PropertyType)
{
//判断都是(非泛型、非数组)class
if (sourceItem.PropertyType.IsClass && targetItem.PropertyType.IsClass && !sourceItem.PropertyType.IsArray && !targetItem.PropertyType.IsArray && !sourceItem.PropertyType.IsGenericType && !targetItem.PropertyType.IsGenericType)
{
var expression = GetClassExpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
memberBindings.Add(Expression.Bind(targetItem, expression));
}
//集合数组类型的转换
if (typeof(IEnumerable).IsAssignableFrom(sourceItem.PropertyType) && typeof(IEnumerable).IsAssignableFrom(targetItem.PropertyType))
{
var expression = GetListExpression(sourceProperty, sourceItem.PropertyType, targetItem.PropertyType);
memberBindings.Add(Expression.Bind(targetItem, expression));
}
continue;
}
//可空类型转换到非可空类型，当可空类型值为null时，用默认值赋给目标属性；不为null就直接转换
if (MapperTools.IsNullableType(sourceItem.PropertyType) && !MapperTools.IsNullableType(targetItem.PropertyType))
{
var hasValueExpression = Expression.Equal(Expression.Property(sourceProperty, "HasValue"), Expression.Constant(true));
var conditionItem = Expression.Condition(hasValueExpression, Expression.Convert(sourceProperty, targetItem.PropertyType), Expression.Default(targetItem.PropertyType));
memberBindings.Add(Expression.Bind(targetItem, conditionItem));
continue;
}
//非可空类型转换到可空类型，直接转换
if (!MapperTools.IsNullableType(sourceItem.PropertyType) && MapperTools.IsNullableType(targetItem.PropertyType))
{
var memberExpression = Expression.Convert(sourceProperty, targetItem.PropertyType);
memberBindings.Add(Expression.Bind(targetItem, memberExpression));
continue;
}
if (targetItem.PropertyType != sourceItem.PropertyType)
{
continue;
}
memberBindings.Add(Expression.Bind(targetItem, sourceProperty));
}
//创建一个if条件表达式
var test = Expression.NotEqual(parameter, Expression.Constant(null, sourceType)); // p==null;
var ifTrue = Expression.MemberInit(Expression.New(targetType), memberBindings);
var condition = Expression.Condition(test, ifTrue, Expression.Constant(null, targetType));
var lambda = Expression.Lambda <Func <TSource, TDest> >(condition, parameter);
return(lambda.Compile());
}
/// <summary>
/// 新建目标类型实例，并将源对象的属性值拷贝至目标对象的对应属性
/// </summary>
/// <param name="source">源对象实例</param>
/// <param name="target">目标对象实例</param>
public static void Copy(TSource source, TDest target)
{
if (source == null)
{
return;
}
// 因为对于泛型类型而言，每次传入不同的泛型参数都会调用静态构造函数，所以可以通过这种方式进行缓存
// 如果之前缓存过，则直接调用缓存的委托
if (_copyAction != null)
{
_copyAction(source, target);
return;
}
Type sourceType = typeof(TSource);
Type targetType = typeof(TDest);
// 如果双方都可以被遍历
if (MapperTools.IsIEnumerableExceptString(sourceType) && MapperTools.IsIEnumerableExceptString(targetType))
{
// TODO
// 向已存在的数组或者ICollection<T>拷贝的功能暂不支持
}
else
{
var paramSourceExpr = Expression.Parameter(sourceType, nameof(source));
var paramTargetExpr = Expression.Parameter(targetType, nameof(target));
var binaryExpressions = new List <Expression>();
// 遍历目标对象的所有属性信息
foreach (var targetPropInfo in targetType.GetProperties())
{
// 从源对象获取同名的属性信息
var sourcePropInfo = sourceType.GetProperty(targetPropInfo.Name);
Type sourcePropType = sourcePropInfo?.PropertyType;
Type targetPropType = targetPropInfo.PropertyType;
// 只在满足以下三个条件的情况下进行拷贝
// 1.源属性类型和目标属性类型一致
// 2.源属性可读
// 3.目标属性可写
if (sourcePropType == targetPropType && sourcePropInfo.CanRead && targetPropInfo.CanWrite)
{
// 获取属性值的表达式
Expression expression = Expression.Property(paramSourceExpr, sourcePropInfo);
Expression targetPropExpr = Expression.Property(paramTargetExpr, targetPropInfo);
// 如果目标属性是值类型或者字符串，则直接做赋值处理
// 暂不考虑目标值类型有非字符串的引用类型这种特殊情况
if (MapperTools.IsRefTypeExceptString(targetPropType))
{
expression = Expression.Call(null, GetCopyMethodInfo(sourcePropType, targetPropType), expression);
}
binaryExpressions.Add(Expression.Assign(targetPropExpr, expression));
}
}
Expression bodyExpr = Expression.Block(binaryExpressions);
var lambdaExpr = Expression.Lambda <Action <TSource, TDest> >(bodyExpr, paramSourceExpr, paramTargetExpr);
_copyAction = lambdaExpr.Compile();
_copyAction(source, target);
}
}
/// <summary>
/// 新建目标类型实例，并将源对象的属性值拷贝至目标对象的对应属性
/// </summary>
/// <param name="source">源对象实例</param>
/// <returns>深拷贝了源对象属性的目标对象实例</returns>
public static TDest Copy(TSource source)
{
if (source == null)
{
return(default(TDest));
}
// 因为对于泛型类型而言，每次传入不同的泛型参数都会调用静态构造函数，所以可以通过这种方式进行缓存
if (_copyFunc != null)
{
// 如果之前缓存过，则直接调用缓存的委托
return(_copyFunc(source));
}
Type sourceType = typeof(TSource);
Type targetType = typeof(TDest);
var paramExpr = Expression.Parameter(sourceType, nameof(source));
Expression bodyExpr;
// 如果对象可以遍历（目前只支持数组和ICollection<T>实现类）
if (sourceType == targetType && MapperTools.IsIEnumerableExceptString(sourceType))
{
bodyExpr = Expression.Call(null, EnumerableCopier.GetMethondInfo(sourceType), paramExpr);
}
else
{
var memberBindings = new List <MemberBinding>();
// 遍历目标对象的所有属性信息
foreach (var targetPropInfo in targetType.GetProperties())
{
// 从源对象获取同名的属性信息
var sourcePropInfo = sourceType.GetProperty(targetPropInfo.Name);
Type sourcePropType = sourcePropInfo?.PropertyType;
Type targetPropType = targetPropInfo.PropertyType;
// 只在满足以下三个条件的情况下进行拷贝
// 1.源属性类型和目标属性类型一致
// 2.源属性可读
// 3.目标属性可写
if (sourcePropType == targetPropType && sourcePropInfo.CanRead && targetPropInfo.CanWrite)
{
// 获取属性值的表达式
Expression expression = Expression.Property(paramExpr, sourcePropInfo);
// 如果目标属性是值类型或者字符串，则直接做赋值处理
// 暂不考虑目标值类型有非字符串的引用类型这种特殊情况
// 非字符串引用类型做递归处理
if (MapperTools.IsRefTypeExceptString(targetPropType))
{
// 进行递归
if (MapperTools.IsRefTypeExceptString(targetPropType))
{
expression = Expression.Call(null, GetCopyMethodInfo(sourcePropType, targetPropType), expression);
}
}
memberBindings.Add(Expression.Bind(targetPropInfo, expression));
}
}
bodyExpr = Expression.MemberInit(Expression.New(targetType), memberBindings);
}
var lambdaExpr = Expression.Lambda <Func <TSource, TDest> >(bodyExpr, paramExpr);
_copyFunc = lambdaExpr.Compile();
return(_copyFunc(source));
}
public void UpdateArticle(int id, DetailsModel item)
{
_articleService.Update(MapperTools.MapTo <DetailsModel, ArticleBl>(item));
}
public void CreateArticle(DetailsModel item)
{
item.DateTime = DateTime.Now;
item.AuthorId = 1;
_articleService.Add(MapperTools.MapTo <DetailsModel, ArticleBl>(item));
}
public DetailsModel GetArticle(int id)
{
var res = MapperTools.MapTo <ArticleBl, DetailsModel>(_articleService.GetById(id));
return(res);
}
// GET: Article/Edit/5
public ActionResult Edit(int id)
{
var res = MapperTools.MapTo <ArticleBl, DetailsModel>(_articleService.GetById(id));
return(View(res));
}
public ActionResult ListArticle()
{
var artCollection = MapperTools.MapToCollection <ArticleBl, DetailsModel>(_articleService.GetAll());
return(View(artCollection));
}
