/// <summary> /// Gets the serializable members for the type. /// </summary> /// <param name="objectType">The type to get serializable members for.</param> /// <returns>The serializable members for the type.</returns> protected virtual List <MemberInfo> GetSerializableMembers(Type objectType) { #if !PocketPC DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType); #endif List <MemberInfo> defaultMembers = ReflectionUtils.GetFieldsAndProperties(objectType, DefaultMembersSearchFlags); List <MemberInfo> allMembers = ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); List <MemberInfo> serializableMembers = new List <MemberInfo>(); foreach (MemberInfo member in allMembers) { if (defaultMembers.Contains(member)) { serializableMembers.Add(member); } else { if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(member) != null) { serializableMembers.Add(member); } #if !PocketPC else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute <DataMemberAttribute>(member) != null) { serializableMembers.Add(member); } #endif } } return(serializableMembers); }
private static string CheckType(Type type) { bool flag = false; string txt = ""; txt += string.Format("检查类型:{0}\n", type); DataContractAttribute attribute = type.GetCustomAttribute <DataContractAttribute>(); if (attribute == null) { txt += string.Format("没有 DataContract !!\n"); flag = true; } foreach (PropertyInfo propertyInfo in type.GetProperties()) { DataMemberAttribute attribute2 = propertyInfo.GetCustomAttribute <DataMemberAttribute>(); if (attribute2 == null) { txt += string.Format("没有DataMember:{0}\n", propertyInfo); flag = true; } } txt += string.Format("\n"); if (flag) { return(txt); } return(""); }
internal void GetStableName(DataContractAttribute dataContractAttribute, out string name, out string ns) { name = null; ns = null; if (dataContractAttribute == null) { GetDefaultStableName(this.UnderlyingType, out name, out ns); } else { if (dataContractAttribute.Name == null || dataContractAttribute.Name.Length == 0) { GetDefaultStableName(this.UnderlyingType, out name, out ns); } else { name = dataContractAttribute.Name; } if (dataContractAttribute.Namespace == null) { //TODO,sowmys: Use DataContractNamespaceAttribute if one is provided if (ns == null) { string defName; GetDefaultStableName(this.UnderlyingType, out defName, out ns); } } else { ns = dataContractAttribute.Namespace; } } }
/// <summary> /// Creates a <see cref="CodeAttributeDeclaration"/> for a <see cref="DataContractAttribute"/> /// </summary> /// <param name="sourceType">The type to which the attribute will be applied (to use as a reference)</param> /// <param name="codeGenerator">The client proxy generator</param> /// <param name="referencingType">The type referencing this declaration</param> /// <returns>The new attribute declaration</returns> internal static CodeAttributeDeclaration CreateDataContractAttributeDeclaration(Type sourceType, CodeDomClientCodeGenerator codeGenerator, CodeTypeDeclaration referencingType) { CodeAttributeDeclaration dataContractAttrib = CodeGenUtilities.CreateAttributeDeclaration(typeof(System.Runtime.Serialization.DataContractAttribute), codeGenerator, referencingType); string dataContractNamespace = CodeGenUtilities.GetContractNamespace(sourceType); string dataContractName = null; // If the user specified a DataContract, we should copy the namespace and name. DataContractAttribute sourceDataContractAttrib = (DataContractAttribute)Attribute.GetCustomAttribute(sourceType, typeof(DataContractAttribute)); if (sourceDataContractAttrib != null) { if (sourceDataContractAttrib.Namespace != null) { dataContractNamespace = sourceDataContractAttrib.Namespace; } if (sourceDataContractAttrib.Name != null) { dataContractName = sourceDataContractAttrib.Name; } } dataContractAttrib.Arguments.Add(new CodeAttributeArgument("Namespace", new CodePrimitiveExpression(dataContractNamespace))); if (dataContractName != null) { dataContractAttrib.Arguments.Add(new CodeAttributeArgument("Name", new CodePrimitiveExpression(dataContractName))); } return(dataContractAttrib); }
public static MemberSerialization GetObjectMemberSerialization(Type objectType, bool ignoreSerializableAttribute) { JsonObjectAttribute objectAttribute = GetCachedAttribute <JsonObjectAttribute>(objectType); if (objectAttribute != null) { return(objectAttribute.MemberSerialization); } DataContractAttribute dataContractAttribute = GetDataContractAttribute(objectType); if (dataContractAttribute != null) { return(MemberSerialization.OptIn); } if (!ignoreSerializableAttribute) { SerializableAttribute serializableAttribute = GetCachedAttribute <SerializableAttribute>(objectType); if (serializableAttribute != null) { return(MemberSerialization.Fields); } } // the default return(MemberSerialization.OptOut); }
public static MemberSerialization GetObjectMemberSerialization(Type objectType, bool ignoreSerializableAttribute) { JsonObjectAttribute objectAttribute = GetJsonObjectAttribute(objectType); if (objectAttribute != null) { return(objectAttribute.MemberSerialization); } #if !PocketPC && !NET20 DataContractAttribute dataContractAttribute = GetDataContractAttribute(objectType); if (dataContractAttribute != null) { return(MemberSerialization.OptIn); } #endif #if !(SILVERLIGHT || NETFX_CORE || PORTABLE) if (!ignoreSerializableAttribute) { SerializableAttribute serializableAttribute = GetSerializableAttribute(objectType); if (serializableAttribute != null) { return(MemberSerialization.Fields); } } #endif // the default return(MemberSerialization.OptOut); }
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType) { DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType); List <MemberInfo> list = (from m in ReflectionUtils.GetFieldsAndProperties(objectType, DefaultMembersSearchFlags) where !ReflectionUtils.IsIndexedProperty(m) select m).ToList(); List <MemberInfo> list2 = (from m in ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) where !ReflectionUtils.IsIndexedProperty(m) select m).ToList(); List <MemberInfo> list3 = new List <MemberInfo>(); foreach (MemberInfo item in list2) { if (SerializeCompilerGeneratedMembers || !item.IsDefined(typeof(CompilerGeneratedAttribute), inherit: true)) { if (list.Contains(item)) { list3.Add(item); } else if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(item) != null) { list3.Add(item); } else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute <DataMemberAttribute>(item) != null) { list3.Add(item); } } } if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", out Type _)) { list3 = list3.Where(ShouldSerializeEntityMember).ToList(); } return(list3); }
/// <summary> /// Gets the namespace from an attribute marked on the type's definition /// </summary> /// <param name="type"></param> /// <returns>Namespace of type</returns> public static string GetNamespace(Type type) { Attribute[] attrs = (Attribute[])type.GetCustomAttributes(typeof(DataContractAttribute), true); if (attrs.Length > 0) { DataContractAttribute dcAttr = (DataContractAttribute)attrs[0]; return(dcAttr.Namespace); } attrs = (Attribute[])type.GetCustomAttributes(typeof(XmlRootAttribute), true); if (attrs.Length > 0) { XmlRootAttribute xmlAttr = (XmlRootAttribute)attrs[0]; return(xmlAttr.Namespace); } attrs = (Attribute[])type.GetCustomAttributes(typeof(XmlTypeAttribute), true); if (attrs.Length > 0) { XmlTypeAttribute xmlAttr = (XmlTypeAttribute)attrs[0]; return(xmlAttr.Namespace); } attrs = (Attribute[])type.GetCustomAttributes(typeof(XmlElementAttribute), true); if (attrs.Length > 0) { XmlElementAttribute xmlAttr = (XmlElementAttribute)attrs[0]; return(xmlAttr.Namespace); } return(null); }
public static MemberSerialization GetObjectMemberSerialization(Type objectType, bool ignoreSerializableAttribute) { JsonObjectAttribute objectAttribute = GetCachedAttribute <JsonObjectAttribute>(objectType); if (objectAttribute != null) { return(objectAttribute.MemberSerialization); } #if HAVE_DATA_CONTRACTS DataContractAttribute dataContractAttribute = GetDataContractAttribute(objectType); if (dataContractAttribute != null) { return(MemberSerialization.OptIn); } #endif #if HAVE_BINARY_SERIALIZATION if (!ignoreSerializableAttribute && IsSerializable(objectType)) { return(MemberSerialization.Fields); } #endif // the default return(MemberSerialization.OptOut); }
private static string GetAndCacheContractIdFromAttribute(Type contractType) { string contractId; DataContractAttribute contract = contractType .GetCustomAttributes(false).Where(attr => attr is DataContractAttribute) .SingleOrDefault() as DataContractAttribute; if (contract == null || String.IsNullOrEmpty(contract.Name)) { if (typeof(IProjection).IsAssignableFrom(contractType) || typeof(IPort).IsAssignableFrom(contractType) || typeof(IAggregateRootApplicationService).IsAssignableFrom(contractType)) { contractId = contractType.GetHashCode().ToString(); } else { throw new Exception(String.Format(@"The message type '{0}' is missing a DataContract attribute. Example: [DataContract(""00000000-0000-0000-0000-000000000000"")]", contractType.FullName)); } } else { contractId = contract.Name; } contractIds.TryAdd(contractType, contractId); return(contractId); }
private void InitializeContract(JsonContract contract) { JsonContainerAttribute containerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType); if (containerAttribute != null) { contract.IsReference = containerAttribute._isReference; } else { DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(contract.UnderlyingType); // doesn't have a null value if (dataContractAttribute != null && dataContractAttribute.IsReference) { contract.IsReference = true; } } contract.Converter = ResolveContractConverter(contract.UnderlyingType); // then see whether object is compadible with any of the built in converters contract.InternalConverter = JsonSerializer.GetMatchingConverter(BuiltInConverters, contract.UnderlyingType); if (ReflectionUtils.HasDefaultConstructor(contract.CreatedType, true) || contract.CreatedType.IsValueType) { contract.DefaultCreator = GetDefaultCreator(contract.CreatedType); contract.DefaultCreatorNonPublic = (!contract.CreatedType.IsValueType && ReflectionUtils.GetDefaultConstructor(contract.CreatedType) == null); } ResolveCallbackMethods(contract, contract.UnderlyingType); }
private void GenerateEnumTypeDeclaration(Type enumType) { DataContractAttribute dataContractAttr = (DataContractAttribute)Attribute.GetCustomAttribute(enumType, typeof(DataContractAttribute)); if (dataContractAttr != null) { this.GenerateDataContractAttribute(enumType); } if (enumType.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0) { this.Write("[System.Flags]\r\n"); } this.Write("public enum "); this.Write(this.ToStringHelper.ToStringWithCulture(CodeGenUtilities.GetSafeName(enumType.Name))); Type underlyingType = enumType.GetEnumUnderlyingType(); if (underlyingType != typeof(int)) { this.Write(" : "); this.Write(this.ToStringHelper.ToStringWithCulture(CodeGenUtilities.GetTypeName(underlyingType))); } }
public void TestDataContractAttribute() { DataContractAttribute x = new DataContractAttribute(); Assert.AreEqual(null, x.Name, "#01"); Assert.AreEqual(null, x.Namespace, "#02"); }
private void method_7(JsonContract jsonContract_0) { JsonContainerAttribute attribute = Class139.smethod_0(jsonContract_0.type_0); if (attribute != null) { jsonContract_0.IsReference = attribute.nullable_0; } else { DataContractAttribute attribute2 = Class139.smethod_5(jsonContract_0.type_0); if ((attribute2 != null) && attribute2.IsReference) { jsonContract_0.IsReference = true; } } jsonContract_0.Converter = this.ResolveContractConverter(jsonContract_0.type_0); jsonContract_0.JsonConverter_0 = JsonSerializer.smethod_1(ilist_0, jsonContract_0.type_0); if (Class194.smethod_6(jsonContract_0.CreatedType, true) || jsonContract_0.CreatedType.smethod_12()) { jsonContract_0.DefaultCreator = this.method_6(jsonContract_0.CreatedType); jsonContract_0.DefaultCreatorNonPublic = !jsonContract_0.CreatedType.smethod_12() && (Class194.smethod_7(jsonContract_0.CreatedType) == null); } this.method_8(jsonContract_0, jsonContract_0.type_0); }
public static MemberSerialization GetObjectMemberSerialization(Type objectType, bool ignoreSerializableAttribute) { JsonObjectAttribute objectAttribute = GetCachedAttribute <JsonObjectAttribute>(objectType); if (objectAttribute != null) { return(objectAttribute.MemberSerialization); } #if !NET20 DataContractAttribute dataContractAttribute = GetDataContractAttribute(objectType); if (dataContractAttribute != null) { return(MemberSerialization.OptIn); } #endif #if !(DOTNET || PORTABLE40 || PORTABLE) if (!ignoreSerializableAttribute) { SerializableAttribute serializableAttribute = GetCachedAttribute <SerializableAttribute>(objectType); if (serializableAttribute != null) { return(MemberSerialization.Fields); } } #endif // the default return(MemberSerialization.OptOut); }
private void InitializeContract(JsonContract contract) { JsonContainerAttribute jsonContainerAttribute = JsonTypeReflector.GetJsonContainerAttribute(contract.UnderlyingType); if (jsonContainerAttribute != null) { contract.IsReference = jsonContainerAttribute._isReference; } else { DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(contract.UnderlyingType); if (dataContractAttribute != null && dataContractAttribute.IsReference) { contract.IsReference = true; } } contract.Converter = ResolveContractConverter(contract.UnderlyingType); contract.InternalConverter = JsonSerializer.GetMatchingConverter(BuiltInConverters, contract.UnderlyingType); if (ReflectionUtils.HasDefaultConstructor(contract.CreatedType, nonPublic: true) || contract.CreatedType.IsValueType) { contract.DefaultCreator = GetDefaultCreator(contract.CreatedType); contract.DefaultCreatorNonPublic = (!contract.CreatedType.IsValueType && ReflectionUtils.GetDefaultConstructor(contract.CreatedType) == null); } ResolveCallbackMethods(contract, contract.UnderlyingType); }
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType) { bool ignoreSerializableAttribute = this.IgnoreSerializableAttribute; MemberSerialization serialization = Class139.smethod_7(objectType, ignoreSerializableAttribute); if (func_0 == null) { func_0 = new Func <MemberInfo, bool>(DefaultContractResolver.smethod_5); } List <MemberInfo> list = Class194.smethod_27(objectType, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).Where <MemberInfo>(func_0).ToList <MemberInfo>(); List <MemberInfo> source = new List <MemberInfo>(); if (serialization != MemberSerialization.Fields) { Type type; DataContractAttribute attribute = Class139.smethod_5(objectType); if (func_1 == null) { func_1 = new Func <MemberInfo, bool>(DefaultContractResolver.smethod_6); } List <MemberInfo> list3 = Class194.smethod_27(objectType, this.DefaultMembersSearchFlags).Where <MemberInfo>(func_1).ToList <MemberInfo>(); foreach (MemberInfo info in list) { if (this.SerializeCompilerGeneratedMembers || !info.IsDefined(typeof(CompilerGeneratedAttribute), true)) { if (list3.Contains(info)) { source.Add(info); } else if (Class139.smethod_17 <JsonPropertyAttribute>(info) != null) { source.Add(info); } else if ((attribute != null) && (Class139.smethod_17 <DataMemberAttribute>(info) != null)) { source.Add(info); } else if ((serialization == MemberSerialization.Fields) && (info.smethod_1() == MemberTypes.Field)) { source.Add(info); } } } if (objectType.smethod_13("System.Data.Objects.DataClasses.EntityObject", out type)) { source = source.Where <MemberInfo>(new Func <MemberInfo, bool>(this.method_2)).ToList <MemberInfo>(); } return(source); } foreach (MemberInfo info2 in list) { FieldInfo info3 = info2 as FieldInfo; if ((info3 != null) && !info3.IsStatic) { source.Add(info2); } } return(source); }
/// <summary> /// Creates a namespace resolution for a <see cref="DataContractAttribute" />-annotated /// type. /// </summary> protected virtual IdentifierResolution CreateNamespaceResolution(Type type, DataContractAttribute attribute) { return(string.IsNullOrEmpty(attribute?.Namespace) ? string.IsNullOrEmpty(type.Namespace) ? null : new IdentifierResolution(type.Namespace) : new IdentifierResolution(attribute.Namespace, true)); }
/// <summary> /// Removes properties that do not have the <see cref="DataMemberAttribute"/> attribute from the enum type. /// </summary> /// <param name="enumTypeConfiguration">The enum type to configure.</param> /// <param name="model">The enum model that this type belongs to.</param> /// <param name="attribute">The <see cref="Attribute"/> found on this type.</param> public override void Apply(EnumTypeConfiguration enumTypeConfiguration, ODataConventionModelBuilder model, Attribute attribute) { if (enumTypeConfiguration == null) { throw Error.ArgumentNull("enumTypeConfiguration"); } if (model == null) { throw Error.ArgumentNull("model"); } if (!enumTypeConfiguration.AddedExplicitly && model.ModelAliasingEnabled) { // set the name, and namespace, if not null DataContractAttribute dataContractAttribute = attribute as DataContractAttribute; if (dataContractAttribute != null) { if (dataContractAttribute.Name != null) { enumTypeConfiguration.Name = dataContractAttribute.Name; } if (dataContractAttribute.Namespace != null) { enumTypeConfiguration.Namespace = dataContractAttribute.Namespace; } } enumTypeConfiguration.AddedExplicitly = false; } IEnumerable <EnumMemberConfiguration> allMembers = enumTypeConfiguration.Members.ToArray(); foreach (EnumMemberConfiguration member in allMembers) { EnumMemberAttribute enumMemberAttribute = enumTypeConfiguration.ClrType.GetField(member.Name) .GetCustomAttributes(typeof(EnumMemberAttribute), inherit: true) .FirstOrDefault() as EnumMemberAttribute; if (!member.AddedExplicitly) { if (model.ModelAliasingEnabled && enumMemberAttribute != null) { if (!string.IsNullOrWhiteSpace(enumMemberAttribute.Value)) { member.Name = enumMemberAttribute.Value; } } else { enumTypeConfiguration.RemoveMember(member.MemberInfo); } } } }
private static string BuildTypeIdForDataContract(object appDataObject) { Type type = appDataObject.GetType(); DataContractAttribute dataContractAttribute = (DataContractAttribute)type.GetCustomAttributes(typeof(DataContractAttribute), false)[0]; string arg = string.IsNullOrEmpty(dataContractAttribute.Name) ? type.Name : dataContractAttribute.Name; string arg2 = string.IsNullOrEmpty(dataContractAttribute.Namespace) ? type.Namespace : dataContractAttribute.Namespace; return(string.Format("DataContract:{0}, {1}, {2}", arg, arg2, type.Assembly.GetName().Version)); }
protected virtual List <MemberInfo> GetSerializableMembers(Type objectType) { bool ignoreSerializableAttribute = this.IgnoreSerializableAttribute; MemberSerialization objectMemberSerialization = JsonTypeReflector.GetObjectMemberSerialization(objectType, ignoreSerializableAttribute); List <MemberInfo> list = (from m in ReflectionUtils.GetFieldsAndProperties(objectType, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) where !ReflectionUtils.IsIndexedProperty(m) select m).ToList <MemberInfo>(); List <MemberInfo> list2 = new List <MemberInfo>(); if (objectMemberSerialization != MemberSerialization.Fields) { DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(objectType); List <MemberInfo> list3 = (from m in ReflectionUtils.GetFieldsAndProperties(objectType, this.DefaultMembersSearchFlags) where !ReflectionUtils.IsIndexedProperty(m) select m).ToList <MemberInfo>(); foreach (MemberInfo current in list) { if (this.SerializeCompilerGeneratedMembers || !current.IsDefined(typeof(CompilerGeneratedAttribute), true)) { if (list3.Contains(current)) { list2.Add(current); } else if (JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(current) != null) { list2.Add(current); } else if (dataContractAttribute != null && JsonTypeReflector.GetAttribute <DataMemberAttribute>(current) != null) { list2.Add(current); } else if (objectMemberSerialization == MemberSerialization.Fields && current.MemberType() == MemberTypes.Field) { list2.Add(current); } } } Type type; if (objectType.AssignableToTypeName("System.Data.Objects.DataClasses.EntityObject", out type)) { list2 = list2.Where(new Func <MemberInfo, bool>(this.ShouldSerializeEntityMember)).ToList <MemberInfo>(); } } else { foreach (MemberInfo current2 in list) { FieldInfo fieldInfo = current2 as FieldInfo; if (fieldInfo != null && !fieldInfo.IsStatic) { list2.Add(current2); } } } return(list2); }
public void Namespace_Set_GetReturnsExpected(string value) { var attribute = new DataContractAttribute() { Namespace = value }; Assert.Equal(value, attribute.Namespace); Assert.True(attribute.IsNamespaceSetExplicitly); }
public void IsReference_Set_GetReturnsExpected(bool value) { var attribute = new DataContractAttribute() { IsReference = value }; Assert.Equal(value, attribute.IsReference); Assert.True(attribute.IsReferenceSetExplicitly); }
public static DataContractAttribute GetDataContractAttribute(Type type) { DataContractAttribute attribute = null; for (Type i = type; attribute == null && i != null; i = i.BaseType) { attribute = CachedAttributeGetter <DataContractAttribute> .GetAttribute(i); } return(attribute); }
private void SetPropertySettingsFromAttributes(JsonProperty property, ICustomAttributeProvider attributeProvider, string name, Type declaringType, MemberSerialization memberSerialization, out bool allowNonPublicAccess, out bool hasExplicitAttribute) { hasExplicitAttribute = false; DataContractAttribute dataContractAttribute = JsonTypeReflector.GetDataContractAttribute(declaringType); DataMemberAttribute dataMemberAttribute = (dataContractAttribute == null || !(attributeProvider is MemberInfo)) ? null : JsonTypeReflector.GetDataMemberAttribute((MemberInfo)attributeProvider); JsonPropertyAttribute attribute = JsonTypeReflector.GetAttribute <JsonPropertyAttribute>(attributeProvider); if (attribute != null) { hasExplicitAttribute = true; } bool flag = JsonTypeReflector.GetAttribute <JsonIgnoreAttribute>(attributeProvider) != null; string propertyName = (attribute != null && attribute.PropertyName != null) ? attribute.PropertyName : ((dataMemberAttribute == null || dataMemberAttribute.Name == null) ? name : dataMemberAttribute.Name); property.PropertyName = ResolvePropertyName(propertyName); property.UnderlyingName = name; if (attribute != null) { property.Required = attribute.Required; property.Order = attribute._order; } else if (dataMemberAttribute != null) { property.Required = (dataMemberAttribute.IsRequired ? Required.AllowNull : Required.Default); property.Order = ((dataMemberAttribute.Order == -1) ? null : new int?(dataMemberAttribute.Order)); } else { property.Required = Required.Default; } property.Ignored = (flag || (memberSerialization == MemberSerialization.OptIn && attribute == null && dataMemberAttribute == null)); property.Converter = JsonTypeReflector.GetJsonConverter(attributeProvider, property.PropertyType); property.MemberConverter = JsonTypeReflector.GetJsonConverter(attributeProvider, property.PropertyType); property.DefaultValue = JsonTypeReflector.GetAttribute <DefaultValueAttribute>(attributeProvider)?.Value; property.NullValueHandling = attribute?._nullValueHandling; property.DefaultValueHandling = attribute?._defaultValueHandling; property.ReferenceLoopHandling = attribute?._referenceLoopHandling; property.ObjectCreationHandling = attribute?._objectCreationHandling; property.TypeNameHandling = attribute?._typeNameHandling; property.IsReference = attribute?._isReference; allowNonPublicAccess = false; if ((DefaultMembersSearchFlags & BindingFlags.NonPublic) == BindingFlags.NonPublic) { allowNonPublicAccess = true; } if (attribute != null) { allowNonPublicAccess = true; } if (dataMemberAttribute != null) { allowNonPublicAccess = true; hasExplicitAttribute = true; } }
/// <summary> /// Returns the xml qualified name for the specified system type id. /// </summary> /// <remarks> /// Returns the xml qualified name for the specified system type id. /// </remarks> /// <param name="systemType">The underlying type to query and return the Xml qualified name of</param> public static XmlQualifiedName GetXmlName(System.Type systemType) { if (systemType == null) { return(null); } object[] attributes = systemType.GetTypeInfo().GetCustomAttributes(typeof(DataContractAttribute), true).ToArray(); if (attributes != null) { for (int ii = 0; ii < attributes.Length; ii++) { DataContractAttribute contract = attributes[ii] as DataContractAttribute; if (contract != null) { if (String.IsNullOrEmpty(contract.Name)) { return(new XmlQualifiedName(systemType.Name, contract.Namespace)); } return(new XmlQualifiedName(contract.Name, contract.Namespace)); } } } attributes = systemType.GetTypeInfo().GetCustomAttributes(typeof(CollectionDataContractAttribute), true).ToArray(); if (attributes != null) { for (int ii = 0; ii < attributes.Length; ii++) { CollectionDataContractAttribute contract = attributes[ii] as CollectionDataContractAttribute; if (contract != null) { if (String.IsNullOrEmpty(contract.Name)) { return(new XmlQualifiedName(systemType.Name, contract.Namespace)); } return(new XmlQualifiedName(contract.Name, contract.Namespace)); } } } if (systemType == typeof(System.Byte[])) { return(new XmlQualifiedName("ByteString")); } return(new XmlQualifiedName(systemType.FullName)); }
private void put_datacontract(Type t, object o, DataContractAttribute dca) { var fields = t.GetFields(); var map = new Dictionary <string, object>(); foreach (var field in fields) { DataMemberAttribute dma = (DataMemberAttribute)field.GetCustomAttribute(typeof(DataMemberAttribute)); if (dma != null) { string name = dma.Name; try { map[name] = field.GetValue(o); } catch (Exception x) { throw new PickleException("cannot pickle [DataContract] object:", x); } } } var properties = t.GetProperties(); foreach (var propinfo in properties) { if (propinfo.CanRead && propinfo.GetCustomAttribute(typeof(DataMemberAttribute)) != null) { string name = propinfo.Name; try { map[name] = propinfo.GetValue(o, null); } catch (Exception x) { throw new PickleException("cannot pickle [DataContract] object:", x); } } } if (string.IsNullOrEmpty(dca.Name)) { // if we're dealing with an anonymous type, don't output the type name. if (!o.GetType().Name.StartsWith("<>")) { map["__class__"] = o.GetType().FullName; } } else { map["__class__"] = dca.Name; } save(map); }
public void Ctor_Default() { var attribute = new DataContractAttribute(); Assert.False(attribute.IsReference); Assert.False(attribute.IsReferenceSetExplicitly); Assert.Null(attribute.Name); Assert.False(attribute.IsNameSetExplicitly); Assert.Null(attribute.Namespace); Assert.False(attribute.IsNamespaceSetExplicitly); }
internal DataContractImplementor(EntityType ospaceEntityType) { _baseClrType = ospaceEntityType.ClrType; var attributes = (DataContractAttribute[])_baseClrType.GetCustomAttributes(typeof(DataContractAttribute), false); if (attributes.Length > 0) { _dataContract = attributes[0]; } }
public CustomAttributes( JsonIgnoreAttribute jsonIgnoreAttribute, JsonPropertyAttribute jsonPropertyAttribute, DataContractAttribute dataContractAttribute, DataMemberAttribute dataMemberAttribute) { JsonIgnoreAttribute = jsonIgnoreAttribute; JsonPropertyAttribute = jsonPropertyAttribute; DataContractAttribute = dataContractAttribute; DataMemberAttribute = dataMemberAttribute; }
static TypeMap CreateTypeMap(Type type, DataContractAttribute dca) { if (dca != null && dca.Name != null && IsInvalidNCName (dca.Name)) throw new InvalidDataContractException (String.Format ("DataContractAttribute for type '{0}' has an invalid name", type)); List<TypeMapMember> members = new List<TypeMapMember> (); foreach (FieldInfo fi in type.GetFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { if (dca != null) { object [] atts = fi.GetCustomAttributes (typeof (DataMemberAttribute), true); if (atts.Length == 0) continue; DataMemberAttribute dma = (DataMemberAttribute) atts [0]; members.Add (new TypeMapField (fi, dma)); } else { if (fi.GetCustomAttributes (typeof (NonSerializedAttribute), false).Length > 0) continue; members.Add (new TypeMapField (fi, null)); } } if (dca != null) { foreach (PropertyInfo pi in type.GetProperties (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { object [] atts = pi.GetCustomAttributes (typeof (DataMemberAttribute), true); if (atts.Length == 0) continue; if (pi.GetIndexParameters ().Length > 0) continue; if (IsCollection (pi.PropertyType)) { if (!pi.CanRead) throw new InvalidDataContractException (String.Format ("Property {0} must have a getter", pi)); } else if (!pi.CanRead || !pi.CanWrite) throw new InvalidDataContractException (String.Format ("Non-collection property {0} must have both getter and setter", pi)); DataMemberAttribute dma = (DataMemberAttribute) atts [0]; members.Add (new TypeMapProperty (pi, dma)); } } members.Sort (delegate (TypeMapMember m1, TypeMapMember m2) { return m1.Order - m2.Order; }); return new TypeMap (type, dca == null ? null : dca.Name, members.ToArray ()); }