/// <summary>
        /// Initializes a new instance of the TypeSerializationInfo class for
        /// legacy serialization mechanisms. For internal use only.
        /// </summary>
        /// <param name="legacyType"></param>
        internal TypeSerializationInfo(LegacySerializationType legacyType)
        {
            deferredInitializationAction = () =>
            {
                switch (legacyType)
                {
                case LegacySerializationType.Version:
                    this.serializeMethod   = SerializeVersionSerializable;
                    this.deserializeMethod = DeserializeVersionSerializable;
                    break;

                case LegacySerializationType.Custom:
                    this.serializeMethod   = SerializeCustomSerializable;
                    this.deserializeMethod = DeserializeCustomSerializable;
                    break;

                case LegacySerializationType.Unknown:
                    this.serializeMethod   = SerializeUnknownType;
                    this.deserializeMethod = DeserializeUnknownType;
                    break;
                }

                this.compareMethod = object.Equals;
            };
        }
Ejemplo n.º 2
0
 public CustomType(Type type, byte code, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction)
 {
     this.Type = type;
     this.Code = code;
     this.SerializeFunction   = serializeFunction;
     this.DeserializeFunction = deserializeFunction;
 }
Ejemplo n.º 3
0
        public static void RegisterTypes(this PhotonClient client)
        {
            Type              typeFromHandle = typeof(Vector3);
            byte              code           = 86;
            SerializeMethod   Serialize1     = new SerializeMethod(JFAFAPNBFLC);
            DeserializeMethod DeSerialize1   = new DeserializeMethod(IKFICLDHAOI);

            PhotonPeer.RegisterType(typeFromHandle, code, Serialize1, DeSerialize1);
            Type              typeFromHandle2 = typeof(Quaternion);
            byte              code2           = 81;
            SerializeMethod   Serialize2      = new SerializeMethod(FECGOFBPKPP);
            DeserializeMethod DeSerialize2    = new DeserializeMethod(KCFONHKNDJH);

            PhotonPeer.RegisterType(typeFromHandle2, code2, Serialize2, DeSerialize2);
            byte              b = 100;
            Type              typeFromHandle3 = typeof(Vector2);
            SerializeMethod   Serialize3      = new SerializeMethod(KMIBNBFAHEN);
            DeserializeMethod DeSerialize3    = new DeserializeMethod(HHBPLJKDKPI);

            GCJHKDFNJEA(typeFromHandle3, ref b, Serialize3, DeSerialize3);
            Type              typeFromHandle4 = typeof(Vector4);
            SerializeMethod   Serialize4      = new SerializeMethod(DFMLPAEPHJD);
            DeserializeMethod DeSerialize4    = new DeserializeMethod(GPJDPFFENPL);

            GCJHKDFNJEA(typeFromHandle4, ref b, Serialize4, DeSerialize4);
        }
Ejemplo n.º 4
0
 internal CustomType(Type type, int typeId, SerializeMethod encodeFunc, DeserializeMethod decodeFunc)
 {
     Type              = type;
     TypeId            = typeId;
     SerializeMethod   = encodeFunc;
     DeserializeMethod = decodeFunc;
 }
Ejemplo n.º 5
0
 public SerializableTypeInfo(Type type, byte id, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction)
 {
     this.Type = type;
     this.Id   = id;
     this.SerializeFunction   = serializeFunction;
     this.DeserializeFunction = deserializeFunction;
 }
Ejemplo n.º 6
0
            private IEnumerator Logout()
            {
                Protocol.TypeDict.Remove(typeof(LogoutType));
                Protocol.CodeDict.Remove(102);

#if STEAM
                SerializeMethod   serializeMethod   = new SerializeMethod(AADBLALKGMG.LDCIBGFMECI);
                DeserializeMethod deserializeMethod = new DeserializeMethod(AADBLALKGMG.JDJKKLNPMNA);
#elif OCULUS
                SerializeMethod   serializeMethod   = new SerializeMethod(AADBLALKGMG.LDCIBGFMECI);
                DeserializeMethod deserializeMethod = new DeserializeMethod(AADBLALKGMG.JDJKKLNPMNA);
#endif

                PhotonPeer.RegisterType(typeof(LogoutType), (byte)102, new SerializeMethod(SerializeThisFunction), deserializeMethod);

                PhotonView photonView = PhotonView.Get(VRC_EventLog.Instance.Replicator);

                for (int i = 0; i < 10; i++)
                {
                    try
                    {
                        if (Targets[0] != null)
                        {
                            photonView.RpcSecure("ProcessEvent", Targets[0], true, new object[]
                            {
#if STEAM
                                new VRC_EventLog.INGKOGDACII()
#elif OCULUS
                                new VRC_EventLog.INGKOGDACII()
#endif
                            });
                        }
                    }
Ejemplo n.º 7
0
        public PropertyConverter(PropertyInfo propertyInfo, IJsonConverter valueConverter)
        {
            var instance  = Expression.Parameter(Typeof <TObject> .Raw, "instance");
            var converter = Expression.Constant(valueConverter, valueConverter.GetType());

            Deserialize = BuildDeserializeMethod(instance, propertyInfo, converter);
            Read        = BuildReadMethod(instance, propertyInfo, converter);
            Serialize   = BuildSerializeMethod(instance, propertyInfo, converter);
            Write       = BuildWriteMethod(instance, propertyInfo, converter);
        }
Ejemplo n.º 8
0
        public static void SendCustomEvent(int photonId, SerializeMethod method)
        {
            void Clear()
            {
                if (originalSerializeMethod == null || originalDeserializeMethod == null)
                {
                    object instance       = typeDictInfo.GetValue(null);
                    object customTypeInfo = typeDictItemInfo.GetValue(instance, new object[] { logoutType });

                    if (originalSerializeMethod == null)
                    {
                        originalSerializeMethod = (SerializeMethod)serializeMethodInfo.GetValue(customTypeInfo);
                    }

                    if (originalDeserializeMethod == null)
                    {
                        originalDeserializeMethod = (DeserializeMethod)deserializeMethodInfo.GetValue(customTypeInfo);
                    }
                }

                TypeDictRemove(logoutType);
                CodeDictRemove(102);
            }

            void RegisterCustom()
            {
                PhotonPeer.RegisterType(logoutType, (byte)102, method, originalDeserializeMethod);
            }

            void Send()
            {
                PhotonView photonView = PhotonView.Get(VRC_EventLog.Instance.Replicator);

                object target = PhotonPlayerWrappers.GetById(photonId);

                if (target != null)
                {
                    RpcSecure(photonView, "ProcessEvent", target, true, new object[]
                    {
                        Activator.CreateInstance(logoutType)
                    });
                }
            }

            void RegisterOriginal()
            {
                PhotonPeer.RegisterType(logoutType, 102, originalSerializeMethod, originalDeserializeMethod);
            }

            Clear();
            RegisterCustom();
            Send();
            Clear();
            RegisterOriginal();
        }
        /// <summary>
        ///     <para>Binary-serializes an object and deserializes it into another object.</para>
        /// </summary>
        /// <typeparam name="T">The Object type.</typeparam>
        /// <param name="original">
        ///     <para>The original instance to serialize.</para>
        /// </param>
        /// <param name="method">
        ///     <para>The method to deserialize the object with.</para>
        /// </param>
        /// <returns>
        ///		<para>The deserialized object of type <typeparam name="T"/>;
        ///		never <see langword="null"/>.</para>
        /// </returns>
        /// <exception cref="ArgumentNullException">
        ///     <para>The argument <paramref name="original"/> is <see langword="null"/>.</para>
        ///     <para>-or-</para>
        ///     <para>The argument <paramref name="method"/> is <see langword="null"/>.</para>
        /// </exception>
        public static T PerformBinaryRoundTrip <T>(T original, DeserializeMethod <T> method) where T : IVersionSerializable
        {
            using (MemoryStream stream = new MemoryStream())
            {
                Serializer.Serialize <T>(stream, original);

                SaveToFile(stream.ToArray(), ".bin");

                stream.Position = 0;
                using (CompactBinaryReader reader = new CompactBinaryReader(stream))
                {
                    return(method(reader));
                }
            }
        }
        void InitializeLegacySerializable()
        {
            if (this.versionSerializable == true)
            {
                this.serializeMethod   = SerializeVersionSerializable;
                this.deserializeMethod = DeserializeVersionSerializable;
            }
            else if (this.type.GetInterface(typeof(ICustomSerializable).Name) != null)
            {
                this.serializeMethod   = SerializeCustomSerializable;
                this.deserializeMethod = DeserializeCustomSerializable;
            }
            else
            {
                this.serializeMethod   = SerializeUnknownType;
                this.deserializeMethod = DeserializeUnknownType;
            }

            this.compareMethod = object.Equals;
        }
Ejemplo n.º 11
0
        /// <summary>registers a custom serializable type using type, a character and 2 methods for serialization and deserilialization</summary>
        public void RegisterCustomType(Type t, char c, SerializeMethod s, DeserializeMethod d)
        {
            if (usedCodes.Contains(c))
            {
                Debug.LogWarningFormat("Failed registering serializable type with code {0}:: code is already used", c);
                return;
            }

            if (SerializedTypes.Contains(t))
            {
                Debug.LogWarningFormat("Failed registering serializable type {0}:: type is already registered", t);
                return;
            }

            if (!PhotonPeer.RegisterType(t, (byte)c, s, d))
            {
                Debug.LogWarningFormat("Failed registering serializable type with code {0}::  check photon requirements for serialization", c);
                return;
            }

            usedCodes.Add(c);
            SerializedTypes.Add(t);
        }
Ejemplo n.º 12
0
 public StorageMgr(string dataFileName, DeserializeMethod ds)
 {
     Deserializer  = ds;
     m_datafileMgr = dataFileName;
     ProcessAttributes();
 }
Ejemplo n.º 13
0
        public static bool TryRegisterType(Type type, byte typeCode, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction)
        {
            bool flag = Protocol.CodeDict.ContainsKey(typeCode) || Protocol.TypeDict.ContainsKey(type);
            bool result;

            if (flag)
            {
                result = false;
            }
            else
            {
                CustomType value = new CustomType(type, typeCode, serializeFunction, deserializeFunction);
                Protocol.CodeDict.Add(typeCode, value);
                Protocol.TypeDict.Add(type, value);
                result = true;
            }
            return(result);
        }
        /// <summary>
        /// Does not support deserializing of anonymous types
        /// Type should be covered by preceeding resolvers in complex/standard resolver.
        /// </summary>
        private object DeserializeByTypeName(ArraySegment <byte> typeName, ref MessagePackReader byteSequence, MessagePackSerializerOptions options)
        {
            // try get type with assembly name, throw if not found
            Type type;

            if (!this.typeCache.TryGetValue(typeName, out type))
            {
                var buffer = new byte[typeName.Count];
                Buffer.BlockCopy(typeName.Array, typeName.Offset, buffer, 0, buffer.Length);
                var str = StringEncoding.UTF8.GetString(buffer);
                type = this.BindToType(str);
                if (type == null)
                {
                    if (IsMscorlib && str.Contains("System.Private.CoreLib"))
                    {
                        str  = str.Replace("System.Private.CoreLib", "mscorlib");
                        type = Type.GetType(str, true); // throw
                    }
                    else if (!IsMscorlib && str.Contains("mscorlib"))
                    {
                        str  = str.Replace("mscorlib", "System.Private.CoreLib");
                        type = Type.GetType(str, true); // throw
                    }
                    else
                    {
                        type = Type.GetType(str, true); // re-throw
                    }
                }

                this.typeCache.TryAdd(buffer, type);
            }

            KeyValuePair <object, DeserializeMethod> formatterAndDelegate;

            if (!this.deserializers.TryGetValue(type, out formatterAndDelegate))
            {
                lock (this.deserializers)
                {
                    if (!this.deserializers.TryGetValue(type, out formatterAndDelegate))
                    {
                        TypeInfo ti = type.GetTypeInfo();

                        IFormatterResolver resolver = options.Resolver;
                        var formatter = resolver.GetFormatterDynamic(type);
                        if (formatter == null)
                        {
                            throw new FormatterNotRegisteredException(type.FullName + " is not registered in this resolver. resolver:" + resolver.GetType().Name);
                        }

                        Type formatterType         = typeof(IMessagePackFormatter <>).MakeGenericType(type);
                        ParameterExpression param0 = Expression.Parameter(typeof(object), "formatter");
                        ParameterExpression param1 = Expression.Parameter(typeof(MessagePackReader).MakeByRefType(), "reader");
                        ParameterExpression param2 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");

                        MethodInfo deserializeMethodInfo = formatterType.GetRuntimeMethod("Deserialize", new[] { typeof(MessagePackReader).MakeByRefType(), typeof(MessagePackSerializerOptions) });

                        MethodCallExpression deserialize = Expression.Call(
                            Expression.Convert(param0, formatterType),
                            deserializeMethodInfo,
                            param1,
                            param2);

                        Expression body = deserialize;
                        if (ti.IsValueType)
                        {
                            body = Expression.Convert(deserialize, typeof(object));
                        }

                        DeserializeMethod lambda = Expression.Lambda <DeserializeMethod>(body, param0, param1, param2).Compile();

                        formatterAndDelegate = new KeyValuePair <object, DeserializeMethod>(formatter, lambda);
                        this.deserializers.TryAdd(type, formatterAndDelegate);
                    }
                }
            }

            return(formatterAndDelegate.Value(formatterAndDelegate.Key, ref byteSequence, options));
        }
Ejemplo n.º 15
0
 /// <summary>registers a custom serializable type using type, a character and 2 methods for serialization and deserilialization</summary>
 public static void RegisterCustomSerializable(Type type, char charCode, SerializeMethod serialize, DeserializeMethod deserialize)
 {
     serialization.RegisterCustomType(type, charCode, serialize, deserialize);
 }
Ejemplo n.º 16
0
        internal static bool TryRegisterType(Type type, byte typeCode, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction)
        {
            if (CodeDict.ContainsKey(typeCode) || TypeDict.ContainsKey(type))
            {
                return(false);
            }
            CustomType customType = new CustomType(type, typeCode, serializeFunction, deserializeFunction);

            CodeDict.Add(typeCode, customType);
            TypeDict.Add(type, customType);
            return(true);
        }
Ejemplo n.º 17
0
        private static void GCJHKDFNJEA(Type GMLMGAFFKEL, ref byte JGJGAENECKO, SerializeMethod HNDHEEONDNN, DeserializeMethod EBMBMGANEJJ)
        {
            byte code;

            JGJGAENECKO = Convert.ToByte((code = JGJGAENECKO) + 1);
            if (PhotonPeer.RegisterType(GMLMGAFFKEL, code, HNDHEEONDNN, EBMBMGANEJJ) && !ILHFIJHBPKK.Contains(GMLMGAFFKEL))
            {
                ILHFIJHBPKK.Add(GMLMGAFFKEL);
            }
        }
Ejemplo n.º 18
0
        /// <summary>
        /// 注册自定义类型的序列化
        /// </summary>
        /// <returns><c>true</c>, if type was registered, <c>false</c> otherwise.</returns>
        /// <param name="type">类型</param>
        /// <param name="typeId">类型 Id</param>
        /// <param name="serializeMethod">序列化方法</param>
        /// <param name="deserializeMethod">反序列化方法</param>
        public static bool RegisterType(Type type, int typeId, SerializeMethod serializeMethod, DeserializeMethod deserializeMethod)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type));
            }
            if (serializeMethod == null)
            {
                throw new ArgumentNullException(nameof(serializeMethod));
            }
            if (deserializeMethod == null)
            {
                throw new ArgumentNullException(nameof(deserializeMethod));
            }
            if (typeDict.ContainsKey(type) || typeIdDict.ContainsKey(typeId))
            {
                return(false);
            }
            var customType = new CustomType(type, typeId, serializeMethod, deserializeMethod);

            typeDict.Add(type, customType);
            typeIdDict.Add(typeId, customType);
            return(true);
        }
Ejemplo n.º 19
0
        }                            // 0x00000001806C6830-0x00000001806C6930

        // Methods
        public static bool TryRegisterType(Type type, byte typeCode, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction) => default;             // 0x00000001806C6660-0x00000001806C6830
Ejemplo n.º 20
0
        public static void RegisterType(Type type, byte id, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction)
        {
            if (TypeDict.ContainsKey(type) || IdDict.ContainsKey(id))
            {
                throw new Exception("Type Already Registed :" + type + "/" + id);
            }
            SerializableTypeInfo customType = new SerializableTypeInfo(type, id, serializeFunction, deserializeFunction);

            TypeDict.Add(type, customType);
            IdDict.Add(id, customType);
        }
        void CreateDeserializationMethod(List <PropertySerializationInfo> properties)
        {
            const string HasNameTableLabel     = "_hasNameTable";
            const string endLabel              = "exitFunction";
            const string SkipPropertyLabel     = "_skipProperty";
            const string BaseSucceededLabel    = "_baseSucceeded";
            const string SkipLegacyDeserialize = "_skipLegacyDeserialize";

            int version = 0;

            PropertySerializationInfo.GenerateArgs args = new PropertySerializationInfo.GenerateArgs();

            args.il = new DynamicMethodHelper(
                "Deserialize_" + type.Name,
                null,
                new Type[] { typeof(object), typeof(int), typeof(TypeSerializationArgs) },
                this.type
                );

            args.instanceArg = 0;
            args.versionArg  = 1;
            args.dataArg     = 2;
            args.streamVar   = "_reader";
            args.headerVar   = "_header";

            args.il.DeclareLocal(args.streamVar, typeof(IPrimitiveReader));
            args.il.GetField(args.dataArg, typeof(TypeSerializationArgs).GetField("Reader"));
            args.il.PopLocal(args.streamVar);

            args.il.DeclareLocal(args.headerVar, typeof(TypeSerializationHeader));
            args.il.GetField(args.dataArg, typeof(TypeSerializationArgs).GetField("Header"));
            args.il.PopLocal(args.headerVar);

            //  Handle legacy deserialization
            if ((this.LegacyVersion > 0) && (this.MinVersion <= this.LegacyVersion))
            {
                MethodInfo method = this.Type.GetMethod(
                    "Deserialize",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                    null,
                    new Type[] { typeof(IPrimitiveReader), typeof(int) },
                    null
                    );

                if (method == null)
                {
                    throw new ApplicationException(string.Format(
                                                       "Class {0} specified a legacy version but could not find the Deserialize method",
                                                       this.Type.Name
                                                       ));
                }

                //
                //  if (dataVersion > legacyVersion)
                //    goto SkipLegacyDeserialize
                //
                //      call instance.Deserialize(reader, version)
                //      goto endLabel
                //
                //  :SkipLegacyDeserialize
                //
                args.il.PushArg(args.versionArg);
                args.il.PushInt(this.LegacyVersion);
                args.il.GotoIfGreater(SkipLegacyDeserialize);

                args.il.PushArg(args.instanceArg);
                args.il.PushLocal(args.streamVar);
                args.il.PushArg(args.versionArg);
                args.il.CallMethod(method);

                args.il.Goto(endLabel);
                args.il.MarkLabel(SkipLegacyDeserialize);
            }

            //  TypeNameTable _typeNameTable = dataArg.NameTable;
            //  if (_typeNameType == null)
            //      _typeNameType = new TypeNameTable();
            //      dataArg.NameTable = _typeNameType;
            args.nameTableVar = "_typeNameTable";
            args.il.DeclareLocal(args.nameTableVar, typeof(TypeNameTable));
            args.il.GetField(args.dataArg, typeof(TypeSerializationArgs).GetField("NameTable"));
            args.il.PopLocal(args.nameTableVar);

            args.il.PushLocal(args.nameTableVar);
            args.il.GotoIfTrue(HasNameTableLabel);

            args.il.NewObject(args.nameTableVar);
            args.il.SetField(args.dataArg, args.nameTableVar, typeof(TypeSerializationArgs).GetField("NameTable"));

            args.il.BeginCallMethod(args.nameTableVar, "Deserialize", new Type[] { typeof(IPrimitiveReader), typeof(TypeSerializationHeader) });
            args.il.PushLocal(args.streamVar);
            args.il.PushLocal(args.headerVar);
            args.il.CallMethod();

            args.il.BeginCallMethod(args.nameTableVar, "GetSerializationInfo", new Type[] { typeof(SerializationInfo), typeof(int) });
            args.il.GetField(args.dataArg, typeof(TypeSerializationArgs).GetField("SerializationInfo"));
            args.il.PushInt(this.CurrentVersion);
            args.il.CallMethod();

            args.il.MarkLabel(HasNameTableLabel);

            //  If the type automatically serializes its base class
            //  then read it now. This must be done after the derived class
            //  has a chance to load the name table
            if (this.serializableBaseType != null)
            {
                FieldInfo fi = typeof(TypeSerializationArgs).GetField("IsBaseClass");

                args.il.PushArg(args.dataArg);
                args.il.PushBool(true);
                args.il.SetField(fi);

                //  Set IsBaseClass field to ensure proper type mapping
                args.il.PushArgAsRef(args.instanceArg);
                args.il.PushArg(args.dataArg);
                args.il.CallMethod(PropertySerializationInfo.GetTypeMethod(this.serializableBaseType, PropertySerializationInfo.TypeMethodType.Deserialize));

                args.il.GotoIfTrue(BaseSucceededLabel);

                args.il.PushArg(args.dataArg);
                args.il.PushBool(false);
                args.il.SetField(typeof(TypeSerializationArgs).GetField("Succeeded"));
                args.il.Goto(endLabel);

                args.il.MarkLabel(BaseSucceededLabel);

                //  Clear IsBaseClass flag
                args.il.PushArg(args.dataArg);
                args.il.PushBool(false);
                args.il.SetField(fi);
            }


            //  Create calls to deserialize each member
            foreach (PropertySerializationInfo propInfo in properties)
            {
                //  If we hit a higher version property then put in
                //  an "if" statement to exit if the serialized version
                //  is lower than the next batch of properties
                if (propInfo.Version > version)
                {
                    //  push versionParam
                    //  push propInfo.Version
                    //  branch_if_less_than endLabel    ; versionParam < propInfo.Version
                    args.il.PushArg(args.versionArg);
                    args.il.PushInt(propInfo.Version);
                    args.il.GotoIfLess(endLabel);

                    version = propInfo.Version;
                }

                args.il.BeginScope();

                //  If this property is marked obsolete, do not deserialize
                //  it if the data min version is equal to or greater than
                //  the version it was made obsolete in.
                if (propInfo.ObsoleteVersion > 0)
                {
                    const string NoHeaderLabel    = "_checkObsoleteNoHeader";
                    const string NotObsoleteLabel = "_notObsolete";

                    args.il.PushLocal(args.headerVar);
                    args.il.GotoIfFalse(NoHeaderLabel);

                    args.il.CallMethod(args.headerVar, typeof(TypeSerializationHeader).GetProperty("DataMinVersion").GetGetMethod());
                    args.il.PushInt(propInfo.ObsoleteVersion);
                    args.il.GotoIfGreaterOrEqual(SkipPropertyLabel);
                    args.il.Goto(NotObsoleteLabel);

                    args.il.MarkLabel(NoHeaderLabel);

                    args.il.PushArg(args.versionArg);
                    args.il.PushInt(propInfo.ObsoleteVersion);
                    args.il.GotoIfGreaterOrEqual(SkipPropertyLabel);

                    args.il.MarkLabel(NotObsoleteLabel);
                }

                propInfo.GenerateReadIL(args);
                args.il.MarkLabel(SkipPropertyLabel);
                args.il.EndScope();
            }

            //  :endFunction
            args.il.MarkLabel(endLabel);
            args.il.Return();

            this.autoDeserializeMethod = (AutoDeserializeMethod)args.il.Compile(typeof(AutoDeserializeMethod));
            this.deserializeMethod     = DeserializeAutoSerializable;
        }
Ejemplo n.º 22
0
 public static bool RegisterType(Type customType, byte code, SerializeMethod serializeMethod, DeserializeMethod constructor)
 {
     return(Protocol.TryRegisterType(customType, code, serializeMethod, constructor));
 }
Ejemplo n.º 23
0
        }                              // Dummy constructor

        public CustomType(Type type, byte code, SerializeMethod serializeFunction, DeserializeMethod deserializeFunction)
        {
        }                                                                                                                            // 0x00000001806ACFB0-0x00000001806AD020
Ejemplo n.º 24
0
 public object ProxyDeserialize(IJsonDict source)
 {
     return(DeserializeMethod.Invoke(this, new object[] { source }));
 }
Ejemplo n.º 25
0
 public bool RegisterSerializableType(Type customType, byte code, SerializeMethod serializeMethod, DeserializeMethod constructor)
 {
     return(PhotonPeer.RegisterType(customType, code, serializeMethod, constructor));
 }