/// <summary> /// Creates an XML element out of <paramref name="eventInfo"/>. /// </summary> /// <param name="eventInfo">The property info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="eventInfo"/> is <see langword="null"/>.</returns> static XElement VisitEventInfo(EventInfo eventInfo) => eventInfo != null ? new XElement( XNames.Elements.Property, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(eventInfo.DeclaringType)), new XAttribute(XNames.Attributes.Name, eventInfo.Name)) : null;
/// <summary> /// De-serializes an object constant. /// </summary> /// <param name="element">The element from which to de-serialize the constant.</param> /// <param name="type">The type.</param> /// <returns>The de-serialized object constant.</returns> /// <exception cref="System.Runtime.Serialization.SerializationException">Expected type attribute.</exception> static object DeserializeCustom( XElement element, Type type) { if (element == null) { throw new ArgumentNullException(nameof(element)); } if (element.Elements().FirstOrDefault() == null) { return(null); } string typeString; var typeAttribute = element.Attribute(XNames.Attributes.Type); if (typeAttribute == null) { throw new SerializationException("Expected type attribute."); } typeString = typeAttribute.Value; if (typeString.StartsWith(anonymousTypePrefix, StringComparison.Ordinal)) { return(DeserializeAnonymous(element, type)); } var serializer = new DataContractSerializer(TypeNameResolver.GetType(typeString)); using (var reader = element.Elements().First().CreateReader()) return(serializer.ReadObject(reader)); }
/// <summary> /// Serializes an object using <see cref="DataContractSerializer"/>. /// </summary> /// <param name="obj">The object to be serialized.</param> /// <param name="type">The type of the object.</param> /// <param name="parent">The parent element where to serialize the object to.</param> static void SerializeCustom( object obj, Type type, XElement parent) { if (parent == null) { throw new ArgumentNullException(nameof(parent)); } var custom = new XElement( XNames.Elements.Custom, new XAttribute( XNames.Attributes.Type, TypeNameResolver.GetTypeName(type))); parent.Add(custom); if (obj == null) { return; } // create a data contract serializer (works with [Serializable] types too) var dcSerializer = new DataContractSerializer( obj.GetType(), Type.EmptyTypes, int.MaxValue, false, false, null); using (var writer = custom.CreateWriter()) dcSerializer.WriteObject(writer, obj); }
/// <summary> /// Serializes a nullable value. /// </summary> /// <param name="nullable">The nullable value to be serialized.</param> /// <param name="type">The type of the value.</param> /// <param name="parent">The parent element where to add the serialized.</param> static void SerializeNullable( object nullable, Type type, XElement parent) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (parent == null) { throw new ArgumentNullException(nameof(parent)); } if (type.GetGenericArguments().Length <= 0) { throw new ArgumentException("The type must be generic.", nameof(type)); } var typeArgument = type.GetGenericArguments()[0]; var nullableElement = new XElement( XNames.Elements.Nullable, new XAttribute(XNames.Attributes.IsNull, XmlConvert.ToString(nullable == null)), nullable == null ? new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(typeArgument)) : null); parent.Add(nullableElement); if (nullable == null) { return; } // get the serializer for the type argument from the table or if (_constantSerializers.TryGetValue(typeArgument, out var serializer)) { serializer(nullable, typeArgument, nullableElement); } else { var valueElement = new XElement( XNames.Elements.Custom, new XAttribute( XNames.Attributes.Type, TypeNameResolver.GetTypeName(type))); nullableElement.Add(valueElement); // create a data contract serializer (should work with [Serializable] types too) var dcSerializer = new DataContractSerializer( type, Type.EmptyTypes, int.MaxValue, false, false, null); using (var writer = valueElement.CreateWriter()) dcSerializer.WriteObject(writer, nullable); } }
/// <summary> /// Creates an XML element out of <paramref name="propertyInfo"/>. /// </summary> /// <param name="propertyInfo">The property info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="propertyInfo"/> is <see langword="null"/>.</returns> static XElement VisitPropertyInfo(PropertyInfo propertyInfo) => propertyInfo != null ? new XElement( XNames.Elements.Property, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(propertyInfo.DeclaringType)), new XAttribute(XNames.Attributes.Name, propertyInfo.Name), VisitParameters(propertyInfo.GetIndexParameters())) : null;
internal static Type GetDataType(XElement element) { if (element == null) { throw new ArgumentNullException(nameof(element)); } var type = TypeNameResolver.GetType(element.Name.LocalName); if (type == null && element.Name == XNames.Elements.Anonymous) { type = DataSerialization.GetType(element); if (type == null) { throw new SerializationException("Expected constant element's type."); } } if (type == typeof(Nullable <>)) { Type valueType = GetType(element); if (valueType != null) { return(typeof(Nullable <>).MakeGenericType(valueType)); } var valueElement = element.Elements().FirstOrDefault(); if (valueElement == null) { return(null); } valueType = GetDataType(valueElement); if (valueType == null) { return(null); } return(typeof(Nullable <>).MakeGenericType(valueType)); } if (type == typeof(object)) { return(GetCustomConstantType(element)); } if (type == typeof(Enum)) { return(GetEnumConstantType(element)); } return(type); }
/// <summary> /// Gets the type corresponding to a type name written in an XML attribute. /// </summary> /// <param name="typeAttribute">The type attribute.</param> /// <returns>The specified type.</returns> internal static Type GetType(XAttribute typeAttribute) { if (typeAttribute == null) { return(null); } return(TypeNameResolver.GetType(typeAttribute.Value)); }
/// <summary> /// Creates an XML element out of <paramref name="eventInfo"/>. /// </summary> /// <param name="eventInfo">The property info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="eventInfo"/> is <see langword="null"/>.</returns> static XElement VisitEventInfo(EventInfo eventInfo) { if (eventInfo == null) { return(null); } return(new XElement( XNames.Elements.Property, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(eventInfo.DeclaringType)), new XAttribute(XNames.Attributes.Name, eventInfo.Name))); }
/// <summary> /// Creates an XML element out of <paramref name="propertyInfo"/>. /// </summary> /// <param name="propertyInfo">The property info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="propertyInfo"/> is <see langword="null"/>.</returns> static XElement VisitPropertyInfo(PropertyInfo propertyInfo) { if (propertyInfo == null) { return(null); } return(new XElement( XNames.Elements.Property, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(propertyInfo.DeclaringType)), new XAttribute(XNames.Attributes.Name, propertyInfo.Name), VisitParameters(propertyInfo.GetIndexParameters()))); }
/// <summary> /// If the unary expression has type conversion component, this method creates an "asType" attribute. /// </summary> /// <param name="node">The unary node.</param> /// <returns>An "asType" attribute or <see langword="null"/> if <paramref name="node"/> does not contain type conversion component.</returns> static XAttribute VisitAsType(UnaryExpression node) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (node.NodeType != ExpressionType.TypeAs && node.NodeType != ExpressionType.Convert) { return(null); } return(new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(node.Type))); }
static Type GetEnumConstantType(XElement element) { if (element == null) { throw new ArgumentNullException(nameof(element)); } var typeAttribute = element.Attribute(XNames.Attributes.Type); if (typeAttribute == null) { throw new SerializationException("Expected type attribute."); } return(TypeNameResolver.GetType(typeAttribute.Value)); }
/// <summary> /// Creates an XML element out of <paramref name="methodInfo"/>. /// </summary> /// <param name="methodInfo">The method info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="methodInfo"/> is <see langword="null"/>.</returns> static XElement VisitMethodInfo(MethodInfo methodInfo) { if (methodInfo == null) { return(null); } XAttribute visibility = null; if (!methodInfo.IsPublic) { if (methodInfo.IsPrivate) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Private); } else if (methodInfo.IsAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Assembly); } else if (methodInfo.IsFamily) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Family); } else if (methodInfo.IsFamilyAndAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.FamilyAndAssembly); } else if (methodInfo.IsFamilyOrAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.FamilyOrAssembly); } } return(new XElement( XNames.Elements.Method, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(methodInfo.DeclaringType)), visibility, methodInfo.IsStatic ? new XAttribute(XNames.Attributes.Static, true) : null, new XAttribute(XNames.Attributes.Name, methodInfo.Name), new XElement( XNames.Elements.Parameters, VisitParameters(methodInfo.GetParameters())))); }
/// <summary> /// Creates an XML element out of <paramref name="constructorInfo"/>. /// </summary> /// <param name="constructorInfo">The method info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="constructorInfo"/> is <see langword="null"/>.</returns> static XElement VisitConstructorInfo(ConstructorInfo constructorInfo) { if (constructorInfo == null) { return(null); } XAttribute visibility = null; if (!constructorInfo.IsPublic) { if (constructorInfo.IsPrivate) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Private); } else if (constructorInfo.IsAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Assembly); } else if (constructorInfo.IsFamily) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Family); } else if (constructorInfo.IsFamilyAndAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.FamilyAndAssembly); } else if (constructorInfo.IsFamilyOrAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.FamilyOrAssembly); } } return(new XElement( XNames.Elements.Constructor, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(constructorInfo.DeclaringType)), visibility, constructorInfo.IsStatic ? new XAttribute(XNames.Attributes.Static, true) : null, new XElement( XNames.Elements.Parameters, VisitParameters(constructorInfo.GetParameters())))); }
/// <summary> /// Creates a sequence of XML elements for each of the <paramref name="parameters"/>. /// </summary> /// <param name="parameters">The parameters.</param> /// <returns>A sequence of elements.</returns> static IEnumerable <XElement> VisitParameters(IEnumerable <ParameterInfo> parameters) { if (parameters == null) { yield break; } foreach (var param in parameters) { yield return(new XElement( XNames.Elements.Parameter, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(param.ParameterType)), new XAttribute(XNames.Attributes.Name, param.Name), param.IsOut || param.ParameterType.IsByRef ? new XAttribute(XNames.Attributes.IsByRef, true) : null)); } }
/// <summary> /// Creates an XML element out of <paramref name="fieldInfo"/>. /// </summary> /// <param name="fieldInfo">The property info.</param> /// <returns>An XML element or <see langword="null"/> if <paramref name="fieldInfo"/> is <see langword="null"/>.</returns> static XElement VisitFieldInfo(FieldInfo fieldInfo) { if (fieldInfo == null) { return(null); } XAttribute visibility = null; if (!fieldInfo.IsPublic) { if (fieldInfo.IsAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Assembly); } else if (fieldInfo.IsFamily) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Family); } else if (fieldInfo.IsPrivate) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.Private); } else if (fieldInfo.IsFamilyAndAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.FamilyAndAssembly); } else if (fieldInfo.IsFamilyOrAssembly) { visibility = new XAttribute(XNames.Attributes.Visibility, XNames.Attributes.FamilyOrAssembly); } } return(new XElement( XNames.Elements.Field, new XAttribute(XNames.Attributes.Type, TypeNameResolver.GetTypeName(fieldInfo.DeclaringType)), visibility, fieldInfo.IsStatic ? new XAttribute(XNames.Attributes.Static, true) : null, new XAttribute(XNames.Attributes.Name, fieldInfo.Name))); }
/// <summary> /// Adds the type attribute. /// </summary> /// <param name="element">The element.</param> /// <param name="expression">The expression.</param> /// <param name="defaultType">The default type.</param> /// <returns>XElement.</returns> /// <exception cref="System.ArgumentNullException"> /// element /// or /// expression /// </exception> public static XElement AddTypeAttribute( this XElement element, Expression expression, Type defaultType = null) { if (element == null) { throw new ArgumentNullException(nameof(element)); } if (expression == null) { throw new ArgumentNullException(nameof(expression)); } if (expression.Type != defaultType) { element.Add( new XAttribute( XNames.Attributes.Type, TypeNameResolver.GetTypeName(expression.Type))); } return(element); }