/// <summary> /// Creates cache information for a property of a serializable class /// </summary> /// <param name="attrib">Serialization attribute applied to the property</param> /// <param name="prop">Property metadata</param> public PropertySerializationInfo( SerializablePropertyAttribute attrib, MemberInfo prop ) { this.attribute = attrib; this.property = prop; DeterminePropertyType(false); }
/// <summary> /// Constructs cache information for the indexer property of a serializable class /// </summary> /// <param name="attrib"></param> /// <param name="type"></param> public PropertySerializationInfo( SerializablePropertyAttribute attrib, Type type ) { Type icoll, idict; MethodInfo add, count; // Verify that the type implements collection semantics if (FindCollectionInterface(type, out icoll, out idict, out add, out count) == false) { throw new ArgumentException(string.Format( "The type {0} must support ICollection<> to serialize the indexer", type.FullName )); } this.attribute = attrib; this.classType = type; DeterminePropertyType(true); }
private static IPropertyDescriptor ConvertPropertyDescriptor(IPropertyDescriptor propertyDescriptor) { SerializablePropertyAttribute attribute = propertyDescriptor.GetCustomAttribute <SerializablePropertyAttribute>(); if (attribute is null) { return(null); } PropertyDescriptor result = new PropertyDescriptor(propertyDescriptor); if (attribute.Name != null) { result.Name = attribute.Name; } result.Order = attribute.BinaryOrder; return(result); }
/// <summary> /// Creates cache information for a property of a serializable class /// </summary> /// <param name="attrib">Serialization attribute applied to the property</param> /// <param name="prop">Property metadata</param> public PropertySerializationInfo( SerializablePropertyAttribute attrib, MemberInfo prop ) { this.attribute = attrib; this.property = prop; DeterminePropertyType(false); }
/// <summary> /// Constructs cache information for the indexer property of a serializable class /// </summary> /// <param name="attrib"></param> /// <param name="type"></param> public PropertySerializationInfo( SerializablePropertyAttribute attrib, Type type ) { Type icoll, idict; MethodInfo add, count; // Verify that the type implements collection semantics if (FindCollectionInterface(type, out icoll, out idict, out add, out count) == false) { throw new ArgumentException(string.Format( "The type {0} must support ICollection<> to serialize the indexer", type.FullName )); } this.attribute = attrib; this.classType = type; DeterminePropertyType(true); }
public static PartDefinition Create(Type type) { if (type == null) { throw new ArgumentNullException("type"); } var classAttributes = Attribute.GetCustomAttributes(type, typeof(SerializableClassAttribute), false); if (classAttributes == null || classAttributes.Length == 0) { throw new BarfException(string.Format("{0} does not define a {1}", type.Name, typeof(SerializableClassAttribute).Name), type, null); } var classAttribute = classAttributes .OfType <SerializableClassAttribute>() .First <SerializableClassAttribute>(); SerializablePropertyAttribute attribute; if (classAttribute.SerializeBaseClass) { attribute = new SerializablePropertyAttribute(0); } else { var attributes = Attribute .GetCustomAttributes(type, typeof(SerializablePropertyAttribute)) .OfType <SerializablePropertyAttribute>() .Where <SerializablePropertyAttribute>(a => !(a is SerializableInheritedPropertyAttribute)) .ToArray <SerializablePropertyAttribute>(); if (attributes.Length > 1) { throw new BarfException(string.Format("Can't have more than one {0} defined on a type.", typeof(SerializablePropertyAttribute).Name), type, null); } if (attributes.Length == 0) { return(null); } attribute = attributes[0]; } if (attribute.Dynamic) { // todo validate better (top level type can't be but generic parameters may be) //throw new BarfException(string.Format("{0}'s that are applied to types may not be Dynamic. Type=\"{1}\"", typeof(SerializablePropertyAttribute).Name, type.Name), type, null); } var partType = type.BaseType; if (partType == typeof(object)) { partType = type .GetInterfaces() .Where(t => { if (t == typeof(ICollection <>)) { return(true); } return(t.IsGenericType && t.GetGenericTypeDefinition() == typeof(ICollection <>)); }) .FirstOrDefault <Type>() ?? typeof(object); } return(new PartDefinition { Member = null, MemberName = "!base", Version = attribute.Version, ObsoleteVersion = attribute.ObsoleteVersion, Flags = attribute.Dynamic ? PartFlags.Dynamic : PartFlags.None, ReadMethod = attribute.ReadMethod, WriteMethod = attribute.WriteMethod, Type = partType }); }
private static IPropertyDescriptor DescriptorWithSerializablePropertyAttribute(SerializablePropertyAttribute attribute) { IPropertyDescriptor result = Substitute.For <IPropertyDescriptor>(); result.GetCustomAttribute <SerializablePropertyAttribute>().Returns(attribute); return(result); }
void BuildPropertyList( List <PropertySerializationInfo> properties, out int obsoleteVersion ) { obsoleteVersion = 0; // If class has SerializableProperty attribute then add Indexer object[] attributes = this.type.GetCustomAttributes(typeof(SerializablePropertyAttribute), false); foreach (SerializablePropertyAttribute attrib in attributes) { PropertySerializationInfo propInfo = null; if (attrib is SerializableInheritedPropertyAttribute) { SerializableInheritedPropertyAttribute inherit = (SerializableInheritedPropertyAttribute)attrib; if (this.serializableBaseType != null) { throw new ApplicationException(string.Format( "The SerializableInheritedProperty attribute cannot be used with SerializeBaseClass=true ({0})", this.type.FullName )); } if (this.type.IsSubclassOf(inherit.BaseClass) == false) { throw new ApplicationException(string.Format( "Invalid SerializableInheritedProperty attribute: {0} is not a base class of {1}", this.type.Name, inherit.BaseClass.Name )); } MemberInfo[] prop = inherit.BaseClass.GetMember( inherit.BasePropertyName, MemberTypes.Field | MemberTypes.Property, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly ); if (prop.Length == 0) { throw new ApplicationException(string.Format( "Failed to located property \"{0}\" inherited from base class \"{1}\"", inherit.BasePropertyName, inherit.BaseClass.Name )); } propInfo = new PropertySerializationInfo(attrib, prop[0]); } else { propInfo = new PropertySerializationInfo(attrib, this.type); } properties.Add(propInfo); obsoleteVersion = Math.Max(obsoleteVersion, propInfo.ObsoleteVersion); } // Get members. We don't need to worry about the member type // because only valid member types can have the SerializableProperty attribute foreach (MemberInfo prop in this.type.GetMembers( BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly )) { PropertySerializationInfo propInfo = null; SerializablePropertyAttribute attrib = null; attrib = SerializablePropertyAttribute.GetAttribute(prop); if (attrib == null) { continue; } propInfo = new PropertySerializationInfo(attrib, prop); properties.Add(propInfo); obsoleteVersion = Math.Max(obsoleteVersion, propInfo.ObsoleteVersion); } }