/// <summary>
/// Implements the requested interface from supplied set of objects.
/// </summary>
/// <param name="interfaceType">An interface type to implement.</param>
/// <param name="baseObjectTypes">Array of types which have all members of the given interface.
/// When this parameter is set to null, the object type will be used.</param>
/// <param name="objects">Array of objects which types expected to have all members of the given interface.</param>
/// <param name="throwException">If true, throws an exception if object can not be created.</param>
/// <returns>An object which implements the interface.</returns>
public static object?Aggregate(this Type interfaceType, Type[]?baseObjectTypes, bool throwException, params object[] objects)
{
if (objects == null)
{
throw new ArgumentNullException(nameof(objects));
}
if (baseObjectTypes == null)
{
baseObjectTypes = new Type[objects.Length];
for (var i = 0; i < objects.Length; i++)
{
if (objects[i] != null)
{
baseObjectTypes[i] = objects[i].GetType();
}
}
}
else
{
if (baseObjectTypes.Length != objects.Length)
{
throw new ArgumentException("Invalid number of 'baseObjectTypes' or 'objects'.", nameof(baseObjectTypes));
}
for (var i = 0; i < objects.Length; i++)
{
var objType = objects[i].GetType();
if (!baseObjectTypes[i].IsSameOrParentOf(objType))
{
throw new ArgumentException($"'{objType.FullName}' is not a subtype of '{baseObjectTypes[i].FullName}'.", nameof(objects));
}
}
}
var duckType = GetDuckType(interfaceType, baseObjectTypes);
if (duckType == null)
{
if (throwException)
{
throw new TypeBuilderException($"Interface '{interfaceType}' cannot be implemented.");
}
return(null);
}
var duck = TypeAccessor.GetAccessor(duckType).CreateInstance();
((DuckType)duck).SetObjects(objects);
return(duck);
}
/// <summary>
/// Implements the requested interface for supplied object.
/// If the supplied object implements the interface, the object itself will be returned.
/// Otherwise a convenient duck object will be created.
/// </summary>
/// <param name="interfaceType">An interface type to implement.</param>
/// <param name="baseObjectType">Any type which has all members of the given interface.
/// When this parameter is set to null, the object type will be used.</param>
/// <param name="obj">An object which type expected to have all members of the given interface.</param>
/// <param name="throwException">If true, throws an exception if object can not be created.</param>
/// <returns>An object which implements the interface.</returns>
public static object?Implement(this Type interfaceType, Type?baseObjectType, object?obj, bool throwException)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
var objType = obj.GetType();
if (interfaceType.IsSameOrParentOf(objType))
{
return(obj);
}
if (obj is DuckType duckObject)
{
if (duckObject.Objects.Length == 1)
{
// Switch to underlying objects when a duck object was passed.
//
return(Implement(interfaceType, baseObjectType, duckObject.Objects[0]));
}
// Re-aggregate underlying objects to expose new interface.
//
return(Aggregate(interfaceType, duckObject.Objects));
}
if (baseObjectType == null)
{
baseObjectType = objType;
}
else if (!baseObjectType.IsSameOrParentOf(objType))
{
throw new ArgumentException($"'{objType.FullName}' is not a subtype of '{baseObjectType.FullName}'.", nameof(obj));
}
var duckType = interfaceType.GetDuckType(baseObjectType);
if (duckType == null)
{
if (throwException)
{
throw new TypeBuilderException($"Interface '{interfaceType}' cannot be implemented.");
}
return(null);
}
var duck = TypeAccessor.GetAccessor(duckType).CreateInstance();
((DuckType)duck).SetObjects(obj);
return(duck);
}
public EntityDescriptor(MappingSchema mappingSchema, Type type)
{
_mappingSchema = mappingSchema;
TypeAccessor = TypeAccessor.GetAccessor(type);
Associations = new List <AssociationDescriptor>();
Columns = new List <ColumnDescriptor>();
Init();
InitInheritanceMapping();
}
/// <summary>
/// Searches for the property using a property expression.
/// </summary>
/// <typeparam name="T">The object type containing the property specified in the expression.</typeparam>
/// <param name="propertyExpression">The property expression (e.g. p => p.PropertyName)</param>
/// <returns>An <see cref="IMemberAccessor"/> instance for the property if found; otherwise <c>null</c>.</returns>
/// <exception cref="ArgumentNullException">Thrown if the <paramref name="propertyExpression"/> is null.</exception>
/// <exception cref="ArgumentException">Thrown when the expression is:<br/>
/// Not a <see cref="MemberExpression"/><br/>
/// The <see cref="MemberExpression"/> does not represent a property.<br/>
/// Or, the property is static.
/// </exception>
public static IMemberAccessor FindProperty <T>(Expression <Func <T> > propertyExpression)
{
if (propertyExpression == null)
{
throw new ArgumentNullException("propertyExpression");
}
TypeAccessor typeAccessor = TypeAccessor.GetAccessor(typeof(T));
return(typeAccessor.FindProperty <T>(propertyExpression));
}
public static IEqualityComparer <T> GetEqualityComparer <T>(
[InstantHandle] Func <MemberAccessor, bool> memberPredicate)
{
if (memberPredicate == null)
{
throw new ArgumentNullException(nameof(memberPredicate));
}
var members = TypeAccessor.GetAccessor <T>().Members.Where(memberPredicate).ToList();
return(new Comparer <T>(GetEqualsFunc <T>(members), GetGetHashCodeFunc <T>(members)));
}
public ShardConfig ShardStrategy <TShardStrategy>(object attributes) where TShardStrategy : IShardStrategy
{
var ta = TypeAccessor.GetAccessor(attributes.GetType());
var d = ta.GetFieldValueDictionary(attributes);
var sd = new Dictionary <string, string>();
foreach (KeyValuePair <string, object> entry in d)
{
sd.Add(entry.Key, entry.Value.ToString());
}
return(ShardStrategy <TShardStrategy>(sd));
}
internal static void ParseSet(
ExpressionBuilder builder,
BuildInfo buildInfo,
LambdaExpression extract,
Expression update,
IBuildContext select,
List <SqlQuery.SetExpression> items)
{
var ext = extract.Body;
if (!ExpressionHelper.IsConstant(update.Type) && !builder.AsParameters.Contains(update))
{
builder.AsParameters.Add(update);
}
while (ext.NodeType == ExpressionType.Convert || ext.NodeType == ExpressionType.ConvertChecked)
{
ext = ((UnaryExpression)ext).Operand;
}
if (ext.NodeType != ExpressionType.MemberAccess || ext.GetRootObject() != extract.Parameters[0])
{
throw new LinqException("Member expression expected for the 'Set' statement.");
}
var body = (MemberExpression)ext;
var member = body.Member;
if (member is MethodInfo)
{
member = TypeHelper.GetPropertyByMethod((MethodInfo)member);
}
var column = select.ConvertToSql(
body, 1, ConvertFlags.Field);
//Expression.MakeMemberAccess(Expression.Parameter(member.DeclaringType, "p"), member), 1, ConvertFlags.Field);
if (column.Length == 0)
{
throw new LinqException("Member '{0}.{1}' is not a table column.", member.DeclaringType.Name, member.Name);
}
var expr = builder.ConvertToSql(select, update, false, false);
if (expr is SqlValueBase && TypeHelper.IsEnumOrNullableEnum(update.Type))
{
var memberAccessor = TypeAccessor.GetAccessor(body.Member.DeclaringType)[body.Member.Name];
((SqlValueBase)expr).SetEnumConverter(memberAccessor, builder.MappingSchema);
}
items.Add(new SqlQuery.SetExpression(column[0].Sql, expr));
}
public static IEqualityComparer <T> GetEqualityComparer <T>(
[InstantHandle] Func <TypeAccessor <T>, IEnumerable <MemberAccessor> > membersToCompare)
{
if (membersToCompare == null)
{
throw new ArgumentNullException(nameof(membersToCompare));
}
var members = membersToCompare(TypeAccessor.GetAccessor <T>()).ToList();
return(new Comparer <T>(GetEqualsFunc <T>(members), GetGetHashCodeFunc <T>(members)));
}
public static object GetId(object entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var metadata = RepositoryFramework.GetDefineMetadataAndCheck(entity.GetType());
var ta = TypeAccessor.GetAccessor(metadata.EntityType);
return(ta.GetProperty(metadata.IdMember.Name, entity));
}
/// <summary>
/// Gets the member information from given expression.
/// </summary>
/// <remarks>
/// Returns member information for given expressions, e.g.:
/// <list type="bullet">
/// <item><description>For: x => x.SomeProperty, returns MemberInfo of SomeProperty.</description></item>
/// <item><description>For: x => x.SomeMethod(), returns MethodInfo of SomeMethod.</description></item>
/// <item><description>For: x => new { X = x.Name }, return ConstructorInfo of anonymous type.</description></item>
/// <item><description>For: x => Sql.Property<int>(x, "SomeProperty"), returns MemberInfo of "SomeProperty" if exists on type, otherwise returns DynamicColumnInfo for SomeProperty on given type.</description></item>
/// </list>
/// </remarks>
/// <param name="expr">The expression.</param>
/// <returns></returns>
/// <exception cref="ArgumentException">Only simple, non-navigational, member names are supported in this context (e.g.: x => Sql.Property(x, \"SomeProperty\")).</exception>
public static MemberInfo GetMemberInfo(Expression expr)
{
while (expr.NodeType == ExpressionType.Convert || expr.NodeType == ExpressionType.ConvertChecked || expr.NodeType == ExpressionType.TypeAs)
{
expr = ((UnaryExpression)expr).Operand;
}
if (expr.NodeType == ExpressionType.New)
{
return(((NewExpression)expr).Constructor);
}
if (expr is MethodCallExpression methodCall && methodCall.Method.IsSqlPropertyMethodEx())
{
// validate expression and get member name
var arg1 = methodCall.Arguments[0].NodeType == ExpressionType.Convert
? ((UnaryExpression)methodCall.Arguments[0]).Operand
: methodCall.Arguments[0];
if (arg1.NodeType != ExpressionType.Constant && arg1.NodeType != ExpressionType.Parameter)
{
throw new ArgumentException("Only simple, non-navigational, member names are supported in this context (e.g.: x => Sql.Property(x, \"SomeProperty\")).");
}
var memberName = (string)methodCall.Arguments[1].EvaluateExpression() !;
// check if member exists on type
var existingMember = TypeAccessor.GetAccessor(arg1.Type).Members.SingleOrDefault(m =>
m.Name == memberName &&
(m.MemberInfo.MemberType == MemberTypes.Property || m.MemberInfo.MemberType == MemberTypes.Field));
if (existingMember != null)
{
return(existingMember.MemberInfo);
}
// create dynamic column info
return(new DynamicColumnInfo(arg1.Type, methodCall.Method.GetGenericArguments()[0], memberName));
}
if (expr.NodeType == ExpressionType.ArrayLength)
{
return(((UnaryExpression)expr).Operand.Type.GetProperty(nameof(Array.Length)) !);
}
return
(expr is MemberExpression me
? me.Member
: expr is MethodCallExpression mce
? mce.Method
: (MemberInfo)((NewExpression)expr).Constructor);
}
public void GetAbstractValue()
{
var ta = TypeAccessor.GetAccessor(typeof(TestObject2));
var o = (TestObject2)ta.CreateInstance();
o.IntProperty = 20;
o.StrProperty = "10";
o.SetProperty = 30;
Assert.AreEqual(20, ta["IntProperty"].GetValue(o));
Assert.AreEqual("10", ta["StrProperty"].GetValue(o));
Assert.AreEqual(30, ta["SetProperty"].GetValue(o));
}
public void Test()
{
TypeAccessor ta = TypeAccessor.GetAccessor(typeof(RootType));
PropertyDescriptorCollection col = ta.CreateExtendedPropertyDescriptors(null, null);
PropertyDescriptor prop = col["Type1+Type2+Name"];
RootType obj = new RootType();
object value = prop.GetValue(obj);
Assert.AreEqual("test", value);
}
public MappingImpl(
ExpressionBuilder builder,
Expression fromExpression,
Expression toExpression)
{
_builder = builder;
_fromExpression = fromExpression;
_toExpression = toExpression;
_localObject = Parameter(_toExpression.Type, "obj" + ++_builder._data.NameCounter);
_fromAccessor = TypeAccessor.GetAccessor(_fromExpression.Type);
_toAccessor = TypeAccessor.GetAccessor(_toExpression.Type);
_cacheMapper = _builder._mapperBuilder.ProcessCrossReferences != false;
}
IClassJoinCascadeProcessor GetProcessor()
{
if (!inited)
{
var pa = TypeAccessor.GetAccessor(typeof(TEntity));
processor.KeyFunc = (entity) => EntityUtil.GetId(entity);
processor.JoinKeyFunc = (join) => EntityUtil.GetId(join);
processor.JoinFunc = (join) => (TJoin)pa.GetProperty(joinMetadata.JoinName, join);
inited = true;
}
return(processor);
}
public void Sort(ListSortDirection direction, params string[] memberNames)
{
if (memberNames == null)
{
throw new ArgumentNullException("memberNames");
}
if (memberNames.Length == 0)
{
throw new ArgumentOutOfRangeException("memberNames");
}
Sort(new SortMemberComparer(TypeAccessor.GetAccessor(ItemType), direction, memberNames));
}
private static MethodInfo FindRelatedMethod()
{
var managerAccessor = TypeAccessor.GetAccessor(typeof(RelationshipManager));
if (managerAccessor == null)
{
return(null);
}
var methodAccessor = managerAccessor.FindMethod("GetRelatedReference", typeof(string), typeof(string));
return(methodAccessor == null ? null : methodAccessor.MethodInfo);
}
public void HasSetter()
{
var ta = TypeAccessor.GetAccessor(typeof(TestObject1));
Assert.IsTrue(ta["IntField"].HasSetter);
Assert.IsTrue(ta["IntProperty"].HasSetter);
Assert.IsTrue(ta["StrField"].HasSetter);
Assert.IsFalse(ta["StrProperty"].HasSetter);
Assert.IsTrue(ta["SetProperty"].HasSetter);
Assert.IsNull(ta["ProtectedProperty"]);
Assert.IsFalse(ta["ProtectedSetter"].HasSetter);
}
void CreateMapper(MappingSchema mappingSchema)
{
if (_mapper != null)
{
return;
}
var entityDesc = mappingSchema.GetEntityDescriptor(typeof(T));
_keyColumns = entityDesc.Columns.Where(c => c.IsPrimaryKey).Select(c => c.MemberAccessor).ToList();
if (_keyColumns.Count == 0)
{
_keyColumns = entityDesc.Columns.Select(c => c.MemberAccessor).ToList();
}
if (typeof(T) == typeof(TK))
{
_mapper = k => (T)(object)k;
return;
}
if (mappingSchema.IsScalarType(typeof(TK)))
{
if (_keyColumns.Count != 1)
{
throw new LinqToDBConvertException($"Type '{typeof(T).Name}' must contain only one key column.");
}
_mapper = v =>
{
var e = entityDesc.TypeAccessor.CreateInstanceEx();
_keyColumns[0].Setter(e, v);
return((T)e);
};
}
else
{
var fromNames = new HashSet <string>(TypeAccessor.GetAccessor <TK>().Members.Select(m => m.Name));
foreach (var column in _keyColumns)
{
if (!fromNames.Contains(column.Name))
{
throw new LinqToDBConvertException($"Type '{typeof(TK).Name}' must contain field or property '{column.Name}'.");
}
}
_mapper = Map.GetMapper <TK, T>(m => m.SetToMemberFilter(ma => _keyColumns.Count == 0 || _keyColumns.Contains(ma))).GetMapper();
}
}
static void BuildSetter(
ExpressionBuilder builder,
IBuildContext into,
List <SqlQuery.SetExpression> items,
IBuildContext ctx,
MemberInitExpression expression,
Expression path)
{
foreach (var binding in expression.Bindings)
{
var member = binding.Member;
if (member is MethodInfo)
{
member = TypeHelper.GetPropertyByMethod((MethodInfo)member);
}
if (binding is MemberAssignment)
{
var ma = binding as MemberAssignment;
var pe = Expression.MakeMemberAccess(path, member);
if (ma.Expression is MemberInitExpression && !into.IsExpression(pe, 1, RequestFor.Field).Result)
{
BuildSetter(
builder,
into,
items,
ctx,
(MemberInitExpression)ma.Expression, Expression.MakeMemberAccess(path, member));
}
else
{
var column = into.ConvertToSql(pe, 1, ConvertFlags.Field);
var expr = builder.ConvertToSqlExpression(ctx, ma.Expression, false);
if (expr is SqlValueBase && TypeHelper.IsEnumOrNullableEnum(ma.Expression.Type))
{
var memberAccessor = TypeAccessor.GetAccessor(ma.Member.DeclaringType)[ma.Member.Name];
((SqlValueBase)expr).SetEnumConverter(memberAccessor, builder.MappingSchema);
}
items.Add(new SqlQuery.SetExpression(column[0].Sql, expr));
}
}
else
{
throw new InvalidOperationException();
}
}
}
IClassJoinCascadeProcessor GetProcessor()
{
if (!inited)
{
var ta = TypeAccessor.GetAccessor(typeof(TEntity));
processor.KeyFunc = (entity) => EntityUtil.GetId(entity);
processor.JoinKeyFunc = (join) => EntityUtil.GetId(join);
processor.JoinFunc = (join) => (IList <TJoin>)ta.GetProperty(joinMetadata.JoinName, join);
processor.SourceJoinFunc = (entity) => (IList <TJoin>)joinMetadata.DataProcesser.Process(entity);
inited = true;
}
return(processor);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicProxy"/> class.
/// </summary>
/// <param name="wrapped">The wrapped object.</param>
/// <param name="safeMode">if set to <c>true</c>, return null when name not found.</param>
public DynamicProxy(object wrapped, bool safeMode)
{
if (wrapped == null)
{
throw new ArgumentNullException("wrapped");
}
_wrapped = wrapped;
SafeMode = safeMode;
Type type = _wrapped.GetType();
_typeAccessor = TypeAccessor.GetAccessor(type);
}
private DataContractJsonSerializer GetSerializer(object obj)
{
var type = TypeAccessor.GetAccessor(MemberAccessor.Type).Type;
var extraType = obj != null?TypeHelper.GetListItemType(obj) : typeof(object);
var extraType2 = TypeHelper.GetListItemType(type);
var extraTypes = new[] { TypeAccessor.GetAccessor(extraType).Type, TypeAccessor.GetAccessor(extraType2).Type };
var serializer = extraType != typeof(object) || extraType2 != typeof(object)
? new DataContractJsonSerializer(type, extraTypes)
: new DataContractJsonSerializer(type);
return(serializer);
}
private EntityMapping GetClassMap(Type type)
{
var classMapping = Configuration.Mapping.GetOrAdd(type, t =>
{
var typeAccessor = TypeAccessor.GetAccessor(t);
var mapping = new EntityMapping(typeAccessor)
{
AutoMap = Configuration.AutoMap
};
return(mapping);
});
return(classMapping);
}
/// <summary>
/// Gets the member information from given expression.
/// </summary>
/// <remarks>
/// Returns member information for given expressions, e.g.:
/// <list type="bullet">
/// <item><description>For: x => x.SomeProperty, returns MemberInfo of SomeProperty.</description></item>
/// <item><description>For: x => x.SomeMethod(), returns MethodInfo of SomeMethod.</description></item>
/// <item><description>For: x => new { X = x.Name }, return ConstructorInfo of anonymous type.</description></item>
/// <item><description>For: x => Sql.Property<int>(x, "SomeProperty"), returns MemberInfo of "SomeProperty" if exists on type, otherwise returns DynamicColumnInfo for SomeProperty on given type.</description></item>
/// </list>
/// </remarks>
/// <param name="expr">The expression.</param>
/// <returns></returns>
/// <exception cref="ArgumentException">Only simple, non-navigational, member names are supported in this context (e.g.: x => Sql.Property(x, \"SomeProperty\")).</exception>
public static MemberInfo GetMemberInfo(Expression expr)
{
while (expr.NodeType == ExpressionType.Convert || expr.NodeType == ExpressionType.ConvertChecked)
{
expr = ((UnaryExpression)expr).Operand;
}
if (expr.NodeType == ExpressionType.New)
{
return(((NewExpression)expr).Constructor);
}
if (expr is MethodCallExpression methodCall && methodCall.Method.IsSqlPropertyMethodEx())
{
// validate expression and get member name
var arg1 = methodCall.Arguments[0].NodeType == ExpressionType.Convert
? ((UnaryExpression)methodCall.Arguments[0]).Operand
: methodCall.Arguments[0];
if (arg1.NodeType != ExpressionType.Constant && arg1.NodeType != ExpressionType.Parameter || methodCall.Arguments[1].NodeType != ExpressionType.Constant)
{
throw new ArgumentException("Only simple, non-navigational, member names are supported in this context (e.g.: x => Sql.Property(x, \"SomeProperty\")).");
}
var memberName = (string)((ConstantExpression)methodCall.Arguments[1]).Value;
// check if member exists on type
var existingMember = TypeAccessor.GetAccessor(arg1.Type).Members.SingleOrDefault(m =>
m.Name == memberName &&
(m.MemberInfo.MemberType == MemberTypes.Property || m.MemberInfo.MemberType == MemberTypes.Field));
if (existingMember != null)
{
return(existingMember.MemberInfo);
}
#if !NETSTANDARD1_6
// create dynamic column info
return(new DynamicColumnInfo(arg1.Type, methodCall.Method.GetGenericArguments()[0], memberName));
#else
throw new NotSupportedException("Dynamic columns are not supported on .NET Standard 1.6.");
#endif
}
return
(expr is MemberExpression ? ((MemberExpression)expr).Member :
expr is MethodCallExpression ? ((MethodCallExpression)expr).Method :
(MemberInfo)((NewExpression)expr).Constructor);
}
public void Test()
{
TypeAccessor ta = TypeAccessor.GetAccessor(typeof(Test1));
Test1 t = (Test1)ta.CreateInstance();
Dictionary <string, object> dic = new Dictionary <string, object>();
dic.Add("Name", "John");
Map.MapSourceToDestination(
Map.DefaultSchema.CreateDictionaryMapper(dic), dic,
Map.GetObjectMapper(t.GetType()), t);
Assert.AreEqual("John", t.Name);
}
/// <summary>
/// Returns <see cref="IValueConverter"/> for specific column.
/// </summary>
public virtual IValueConverter?GetValueConverter(ColumnDescriptor columnDescriptor)
{
if (ValueConverter != null)
{
return(ValueConverter);
}
if (ConverterType == null)
{
return(null);
}
var dynamicConverter = (IValueConverter)TypeAccessor.GetAccessor(ConverterType).CreateInstance();
return(dynamicConverter);
}
protected override void OnConnectionTypeCreated(Type connectionType)
{
_mySqlDecimalType = connectionType.AssemblyEx().GetType("MySql.Data.Types.MySqlDecimal", true);
_mySqlDateTimeType = connectionType.AssemblyEx().GetType("MySql.Data.Types.MySqlDateTime", true);
_mySqlDecimalValueGetter = TypeAccessor.GetAccessor(_mySqlDecimalType) ["Value"].Getter;
_mySqlDateTimeValueGetter = TypeAccessor.GetAccessor(_mySqlDateTimeType)["Value"].Getter;
SetProviderField(_mySqlDecimalType, "GetMySqlDecimal");
SetProviderField(_mySqlDateTimeType, "GetMySqlDateTime");
SetToTypeField(_mySqlDecimalType, "GetMySqlDecimal");
SetToTypeField(_mySqlDateTimeType, "GetMySqlDateTime");
MappingSchema.SetDataType(_mySqlDecimalType, DataType.Decimal);
MappingSchema.SetDataType(_mySqlDateTimeType, DataType.DateTime2);
}
/// <summary>
/// Creates an instance of the specified type.
/// </summary>
/// <param name="type">The type to create.</param>
/// <returns>A new instance of the specified type.</returns>
public static object CreateInstance(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
var typeAccessor = TypeAccessor.GetAccessor(type);
if (typeAccessor == null)
{
throw new InvalidOperationException(string.Format("Could not find constructor for {0}.", type.Name));
}
return(typeAccessor.Create());
}
internal void CloneEntity(object source, object target)
{
if (source == null)
{
return;
}
Arguments.NotNull(target, "target");
if (dataCloners == null || dataCloners.Count == 0)
{
var ta = TypeAccessor.GetAccessor(entityType);
dataCloners = dataProperties.Select(o => ta.GetPropertyClone(o.Name)).ToList();
}
dataCloners.ForEach(o => o(source, target));
}
internal IMethodAccessor GetFormatter(Type entityType, string name)
{
string fullName = entityType.FullName + "." + name;
return(_formatterCache.GetOrAdd(fullName, key =>
{
var formatAttribute = GetAttribute <AuditPropertyFormatAttribute>(entityType, name);
if (formatAttribute == null)
{
return null;
}
var typeAccessor = TypeAccessor.GetAccessor(formatAttribute.FormatType);
return typeAccessor.FindMethod(formatAttribute.MethodName, typeof(AuditPropertyContext));
}));
}
