public T CopyBySerialization <T>(T obj, SerializationBackend serializationBackend) { var result = default(T); if (serializationBackend == SerializationBackend.Binary) { var memoryStream = new MemoryStream(); var writer = new BinarySerializationWriter(memoryStream); writer.Write(obj); writer.Flush(); memoryStream.Seek(0, SeekOrigin.Begin); var reader = new BinarySerializationReader(memoryStream); reader.Serialize(ref result, ArchiveMode.Deserialize); } //else if (serializationBackend == SerializationBackend.Xml) //{ // var xmlDoc = new XmlDocument(); // var xmlElement = xmlDoc.CreateElement("object"); // var writer = new XmlSerializationWriter(xmlElement); // writer.Write(obj); // writer.Flush(); // var reader = new XmlSerializationReader(xmlElement); // reader.Serialize(ref result, ArchiveMode.Deserialize); //} return(result); }
public void TestSerializationStructType(SerializationBackend serializationBackend) { var source = new SerializeTypeTest { A = new S { A = 32 } }; var copy = CopyBySerialization(source, serializationBackend); Assert.That(copy.A, Is.InstanceOf(typeof(S))); Assert.That(((S)source.A).A, Is.EqualTo(((S)copy.A).A)); }
public void TestSerializationComplexTypeClass(SerializationBackend serializationBackend) { var source = new SerializeClassTest { A = 32, B = 123 }; var copy = CopyBySerialization(source, serializationBackend); Assert.That(copy.A, Is.EqualTo(source.A)); Assert.That(copy.B, Is.EqualTo(source.B)); }
public void TestSerializationList(SerializationBackend serializationBackend) { var source = new List<int> { 32, 12, 15 }; var copy = CopyBySerialization(source, serializationBackend); Assert.That(copy.Count, Is.EqualTo(source.Count)); for (int i = 0; i < source.Count; ++i) Assert.That(copy[i], Is.EqualTo(source[i])); }
public void TestSerializationType(SerializationBackend serializationBackend) { var source = new SerializeTypeTest { A = new B() }; var copy = CopyBySerialization(source, serializationBackend); Assert.True(copy.A is B); }
protected override void Initialize() { this.backend = this.Property.ValueEntry.SerializationBackend; if (!ChildInfos.ContainsKey(backend)) { ChildInfos[backend] = InspectorPropertyInfoUtility.GetDefaultPropertiesForType(this.Property, typeof(EditableKeyValuePair <TKey, TValue>), false); } }
public void TestSerializationType(SerializationBackend serializationBackend) { var source = new SerializeTypeTest { A = new B() }; var copy = CopyBySerialization(source, serializationBackend); Assert.That(copy.A, Is.InstanceOf(typeof(B))); }
public void TestSerializationStructType(SerializationBackend serializationBackend) { var source = new SerializeTypeTest { A = new S { A = 32 } }; var copy = CopyBySerialization(source, serializationBackend); Assert.True(copy.A is S); Assert.Equal(((S)source.A).A, ((S)copy.A).A); }
/// <summary> /// Initializes a new instance of the <see cref="InspectorValuePropertyInfo{TOwner, TValue}"/> class. /// </summary> /// <param name="fieldInfo">The field to represent.</param> /// <param name="serializationBackend">The serialization backend.</param> /// <param name="allowEditable">Whether the property can be editable.</param> public InspectorValuePropertyInfo(FieldInfo fieldInfo, SerializationBackend serializationBackend, bool allowEditable) : base(fieldInfo, fieldInfo.FieldType.IsValueType ? PropertyType.ValueType : PropertyType.ReferenceType, serializationBackend, allowEditable) { MemberAliasFieldInfo aliasFieldInfo = fieldInfo as MemberAliasFieldInfo; if (aliasFieldInfo != null) { fieldInfo = aliasFieldInfo.AliasedField; } this.getter = EmitUtilities.CreateInstanceFieldGetter <TOwner, TValue>(fieldInfo); this.setter = EmitUtilities.CreateInstanceFieldSetter <TOwner, TValue>(fieldInfo); }
public void TestSerializationBaseTypes(SerializationBackend serializationBackend) { var source = new SerializeBaseTypeTest { Nullable1 = 546, Bool = true, B = 12, SB = 14, C = 'a', F = 12.0f, D = 13.0, Enum = SerializeEnum.Enum2, Enum2 = SerializeEnum.Enum3, I16 = -8, I32 = -12, I64 = -16, U16 = 8, U32 = 12, U64 = 16, //Decimal = 12300, String = "Tat\"asd\\a", Data = new byte[] { 12, 31, 11 }, Guid = Guid.NewGuid(), }; var copy = CopyBySerialization(source, serializationBackend); Assert.Equal(source.Nullable1, copy.Nullable1); Assert.Equal(source.Nullable2, copy.Nullable2); Assert.Equal(source.Bool, copy.Bool); Assert.Equal(source.C, copy.C); Assert.Equal(source.B, copy.B); Assert.Equal(source.SB, copy.SB); Assert.Equal(source.F, copy.F); Assert.Equal(source.D, copy.D); Assert.Equal(source.U16, copy.U16); Assert.Equal(source.I16, copy.I16); Assert.Equal(source.U32, copy.U32); Assert.Equal(source.I32, copy.I32); Assert.Equal(source.U64, copy.U64); Assert.Equal(source.I64, copy.I64); Assert.Equal(source.Enum, copy.Enum); Assert.Equal(source.Enum2, copy.Enum2); Assert.Equal(source.EnumNull, copy.EnumNull); Assert.Equal(source.String, copy.String); Assert.Equal(source.StringNull, copy.StringNull); Assert.Equal(source.Data, copy.Data); Assert.Equal(source.DataNull, copy.DataNull); Assert.Equal(source.Guid, copy.Guid); }
/// <summary> /// Initializes a new instance of the <see cref="InspectorValuePropertyInfo{TOwner, TValue}"/> class. /// </summary> /// <param name="propertyInfo">The property to represent.</param> /// <param name="serializationBackend">The serialization backend.</param> /// <param name="allowEditable">Whether the property can be editable.</param> public InspectorValuePropertyInfo(PropertyInfo propertyInfo, SerializationBackend serializationBackend, bool allowEditable) : base(propertyInfo, propertyInfo.PropertyType.IsValueType ? PropertyType.ValueType : PropertyType.ReferenceType, serializationBackend, allowEditable) { MemberAliasPropertyInfo aliasPropertyInfo = propertyInfo as MemberAliasPropertyInfo; if (aliasPropertyInfo != null) { propertyInfo = aliasPropertyInfo.AliasedProperty; } this.getter = EmitUtilities.CreateInstancePropertyGetter <TOwner, TValue>(propertyInfo); if (propertyInfo.CanWrite) { this.setter = EmitUtilities.CreateInstancePropertySetter <TOwner, TValue>(propertyInfo); } }
public static InspectorPropertyInfo CreateValue(string name, int order, SerializationBackend serializationBackend, IValueGetterSetter getterSetter, IEnumerable <Attribute> attributes) { if (name == null) { throw new ArgumentNullException("name"); } if (getterSetter == null) { throw new ArgumentNullException("getterSetter"); } if (name.Contains('.')) { throw new ArgumentException("Property names may not contain '.'; was given the name '" + name + "'."); } var result = new InspectorPropertyInfo(); result.memberInfos = new MemberInfo[0]; result.typeOfOwner = getterSetter.OwnerType; result.typeOfValue = getterSetter.ValueType; if (attributes == null) { result.attributes = new List <Attribute>(); } else { result.attributes = attributes.Where(attr => attr != null).ToList(); } result.PropertyName = name; result.PropertyType = PropertyType.Value; result.SerializationBackend = serializationBackend; result.IsEditable = !getterSetter.IsReadonly; result.getterSetter = getterSetter; return(result); }
public void TestSerializationCollectionTypes(SerializationBackend serializationBackend) { var source = new SerializeCollectionTest { List = new List <int> { 3112, 123 }, ListInterface = new List <int> { 5112, 623 }, ListClass = new List <SerializeClassTest> { new SerializeClassTest { A = 1, B = 2 }, new SerializeClassTest { A = 3, B = 4 } }, ReadOnlyList = { 345, 567 }, Dictionary = new Dictionary <string, string> { { "a", "b" }, { "c", "d" } }, }; var copy = CopyBySerialization(source, serializationBackend); Assert.Equal(source.List, copy.List); Assert.Null(copy.ListNull); Assert.Equal(source.ListInterface, copy.ListInterface); Assert.Null(copy.ListInterfaceNull); Assert.Equal(source.ListClass.Count, copy.ListClass.Count); Assert.Equal(source.ReadOnlyList.Count, copy.ReadOnlyList.Count); for (int i = 0; i < source.ListClass.Count; ++i) { Assert.Equal(source.ListClass[i].A, copy.ListClass[i].A); Assert.Equal(source.ListClass[i].B, copy.ListClass[i].B); } Assert.Equal(source.Dictionary, copy.Dictionary); Assert.Null(copy.DictionaryNull); }
public static void AddMember(this IList <InspectorPropertyInfo> infos, string name, bool allowEditable = true, SerializationBackend backend = SerializationBackend.None, params Attribute[] attributes) { var members = ProcessingOwnerType.GetMember(name, MemberTypes.Field | MemberTypes.Method | MemberTypes.Property, Flags.AllMembers); if (members.Length == 0 || members.Length > 1) { throw new ArgumentException("Could not find precisely 1 member on type '" + ProcessingOwnerType.GetNiceName() + "' with name '" + name + "'; found " + members.Length + " members."); } AddMember(infos, members[0], true, SerializationBackend.None, attributes ?? new Attribute[0]); }
public static InspectorPropertyInfo CreateForMember(MemberInfo member, bool allowEditable, SerializationBackend serializationBackend, IEnumerable <Attribute> attributes) { return(CreateForMember(member, allowEditable, serializationBackend, attributes.ToList())); }
public static void AddProcessedMember(this IList <InspectorPropertyInfo> infos, InspectorProperty parentProperty, MemberInfo member, bool allowEditable = true, SerializationBackend backend = SerializationBackend.None, params Attribute[] attributes) { var list = new List <Attribute>(); if (attributes != null) { list.AddRange(attributes); } InspectorPropertyInfoUtility.ProcessAttributes(parentProperty, member, list); infos.Add(InspectorPropertyInfo.CreateForMember(member, allowEditable, backend, list)); }
public static void AddMember(this IList <InspectorPropertyInfo> infos, MemberInfo member, bool allowEditable = true, SerializationBackend backend = SerializationBackend.None, params Attribute[] attributes) { infos.Add(InspectorPropertyInfo.CreateForMember(member, allowEditable, backend, attributes ?? new Attribute[0])); }
public static InspectorPropertyInfo CreateValue(string name, int order, SerializationBackend serializationBackend, IValueGetterSetter getterSetter, params Attribute[] attributes) { return(CreateValue(name, order, serializationBackend, getterSetter, (IEnumerable <Attribute>)attributes)); }
public static void AddProcessedMember(this IList <InspectorPropertyInfo> infos, InspectorProperty parentProperty, string name, bool allowEditable = true, SerializationBackend backend = SerializationBackend.None, params Attribute[] attributes) { var type = ProcessingOwnerType; type = (parentProperty.ValueEntry != null) ? parentProperty.ValueEntry.TypeOfValue : ProcessingOwnerType; var members = type.GetMember(name, MemberTypes.Field | MemberTypes.Method | MemberTypes.Property, Flags.AllMembers); if (members.Length == 0 || members.Length > 1) { throw new ArgumentException("Could not find precisely 1 member on type '" + type.GetNiceName() + "' with name '" + name + "'; found " + members.Length + " members."); } var list = new List <Attribute>(); if (attributes != null) { list.AddRange(attributes); } InspectorPropertyInfoUtility.ProcessAttributes(parentProperty, members[0], list); infos.Add(InspectorPropertyInfo.CreateForMember(members[0], allowEditable, backend, list)); }
public static InspectorPropertyInfo CreateForMember(MemberInfo member, bool allowEditable, SerializationBackend serializationBackend, params Attribute[] attributes) { var list = new List <Attribute>(attributes.Length); for (int i = 0; i < attributes.Length; i++) { list.Add(attributes[i]); } return(CreateForMember(member, allowEditable, serializationBackend, list)); }
public static void AddValue <TValue>(this IList <InspectorPropertyInfo> infos, string name, Func <TValue> getter, Action <TValue> setter, int order = 0, SerializationBackend backend = SerializationBackend.None) { AddValue <TValue>(infos, name, getter, setter, 0, SerializationBackend.None, null); }
public static InspectorPropertyInfo CreateForMember(MemberInfo member, bool allowEditable, SerializationBackend serializationBackend, List <Attribute> attributes) { if (member == null) { throw new ArgumentNullException("member"); } if (!(member is FieldInfo || member is PropertyInfo || member is MethodInfo)) { throw new ArgumentException("Can only create inspector properties for field, property and method members."); } if (member is MethodInfo && serializationBackend != SerializationBackend.None) { throw new ArgumentException("Serialization backend can only be None for method members."); } if (member is MethodInfo && allowEditable) { //throw new ArgumentException("allowEditable can only be false for method members."); allowEditable = false; } if (allowEditable && member is FieldInfo && (member as FieldInfo).IsLiteral) { allowEditable = false; } string name = null; if (member is MethodInfo) { var mi = member as MethodInfo; var parameters = mi.GetParameters(); if (parameters.Length > 0) { name = mi.GetNiceName(); } } if (name == null) { name = member.Name; } if (name.Contains(".")) { var index = name.LastIndexOf(".") + 1; if (index < name.Length) { name = name.Substring(index); } else { throw new ArgumentException("A member name somehow had a '.' as the last character. This shouldn't be possible, but the '" + member.Name + "' has messed things up for everyone now. Good job!"); } } var result = new InspectorPropertyInfo(); if (member.IsDefined(typeof(OmitFromPrefabModificationPathsAttribute), true)) { name = "#" + name; } result.memberInfos = new MemberInfo[] { member }; result.PropertyName = name; result.PropertyType = member is MethodInfo ? PropertyType.Method : PropertyType.Value; result.SerializationBackend = serializationBackend; if (attributes == null) { result.attributes = new List <Attribute>(); } else { result.attributes = attributes; for (int i = attributes.Count - 1; i >= 0; i--) { var attr = attributes[i]; if (attr == null) { attributes.RemoveAt(i); continue; } var orderAttr = attr as PropertyOrderAttribute; if (orderAttr != null) { result.Order = orderAttr.Order; } } } result.typeOfOwner = member.DeclaringType; if (member is FieldInfo || member is PropertyInfo) { var valueType = member.GetReturnType(); result.typeOfValue = valueType; result.getterSetter = GetEmittedGetterSetterCreator(member.DeclaringType, valueType)(member, !allowEditable); //if (member is FieldInfo) //{ // //TwoArgsObjectArray[0] = member; // //TwoArgsObjectArray[1] = !allowEditable; // //var con = getterSetterType.GetConstructor(GetterSetterFieldConstructorSignature); // //result.getterSetter = (IValueGetterSetter)con.Invoke(TwoArgsObjectArray); // //result.getterSetter = (IValueGetterSetter)Activator.CreateInstance(typeof(GetterSetter<,>).MakeGenericType(member.DeclaringType, valueType), member, !allowEditable); // result.getterSetter = GetEmittedFieldGetterSetterCreator(member.DeclaringType, valueType)(member as FieldInfo, !allowEditable); //} //else //{ // //OneArgObjectArray[0] = member; // //var con = getterSetterType.GetConstructor(GetterSetterPropertyConstructorSignature); // //result.getterSetter = (IValueGetterSetter)con.Invoke(OneArgObjectArray); // //result.getterSetter = (IValueGetterSetter)Activator.CreateInstance(typeof(GetterSetter<,>).MakeGenericType(member.DeclaringType, valueType), member); //} result.IsEditable = allowEditable && !attributes.HasAttribute <ReadOnlyAttribute>() && !result.getterSetter.IsReadonly; } return(result); }
public static void AddValue <TValue>(this IList <InspectorPropertyInfo> infos, string name, Func <TValue> getter, Action <TValue> setter, int order = 0, SerializationBackend backend = SerializationBackend.None, params Attribute[] attributes) { infos.Add(InspectorPropertyInfo.CreateValue(name, order, backend, new GetterSetter <object, TValue>(getter, setter), attributes)); }