public static void EnableDebugging(this TypeAdapterConfig config, string sourceCodePath = null)
{
if (sourceCodePath == null)
{
sourceCodePath = GetDefaultSourceCodePath();
}
//initialize on first call
if (_registeredFilename == null)
{
_registeredFilename = new Dictionary <string, int>();
_assemblyName = GetAssemblyName();
}
config.Compiler = lambda =>
{
var filename = lambda.Parameters[0].Type.Name + "-" + lambda.ReturnType.Name;
var key = filename;
lock (_registeredFilename)
{
if (!_registeredFilename.TryGetValue(key, out var num))
{
_registeredFilename[key] = 0;
}
else
{
filename += "-" + num;
}
_registeredFilename[key]++;
}
var path = Path.Combine(sourceCodePath, filename + ".cs");
using (var injector = new DebugInfoInjectorEx(path))
{
return(injector.Compile(lambda, _assemblyName));
}
};
}
public TypeAdapterSetter(TypeAdapterSettings settings, TypeAdapterConfig parentConfig)
{
this.Settings = settings;
this.ParentConfig = parentConfig;
}
/// <summary>
/// Adapt the source object to the destination type.
/// </summary>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <param name="source">Source object to adapt.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static TDestination Adapt <TDestination>(this object source, TypeAdapterConfig config)
{
if (source == null)
{
return(default !);
public static IQueryable <TDestination> ProjectToType <TDestination>(this IQueryable source, TypeAdapterConfig config = null)
{
config = config ?? TypeAdapterConfig.GlobalSettings;
var mockCall = config.GetProjectionCallExpression(source.ElementType, typeof(TDestination));
var sourceCall = Expression.Call(mockCall.Method, source.Expression, mockCall.Arguments[1]);
return(source.Provider.CreateQuery <TDestination>(sourceCall));
}
public static TypeAdapterBuilder <TSource> BuildAdapter <TSource>(this TSource source, TypeAdapterConfig config)
{
return(new TypeAdapterBuilder <TSource>(source, config));
}
public CompileContext(TypeAdapterConfig config)
{
this.Config = config;
}
public static void EnableJsonMapping(this TypeAdapterConfig config)
{
config.Rules.Add(new JsonAdapter().CreateRule());
}
/// <summary>
/// Adapt the source object to an existing destination object.
/// </summary>
/// <param name="source">Source object to adapt.</param>
/// <param name="destination">Destination object to populate.</param>
/// <param name="sourceType">The type of the source object.</param>
/// <param name="destinationType">The type of the destination object.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static object Adapt(this object source, object destination, Type sourceType, Type destinationType, TypeAdapterConfig config)
{
dynamic fn = config.GetMapToTargetFunction(sourceType, destinationType);
return(fn((dynamic)source, (dynamic)destination));
}
/// <summary>
/// Returns an instance representation of the adapter, mainly for DI/IOC situations.
/// </summary>
/// <param name="config">Configuration</param>
/// <returns>Instance of the adapter.</returns>
public static IAdapter GetInstance(TypeAdapterConfig config = null)
{
return(new Adapter(config ?? TypeAdapterConfig.GlobalSettings));
}
/// <summary>
/// Adapte the source object to an existing destination object.
/// </summary>
/// <param name="source">Source object to adapt.</param>
/// <param name="destination">Destination object to populate.</param>
/// <param name="sourceType">The type of the source object.</param>
/// <param name="destinationType">The type of the destination object.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static object Adapt(object source, object destination, Type sourceType, Type destinationType, TypeAdapterConfig config = null)
{
config = config ?? TypeAdapterConfig.GlobalSettings;
dynamic fn = config.GetMapToTargetFunction(sourceType, destinationType);
try
{
return(fn((dynamic)source, (dynamic)destination));
}
finally
{
MapContext.Clear();
}
}
/// <summary>
/// Adapte the source object to the existing destination object.
/// </summary>
/// <typeparam name="TSource">Source type.</typeparam>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <param name="source">Source object to adapt.</param>
/// <param name="destination">The destination object to populate.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static TDestination Adapt <TSource, TDestination>(TSource source, TDestination destination, TypeAdapterConfig config = null)
{
config = config ?? TypeAdapterConfig.GlobalSettings;
var fn = config.GetMapToTargetFunction <TSource, TDestination>();
try
{
return(fn(source, destination));
}
finally
{
MapContext.Clear();
}
}
/// <summary>
/// Adapt the source object to an existing destination object.
/// </summary>
/// <param name="source">Source object to adapt.</param>
/// <param name="destination">Destination object to populate.</param>
/// <param name="sourceType">The type of the source object.</param>
/// <param name="destinationType">The type of the destination object.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static object Adapt(this object source, object destination, Type sourceType, Type destinationType, TypeAdapterConfig config)
{
var del = config.GetMapToTargetFunction(sourceType, destinationType);
if (sourceType.GetTypeInfo().IsVisible&& destinationType.GetTypeInfo().IsVisible)
{
dynamic fn = del;
return(fn((dynamic)source, (dynamic)destination));
}
else
{
//NOTE: if type is non-public, we cannot use dynamic
//DynamicInvoke is slow, but works with non-public
return(del.DynamicInvoke(source, destination));
}
}
public CompileContext(TypeAdapterConfig config)
{
Configs.Push(config);
}
public static void EnableImmutableMapping(this TypeAdapterConfig config)
{
config.Rules.Add(new ImmutableAdapter().CreateRule());
}
public TypeAdapterSetter(TypeAdapterSettings settings, TypeAdapterConfig config)
{
this.Settings = settings;
this.Config = config;
}
/// <summary>
/// Adapt the source object to the destination type.
/// </summary>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <param name="source">Source object to adapt.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static TDestination Adapt <TDestination>(this object source, TypeAdapterConfig config)
{
dynamic fn = config.GetMapFunction(source.GetType(), typeof(TDestination));
return((TDestination)fn((dynamic)source));
}
public Adapter(TypeAdapterConfig config)
{
_config = config;
}
/// <summary>
/// Adapt the source object to the existing destination object.
/// </summary>
/// <typeparam name="TSource">Source type.</typeparam>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <param name="source">Source object to adapt.</param>
/// <param name="destination">The destination object to populate.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static TDestination Adapt <TSource, TDestination>(this TSource source, TDestination destination, TypeAdapterConfig config)
{
var fn = config.GetMapToTargetFunction <TSource, TDestination>();
return(fn(source, destination));
}
internal TypeAdapterBuiler(TSource source, TypeAdapterConfig config)
{
this.Source = source;
this.Config = config;
}
/// <summary>
/// Adapt the source object to the destination type.
/// </summary>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <param name="source">Source object to adapt.</param>
/// <param name="config">Configuration</param>
/// <returns>Adapted destination type.</returns>
public static TDestination Adapt <TDestination>(this object source, TypeAdapterConfig config)
{
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (source == null)
{
return(default !);
