示例#1
0
        private void Write(Type value)
        {
            if (value == null)
            {
                SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, Guid.Empty);

                return;
            }
            if (value.IsArray)
            {
                SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, SerializeWriter.arrayGuid);

                this.Write(value.GetElementType());
                this.WriteCount(value.Name.EndsWith("[]") ? 0 : value.GetArrayRank());
                return;
            }
            if (value.IsGenericType)
            {
                SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, value.GetGenericTypeDefinition().GUID);

                Type[] genericArguments = value.GetGenericArguments();
                int    i   = 0;
                int    num = genericArguments.Length;
                while (i < num)
                {
                    this.Write(genericArguments[i]);
                    i++;
                }
                return;
            }
            SerializeWriterHelper <Guid, SerializeWriter> .Serialize(ref this, value.GUID);
        }
示例#2
0
 private void Write <T>(T?value) where T : struct
 {
     this.Write(value != null);
     if (value != null)
     {
         SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value.Value);
     }
 }
示例#3
0
        public static Packet ToBinary(object value)
        {
            int             length          = SerializedSizeCalculator.Calculate <object>(value);
            SerializeWriter serializeWriter = new SerializeWriter(length, 0);

            SerializeWriterHelper <object, SerializeWriter> .Serialize(ref serializeWriter, value);

            return(serializeWriter.data);
        }
示例#4
0
 private void Write <T>(ICollection <T> values)
 {
     if (values == null)
     {
         this.WriteCount(0);
         return;
     }
     this.WriteCount(values.Count + 1);
     foreach (T value in values)
     {
         SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value);
     }
 }
示例#5
0
        public static Packet ToBinary <T>(T value)
        {
            int categoryId = ClassInfo <T> .CategoryId;

            if (categoryId == 0)
            {
                return(SerializeWriter.ToBinary(value));
            }
            int             length          = SerializedSizeCalculator.Calculate <T>(value);
            SerializeWriter serializeWriter = new SerializeWriter(length, categoryId);

            SerializeWriterHelper <T, SerializeWriter> .Serialize(ref serializeWriter, value);

            return(serializeWriter.data);
        }
示例#6
0
        private void Write <T>(ArraySegment <T> value)
        {
            if (value.Array == null)
            {
                this.WriteCount(0);
                return;
            }
            this.WriteCount(value.Count + 1);
            int i   = value.Offset;
            int num = value.Offset + value.Count;

            while (i < num)
            {
                SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value.Array[i]);

                i++;
            }
        }
示例#7
0
        private void Write <T>(IList <T> value)
        {
            if (value == null)
            {
                this.WriteCount(0);
                return;
            }
            this.WriteCount(value.Count + 1);
            int i     = 0;
            int count = value.Count;

            while (i < count)
            {
                SerializeWriterHelper <T, SerializeWriter> .Serialize(ref this, value[i]);

                i++;
            }
        }
示例#8
0
        private static void SerializeCoreVirtual(ref W writer, T value)
        {
            Type type = (value == null) ? typeof(T) : value.GetType();

            SerializeWriterHelper <Type, W> .Serialize(ref writer, type);

            if (SerializeWriterHelper <T, W> .serializers == null)
            {
                SerializeWriterHelper <T, W> .serializers = new Dictionary <Type, SerializeWriterHelper <T, W> .SerializeDelegate>();
            }
            SerializeWriterHelper <T, W> .SerializeDelegate serializeDelegate;
            if (!SerializeWriterHelper <T, W> .serializers.TryGetValue(type, out serializeDelegate))
            {
                MethodInfo method = typeof(SerializeWriterHelper <, >).MakeGenericType(new Type[]
                {
                    type,
                    typeof(W)
                }).GetMethod("SerializeCore", BindingFlags.Static | BindingFlags.NonPublic);
                DynamicMethod dynamicMethod = new DynamicMethod(string.Format("{0}.{1}.SerializeAs[{2}.{3}]", new object[]
                {
                    typeof(SerializeWriterHelper <Type, W>).Namespace,
                    typeof(SerializeWriterHelper <Type, W>).Name,
                    typeof(T).Namespace,
                    typeof(T)
                }), null, new Type[]
                {
                    typeof(W).MakeByRefType(),
                    typeof(T)
                }, typeof(SerializeWriterHelper <Type, W>), true);
                dynamicMethod.DefineParameter(1, ParameterAttributes.In | ParameterAttributes.Out, "writer");
                dynamicMethod.DefineParameter(2, ParameterAttributes.In, "value");
                ILGenerator ilgenerator = dynamicMethod.GetILGenerator();
                ilgenerator.Emit(OpCodes.Ldarg_0);
                ilgenerator.Emit(OpCodes.Ldarg_1);
                ilgenerator.Emit(OpCodes.Unbox_Any, method.GetParameters()[1].ParameterType);
                ilgenerator.EmitCall(OpCodes.Call, method, null);
                ilgenerator.Emit(OpCodes.Ret);
                serializeDelegate = (dynamicMethod.CreateDelegate(typeof(SerializeWriterHelper <T, W> .SerializeDelegate)) as SerializeWriterHelper <T, W> .SerializeDelegate);
                SerializeWriterHelper <T, W> .serializers.Add(type, serializeDelegate);
            }
            serializeDelegate(ref writer, value);
        }
示例#9
0
        private static void EmitWriteFields(ILGenerator il, Type type)
        {
            foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                if (!fieldInfo.IsInitOnly && !fieldInfo.IsLiteral && !fieldInfo.IsNotSerialized)
                {
                    Type       fieldType  = fieldInfo.FieldType;
                    MethodInfo methodInfo = SerializeWriterHelper <T, W> .FindDefinedSerializeMethod(fieldType);

                    if (methodInfo == null)
                    {
                        methodInfo = typeof(SerializeWriterHelper <, >).MakeGenericType(new Type[]
                        {
                            fieldType,
                            typeof(W)
                        }).GetMethod("Serialize");
                    }
                    il.Emit(OpCodes.Ldarg_0);
                    il.Emit(OpCodes.Ldarg_1);
                    il.Emit(OpCodes.Ldfld, fieldInfo);
                    il.EmitCall(OpCodes.Call, methodInfo, null);
                }
            }
        }
示例#10
0
 public static void Serialize(ref W writer, T value)
 {
     SerializeWriterHelper <T, W> .serialize(ref writer, value);
 }
示例#11
0
        private static void GenerateSerializeMethod()
        {
            object[] @namespace = new object[] { typeof(SerializeWriterHelper <Type, W>).Namespace, typeof(SerializeWriterHelper <Type, W>).Name, typeof(T).Namespace, typeof(T).Name };
            string   str        = string.Format("{0}.{1}.SerializeCore[{2}.{3}]", @namespace);

            Type[]        typeArray     = new Type[] { typeof(W).MakeByRefType(), typeof(T) };
            DynamicMethod dynamicMethod = new DynamicMethod(str, null, typeArray, typeof(SerializeWriterHelper <T, W>), true);

            dynamicMethod.DefineParameter(1, ParameterAttributes.In | ParameterAttributes.Out, "writer");
            dynamicMethod.DefineParameter(2, ParameterAttributes.In, "value");
            ILGenerator lGenerator = dynamicMethod.GetILGenerator();
            Type        baseType   = typeof(T);

            if (!baseType.IsSerializable && SerializeWriterHelper <T, W> .FindDefinedSerializeMethod(baseType) == null)
            {
                throw new SerializationException(string.Format("Type is not serializable: {0}", baseType.AssemblyQualifiedName));
            }
            Label?nullable = null;

            if (!baseType.IsValueType && SerializeWriterHelper <T, W> .FindDefinedSerializeMethod(baseType) == null)
            {
                MethodInfo method = SerializeWriterHelper <T, W> .FindDefinedSerializeMethod(typeof(bool));

                if (method == null)
                {
                    Type   type       = typeof(SerializeWriterHelper <,>);
                    Type[] typeArray1 = new Type[] { typeof(bool), typeof(W) };
                    method = type.MakeGenericType(typeArray1).GetMethod("Serialize");
                }
                lGenerator.Emit(OpCodes.Ldarg_0);
                lGenerator.Emit(OpCodes.Ldarg_1);
                lGenerator.Emit(OpCodes.Ldnull);
                lGenerator.Emit(OpCodes.Ceq);
                lGenerator.Emit(OpCodes.Ldc_I4_0);
                lGenerator.Emit(OpCodes.Ceq);
                lGenerator.EmitCall(OpCodes.Call, method, null);
                lGenerator.Emit(OpCodes.Ldarg_1);
                nullable = new Label?(lGenerator.DefineLabel());
                lGenerator.Emit(OpCodes.Brfalse, nullable.Value);
            }
            Stack <Type> types = new Stack <Type>();

            while (true)
            {
                if (baseType != null)
                {
                    MethodInfo methodInfo = SerializeWriterHelper <T, W> .FindDefinedSerializeMethod(baseType);

                    if (methodInfo == null)
                    {
                        if (baseType.IsSerializable)
                        {
                            types.Push(baseType);
                        }
                        baseType = baseType.BaseType;
                    }
                    else
                    {
                        SerializeWriterHelper <T, W> .EmitWritePredefinedType(lGenerator, methodInfo);

                        break;
                    }
                }
                else
                {
                    break;
                }
            }
            while (0 < types.Count)
            {
                SerializeWriterHelper <T, W> .EmitWriteFields(lGenerator, types.Pop());
            }
            if (nullable.HasValue)
            {
                lGenerator.MarkLabel(nullable.Value);
            }
            lGenerator.Emit(OpCodes.Ret);
            SerializeWriterHelper <T, W> .serializeCore = dynamicMethod.CreateDelegate(typeof(SerializeWriterHelper <T, W> .SerializeDelegate)) as SerializeWriterHelper <T, W> .SerializeDelegate;
            if (typeof(T).IsSealed || SerializeWriterHelper <T, W> .FindDefinedSerializeMethod(typeof(T)) != null)
            {
                SerializeWriterHelper <T, W> .serialize = SerializeWriterHelper <T, W> .serializeCore;
                return;
            }
            SerializeWriterHelper <T, W> .serialize = new SerializeWriterHelper <T, W> .SerializeDelegate(SerializeWriterHelper <T, W> .SerializeCoreVirtual);
        }
示例#12
0
 private static void SerializeCore(ref W writer, T value)
 {
     SerializeWriterHelper <T, W> .serializeCore(ref writer, value);
 }
示例#13
0
 static SerializeWriterHelper()
 {
     SerializeWriterHelper <T, W> .GenerateSerializeMethod();
 }