public TDestination Map <TDestination>(object source, TDestination destination = null)
where TDestination : class
{
if (destination != null)
{
return(source.Adapt(destination));
}
return(source.Adapt <TDestination>());
}
public static ValidationErrors Value(object target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
// Self validation should be tried first; then the validator should be created
ISelfValidation sv = target.Adapt <ISelfValidation>();
if (sv != null)
{
return(sv.Validate());
}
Validator v = Validator.CreateSelfValidator(target.GetType());
if (v != null)
{
return(v.Validate(target));
}
v = Validator.Create(target.GetType());
if (v != null)
{
return(v.Validate(target));
}
throw ValidationFailure.ValidationNotDefined();
}
private EntityCore GetByType(object src)
{
EntityCore res = new EntityCore();
if (src.GetType() == typeof(LeadViewModel))
{
res = src.Adapt <Lead>(config);
}
if (src.GetType() == typeof(ContactViewModel))
{
res = src.Adapt <Contact>(config);
}
return(res);
}
public TDestination Map <TDestination>(object source)
{
Type sourceType = source.GetType().Namespace == "System.Data.Entity.DynamicProxies"
? source.GetType().BaseType
: source.GetType();
return((TDestination)source.Adapt(sourceType, typeof(TDestination), _mapsterConfiguration.Configuration));
}
private T AdaptTypeToDesirableType <T>(object item)
{
if (item.GetType() == typeof(T))
{
return((T)item);
}
return(item.Adapt <T>());
}
/// <summary>
/// Imports / maps the given Poco to the current Bean.
/// Poco properties and Bean properties must match exactly.
/// </summary>
/// <param name="poco">Simple Poco instance</param>
public Bean ImportPoco(object poco)
{
var config = new TypeAdapterConfig();
config.ForType(poco.GetType(), typeof(Dictionary <string, object>)).IgnoreNullValues(true);
return(Import(poco.Adapt <Dictionary <string, object> >(config)));
}
public static T MapTo <T>(this object obj)
{
if (obj == null)
{
return(default(T));
}
return(obj.Adapt <T>());
}
/// <summary>
/// 对象映射
/// </summary>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <param name="ignoreNames">忽略字段</param>
/// <returns></returns>
public static TDestination MapTo <TDestination>(this object source, IEnumerable <string> ignoreNames)
{
if (source == null)
{
return(default(TDestination));
}
var setting = new TypeAdapterConfig().NewConfig(source.GetType(), typeof(TDestination)).Ignore(ignoreNames.ToArray());
return(source.Adapt <TDestination>(setting.Config));
}
private Object ConvertEntityCollectionToDto(object elements)
{
var type1 = elements.GetType();
genericListType = listType.MakeGenericType(this.dtoType);
var array = elements.Adapt(type1, this.genericListType);
return(array);
}
/// <summary>
/// Converts an object to another using Mapster library. Creates a new object of
/// <typeparamref name="TDestination" />.
/// There must be a mapping between objects before calling this method.
/// </summary>
/// <typeparam name="TDestination">Type of the destination object</typeparam>
/// <param name="source">Source object</param>
public static TDestination MapTo <TDestination>([NotNull] this object source)
{
return(source.Adapt <TDestination>(TypeAdapterConfig.GlobalSettings));
}
public TTarget Map <TTarget>(object source)
{
return(source.Adapt <TTarget>());
}
private object ConvertIt(object @object, Type from, Type to)
{
var toObject = @object.Adapt(from, to);
return(toObject);
}
public static List <TTarget> MapToList <TTarget>(this object source)
{
return(source.Adapt <List <TTarget> >());
}
/// <summary>
/// 对象映射
/// </summary>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <param name="sourceType"></param>
/// <param name="destinationType"></param>
/// <returns></returns>
public static object MapTo(this object source, object destination, Type sourceType, Type destinationType)
{
return(source.Adapt(destination, sourceType, destinationType));
}
public void Map(object source, object target)
{
source.Adapt(target);
}
/// <summary>
///
/// </summary>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public TDestination Map <TDestination>(object source)
{
return(source.Adapt <TDestination>());
}
/// <summary>
/// Converts an object to another using Mapster library. Creates a new object of
/// <typeparamref name="TDestination" />.
/// There must be a mapping between objects before calling this method.
/// </summary>
/// <typeparam name="TDestination">Type of the destination object</typeparam>
/// <param name="source">Source object</param>
public static TDestination MapTo <TDestination>(this object source)
{
return(source.Adapt <TDestination>());
}
/// <summary>
/// 对象映射
/// </summary>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <param name="sourceType"></param>
/// <param name="destinationType"></param>
/// <param name="ignoreNames">忽略字段</param>
/// <returns></returns>
public static object MapTo(this object source, object destination, Type sourceType, Type destinationType, params string[] ignoreNames)
{
var setting = new TypeAdapterConfig().NewConfig(sourceType, destinationType).Ignore(ignoreNames);
return(source.Adapt(destination, sourceType, destinationType, setting.Config));
}
/// <summary>
/// 对象映射
/// </summary>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <param name="sourceType"></param>
/// <param name="destinationType"></param>
/// <param name="ignoreNames">忽略字段</param>
/// <returns></returns>
public static object MapTo(this object source, object destination, Type sourceType, Type destinationType, IEnumerable <string> ignoreNames)
{
var setting = new TypeAdapterConfig().NewConfig(sourceType, destinationType).Ignore(ignoreNames.ToArray());
return(source.Adapt(destination, sourceType, destinationType, setting.Config));
}
public Task <TD> Map <TD>(object message)
{
return(Task.FromResult(message.Adapt <TD>()));
}
public TDestination MapTo <TDestination>(object source) => source.Adapt <TDestination>();
/// <summary> /// Adapt extension of Mapster /// </summary> /// <typeparam name="T"></typeparam> /// <param name="obj"></param> /// <returns></returns> public static T MapType <T>(this object obj) => obj.Adapt <T>();
public static TTarget MapTo <TTarget>(this object source)
{
return(source.Adapt <TTarget>());
}
public TTarget Map <TTarget>(object source) where TTarget : class
{
return(source.Adapt <TTarget>());
}
public TDestination Map <TDestination>(object source)
{
return(source.Adapt <TDestination>(_mapsterConfiguration.Configuration));
}
public object Map(object source, Type targetType)
{
return(source.Adapt(source.GetType(), targetType));
}
public TDestination Map <TDestination>(object source)
{
TypeAdapterConfig typeAdapterConfig = TypeAdapterConfig <object, TDestination> .NewConfig().PreserveReference(true).Config;
return(source.Adapt <TDestination>(typeAdapterConfig));
}
/// <summary>
/// Mapping to an existing object.
///
/// </summary>
/// <typeparam name="TDestination"></typeparam>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <returns></returns>
public static TDestination MapTo <TDestination>(this object source, TDestination destination)
{
return(source.Adapt(destination));
}
