private static object GetValue(TypeExtension typeExtension, MemberAccessor member, string elemName, out bool isSet) { var value = typeExtension[member.Name][elemName].Value; isSet = value != null; return value; }
private static object GetValue(ObjectMapper mapper, MemberAccessor member, string elemName, out bool isSet) { object value = mapper.Extension[member.Name][elemName].Value; isSet = value != null; return value; }
public virtual bool GetMapIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { isSet = false; return TypeHelper.IsScalar(member.Type) == false;// || //(member.MemberInfo is FieldInfo && ((FieldInfo)member.MemberInfo).IsLiteral); }
public ToDefinition(MemberInfo memberInfo) { Require.NotNull(memberInfo, "memberInfo"); // We need a getter as well for situations where we are mapping into an existing object and need to merge into // 'child' members, rather than just creating new instances of them. Accessor = new MemberAccessor(memberInfo); }
public override string GetFieldStorage(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var value = GetValue(typeExtension, member, "FieldStorage", out isSet); if (value != null) return value.ToString(); return base.GetFieldStorage(typeExtension, member, out isSet); }
public override bool GetInheritanceDiscriminator(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var value = GetValue(typeExtension, member, "IsInheritanceDiscriminator", out isSet); if (value != null) return TypeExtension.ToBoolean(value); return base.GetInheritanceDiscriminator(typeExtension, member, out isSet); }
public override bool GetMapIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var value = GetValue(typeExtension, member, "MapIgnore", out isSet); if (value != null) return TypeExtension.ToBoolean(value); return base.GetMapIgnore(typeExtension, member, out isSet) || GetAssociation(typeExtension, member) != null; }
public override string GetFieldName(ObjectMapper mapper, MemberAccessor member, out bool isSet) { object value = GetValue(mapper, member, "MapField", out isSet); if (value != null) return value.ToString(); return base.GetFieldName(mapper, member, out isSet); }
public override bool GetIgnore(ObjectMapper mapper, MemberAccessor member, out bool isSet) { object value = GetValue(mapper, member, "MapIgnore", out isSet); if (value != null) return TypeExtension.ToBoolean(value); return base.GetIgnore(mapper, member, out isSet); }
public override bool GetIgnore(ObjectMapper mapper, MemberAccessor member, out bool isSet) { if (IsLinqObject(mapper.TypeAccessor.Type)) { isSet = true; return member.GetAttribute<ColumnAttribute>() == null; } return base.GetIgnore(mapper, member, out isSet); }
public MemberAccessorTests() { person = new Person(); person.NameField = "John Smith"; person.Forename = "John"; person.Address = new Address {Country = new Country {Name = "United States"}}; nameFieldAccessor = MemberAccessor<Person>.From(x => x.NameField); forenameAccessor = MemberAccessor<Person>.From(x => x.Forename); countryNameAccessor = MemberAccessor<Person>.From(x => x.Address.Country.Name); }
void SetEnumConverterInternal(MemberAccessor ma, MappingSchema ms) { if (_valueConverter == null) { _valueConverter = o => ms.MapEnumToValue(o, ma, true); } else { var converter = _valueConverter; _valueConverter = o => ms.MapEnumToValue(converter(o), ma, true); } }
public override string GetFieldStorage(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { foreach (var p in _list) { var name = p.GetFieldStorage(typeExtension, member, out isSet); if (isSet) return name; } return base.GetFieldStorage(typeExtension, member, out isSet); }
public override bool GetInheritanceDiscriminator(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { foreach (var p in _list) { var value = p.GetInheritanceDiscriminator(typeExtension, member, out isSet); if (isSet) return value; } return base.GetInheritanceDiscriminator(typeExtension, member, out isSet); }
public override bool GetIgnore(ObjectMapper mapper, MemberAccessor member, out bool isSet) { foreach (MetadataProviderBase p in _list) { bool ignore = p.GetIgnore(mapper, member, out isSet); if (isSet) return ignore; } return base.GetIgnore(mapper, member, out isSet); }
public override bool GetTrimmable(ObjectMapper mapper, MemberAccessor member, out bool isSet) { if (member.Type == typeof(string)) { object value = GetValue(mapper, member, "Trimmable", out isSet); if (value != null) return TypeExtension.ToBoolean(value); } return base.GetTrimmable(mapper, member, out isSet); }
public override string GetFieldName(ObjectMapper mapper, MemberAccessor member, out bool isSet) { foreach (MetadataProviderBase p in _list) { string name = p.GetFieldName(mapper, member, out isSet); if (isSet) return name; } return base.GetFieldName(mapper, member, out isSet); }
public void When_Member_Is_WriteOnlyProperty_Then_Constructed_Correctly() { // Act var sut = new MemberAccessor(ReadWriteTestEntity.WriteOnlyPropertyMemberInfo); // Asert Assert.AreEqual(sut.Type, MemberAccessorType.Property); Assert.AreEqual(sut.MemberName, ReadWriteTestEntity.WriteOnlyPropertyName); Assert.AreEqual(typeof(ReadWriteTestEntity), sut.DeclaringType); Assert.AreEqual(typeof(int), sut.MemberType); Assert.IsNull(sut.Getter); Assert.NotNull(sut.Setter); }
internal void SetEnumConverter(MemberAccessor ma, MappingSchema ms) { if (!_isEnumConverterSet) { _isEnumConverterSet = true; if (EnumTypes == null) EnumTypes = new List<Type>(); EnumTypes.Add(ma.Type); SetEnumConverterInternal(ma, ms); } }
public void QueryInstanceBindingFlag() { var initialQuery = new MemberAccessor<MemberDescriptor>(); //var query = initialQuery.Where(x => x.AccessMode == MemberAccessMode.Instance).ToList(); var query1 = initialQuery.Where( x => x.MemberTypes == MemberTypes.Property && x.AccessMode == MemberAccessMode.Instance && (x.Visibility == MemberVisibility.NonPublic || x.Visibility == MemberVisibility.Public) && x.Name == "Test" ).ToList(); }
void SetEnumConverterInternal(MemberAccessor ma, MappingSchema ms) { if (_valueConverter == null) { _valueConverter = o => ms.MapEnumToValue(o, ma, true); } else { var converter = _valueConverter; _valueConverter = o => ms.MapEnumToValue(converter(o), ma, true); } // update system type in SqlValue :-/ var tmp = Value; }
public override bool GetNullable(ObjectMapper mapper, MemberAccessor member, out bool isSet) { if (IsLinqObject(mapper.TypeAccessor.Type)) { var attr = member.GetAttribute<ColumnAttribute>(); if (attr != null) { isSet = true; return attr.CanBeNull; } } return base.GetNullable(mapper, member, out isSet); }
public override string GetFieldName(ObjectMapper mapper, MemberAccessor member, out bool isSet) { if (IsLinqObject(mapper.TypeAccessor.Type)) { ColumnAttribute a = member.GetAttribute<ColumnAttribute>(); if (a != null && !string.IsNullOrEmpty(a.Name)) { isSet = true; return a.Name; } } return base.GetFieldName(mapper, member, out isSet); }
public override string GetFieldStorage(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { if (IsLinqObject(member.TypeAccessor.Type)) { var a = member.GetAttribute<ColumnAttribute>(); if (a != null && !string.IsNullOrEmpty(a.Name)) { isSet = true; return a.Storage; } } return base.GetFieldStorage(typeExtension, member, out isSet); }
public override Association GetAssociation(TypeExtension typeExtension, MemberAccessor member) { var aa = member.GetAttribute <AssociationAttribute>(); if (aa == null) { return(base.GetAssociation(typeExtension, member)); } return(new Association( member, aa.GetThisKeys(), aa.GetOtherKeys(), aa.Storage, aa.CanBeNull)); }
/// <summary> /// Ariel Sigo /// Created 2016/11/22 /// </summary> /// <param name="oldMember"></param> /// <param name="newMember"></param> /// <returns>true if update succeeded</returns> public bool UpdateMember(Member oldMember, Member newMember) { var result = false; if (result = (1 == MemberAccessor.UpdateMember(oldMember.MemberID, newMember.MemberID, oldMember.FirstName, newMember.FirstName, oldMember.LastName, newMember.LastName, oldMember.PhoneNumber, newMember.PhoneNumber, oldMember.Status, newMember.Status, oldMember.Birthday, newMember.Birthday, oldMember.StartDate, newMember.StartDate, oldMember.MembershipTypeID, newMember.MembershipTypeID, oldMember.MemberPoleLevel, newMember.MemberPoleLevel, oldMember.MemberAcroLevel, newMember.MemberAcroLevel, oldMember.MemberSilksLevel, newMember.MemberSilksLevel, oldMember.MemberLyraLevel, newMember.MemberLyraLevel))) { return(result); } else { result = false; return(result); } }
public override bool GetMapIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { if (member.GetAttribute <AssociationAttribute>() != null) { isSet = true; return(true); } if (IsLinqObject(member.TypeAccessor.Type)) { isSet = true; return(member.GetAttribute <ColumnAttribute>() == null); } return(base.GetMapIgnore(typeExtension, member, out isSet)); }
internal void SetEnumConverter(MemberAccessor ma, MappingSchema ms) { if (!_isEnumConverterSet) { _isEnumConverterSet = true; if (EnumTypes == null) { EnumTypes = new List <Type>(); } EnumTypes.Add(ma.Type); SetEnumConverterInternal(ma, ms); } }
public override bool GetTrimmable(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { if (member.Type == typeof(string)) { foreach (var p in _list) { var trimmable = p.GetTrimmable(typeExtension, member, out isSet); if (isSet) { return(trimmable); } } } return(base.GetTrimmable(typeExtension, member, out isSet)); }
// Try to generate an accessor for a built-in primitive type. static bool TryGenerateAccessorPrimitive(ref MemberAccessor accessor, Type parentType, Type type, PropertyInfo property) { TypeCode typeCode = Type.GetTypeCode(type); // If it's not in the range of supported types (bool, DateTime, primitives) don't do the primitive accessor. if (typeCode < TypeCode.Boolean || typeCode > TypeCode.DateTime) { return(false); } Delegate?getter = property.GetGetMethod() !.CreateDelegate(GenericPrimitivePropertyGetter.MakeGenericType(parentType, type)); Delegate?setter = property.GetSetMethod() !.CreateDelegate(GenericPropertySetter.MakeGenericType(parentType, type)); accessor.Initialize(MemberAccessorType.PrimitiveProperty, getter, setter); accessor.PrimitiveTypeCode = typeCode; return(true); }
Action <IDatabase, DbCommand, TEntity> CreateParameterBinder() { var members = _members.Select((_, i) => new MemberTuple <TEntity>( _.Name, _.DbType, BuildParameterName(i), MemberAccessor <TEntity, object> .GetGetter(_.Member) )).ToArray(); return((db, command, entity) => { foreach (var member in members) { db.AddInParameter(command, member.ParameterName, member.DbType, member.Getter(entity)); } }); }
public MemberBindable(MemberAccessor access, NotificationMode mode = null) { _accessor = access; var instance = _accessor.RootObject; var changed = instance as INotifyPropertyChanged; if (changed != null) { changed.PropertyChanged += (sender, args) => { if (args.PropertyName == access.MemberChain[0].Name) { NotifyChange(); } }; } mode?.Subscribe(instance, this); }
public override bool GetTrimmable(ObjectMapper mapper, MemberAccessor member, out bool isSet) { if (member.Type == typeof(string)) { foreach (MetadataProviderBase p in _list) { bool trimmable = p.GetTrimmable(mapper, member, out isSet); if (isSet) { return(trimmable); } } } return(base.GetTrimmable(mapper, member, out isSet)); }
public void Setup() { person = new Person(); person.NameField = "John Smith"; person.Forename = "John"; person.Address = new Address { Country = new Country { Name = "United States" } }; nameFieldAccessor = MemberAccessor <Person> .From(x => x.NameField); forenameAccessor = MemberAccessor <Person> .From(x => x.Forename); countryNameAccessor = MemberAccessor <Person> .From(x => x.Address.Country.Name); }
public void Testインスタンスプロパティ() { Table1.StaticValue = "STATIC"; Table1 obj = new Table1() { InstanceValue = "INSTANCE" }; PropertyInfo prop = obj.GetType().GetProperty("InstanceValue"); object actual1 = MemberAccessor.GetValue(obj, prop); Assert.AreEqual("INSTANCE", actual1); MemberAccessor.SetValue(obj, prop, "CHANGEDVALUE"); object actual2 = MemberAccessor.GetValue(obj, prop); Assert.AreEqual("CHANGEDVALUE", actual2); }
public override int GetPrimaryKeyOrder(Type type, TypeExtension typeExt, MemberAccessor member, out bool isSet) { var keyAttr = member.GetAttribute <KeyAttribute>(); if (keyAttr != null) { isSet = true; var colAttr = member.GetAttribute <ColumnAttribute>(); if (colAttr != null) { return(colAttr.Order); } return(0); } return(base.GetPrimaryKeyOrder(type, typeExt, member, out isSet)); }
internal Action <IDatabase, DbCommand, TEntity> BuildCommandExecutor() { // 不带返回 if (_identity == null && _outputs.Length == 0) { return((db, command, entity) => db.ExecuteNonQuery(command)); } Action <IDatabase, TEntity> rerverseBindId = (db, entity) => { }; Action <IDatabase, TEntity> reverseBind = rerverseBindId; if (_identity != null) { var setId = MemberAccessor <TEntity, object> .GetSetter(_identity.Member); rerverseBindId = (db, entity) => { setId(entity, db.ExecuteScalar("SELECT LAST_INSERT_ROWID()")); }; } if (_outputs.Length > 0) { var assigns = _outputs.Select(_ => MemberAccessor.GetAssign <TEntity>(_.Member)).ToArray(); reverseBind = (db, entity) => { var reverseEntity = db.LoadEntity(entity); foreach (var assign in assigns) { assign(reverseEntity, entity); } }; } return((db, command, entity) => { using (var transactionManager = new TransactionManager()) { db.ExecuteNonQuery(command); rerverseBindId(db, entity); reverseBind(db, entity); transactionManager.Commit(); } }); }
public override bool GetMapIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { if (member.IsDefined <NotMappedAttribute>() || member.IsDefined <ScaffoldColumnAttribute>() || member.IsDefined <System.ComponentModel.DataAnnotations.AssociationAttribute>()) { isSet = true; return(true); } if (member.IsDefined <ColumnAttribute>()) { isSet = true; return(false); } return(base.GetMapIgnore(typeExtension, member, out isSet)); }
static Action <IDatabase, DbCommand, TEntity> CreateParameterBinder(MemberDescriptor[] descriptors, Func <int, string> parameterNameBuilder) { var members = descriptors.Select((_, i) => new MemberTuple <TEntity>( _.Name, _.DbType, parameterNameBuilder(i), MemberAccessor <TEntity, object> .GetGetter(_.Member) )).ToArray(); return((db, command, entity) => { foreach (var member in members) { db.AddInParameter(command, member.ParameterName, member.DbType, member.Getter(entity)); } }); }
public Expression BuildSql(MemberAccessor ma, int idx, MethodInfo checkNullFunction, Expression context) { var expr = Expression.Call(DataReaderParam, ReflectionHelper.DataReader.GetValue, Expression.Constant(idx)); if (checkNullFunction != null) { expr = Expression.Call(null, checkNullFunction, expr, context); } Expression mapper; if (TypeHelper.IsEnumOrNullableEnum(ma.Type)) { var type = TypeHelper.ToNullable(ma.Type); mapper = Expression.Convert( Expression.Call( Expression.Constant(MappingSchema), ReflectionHelper.MapSchema.MapValueToEnumWithMemberAccessor, expr, Expression.Constant(ma)), type); } else { MethodInfo mi; if (!ReflectionHelper.MapSchema.Converters.TryGetValue(ma.Type, out mi)) { mapper = Expression.Convert( Expression.Call( Expression.Constant(MappingSchema), ReflectionHelper.MapSchema.ChangeType, expr, Expression.Constant(ma.Type)), ma.Type); } else { mapper = Expression.Call(Expression.Constant(MappingSchema), mi, expr); } } return(mapper); }
public override bool GetSqlIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var attr = member.GetAttribute <SqlIgnoreAttribute>(); if (attr == null) { attr = (SqlIgnoreAttribute)TypeHelper.GetFirstAttribute(member.Type, typeof(SqlIgnoreAttribute)); } if (attr != null) { isSet = true; return(attr.Ignore); } return(base.GetSqlIgnore(typeExtension, member, out isSet)); }
public void Same_Scoped_Expressions_With_Different_ToStrings_Are_Equal() { var bindable = ObservedPropertyModels.CreateFirst(""); MemberAccessor <string> ae1, ae2; { var item1 = bindable.Second; ae1 = MemberAccessor.Create(() => item1.Third.Value); } { var item2 = bindable.Second; ae2 = MemberAccessor.Create(() => item2.Third.Value); } Assert.Equal(ae1, ae2); }
protected internal virtual MemberMapper[] GetKeyFieldList(DbManager db, Type type) { string key = type.FullName + "$" + db.DataProvider.UniqueName; MemberMapper[] mmList = (MemberMapper[])_keyList[key]; if (mmList == null) { TypeExtension typeExt = TypeExtension.GetTypeExtension(type, Extensions); List <MemberOrder> list = new List <MemberOrder>(); foreach (MemberMapper mm in db.MappingSchema.GetObjectMapper(type)) { if (mm.MapMemberInfo.SqlIgnore) { continue; } MemberAccessor ma = mm.MapMemberInfo.MemberAccessor; if (TypeHelper.IsScalar(ma.Type)) { bool isSet; int order = MappingSchema.MetadataProvider.GetPrimaryKeyOrder(type, typeExt, ma, out isSet); if (isSet) { list.Add(new MemberOrder(mm, order)); } } } list.Sort(delegate(MemberOrder x, MemberOrder y) { return(x.Order - y.Order); }); _keyList[key] = mmList = new MemberMapper[list.Count]; for (int i = 0; i < list.Count; i++) { mmList[i] = list[i].MemberMapper; } } return(mmList); }
ConstantExpression EvaluateExternalMember(MemberExpression node) { if (node.Expression == null) // static member { return(Expression.Constant(MemberAccessor.GetGetter(node.Member)(null))); } switch (node.Expression.NodeType) { case ExpressionType.Constant: return(Expression.Constant(MemberAccessor.GetGetter(node.Member)(((ConstantExpression)node.Expression).Value))); case ExpressionType.MemberAccess: var value = EvaluateExternalMember((MemberExpression)node.Expression); // 递归向内获取 return(Expression.Constant(MemberAccessor.GetGetter(node.Member)(value.Value))); default: throw new NotSupportedException("不支持的外部值访问:" + node); } }
internal Action <IDatabase, DbCommand, TEntity> BuildCommandExecutor() { // 不带返回 if (_outputs.Length == 0) { return((db, command, entity) => db.ExecuteNonQuery(command)); } var assigns = _outputs.Select(_ => MemberAccessor.GetAssign <TEntity>(_.Member)).ToArray(); return((db, command, entity) => { var result = db.ExecuteEntity <TEntity>(command); foreach (var assign in assigns) { assign(result, entity); // 回写 } }); }
public void AddHook <H, T, C>( H hookedItem, MemberAccessor <H, T> hookMember, C chainItem, MemberAccessor <C, T> chainMember, T defaultValue) { hooks.Add( new Hook <T, T>() { HookGetter = () => hookMember.Getter(hookedItem), HookSetter = (t) => hookMember.Setter(hookedItem, t), ChainGetter = () => chainMember.Getter(chainItem), ChainSetter = (t) => chainMember.Setter(chainItem, t), Default = defaultValue, PullConverter = (t) => t, PushConverter = (t) => t }); }
public override void EnsureMapper(TypeAccessor typeAccessor, MappingSchema mappingSchema, EnsureMapperHandler handler) { foreach (MapFieldAttribute attr in GetMapFieldAttributes(typeAccessor)) { if (attr.OrigName != null) { handler(attr.MapName, attr.OrigName); } else { MemberAccessor ma = typeAccessor[attr.MapName]; foreach (MemberMapper inner in mappingSchema.GetObjectMapper(ma.Type)) { handler(string.Format(attr.Format, inner.Name), ma.Name + "." + inner.MemberName); } } } }
private static T GetPropertyValue <T>(Type objType, string propertyName, object obj) { var key = objType.FullName + "_" + propertyName; object accessor; MemberAccessor <T> typedAccessor; if (!accessors.TryGetValue(key, out accessor)) { var property = objType.GetProperty(propertyName); typedAccessor = property != null ? MemberAccessor <T> .Get(property) : null; accessors.TryAdd(key, typedAccessor); } else { typedAccessor = (MemberAccessor <T>)accessor; } return(typedAccessor == null ? default(T) : typedAccessor.Get(obj)); }
public override Association GetAssociation(TypeExtension typeExtension, MemberAccessor member) { if (member.Type.IsClass && !member.Type.FullName.StartsWith("System")) { bool canBeNull = !member.IsDefined <RequiredAttribute>(); Type otherType = member.Type; if (otherType.IsGenericType) { otherType = otherType.GetGenericArguments()[0]; } string[] otherKeys = null; string[] thisKeys = null; if (member.IsDefined <System.ComponentModel.DataAnnotations.AssociationAttribute>()) { var asAttr = member.GetAttribute <System.ComponentModel.DataAnnotations.AssociationAttribute>(); thisKeys = asAttr.ThisKeyMembers.ToArray(); otherKeys = asAttr.OtherKeyMembers.ToArray(); } else if (member.IsDefined <ForeignKeyAttribute>()) { var fkAttr = member.GetAttribute <ForeignKeyAttribute>(); otherKeys = GetTypeKeyNames(otherType); thisKeys = fkAttr.Name.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); } else { otherKeys = GetTypeKeyNames(otherType); thisKeys = otherKeys; } if (thisKeys != null && otherKeys != null && thisKeys.Length == otherKeys.Length && thisKeys.Length > 0) { return(new Association( member, thisKeys, otherKeys, string.Format("FK_{0}_{1}", member.TypeAccessor.Type, otherType), canBeNull)); } } return(base.GetAssociation(typeExtension, member)); }
public override bool GetNullable(ObjectMapper mapper, MemberAccessor member, out bool isSet) { // Check extension <Member1 Nullable='true' /> // object value = GetValue(mapper, member, "Nullable", out isSet); if (isSet) { return(TypeExtension.ToBoolean(value)); } // Check extension <Member1 NullValue='-1' /> // if (GetValue(mapper, member, "NullValue", out isSet) != null) { return(true); } return(base.GetNullable(mapper, member, out isSet)); }
public override bool GetMapIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var attr = member.GetAttribute <MapIgnoreAttribute>() ?? (MapIgnoreAttribute)TypeHelper.GetFirstAttribute(member.Type, typeof(MapIgnoreAttribute)); if (attr != null) { isSet = true; return(attr.Ignore); } if (member.GetAttribute <MapFieldAttribute>() != null || member.GetAttribute <MapImplicitAttribute>() != null || TypeHelper.GetFirstAttribute(member.Type, typeof(MapImplicitAttribute)) != null) { isSet = true; return(false); } return(base.GetMapIgnore(typeExtension, member, out isSet) || member.GetAttribute <AssociationAttribute>() != null); }
public override bool GetSqlIgnore(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var ignoreAttr = member.GetAttribute <NotMappedAttribute>(); if (ignoreAttr != null) { isSet = true; return(true); } var scAttr = member.GetAttribute <ScaffoldColumnAttribute>(); if (scAttr != null) { isSet = true; return(true); } return(base.GetSqlIgnore(typeExtension, member, out isSet)); }
public ColumnPropertyInfo(PropertyInfo property, ColumnAttribute column) { Property = property; ColumnName = column.ColumnName ?? property.Name; IsCustomColumnName = column.ColumnName != null; HasDefaultConstraint = column.HasDefaultConstraint; var type = property.PropertyType; _accessor = new MemberAccessor(property); if (type.IsValueType) { _defaultValue = ValueTypeDefaultCache.GetDefaultValue(type); } else { _defaultValue = null; } HasSetter = _accessor.HasSetter; }
protected MemberMapper[] GetNonKeyFieldList(ObjectMapper om) { TypeExtension typeExt = TypeExtension.GetTypeExtension(om.TypeAccessor.OriginalType, Extensions); List <MemberMapper> list = new List <MemberMapper>(); foreach (MemberMapper mm in om) { MemberAccessor ma = mm.MemberAccessor; bool isSet; MappingSchema.MetadataProvider.GetPrimaryKeyOrder(om.TypeAccessor.OriginalType, typeExt, ma, out isSet); if (!isSet) { list.Add(mm); } } return(list.ToArray()); }
public override string GetFieldStorage(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { var a = member.GetAttribute<MapFieldAttribute>(); if (a != null) { isSet = true; return a.Storage; } foreach (MapFieldAttribute attr in GetMapFieldAttributes(member.TypeAccessor)) { if (string.Equals(attr.OrigName, member.Name, StringComparison.InvariantCultureIgnoreCase)) { isSet = true; return attr.Storage; } } return base.GetFieldStorage(typeExtension, member, out isSet); }
public override Association GetAssociation(TypeExtension typeExtension, MemberAccessor member) { if (member.Type.IsClass && !member.Type.FullName.StartsWith("System")) { bool canBeNull = !member.IsDefined<RequiredAttribute>(); Type otherType = member.Type; if(otherType.IsGenericType) otherType = otherType.GetGenericArguments()[0]; string[] otherKeys = null; string[] thisKeys = null; if (member.IsDefined<System.ComponentModel.DataAnnotations.AssociationAttribute>()) { var asAttr = member.GetAttribute<System.ComponentModel.DataAnnotations.AssociationAttribute>(); thisKeys = asAttr.ThisKeyMembers.ToArray(); otherKeys = asAttr.OtherKeyMembers.ToArray(); } else if (member.IsDefined<ForeignKeyAttribute>()) { var fkAttr = member.GetAttribute<ForeignKeyAttribute>(); otherKeys = GetTypeKeyNames(otherType); thisKeys = fkAttr.Name.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); } else { otherKeys = GetTypeKeyNames(otherType); thisKeys = otherKeys; } if (thisKeys != null && otherKeys != null && thisKeys.Length == otherKeys.Length && thisKeys.Length > 0) { return new Association( member, thisKeys, otherKeys, string.Format("FK_{0}_{1}", member.TypeAccessor.Type, otherType), canBeNull); } } return base.GetAssociation(typeExtension, member); }
public override bool GetIgnore(ObjectMapper mapper, MemberAccessor member, out bool isSet) { MapIgnoreAttribute attr = member.GetAttribute<MapIgnoreAttribute>(); if (attr == null) attr = (MapIgnoreAttribute)TypeHelper.GetFirstAttribute(member.Type, typeof(MapIgnoreAttribute)); if (attr != null) { isSet = true; return attr.Ignore; } if (member.GetAttribute<MapImplicitAttribute>() != null || TypeHelper.GetFirstAttribute(member.Type, typeof(MapImplicitAttribute)) != null) { isSet = true; return false; } return base.GetIgnore(mapper, member, out isSet); }
public override string GetFieldName(TypeExtension typeExtension, MemberAccessor member, out bool isSet) { string name = string.Empty; foreach (char c in member.Name) { if (char.IsUpper(c)) { if (name.Length > 0) name += '_'; name += c; } else { name += char.ToUpper(c); } } isSet = true; return name; }
public override string GetFieldName(ObjectMapper mapper, MemberAccessor member, out bool isSet) { MapFieldAttribute a = member.GetAttribute<MapFieldAttribute>(); if (a != null) { isSet = true; return a.MapName; } string name = member.Name.ToLower(); foreach (MapFieldAttribute attr in GetMapFieldAttributes(mapper)) { if (attr.OrigName.ToLower() == name) { isSet = true; return attr.MapName; } } return base.GetFieldName(mapper, member, out isSet); }
public override MapValue[] GetMapValues(ObjectMapper mapper, MemberAccessor member, out bool isSet) { AttributeExtensionCollection extList = mapper.Extension[member.Name]["MapValue"]; if (extList == AttributeExtensionCollection.Null) return GetMapValues(mapper.Extension, member.Type, out isSet); List<MapValue> list = new List<MapValue>(extList.Count); foreach (AttributeExtension ext in extList) { object origValue = ext["OrigValue"]; if (origValue != null) { origValue = TypeExtension.ChangeType(origValue, member.Type); list.Add(new MapValue(origValue, ext.Value)); } } isSet = true; return list.ToArray(); }