Exemple #1
0
                public SetterFieldDescription GetSetterFieldDescription()
                {
                    TypeSyntax fieldType;

                    if (ContainingType != null && ContainingType.IsValueType)
                    {
                        fieldType = _libraryTypes.ValueTypeSetter_2.ToTypeSyntax(GetTypeSyntax(ContainingType), TypeSyntax);
                    }
                    else
                    {
                        fieldType = _libraryTypes.Action_2.ToTypeSyntax(GetTypeSyntax(ContainingType), TypeSyntax);
                    }

                    // Generate syntax to initialize the field in the constructor
                    var fieldAccessorUtility   = AliasQualifiedName("global", IdentifierName("Orleans.Serialization")).Member("Utilities").Member("FieldAccessor");
                    var fieldInfo              = SerializableMember.GetGetFieldInfoExpression(ContainingType, FieldName);
                    var isContainedByValueType = ContainingType != null && ContainingType.IsValueType;
                    var accessorMethod         = isContainedByValueType ? "GetValueSetter" : "GetReferenceSetter";
                    var accessorInvoke         = CastExpression(
                        fieldType,
                        InvocationExpression(fieldAccessorUtility.Member(accessorMethod))
                        .AddArgumentListArguments(Argument(fieldInfo)));

                    var initializationSyntax = ExpressionStatement(
                        AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, IdentifierName(SetterFieldName), accessorInvoke));

                    return(new SetterFieldDescription(fieldType, SetterFieldName, initializationSyntax));
                }
Exemple #2
0
            public IEnumerable <SerializableMember> EnumerateMembersToSerialize(TypeInfo forType)
            {
                var ix  = SerializableMember.ForProperty(typeof(_BridgeDelegate).GetProperty(nameof(_BridgeDelegate.Ix)));
                var foo = SerializableMember.ForProperty(typeof(_BridgeDelegate).GetProperty(nameof(_BridgeDelegate.Foo)));

                return(new[] { ix, foo });
            }
        public void SetUp()
        {
            member = new SerializableMember
            {
                ClassCoupling       = 1,
                CylomaticComplexity = 2,
                LinesOfCode         = 3,
                MissingDefaultCase  = 4,
                Name               = "member",
                NoFallthrough      = 5,
                NumberOfParameters = 6
            };

            toSerialize = new SerializableClass
            {
                ClassCoupling        = 1,
                CyclomaticComplexity = 2,
                DepthOfInheritance   = 3,
                LinesOfCode          = 4,
                NumberOfMethods      = 5,
                Toxicity             = 6,
                Name    = "MyClass",
                CodeBag = new SerializeableCodeBag {
                    Name = "MyNamespace"
                },
                Members = new[] { member }
            };
        }
 /// <summary>
 /// 序列化指定成员;
 /// </summary>
 /// <exception cref="ObjectDisposedException"></exception>
 /// <exception cref="InvalidOperationException"></exception>
 private void Serialize(Content writableContent, ref T instance, SerializableMember member)
 {
     using (var stream = writableContent.GetOutputStream(member.MemberInfo.RelativePath))
     {
         var value = member.MemberInfo.GetValue(instance);
         member.Serializer.Serialize(stream, value);
     }
 }
Exemple #5
0
        static XmlObjectSerializer()
        {
            var members = ResolveFields(typeof(T))
                          .Select(field =>
                                  Handle(
                                      field,
                                      field.FieldType,
                                      field.IsPublic
                                      )
                                  ).Concat(ResolveProperties(typeof(T))
                                           // Ignore index properties
                                           .Where(property => property.GetIndexParameters().IsNullOrEmpty())
                                           .Select(property =>
                                                   Handle(
                                                       property,
                                                       property.PropertyType,
                                                       property.CanRead && property.CanWrite && (property.IsPublic() || property.HasPublicSetter())
                                                       )
                                                   )
                                           )
                          .Where(Func.NotNull)
                          .ToLookup(member => member.NodeType);

            AttributeMembers =
                members[XmlNodeType.Attribute].Where(member => !member.MatchAny).ToDictionary(member => member.MemberName);
            AnyAttributeMember =
                members[XmlNodeType.Attribute].Where(member => member.MatchAny).FirstOrDefault();
            ElementMembers =
                members[XmlNodeType.Element]
                .GroupBy(member => member.Order)
                .OrderBy(grp => grp.Key)
                .Select(grp => grp.ToList())
                .ToList();
            TextMember = members[XmlNodeType.Text].SingleOrDefault();

            var knownTypes = new Queue <XmlIncludeAttribute>(typeof(T).GetCustomAttributes <XmlIncludeAttribute>(inherit: false));

            if (knownTypes.Any())
            {
                KnownTypeSerializers       = new Dictionary <Type, Tuple <String, IXmlSerializer> >();
                KnownTypeSerializersByName = new Dictionary <String, IXmlSerializer>();
                while (knownTypes.Any())
                {
                    var knownType  = knownTypes.Dequeue();
                    var serializer = XmlSerializerBase.ForType(knownType.Type);
                    // TODO figure out the type name mapping for primitives.
                    var typeName = knownType.Type.Name;
                    KnownTypeSerializers.Add(knownType.Type, Tuple.Create(typeName, serializer));
                    KnownTypeSerializersByName.Add(typeName, serializer);

                    foreach (var subKnownType in knownType.Type.GetCustomAttributes <XmlIncludeAttribute>(inherit: false))
                    {
                        knownTypes.Enqueue(subKnownType);
                    }
                }
            }
        }
Exemple #6
0
        ComponentBlueprint ParseComponentBlueprint(string name, JsonData componentData)
        {
            var componentBlueprint = new ComponentBlueprint(name);
            var members            = new SerializableMember[componentData.Count];
            int i = 0;

            foreach (KeyValuePair <string, JsonData> n in componentData)
            {
                members[i] = new JsonSerializableMember(n.Key, n.Value);
                i++;
            }

            componentBlueprint.Members = members;
            return(componentBlueprint);
        }
        private void Add(MemberInfo info, object value)
        {
            if (Utility.IsNull(value))
            {
                throw new NullReferenceException();
            }

            Debugging.Verbose("Adding member " + Utility.GetObjectMemberName(info) + " with value " + value + " IsNull: " + (value == null));

            SerializableMember member = new SerializableMember(info, value);

            if (!member.IsJSONEmpty())
            {
                _members.Add(member);
            }
        }
 /// <summary>
 /// 反序列化成员;
 /// </summary>
 /// <exception cref="FileNotFoundException"></exception>
 /// <exception cref="ObjectDisposedException"></exception>
 private void Deserialize(Content content, T instance, SerializableMember member)
 {
     try
     {
         using (var stream = content.GetInputStream(member.MemberInfo.RelativePath))
         {
             var value = member.Serializer.Deserialize(stream);
             member.MemberInfo.SetValue(instance, value);
         }
     }
     catch (FileNotFoundException ex)
     {
         if (member.MemberInfo.IsNecessaryAsset)
         {
             throw ex;
         }
     }
 }
        public void Simple_Serialize()
        {
            var surrogate = new SurrogateTypeDescriber(false);

            surrogate.AddSurrogateType(typeof(_Simple_Real).GetTypeInfo(), typeof(_Simple_Surrogate).GetTypeInfo());

            // maps!
            {
                var res = surrogate.EnumerateMembersToSerialize(typeof(_Simple_Real).GetTypeInfo());

                Assert.Collection(
                    res,
                    a =>
                {
                    Assert.True(a.EmitDefaultValue);
                    Assert.Null(a.Field);
                    Assert.Equal(SerializableMember.GetDefaultFormatter(typeof(string).GetTypeInfo()), a.Formatter);
                    Assert.Equal("bar", a.Name);
                    Assert.Equal(typeof(_Simple_Real).GetProperty(nameof(_Simple_Real.Foo)).GetMethod, a.Getter);
                    Assert.Null(a.ShouldSerialize);
                }
                    );
            }

            // doesn't map
            {
                var res = surrogate.EnumerateMembersToSerialize(typeof(_Simple_Surrogate).GetTypeInfo());

                Assert.Collection(
                    res,
                    a =>
                {
                    Assert.True(a.EmitDefaultValue);
                    Assert.Null(a.Field);
                    Assert.Equal(SerializableMember.GetDefaultFormatter(typeof(string).GetTypeInfo()), a.Formatter);
                    Assert.Equal("bar", a.Name);
                    Assert.Equal(typeof(_Simple_Surrogate).GetProperty(nameof(_Simple_Surrogate.Foo)).GetMethod, a.Getter);
                    Assert.Null(a.ShouldSerialize);
                }
                    );
            }
        }
Exemple #10
0
        public void SetUp()
        {
            versionInfo = new SerializableClassVersionInfo
            {
                CommitMessage = "msg",
                FileName      = "filename",
                TimeStamp     = DateTime.Now
            };

            member = new SerializableMember
            {
                ClassCoupling       = 1,
                CylomaticComplexity = 2,
                LinesOfCode         = 3,
                MissingDefaultCase  = 4,
                Name               = "member",
                NoFallthrough      = 5,
                NumberOfParameters = 6
            };

            toSerialize = new SerializableClass
            {
                ClassCoupling        = 1,
                CyclomaticComplexity = 2,
                DepthOfInheritance   = 3,
                LinesOfCode          = 4,
                NumberOfMethods      = 5,
                Toxicity             = 6,
                Name    = "MyClass",
                CodeBag = new SerializeableCodeBag {
                    Name = "MyNamespace"
                },
                Meta    = new[] { versionInfo },
                Members = new[] { member }
            };
        }
Exemple #11
0
 public GetterFieldDescription(TypeSyntax fieldType, string fieldName, ITypeSymbol targetFieldType, SerializableMember member) : base(fieldType, fieldName)
 {
     this.TargetFieldType = targetFieldType;
     this.Member          = member;
 }
Exemple #12
0
        private static SerializableMember Handle <TMember>(TMember member, Type memberType, Boolean includeByDefault) where TMember : MemberInfo
        {
            var xmlAttribute =
                Attribute.GetCustomAttributes(member, inherit: false)
                .Where(attr => XmlObjectSerializer <T> .SupportedAttributeTypes.Contains(attr.GetType()) ||
                       XmlObjectSerializer <T> .UnsupportedAttributeTypes.Contains(attr.GetType()))
                .SingleOrDefault();

            SerializableMember result;

            if (xmlAttribute == null)
            {
                if (includeByDefault)
                {
                    result = new SerializableMember(XmlNodeType.Element, new XmlNameDeclaration(member.Name), -1, member);
                }
                else
                {
                    // Skip
                    result = null;
                }
            }
            else if (xmlAttribute is XmlElementAttribute)
            {
                var elem = (XmlElementAttribute)xmlAttribute;
                if (XmlCollectionSerializer.IsCollection(memberType) && !typeof(IXmlSerializable).IsAssignableFrom(memberType))
                {
                    result = new SerializableMember(
                        XmlNodeType.Element,
                        new XmlNameDeclaration(
                            elem.ElementName.EmptyAsNull() ?? member.Name,
                            elem.Namespace.EmptyAsNull()
                            ),
                        elem.Order,
                        member,
                        // If an XmlElement is specified on a collection type the members of the collection are serialized without a containing element.
                        wrapCollection: false
                        );
                }
                else
                {
                    result = new SerializableMember(
                        XmlNodeType.Element,
                        new XmlNameDeclaration(
                            elem.ElementName.EmptyAsNull() ?? member.Name,
                            elem.Namespace.EmptyAsNull()
                            ),
                        elem.Order,
                        member
                        );
                }
            }
            else if (xmlAttribute is XmlAnyElementAttribute)
            {
                var elem = (XmlAnyElementAttribute)xmlAttribute;
                result = new SerializableMember(
                    XmlNodeType.Element,
                    elem.Order,
                    member
                    );
            }
            else if (xmlAttribute is XmlArrayAttribute)
            {
                if (!XmlCollectionSerializer.IsCollection(memberType))
                {
                    throw new InvalidOperationException(
                              String.Format(
                                  "The XmlArrayAttribute was used on a member of type '{0}' which does not implement ICollection<>.",
                                  memberType.FullName
                                  )
                              );
                }
                var array      = (XmlArrayAttribute)xmlAttribute;
                var arrayItems =
                    member.GetCustomAttributes <XmlArrayItemAttribute>().EmptyAsNull();
                result = new SerializableMember(
                    XmlNodeType.Element,
                    new XmlNameDeclaration(
                        array.ElementName.EmptyAsNull() ?? member.Name,
                        array.Namespace.EmptyAsNull()
                        ),
                    array.Order,
                    member,
                    arrayItems: arrayItems
                    );
            }
            else if (xmlAttribute is XmlAttributeAttribute)
            {
                var attr = (XmlAttributeAttribute)xmlAttribute;
                // Attribute children do not inherit the namespace of their parent.
                result = new SerializableMember(
                    XmlNodeType.Attribute,
                    new XmlNameDeclaration(
                        attr.AttributeName.EmptyAsNull() ?? member.Name,
                        attr.Namespace.EmptyAsNull()
                        ),
                    -1,
                    member
                    );
            }
            else if (xmlAttribute is XmlAnyAttributeAttribute)
            {
                result = new SerializableMember(
                    XmlNodeType.Attribute,
                    -1,
                    member
                    );
            }
            else if (xmlAttribute is XmlTextAttribute)
            {
                // var txt = (XmlTextAttribute)xmlAttribute;
                // TODO: support DataType/Type/TypeId parameters
                result = new SerializableMember(XmlNodeType.Text, null, -1, member);
            }
            else if (xmlAttribute is XmlIgnoreAttribute)
            {
                // Skip
                result = null;
            }
            else
            {
                throw new NotSupportedException(
                          String.Format(
                              "The XML serialization attribute '{0}' is not yet supported",
                              xmlAttribute.GetType().Name
                              )
                          );
            }

            return(result);
        }
Exemple #13
0
        public override T Deserialize(XmlReader reader, T instance, Action <XmlReader> onUnknownElement = null)
        {
            // See if we should be using a subtype serializer
            if (KnownTypeSerializersByName != null)
            {
                var xsiType = reader.GetAttribute("type", "http://www.w3.org/2001/XMLSchema-instance");
                if (xsiType != null)
                {
                    IXmlSerializer subTypeSerializer;
                    if (KnownTypeSerializersByName.TryGetValue(xsiType, out subTypeSerializer))
                    {
                        return((T)subTypeSerializer.Deserialize(reader, subTypeSerializer.CreateInstance()));
                    }
                }
            }

            // We're the actual serializer that should be used for this element.
            // Here comes the heavy lifting.
            var startElement = reader.Name;

            while (reader.MoveToNextAttribute())
            {
                SerializableMember member;
                if (AttributeMembers.TryGetValue(reader.GetQualifiedName(), out member) ||
                    AttributeMembers.TryGetValue(new XmlQualifiedName(reader.LocalName), out member))
                {
                    instance = member.DeserializeMember(reader, instance);
                }
                else if (AnyAttributeMember != null)
                {
                    instance = AnyAttributeMember.DeserializeMember(reader, instance);
                }
            }
            reader.MoveToElement();
            if (!reader.IsEmptyElement)
            {
                // Advance to the first child
                reader.Read();
                var pos = 0;

                while (reader.NodeType != XmlNodeType.EndElement)
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        SerializableMember member = null;
                        var nextPos = pos;
                        while (member == null && nextPos < ElementMembers.Count)
                        {
                            member =
                                ElementMembers[nextPos].SingleOrDefault(
                                    mem => !mem.MatchAny && mem.MemberName.Equals(reader.GetQualifiedName())
                                    );

                            if (member == null)
                            {
                                member = ElementMembers[nextPos].SingleOrDefault(
                                    mem => mem.MatchAny
                                    );
                            }

                            if (member == null)
                            {
                                nextPos++;
                            }
                        }

                        if (member != null)
                        {
                            pos = nextPos;
                            var xsiNil = reader.GetAttribute("nil", XsiNamespace);
                            if (xsiNil != null && String.Equals(xsiNil, "true", StringComparison.OrdinalIgnoreCase))
                            {
                                if (member.Setter != null)
                                {
                                    instance = member.Setter(instance, member.MemberType.GetDefaultValue());
                                }
                            }
                            else
                            {
                                instance = member.DeserializeMember(reader, instance);
                            }
                        }
                        else
                        {
                            // Ignore unexpected elements
                            if (onUnknownElement != null)
                            {
                                onUnknownElement(reader);
                            }
                            else
                            {
                                reader.Skip();
                            }
                        }
                        break;

                    case XmlNodeType.Text:
                    case XmlNodeType.CDATA:
                        if (TextMember != null)
                        {
                            instance = TextMember.DeserializeMember(reader, instance);
                        }
                        else
                        {
                            reader.Skip();
                        }
                        break;

                    case XmlNodeType.None:
                        throw new XmlException("Unexpected end of document.");

                    default:
                        reader.Skip();
                        break;
                    }
                }
                if (reader.NodeType != XmlNodeType.EndElement || reader.Name != startElement)
                {
                    throw new XmlException("Unexpected end element found.");
                }
                else
                {
                    reader.ReadEndElement();
                }
            }
            else
            {
                // Done
                reader.Skip();
            }

            return(instance);
        }