public static string SerializeJson(object obj) { var writer = new Siren.Protocol.Json.JsonWriter(); Serializer serializer = new Serializer(writer); serializer.SerializeHelper(obj, SirenFactory.FindClass(obj.GetType())); return(writer.FlushToString()); }
public static ArraySegment <byte> Serialize <TWriter>(object obj) where TWriter : BaseProtocolWriter, new() { var writer = new TWriter(); Serializer serializer = new Serializer(writer); serializer.SerializeHelper(obj, SirenFactory.FindClass(obj.GetType())); return(writer.ToBuffer()); }
public ushort GetBasePropertyCount() { if (Type.BaseType != typeof(object)) { var baseClass = SirenFactory.FindClass(Type.BaseType); if (baseClass != null) { return((ushort)(baseClass.GetBasePropertyCount() + (ushort)baseClass.Properties.Count)); } } return(0); }
public static T Deserialize <T, TReader>(ArraySegment <byte> data) where T : class, new() where TReader : BaseProtocolReader, new() { var reader = new TReader(); reader.Accept(data); Deserializer deserializer = new Deserializer(reader); object obj = new T(); deserializer.DeserializeHelper(typeof(T), ref obj, SirenFactory.FindClass(typeof(T))); return((T)obj); }
public static T DeserializeJson <T>(string str) where T : class, new() { var reader = new Siren.Protocol.Json.JsonReader(); reader.Accept(str); Deserializer deserializer = new Deserializer(reader); object obj = new T(); deserializer.DeserializeHelper(typeof(T), ref obj, SirenFactory.FindClass(typeof(T))); return((T)obj); //JsonSerializerSettings settings = new JsonSerializerSettings //{ // ContractResolver = Serializer.SirenContractResolver.Instance //}; //return JsonConvert.DeserializeObject<T>(str, settings); }
public void SerializeBase(object obj, SirenClass sirenClass) { if (sirenClass.BaseSirenClass != null) { SerializeBase(obj, sirenClass.BaseSirenClass); } foreach (var sirenProperty in sirenClass.Properties) { if (sirenProperty.Attribute.Modifier == SirenFieldModifier.Required) { if (!sirenProperty.HasValue(obj)) { Console.WriteLine("Forget to set {0}.{1}", sirenClass.Name, sirenProperty.Name); Writer.OnError(); return; } } else { if (!sirenProperty.HasValue(obj)) { //skip return; } } Writer.OnPropertyBegin(sirenProperty.Name, sirenProperty.Id, sirenProperty.DataType); switch (sirenProperty.FieldType) { case SirenPropertyFieldType.Value: Writer.OnValue(sirenProperty.Info.GetValue(obj)); break; case SirenPropertyFieldType.String: Writer.OnString(sirenProperty.Info.GetValue(obj) as string); break; case SirenPropertyFieldType.Blob: Writer.OnMemoryData(sirenProperty.Info.GetValue(obj) as byte[]); break; case SirenPropertyFieldType.List: { object items = sirenProperty.Info.GetValue(obj); var listType = sirenProperty.Type; int count = Convert.ToInt32(listType.GetProperty("Count").GetValue(items)); var itemType = sirenProperty.Type.GenericTypeArguments[0]; SirenFieldType itemDataType = SirenFactory.GetPropertyType(itemType); Writer.OnListBegin(itemDataType, count); var itemsProperty = listType.GetProperty("Item"); for (int i = 0; i < count; i++) { object listItem = itemsProperty.GetValue(items, new object[] { i }); SerializeHelper(listItem, sirenProperty.ValueSirenClass); } Writer.OnListEnd(); } break; case SirenPropertyFieldType.Dictionary: { object items = sirenProperty.Info.GetValue(obj); var dictType = sirenProperty.Type; int count = Convert.ToInt32(dictType.GetProperty("Count").GetValue(items)); var keyType = sirenProperty.Type.GenericTypeArguments[0]; var valueType = sirenProperty.Type.GenericTypeArguments[1]; SirenFieldType keyDataType = SirenFactory.GetPropertyType(keyType); SirenFieldType valueDataType = SirenFactory.GetPropertyType(valueType); Writer.OnDictionaryBegin(keyDataType, valueDataType, count); foreach (var o in (items as IEnumerable)) { var itemKey = o.GetType().GetProperty("Key").GetValue(o, null); SerializeHelper(itemKey, sirenProperty.KeySirenClass); var itemValue = o.GetType().GetProperty("Value").GetValue(o, null); SerializeHelper(itemValue, sirenProperty.ValueSirenClass); } Writer.OnDictionaryEnd(); } break; case SirenPropertyFieldType.Pointer: case SirenPropertyFieldType.Struct: { object val = sirenProperty.Info.GetValue(obj); SerializeHelper(val, sirenProperty.ValueSirenClass); } break; } Writer.OnPropertyEnd(); } }
public bool Initialzie() { //get template Template = SirenFactory.Create(Attribute.Template) as ISirenTemplate; if (Template == null) { return(false); } if (Type.IsEnum) { return(true); } //get methods SerializeMethodInfo = Type.GetMethod("Serialize", BindingFlags.Public | BindingFlags.Instance); DeserializeMethodInfo = Type.GetMethod("Deserialize", BindingFlags.Public | BindingFlags.Instance); RegisterMethodInfo = Type.GetMethod("Register", BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static); if (RegisterMethodInfo != null && !Type.ContainsGenericParameters) { RegisterMethodInfo.Invoke(null, null); } //get properties uint index = 0; ushort id = GetBasePropertyCount(); var properties = Type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance); foreach (var propertyInfo in properties) { SirenPropertyAttribute propertyAttribute = propertyInfo.GetCustomAttribute <SirenPropertyAttribute>(); if (propertyAttribute != null) { SirenProperty property = new SirenProperty(this, propertyInfo, propertyAttribute, index++, id++); Properties.Add(property); PropertyIdDict.Add(property.Id, property); PropertyNameDict.Add(property.Name, property); } } if (Properties.Count == 0) { if (Type.BaseType == typeof(object) || Type.BaseType.IsValueType) { return(false); } } //get include types foreach (var property in Properties) { var type = property.Type; if (type.IsGenericType) { if (type.Name.StartsWith("List")) { var valueType = type.GenericTypeArguments[0]; AddIncludeType(valueType); } else if (type.Name.StartsWith("Dictionary")) { var keyType = type.GenericTypeArguments[0]; var valueType = type.GenericTypeArguments[1]; AddIncludeType(keyType); AddIncludeType(valueType); } else { AddIncludeType(type); } } else { AddIncludeType(type); } } if (Type.BaseType != typeof(object) && !Type.BaseType.IsValueType) { //has base type if (!IncludeTypes.Contains(Type.BaseType)) { IncludeTypes.Add(Type.BaseType); } BaseSirenClass = SirenFactory.FindClass(Type.BaseType); if (BaseSirenClass != null) { //add base properties foreach (var sirenProperty in BaseSirenClass.PropertyIdDict) { PropertyIdDict.Add(sirenProperty.Key, sirenProperty.Value); } foreach (var sirenProperty in BaseSirenClass.PropertyNameDict) { PropertyNameDict.Add(sirenProperty.Key, sirenProperty.Value); } } } return(true); }
public SirenProperty(SirenClass parentSirenClass, PropertyInfo info, SirenPropertyAttribute attribute, uint index, ushort id) { ParentSirenClass = parentSirenClass; Info = info; Id = id; Attribute = attribute; Index = index; FieldType = SirenPropertyFieldType.Struct; DataType = SirenFactory.GetDataType(Type); MethodType = SirenPropertyMethodType.Unsupported; if (Type.IsGenericType) { if (Type.Name.StartsWith("List")) { MethodType = SirenPropertyMethodType.List; FieldType = SirenPropertyFieldType.List; ValueType = Type.GenericTypeArguments[0]; ValueSirenClass = SirenFactory.FindClass(ValueType); } else if (Type.Name.StartsWith("Dictionary")) { MethodType = SirenPropertyMethodType.Dictionary; FieldType = SirenPropertyFieldType.Dictionary; KeyType = Type.GenericTypeArguments[0]; ValueType = Type.GenericTypeArguments[1]; KeySirenClass = SirenFactory.FindClass(KeyType); ValueSirenClass = SirenFactory.FindClass(ValueType); } else { ValueSirenClass = SirenFactory.FindClass(Type); if (Attribute.Modifier == SirenPropertyModifier.Required) { MethodType = SirenPropertyMethodType.Value; FieldType = SirenPropertyFieldType.Struct; } else { MethodType = SirenPropertyMethodType.Pointer; FieldType = SirenPropertyFieldType.Pointer; } } DefaultValueString = String.Empty; } else { if (Type.IsValueType || Type == typeof(string) || Type == typeof(byte[])) { MethodType = SirenPropertyMethodType.Value; if (Type == typeof(string)) { FieldType = SirenPropertyFieldType.String; } else if (Type == typeof(byte[])) { FieldType = SirenPropertyFieldType.Blob; } else { FieldType = SirenPropertyFieldType.Value; } } else { if (Attribute.Modifier == SirenPropertyModifier.Required) { MethodType = SirenPropertyMethodType.Value; FieldType = SirenPropertyFieldType.Struct; } else { MethodType = SirenPropertyMethodType.Pointer; FieldType = SirenPropertyFieldType.Pointer; } ValueSirenClass = SirenFactory.FindClass(Type); } DefaultValueString = String.Empty; if (Type.IsValueType) { if (Attribute.DefaultValue != null) { if (Type.IsEnum) { DefaultValueString = String.Format("({0}){1}", Type.Name, Convert.ToUInt32(Attribute.DefaultValue)); } else { DefaultValueString = Attribute.DefaultValue.ToString(); } } else { if (Type == typeof(bool)) { DefaultValueString = "false"; } else if (Type == typeof(float)) { DefaultValueString = "0.f"; } else if (Type == typeof(double)) { DefaultValueString = "0.0"; } else { if (Type.IsEnum) { DefaultValueString = String.Format("({0})0", Type.Name); } else { DefaultValueString = "0"; } } } } } }
public void DeserializeBase(ref object obj, SirenClass sirenClass) { if (sirenClass.BaseSirenClass != null) { DeserializeBase(ref obj, sirenClass.BaseSirenClass); } foreach (var sirenProperty in sirenClass.Properties) { while (true) { if (Reader.IsEnd()) { Console.WriteLine("Reach end of file.Cannot find property {0}.{1}", sirenClass.Name, sirenProperty.Name); Reader.OnError(); return; } ushort outId; SirenFieldType outDataType; int result = Reader.OnPropertyBegin(sirenProperty.Name, sirenProperty.Id, sirenProperty.DataType, out outId, out outDataType); if (result == 0) { object val = null; switch (sirenProperty.FieldType) { case SirenPropertyFieldType.Value: case SirenPropertyFieldType.String: case SirenPropertyFieldType.Blob: DeserializeHelper(sirenProperty.Type, ref val, sirenProperty.ValueSirenClass); break; case SirenPropertyFieldType.Struct: case SirenPropertyFieldType.Pointer: val = SirenFactory.Create(sirenProperty.Type); DeserializeHelper(sirenProperty.Type, ref val, sirenProperty.ValueSirenClass); break; case SirenPropertyFieldType.List: { val = SirenFactory.Create(sirenProperty.Type); SirenFieldType valueDataType; int count; Reader.OnListBegin(out valueDataType, out count); //get count and type var addMethod = sirenProperty.Type.GetMethod("Add"); for (int i = 0; i < count; i++) { var listItem = SirenFactory.Create(sirenProperty.ValueType); DeserializeHelper(sirenProperty.ValueType, ref listItem, sirenProperty.ValueSirenClass); addMethod.Invoke(val, new[] { listItem }); } Reader.OnListEnd(); } break; case SirenPropertyFieldType.Dictionary: { val = SirenFactory.Create(sirenProperty.Type); SirenFieldType keyDataType; SirenFieldType valueDataType; int count; Reader.OnDictionaryBegin(out keyDataType, out valueDataType, out count); //get count and type var addMethod = sirenProperty.Type.GetMethod("Add"); for (int i = 0; i < count; i++) { var dictKey = SirenFactory.Create(sirenProperty.KeyType); var dictValue = SirenFactory.Create(sirenProperty.ValueType); DeserializeHelper(sirenProperty.KeyType, ref dictKey, sirenProperty.KeySirenClass); DeserializeHelper(sirenProperty.ValueType, ref dictValue, sirenProperty.ValueSirenClass); addMethod.Invoke(val, new[] { dictKey, dictValue }); } Reader.OnDictionaryEnd(); } break; } sirenProperty.Info.SetValue(obj, val); Reader.OnPropertyEnd(); break; } else if (result < 0) { //Current filed missed if (sirenProperty.Attribute.Modifier == SirenFieldModifier.Required) { //cannot find this property Console.WriteLine("Cannot find property {0}.{1}", sirenClass.Name, sirenProperty.Name); Reader.OnError(); return; } else { sirenProperty.SetToDefault(obj); break; } } else { //Read unknown field //skip current field Reader.OnPropertySkip(sirenProperty.DataType); //read next field } } } }