コード例 #1
0
        /// <summary>
        /// Recupera o substituto para tratar o tipo.
        /// </summary>
        /// <param name="handle"></param>
        /// <param name="cacheContext"></param>
        /// <returns></returns>
        internal static ISerializationSurrogate GetSurrogateForTypeHandle(short handle, string cacheContext)
        {
            ISerializationSurrogate defaultSurrogate = null;

            if (handle < CUSTOM_TYPE_RANGE)
            {
                defaultSurrogate = (ISerializationSurrogate)handleSurrogateMap[handle];
            }
            else
            {
                Hashtable hashtable = (Hashtable)userTypeHandleSurrogateMap[cacheContext];
                if ((hashtable != null) && hashtable.Contains(handle))
                {
                    if (!(hashtable[handle] is ISerializationSurrogate))
                    {
                        return(null);
                    }
                    defaultSurrogate = (ISerializationSurrogate)hashtable[handle];
                }
            }
            if (defaultSurrogate == null)
            {
                defaultSurrogate = TypeSurrogateSelector.defaultSurrogate;
            }
            return(defaultSurrogate);
        }
コード例 #2
0
 internal Registration(double startVersion, Type targetType, ISerializationSurrogate surrogate)
 {
     this.startVersion = startVersion;
     this.endVersion   = Double.MaxValue;
     this.targetType   = targetType;
     this.surrogate    = surrogate;
 }
コード例 #3
0
        /// <summary>
        /// Deserializes an object from the specified compact binary writer.
        /// </summary>
        /// <param name="reader">Stream containing reader</param>
        /// <param name="cacheContext">Name of the cache</param>
        /// <param name="skip">True to skip the bytes returning null</param>
        static internal object Deserialize(CompactBinaryReader reader, string cacheContext, bool skip)
        {
            // read type handle
            short handle = reader.ReadInt16();

            reader.Context.CacheContext = cacheContext;
            // Find an appropriate surrogate by handle
            ISerializationSurrogate surrogate =
                TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, cacheContext);

            if (surrogate == null)
            {
                surrogate = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), cacheContext);
            }

            if (surrogate == null)
            {
                throw new CompactSerializationException("Type handle " + handle + "is not registered with Compact Serialization Framework");
            }
            if (!skip)
            {
                return(surrogate.Read(reader));
            }
            else
            {
                surrogate.Skip(reader);
                return(null);
            }
        }
コード例 #4
0
        /// <summary>
        /// Returns the surrogate for a particular type.
        /// </summary>
        ///
        /// <returns>The surrogate for a particular type.</returns>
        /// <param name="type">The <see cref="T:System.Type"/> for which the surrogate is
        /// requested.</param>
        /// <param name="context">The streaming context.</param>
        /// <param name="selector">The surrogate to use.</param>
        /// <exception cref="T:System.ArgumentNullException">The
        /// <paramref name="type"/>parameter is null.</exception>
        /// <exception cref="T:System.Security.SecurityException">The caller does not have the
        /// required permission.</exception>
        /// <PermissionSet><IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="SerializationFormatter"/></PermissionSet>
        public virtual ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type is null.");
            }

            Dictionary <StreamingContextStates, ISerializationSurrogate> surrogates;
            ISerializationSurrogate serializationSurrogate = null;

            if (_surrogates.TryGetValue(type, out surrogates))
            {
                surrogates.TryGetValue(context.State, out serializationSurrogate);
            }

            if (serializationSurrogate != null)
            {
                selector = this;
                return(serializationSurrogate);
            }

            else
            {
                if (_nextSelector != null)
                {
                    return(_nextSelector.GetSurrogate(type, context, out selector));
                }

                selector = null;
                return(null);
            }
        }
コード例 #5
0
 private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, string assemblyName)
 {
     if (objectType.IsArray)
     {
         this.arrayElemObjectInfo = Create(objectType.GetElementType(), surrogateSelector, context, this.objectManager, this.serObjectInfoInit, this.formatterConverter, assemblyName);
         this.typeAttributeInfo   = this.GetTypeAttributeInfo();
         this.InitNoMembers();
     }
     else
     {
         ISurrogateSelector selector = null;
         if (surrogateSelector != null)
         {
             this.serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out selector);
         }
         if (this.serializationSurrogate != null)
         {
             this.isSi = true;
         }
         else if (!(objectType == Converter.typeofObject) && Converter.typeofISerializable.IsAssignableFrom(objectType))
         {
             this.isSi = true;
         }
         if (this.isSi)
         {
             this.si = new SerializationInfo(objectType, this.formatterConverter);
             this.InitSiRead(assemblyName);
         }
         else
         {
             this.InitMemberInfo();
         }
     }
 }
コード例 #6
0
        /// <summary>
        /// this method will filter out any IList or IDictionary surrogate if already exists in userTypeMap
        /// </summary>
        /// <param name="type"></param>
        /// <param name="cacheContext"></param>
        /// <returns></returns>
        static internal ISerializationSurrogate CheckForListAndDictionaryTypes(Type type, string cacheContext)
        {
            ISerializationSurrogate surrogate = null;

            if (cacheContext != null)
            {
                Hashtable userTypeMap = (Hashtable)userTypeSurrogateMap[cacheContext];
                if (userTypeMap != null)
                {
                    Type listOrDictionaryType = null;
                    IDictionaryEnumerator ide = userTypeMap.GetEnumerator();
                    while (ide.MoveNext())
                    {
                        listOrDictionaryType = (Type)ide.Key;
                        if (listOrDictionaryType != null && listOrDictionaryType.FullName == typeof(IList <>).FullName && type.FullName == typeof(List <>).FullName)
                        {
                            surrogate = (ISerializationSurrogate)userTypeMap[listOrDictionaryType];
                            break;
                        }
                        if (listOrDictionaryType != null && listOrDictionaryType.FullName == typeof(IDictionary <,>).FullName && type.FullName == typeof(Dictionary <,>).FullName)
                        {
                            surrogate = (ISerializationSurrogate)userTypeMap[listOrDictionaryType];
                            break;
                        }
                    }
                }
            }
            return(surrogate);
        }
コード例 #7
0
        public override void Skip(CompactBinaryReader reader)
        {
            // read type handle
            short handle = reader.ReadInt16();

            // Find an appropriate surrogate by handle
            ISerializationSurrogate typeSurr = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, null);

            if (typeSurr == null)
            {
                typeSurr = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), reader.Context.CacheContext);
            }

            int length = reader.ReadInt32();

            T?[] array = new T?[length];
            while (true)
            {
                int index = reader.ReadInt32();
                if (index < 0)
                {
                    break;
                }

                typeSurr.Skip(reader);
            }
        }
コード例 #8
0
        /// <summary>
        /// Registra um tipo compacto.
        /// </summary>
        /// <param name="type"></param>
        public static void RegisterCompactType(Type type)
        {
            type.Require("type").NotNull();
            if (TypeSurrogateSelector.GetSurrogateForTypeStrict(type, null) != null)
            {
                throw new ArgumentException(ResourceMessageFormatter.Create(() => Properties.Resources.Argument_TypeAlreadyRegistered2, type.FullName).Format());
            }
            ISerializationSurrogate surrogate = null;

            if (typeof(IDictionary).IsAssignableFrom(type))
            {
                surrogate = new IDictionarySerializationSurrogate(type);
            }
            else if (type.IsArray)
            {
                surrogate = new ArraySerializationSurrogate(type);
            }
            else if (typeof(IList).IsAssignableFrom(type))
            {
                surrogate = new IListSerializationSurrogate(type);
            }
            else if (typeof(ICompactSerializable).IsAssignableFrom(type))
            {
                surrogate = new ICompactSerializableSerializationSurrogate(type);
            }
            else if (typeof(Enum).IsAssignableFrom(type))
            {
                surrogate = new EnumSerializationSurrogate(type);
            }
            if (surrogate == null)
            {
                throw new ArgumentException(ResourceMessageFormatter.Create(() => Properties.Resources.Argument_NoAppropriateSurrogateFound, type.FullName).Format());
            }
            TypeSurrogateSelector.RegisterTypeSurrogate(surrogate);
        }
コード例 #9
0
ファイル: CompactBinaryReader.cs プロジェクト: yaobos/NCache
        /// <summary>
        /// Reads an object of type <see cref="object"/> from the current stream
        /// and advances the stream position.
        /// </summary>
        /// <returns>object read from the stream</returns>
        public override object ReadObject()
        {
            // read type handle
            short handle = reader.ReadInt16();
            // Find an appropriate surrogate by handle
            ISerializationSurrogate surrogate =
                TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, context.CacheContext);

            object obj = null;

            try
            {
                obj = surrogate.Read(this);
            }
            catch (CompactSerializationException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new CompactSerializationException(e.Message, e);
            }

            return(obj);
        }
コード例 #10
0
        /// <summary>
        /// Finds and returns an appropriate <see cref="ISerializationSurrogate"/> for the given
        /// type handle.
        /// </summary>
        /// <param name="handle">type handle</param>
        /// <returns><see cref="ISerializationSurrogate"/>Object otherwise returns null if typeHandle is base Handle if Portable</returns>
        static internal ISerializationSurrogate GetSurrogateForTypeHandle(short handle, string cacheContext)
        {
            ISerializationSurrogate surrogate = null;

            if (handle < CUSTOM_TYPE_RANGE)
            {
                surrogate = (ISerializationSurrogate)handleSurrogateMap[handle];
            }
            else
            {
                Hashtable userTypeMap = (Hashtable)userTypeHandleSurrogateMap[cacheContext.ToLower()];
                if (userTypeMap != null)
                {
                    if (userTypeMap.Contains(handle))
                    {
                        if (userTypeMap[handle] is ISerializationSurrogate)
                        {
                            surrogate = (ISerializationSurrogate)userTypeMap[handle];
                        }
                        else
                        {
                            return(null);
                        }
                    }
                }
            }

            if (surrogate == null)
            {
                surrogate = defaultSurrogate;
            }
            return(surrogate);
        }
コード例 #11
0
        /// <summary>
        /// Skips an object of type <see cref="object"/> from the current stream
        /// and advances the stream position.
        /// </summary>
        public override void SkipObject()
        {
            // read type handle
            short handle = reader.ReadInt16();
            // Find an appropriate surrogate by handle
            ISerializationSurrogate surrogate =
                TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, context.CacheContext);

            if (surrogate == null)
            {
                surrogate = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), context.CacheContext);
            }

            //If surrogate not found, returns defaultSurrogate
            //if (surrogate == null) throw new CompactSerializationException("Type handle " + handle + " is not registered with Compact Serialization Framework");

            try
            {
                surrogate.Skip(this);
            }
            catch (CompactSerializationException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new CompactSerializationException(e.Message);
            }
        }
            private protected bool TryGetSurrogate(Type type, out ISerializationSurrogate surrogate, out ISurrogateSelector selector)
            {
                surrogate = null;
                selector  = null;
                if (surrogateSelector == null)
                {
                    return(false);
                }

                if (surrogates.TryGetValue(type, out KeyValuePair <ISerializationSurrogate, ISurrogateSelector> result))
                {
                    if (result.Key == null)
                    {
                        return(false);
                    }

                    surrogate = result.Key;
                    selector  = result.Value;
                    return(true);
                }

                DoGetSurrogate(type, out surrogate, out selector);
                surrogates[type] = new KeyValuePair <ISerializationSurrogate, ISurrogateSelector>(surrogate, selector);
                return(surrogate != null);
            }
コード例 #13
0
 internal SurrogateDataContractCriticalHelper(Type type, ISerializationSurrogate serializationSurrogate)
     : base(type)
 {
     _serializationSurrogate = serializationSurrogate;
     DataContract.GetDefaultStableName(DataContract.GetClrTypeFullName(type), out string name, out string ns);
     SetDataContractName(CreateQualifiedName(name, ns));
 }
コード例 #14
0
ファイル: Packet.cs プロジェクト: driesmeyers/Nitrox
        static Packet()
        {
            surrogateSelector = new SurrogateSelector();
            streamingContext  = new StreamingContext(StreamingContextStates.All); // Our surrogates can be safely used in every context.
            IEnumerable <Type> types = AppDomain.CurrentDomain.GetAssemblies()
                                       .SelectMany(a => a.GetTypes()
                                                   .Where(t =>
                                                          t.BaseType != null &&
                                                          t.BaseType.IsGenericType &&
                                                          t.BaseType.GetGenericTypeDefinition() == typeof(SerializationSurrogate <>) &&
                                                          t.IsClass &&
                                                          !t.IsAbstract));

            foreach (Type type in types)
            {
                ISerializationSurrogate surrogate = (ISerializationSurrogate)Activator.CreateInstance(type);
                Type surrogatedType = type.BaseType.GetGenericArguments()[0];
                surrogateSelector.AddSurrogate(surrogatedType, streamingContext, surrogate);

                Log.Debug("Added surrogate " + surrogate.GetType().Name + " for type " + surrogatedType);
            }

            // For completeness, we could pass a StreamingContextStates.CrossComputer.
            serializer = new BinaryFormatter(surrogateSelector, streamingContext);
        }
コード例 #15
0
        private void FixupSpecialObject(ObjectHolder holder)
        {
            ISurrogateSelector selector = null;

            if (holder.HasSurrogate)
            {
                ISerializationSurrogate surrogate = holder.Surrogate;
                object obj = surrogate.SetObjectData(holder.ObjectValue, holder.SerializationInfo, this.m_context, selector);
                if (obj != null)
                {
                    if (!holder.CanSurrogatedObjectValueChange && obj != holder.ObjectValue)
                    {
                        throw new SerializationException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_NotCyclicallyReferenceableSurrogate"), surrogate.GetType().FullName));
                    }
                    holder.SetObjectValue(obj, this);
                }
                holder.m_surrogate = null;
                holder.SetFlags();
            }
            else
            {
                this.CompleteISerializableObject(holder.ObjectValue, holder.SerializationInfo, this.m_context);
            }
            holder.SerializationInfo    = null;
            holder.RequiresSerInfoFixup = false;
            if (holder.RequiresValueTypeFixup && holder.ValueTypeFixupPerformed)
            {
                this.DoValueTypeFixup(null, holder, holder.ObjectValue);
            }
            this.DoNewlyRegisteredObjectFixups(holder);
        }
コード例 #16
0
        /// <summary>
        /// Writes <paramref name="graph"/> to the current stream and advances the stream position.
        /// </summary>
        /// <param name="graph">Object to write</param>
        public override void WriteObject(object graph)
        {
            // Find an appropriate surrogate for the object
            ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(graph, context.CacheContext);

            // write type handle
            writer.Write(surrogate.TypeHandle);
            try
            {
                surrogate.Write(this, graph);
            }
            catch (CompactSerializationException)
            {
                throw;
            }
            catch (System.Threading.ThreadAbortException)
            {
                throw;
            }
            catch (System.Threading.ThreadInterruptedException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new CompactSerializationException(e.Message);
            }
        }
コード例 #17
0
ファイル: ObjectHolder.cs プロジェクト: randomize/VimConfig
 internal ObjectHolder(object obj, long objID, System.Runtime.Serialization.SerializationInfo info, ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex)
 {
     this.m_object = obj;
     this.m_id = objID;
     this.m_flags = 0;
     this.m_missingElementsRemaining = 0;
     this.m_missingDecendents = 0;
     this.m_dependentObjects = null;
     this.m_next = null;
     this.m_serInfo = info;
     this.m_surrogate = surrogate;
     this.m_markForFixupWhenAvailable = false;
     if (obj is TypeLoadExceptionHolder)
     {
         this.m_typeLoad = (TypeLoadExceptionHolder) obj;
     }
     if ((idOfContainingObj != 0L) && (((field != null) && field.FieldType.IsValueType) || (arrayIndex != null)))
     {
         if (idOfContainingObj == objID)
         {
             throw new SerializationException(Environment.GetResourceString("Serialization_ParentChildIdentical"));
         }
         this.m_valueFixup = new ValueTypeFixupInfo(idOfContainingObj, field, arrayIndex);
     }
     this.SetFlags();
 }
コード例 #18
0
        /// <summary>
        /// Unregisters the surrogate for the Custom specified type that implements
        /// <see cref="ICompactSerializable"/> from the system.
        /// </summary>
        /// <param name="type">the specified type</param>
        static public void UnregisterCustomCompactType(Type type, string cacheContext)
        {
            throw new NotImplementedException();
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }
            if (cacheContext == null)
            {
                throw new ArgumentException("cacheContext can not be null");
            }

            if (TypeSurrogateSelector.GetSurrogateForTypeStrict(type, cacheContext) == null)
            {
                return;
            }

            if (type.IsArray ||
                //typeof(IDictionary).IsAssignableFrom(type) ||
                //typeof(IList).IsAssignableFrom(type) ||
                typeof(Dictionary <,>).Equals(type) ||
                typeof(List <>).Equals(type) ||
                typeof(ICompactSerializable).IsAssignableFrom(type) ||
                typeof(Enum).IsAssignableFrom(type))
            {
                ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForTypeStrict(type, cacheContext);
                TypeSurrogateSelector.UnregisterTypeSurrogate(surrogate, cacheContext);
                System.Diagnostics.Debug.WriteLine("Unregistered surrogate for type " + type.FullName);
            }
        }
コード例 #19
0
        public override void WriteDirect(CompactBinaryWriter writer, object graph)
        {
            object[] array = (object[])graph;
            writer.Write(array.Length);

            if (!typeof(object[]).Equals(graph.GetType()))
            {
                object obj = null;
                for (int i = 0; i < array.Length; i++)
                {
                    if (array[i] != null)
                    {
                        obj = array[i];
                        break;
                    }
                }
                ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(obj, writer.CacheContext);
                writer.Write(surrogate.TypeHandle);
                if (surrogate.SubTypeHandle > 0)
                {
                    writer.Write(surrogate.SubTypeHandle);
                }
            }
            else
            {
                ISerializationSurrogate surrogate = TypeSurrogateSelector.GetSurrogateForObject(new object(), writer.CacheContext);
                writer.Write(surrogate.TypeHandle);
            }

            for (int i = 0; i < array.Length; i++)
            {
                writer.WriteObject(array[i]);
            }
        }
コード例 #20
0
        private static T FormatterClone <T>(
            T obj,
            ISerializationSurrogate surrogate     = null,
            FormatterAssemblyStyle assemblyFormat = FormatterAssemblyStyle.Full,
            TypeFilterLevel filterLevel           = TypeFilterLevel.Full,
            FormatterTypeStyle typeFormat         = FormatterTypeStyle.TypesAlways)
        {
            BinaryFormatter f;

            if (surrogate == null)
            {
                f = new BinaryFormatter();
            }
            else
            {
                var c = new StreamingContext();
                var s = new SurrogateSelector();
                s.AddSurrogate(obj.GetType(), c, surrogate);
                f = new BinaryFormatter(s, c);
            }
            f.AssemblyFormat = assemblyFormat;
            f.FilterLevel    = filterLevel;
            f.TypeFormat     = typeFormat;

            using (var s = new MemoryStream())
            {
                f.Serialize(s, obj);
                Assert.NotEqual(0, s.Position);
                s.Position = 0;
                return((T)(f.Deserialize(s)));
            }
        }
コード例 #21
0
        public override void Skip(CompactBinaryReader reader)
        {
            ISerializationSurrogate decimalSurrogate = TypeSurrogateSelector.GetSurrogateForType(typeof(decimal), null);

            decimalSurrogate.Skip(reader);
            decimalSurrogate.Skip(reader);
        }
コード例 #22
0
        /// <summary>
        /// Skips an object of type <see cref="object"/> from the current stream
        /// and advances the stream position.
        /// </summary>
        public override void SkipObject()
        {
            // read type handle
            short handle = reader.ReadInt16();
            // Find an appropriate surrogate by handle
            ISerializationSurrogate surrogate =
                TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, context.CacheContext);

            if (surrogate == null)
            {
                surrogate = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, reader.ReadInt16(), context.CacheContext);
            }


            try
            {
                surrogate.Skip(this);
            }
            catch (CompactSerializationException)
            {
                throw;
            }
            catch (Exception e)
            {
                throw new CompactSerializationException(e.Message);
            }
        }
コード例 #23
0
        public virtual ISerializationSurrogate GetSurrogate(Type type,
                                                            StreamingContext context, out ISurrogateSelector selector)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type is null.");
            }

            // Check this selector, and if the surrogate is not found,
            // check the chained selectors

            string key = type.FullName + "#" + context.ToString();
            ISerializationSurrogate surrogate = (ISerializationSurrogate)Surrogates [key];

            if (surrogate != null)
            {
                selector = this;
                return(surrogate);
            }

            if (nextSelector != null)
            {
                return(nextSelector.GetSurrogate(type, context, out selector));
            }
            else
            {
                selector = null;
                return(null);
            }
        }
コード例 #24
0
ファイル: BinaryObjectInfo.cs プロジェクト: rsumner31/corefx2
        private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context)
        {
            if (objectType.IsArray)
            {
                InitNoMembers();
                return;
            }

            ISurrogateSelector surrogateSelectorTemp = null;

            if (surrogateSelector != null)
            {
                _serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);
            }

            if (_serializationSurrogate != null)
            {
                _isSi = true;
            }
            else if (!ReferenceEquals(objectType, Converter.s_typeofObject) && Converter.s_typeofISerializable.IsAssignableFrom(objectType))
            {
                _isSi = true;
            }

            if (_isSi)
            {
                InitSiRead();
            }
            else
            {
                InitMemberInfo();
            }
        }
コード例 #25
0
        static Packet()
        {
            surrogateSelector = new SurrogateSelector();
            streamingContext  = new StreamingContext(StreamingContextStates.All); // Our surrogates can be safely used in every context.

            Type[] types = Assembly.GetExecutingAssembly()
                           .GetTypes();

            types.Where(t =>
                        t.BaseType != null &&
                        t.BaseType.IsGenericType &&
                        t.BaseType.GetGenericTypeDefinition() == typeof(SerializationSurrogate <>) &&
                        t.IsClass &&
                        !t.IsAbstract)
            .ForEach(t =>
            {
                ISerializationSurrogate surrogate = (ISerializationSurrogate)Activator.CreateInstance(t);
                Type surrogatedType = t.BaseType.GetGenericArguments()[0];
                surrogateSelector.AddSurrogate(surrogatedType, streamingContext, surrogate);

                Log.Debug("Added surrogate " + surrogate + " for type " + surrogatedType);
            });

            // For completeness, we could pass a StreamingContextStates.CrossComputer.
            Serializer = new BinaryFormatter(surrogateSelector, streamingContext);
        }
コード例 #26
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public override object ReadObject()
        {
            short handle = _reader.ReadInt16();
            ISerializationSurrogate surrogateForTypeHandle = TypeSurrogateSelector.GetSurrogateForTypeHandle(handle, _context.CacheContext);

            if (surrogateForTypeHandle == null)
            {
                surrogateForTypeHandle = TypeSurrogateSelector.GetSurrogateForSubTypeHandle(handle, _reader.ReadInt16(), _context.CacheContext);
            }
            object obj2 = null;

            try
            {
                obj2 = surrogateForTypeHandle.Read(this);
            }
            catch (CompactSerializationException)
            {
                throw;
            }
            catch (Exception exception)
            {
                throw new CompactSerializationException(exception.Message);
            }
            return(obj2);
        }
コード例 #27
0
 internal ObjectHolder(object obj, long objID, System.Runtime.Serialization.SerializationInfo info, ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex)
 {
     this.m_object = obj;
     this.m_id     = objID;
     this.m_flags  = 0;
     this.m_missingElementsRemaining = 0;
     this.m_missingDecendents        = 0;
     this.m_dependentObjects         = null;
     this.m_next      = null;
     this.m_serInfo   = info;
     this.m_surrogate = surrogate;
     this.m_markForFixupWhenAvailable = false;
     if (obj is TypeLoadExceptionHolder)
     {
         this.m_typeLoad = (TypeLoadExceptionHolder)obj;
     }
     if ((idOfContainingObj != 0L) && (((field != null) && field.FieldType.IsValueType) || (arrayIndex != null)))
     {
         if (idOfContainingObj == objID)
         {
             throw new SerializationException(Environment.GetResourceString("Serialization_ParentChildIdentical"));
         }
         this.m_valueFixup = new ValueTypeFixupInfo(idOfContainingObj, field, arrayIndex);
     }
     this.SetFlags();
 }
コード例 #28
0
ファイル: SoapWriter.cs プロジェクト: pmq20/mono_forked
        private void SerializeObject(object currentObject, long currentObjectId)
        {
            bool needsSerializationInfo = false;
            ISurrogateSelector      selector;
            ISerializationSurrogate surrogate = null;

            if (_surrogateSelector != null)
            {
                surrogate = _surrogateSelector.GetSurrogate(
                    currentObject.GetType(),
                    _context,
                    out selector);
            }
            if (currentObject is ISerializable || surrogate != null)
            {
                needsSerializationInfo = true;
            }

#if NET_2_0 && !TARGET_JVM
            _manager.RegisterObject(currentObject);
#endif

            if (needsSerializationInfo)
            {
                SerializeISerializableObject(currentObject, currentObjectId, surrogate);
            }
            else
            {
                if (!currentObject.GetType().IsSerializable)
                {
                    throw new SerializationException(String.Format("Type {0} in assembly {1} is not marked as serializable.", currentObject.GetType(), currentObject.GetType().Assembly.FullName));
                }
                SerializeSimpleObject(currentObject, currentObjectId);
            }
        }
コード例 #29
0
 private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context)
 {
     if (objectType.IsArray)
     {
         this.InitNoMembers();
     }
     else
     {
         ISurrogateSelector selector = null;
         if (surrogateSelector != null)
         {
             this.serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out selector);
         }
         if (this.serializationSurrogate != null)
         {
             this.isSi = true;
         }
         else if (!object.ReferenceEquals(objectType, Converter.typeofObject) && Converter.typeofISerializable.IsAssignableFrom(objectType))
         {
             this.isSi = true;
         }
         if (this.isSi)
         {
             this.InitSiRead();
         }
         else
         {
             this.InitMemberInfo();
         }
     }
 }
 internal SurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
 {
     if (innerSurrogate == null)
     {
         throw new ArgumentNullException("innerSurrogate");
     }
     this.innerSurrogate = innerSurrogate;
 }
コード例 #31
0
        public void GetSurrogateForCyclicalReference_ValidSurrogate_GetsObject()
        {
            var surrogate = new NonSerializablePairSurrogate();
            ISerializationSurrogate newSurrogate = FormatterServices.GetSurrogateForCyclicalReference(surrogate);

            Assert.NotNull(newSurrogate);
            Assert.NotSame(surrogate, newSurrogate);
        }
コード例 #32
0
ファイル: CompactBinaryReader.cs プロジェクト: yaobos/NCache
        public override void SkipObjectAs <T>()
        {
            // Find an appropriate surrogate by type
            ISerializationSurrogate surrogate =
                TypeSurrogateSelector.GetSurrogateForType(typeof(T), context.CacheContext);

            surrogate.Skip(this);
        }
コード例 #33
0
ファイル: surrogateselector.cs プロジェクト: ArildF/masters
     // Adds a surrogate to the list of surrogates checked.
     /// <include file='doc\SurrogateSelector.uex' path='docs/doc[@for="SurrogateSelector.AddSurrogate"]/*' />
     public virtual void AddSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate) {
         if (type==null) {
             throw new ArgumentNullException("type");
         }
         if (surrogate==null) {
             throw new ArgumentNullException("surrogate");
         }
 
         SurrogateKey key = new SurrogateKey(type, context);
         m_surrogates.Add(key, surrogate);  // Hashtable does duplicate checking.
     }
コード例 #34
0
        /// <summary>
        /// Adds a surrogate to the list of checked surrogates.
        /// </summary>
        /// <param name="type">The <see cref="T:System.Type"/> for which the surrogate is
        /// required.</param>
        /// <param name="context">The context-specific data.</param>
        /// <param name="surrogate">The surrogate to call for this type.</param>
        /// <exception cref="T:System.ArgumentNullException">The
        /// <paramref name="type"/>or
        /// <paramref name="surrogate"/>parameter is null.</exception>
        /// <exception cref="T:System.ArgumentException">A surrogate already exists for this type
        /// and context.</exception>
        public virtual void AddSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate) {
            if (type == null || surrogate == null)
                throw new ArgumentNullException("Null reference.");

            if (_surrogates.ContainsKey(type)) {
                throw new ArgumentException("A surrogate for " + type + " already exists.");
            }

            if (_surrogates.ContainsKey(type) == false) {
                _surrogates[type] = new Dictionary<StreamingContextStates, ISerializationSurrogate>();
            }
            _surrogates[type][context.State] = surrogate;
        }
コード例 #35
0
ファイル: SurrogateSelector.cs プロジェクト: jack-pappas/mono
		// Methods
		public virtual void AddSurrogate (Type type,
			  StreamingContext context, ISerializationSurrogate surrogate)
		{
			if (type == null || surrogate == null)
				throw new ArgumentNullException ("Null reference.");

			string currentKey = type.FullName + "#" + context.ToString ();

			if (Surrogates.ContainsKey (currentKey))
				throw new ArgumentException ("A surrogate for " + type.FullName + " already exists.");

			Surrogates.Add (currentKey, surrogate);
		}
コード例 #36
0
        /// <summary>
        /// Constructs a new <see cref="DotNetSerializationSurrogateSurrogate"/>.
        /// </summary>
        /// <param name="context"><see cref="FudgeContext"/> to use.</param>
        /// <param name="typeData"><see cref="TypeData"/> for the type for this surrogate.</param>
        /// <param name="surrogate">Surrogate that maps the object to or from a <see cref="SerializationInfo"/>.</param>
        /// <param name="selector">Selector that produced the surrogate.</param>
        public DotNetSerializationSurrogateSurrogate(FudgeContext context, TypeData typeData, ISerializationSurrogate surrogate, ISurrogateSelector selector)
        {
            if (context == null)
                throw new ArgumentNullException("context");
            if (typeData == null)
                throw new ArgumentNullException("typeData");
            if (surrogate == null)
                throw new ArgumentNullException("surrogate");
            // Don't care if selector is null

            this.helper = new SerializationInfoMixin(context, typeData.Type, new BeforeAfterSerializationMixin(context, typeData));
            this.surrogate = surrogate;
            this.selector = selector;
        }
コード例 #37
0
		/// <summary>
		/// Registers a surrogate for a given type, from a given recording version on.
		/// </summary>
		public void RegisterSurrogate(double version, Type targetType, ISerializationSurrogate surrogate)
		{
			#region Check preconditions
			if (targetType == null) throw new ArgumentNullException("targetType");
			if (surrogate == null) throw new ArgumentNullException("surrogate");
			#endregion Check preconditions

			// Check that no surrogate conflicts:
			foreach (Registration reg in register)
			{
				if (reg.MatchesTypeAndVersion(targetType, version))
				{
					throw new InvalidOperationException("The SerializationSurrogate conflicts with an already registered surrogate for same version and target type.");
				}
			}
			// Register surrogate:
			register.Add(new Registration(version, targetType, surrogate));
		}
コード例 #38
0
        public static void AddSurrogate(Type type,ISerializationSurrogate surrogate)
        {
            if(__surrogateSelector==null){

                __surrogateSelector=new SurrogateSelector();

                __streamingContext=new StreamingContext();

            }

            ISurrogateSelector surrogateExist=null;

            __surrogateSelector.GetSurrogate (type, __streamingContext,out surrogateExist);

            if(surrogateExist==null)

                __surrogateSelector.AddSurrogate(type,__streamingContext, surrogate);
        }
コード例 #39
0
ファイル: ObjectHolder.cs プロジェクト: randomize/VimConfig
 internal ObjectHolder(string obj, long objID, System.Runtime.Serialization.SerializationInfo info, ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex)
 {
     this.m_object = obj;
     this.m_id = objID;
     this.m_flags = 0;
     this.m_missingElementsRemaining = 0;
     this.m_missingDecendents = 0;
     this.m_dependentObjects = null;
     this.m_next = null;
     this.m_serInfo = info;
     this.m_surrogate = surrogate;
     this.m_markForFixupWhenAvailable = false;
     if ((idOfContainingObj != 0L) && (arrayIndex != null))
     {
         this.m_valueFixup = new ValueTypeFixupInfo(idOfContainingObj, field, arrayIndex);
     }
     if (this.m_valueFixup != null)
     {
         this.m_flags |= 8;
     }
 }
コード例 #40
0
ファイル: objectmanager.cs プロジェクト: ArildF/masters
        internal ObjectHolder(String obj, long objID, SerializationInfo info, 
                              ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex) {
            BCLDebug.Assert(objID>=0,"objID>=0");
            
            m_object=obj; //May be null;
            m_id=objID;
    
            m_flags=0;
            m_missingElementsRemaining=0;
            m_missingDecendents = 0;
            m_dependentObjects=null;
            m_next=null;
            
            m_serInfo = info;
            m_surrogate = surrogate;
            m_markForFixupWhenAvailable = false;

            if (idOfContainingObj!=0 && arrayIndex!=null) {
                m_valueFixup = new ValueTypeFixupInfo(idOfContainingObj, field, arrayIndex);
            }

            if (m_valueFixup!=null) {
                m_flags|=REQUIRES_VALUETYPE_FIXUP;
            }
        }
コード例 #41
0
ファイル: objectmanager.cs プロジェクト: ArildF/masters
        internal ObjectHolder(Object obj, long objID, SerializationInfo info, 
                              ISerializationSurrogate surrogate, long idOfContainingObj, FieldInfo field, int[] arrayIndex) {
            BCLDebug.Assert(objID>=0,"objID>=0");
            
            m_object=obj; //May be null;
            m_id=objID;
    
            m_flags=0;
            m_missingElementsRemaining=0;
            m_missingDecendents = 0;
            m_dependentObjects=null;
            m_next=null;
            
            m_serInfo = info;
            m_surrogate = surrogate;
            m_markForFixupWhenAvailable = false;


            if (idOfContainingObj!=0 && ((field!=null && field.FieldType.IsValueType) || arrayIndex!=null)) {
                if (idOfContainingObj == objID) {
                    throw new SerializationException(Environment.GetResourceString("Serialization_ParentChildIdentical"));
                }

                m_valueFixup = new ValueTypeFixupInfo(idOfContainingObj, field, arrayIndex);
            }

            SetFlags();
        }
コード例 #42
0
ファイル: SerializationUtil.cs プロジェクト: vc3/Amnesia
        /// <summary>
        /// Wraps an ISerializationSurrogate surrogate with special one to enable cyclical references during serialization
        /// if hotfix http://support.microsoft.com/kb/931634, or later is installed.  Wrapping the surrogate
        /// should fix the "The object with ID X was referenced in a fixup but does not exist." error that occurs during
        /// deserialization.
        /// </summary>
        public static ISerializationSurrogate EnableCyclicalReferences(ISerializationSurrogate surrogate)
        {
            // Look for the FormatterServices.GetSurrogateForCyclicalReference() method
            // This method cannot be called directly because it may not exist in all environments and currently
            // only exists on the Server-version of Windows.
            foreach (MethodInfo method in typeof(FormatterServices).GetMethods(BindingFlags.Public | BindingFlags.Static))
            {
                if (method.Name == "GetSurrogateForCyclicalReference")
                {
                    return (ISerializationSurrogate)method.Invoke(null, new object[] { surrogate });
                }
            }

            return surrogate;
        }
コード例 #43
0
        [System.Security.SecurityCritical]  // auto-generated
        internal void InitSerialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder)
        {

            SerTrace.Log( this, objectInfoId," Constructor 2 ",objectType);

            this.objectType = objectType;
            this.context = context;
            this.serObjectInfoInit = serObjectInfoInit;

            if (objectType.IsArray)
            {
                InitNoMembers();
                return;
            }

            InvokeSerializationBinder(binder);

            ISurrogateSelector surrogateSelectorTemp = null;

            if (surrogateSelector!=null)
                serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);

            if (serializationSurrogate != null)
            {
                // surrogate does not have this problem since user has pass in through the BF's ctor
                si = new SerializationInfo(objectType, converter);
                cache = new SerObjectInfoCache(objectType);

                isSi = true;
            }
            else if (Object.ReferenceEquals(objectType, Converter.typeofObject))
            {
            }
            else if (Converter.typeofISerializable.IsAssignableFrom(objectType))
            {
                si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
                cache = new SerObjectInfoCache(objectType);
                CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);

                isSi = true;
            }

            if (!isSi)
            {
                InitMemberInfo();
                CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
            }

            SerTrace.Log( this,objectInfoId," ", objectType," InitSerialize Exit ",isSi);
        }
コード例 #44
0
	// Add a surrogate for a specific type.
	public virtual void AddSurrogate(Type type, StreamingContext context,
									 ISerializationSurrogate surrogate)
			{
				if(type == null)
				{
					throw new ArgumentNullException("type");
				}
				if(surrogate == null)
				{
					throw new ArgumentNullException("surrogate");
				}
				table.Add(new KeyInfo(type, context), surrogate);
			}
コード例 #45
0
 internal SurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
 {
     Debug.Assert(innerSurrogate != null);
     _innerSurrogate = innerSurrogate;
 }
 public virtual new void AddSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate)
 {
 }
 internal SurrogateDataContract(Type type, ISerializationSurrogate serializationSurrogate) : base(new SurrogateDataContractCriticalHelper(type, serializationSurrogate))
 {
     this.helper = base.Helper as SurrogateDataContractCriticalHelper;
 }
コード例 #48
0
ファイル: ObjectHolder.cs プロジェクト: randomize/VimConfig
 internal void UpdateData(object obj, System.Runtime.Serialization.SerializationInfo info, ISerializationSurrogate surrogate, long idOfContainer, FieldInfo field, int[] arrayIndex, ObjectManager manager)
 {
     this.SetObjectValue(obj, manager);
     this.m_serInfo = info;
     this.m_surrogate = surrogate;
     if ((idOfContainer != 0L) && (((field != null) && field.FieldType.IsValueType) || (arrayIndex != null)))
     {
         if (idOfContainer == this.m_id)
         {
             throw new SerializationException(Environment.GetResourceString("Serialization_ParentChildIdentical"));
         }
         this.m_valueFixup = new ValueTypeFixupInfo(idOfContainer, field, arrayIndex);
     }
     this.SetFlags();
     if (this.RequiresValueTypeFixup)
     {
         this.UpdateDescendentDependencyChain(this.m_missingElementsRemaining, manager);
     }
 }
 internal SurrogateDataContractCriticalHelper(Type type, ISerializationSurrogate serializationSurrogate) : base(type)
 {
     string str;
     string str2;
     this.serializationSurrogate = serializationSurrogate;
     DataContract.GetDefaultStableName(DataContract.GetClrTypeFullName(type), out str, out str2);
     base.SetDataContractName(DataContract.CreateQualifiedName(str, str2));
 }
コード例 #50
0
 public virtual void UseSoapFormat()
 {
     _messageSurrogate = new SoapMessageSurrogate(this);
     ((SoapMessageSurrogate)_messageSurrogate).SetRootObject(_rootObj);
 }
コード例 #51
0
        [System.Security.SecurityCritical]  // auto-generated
        private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context)
        {
            SerTrace.Log( this,objectInfoId," ", objectType," InitReadConstructor Entry ",objectType);

            if (objectType.IsArray)
            {
                InitNoMembers();
                return;
            }

            ISurrogateSelector surrogateSelectorTemp = null;

            if (surrogateSelector!=null)
                serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);

            if (serializationSurrogate != null)
            {
                isSi = true;
            }
            else if (Object.ReferenceEquals(objectType, Converter.typeofObject))
            {
            }
            else if (Converter.typeofISerializable.IsAssignableFrom(objectType))
                isSi = true;

            if (isSi)
            {
                InitSiRead();
            }
            else
            {
                InitMemberInfo();
            }
            SerTrace.Log( this,objectInfoId," ", objectType," InitReadConstructor Exit ",isSi);
        }
コード例 #52
0
ファイル: objectmanager.cs プロジェクト: ArildF/masters
        /*==================================UpdateData==================================
        **Action: Update the data in the object holder.  This should be called when the object
        **        is finally registered.  Presumably the ObjectHolder was created to track 
        **        some dependencies or preregistered fixups and we now need to actually record the
        **        object and other associated data.  We take this opportunity to set the flags
        **        so that we can do some faster processing in the future.
        **Returns: void
        **Arguments: obj -- The object being held by this object holder. (This should no longer be null).
        **           info --The SerializationInfo associated with this object, only required if we're doing delayed fixups.
        **           surrogate -- The surrogate handling this object.  May be null.
        **           idOfContainer -- The id of the object containing this one if this is a valuetype.
        **           member -- the MemberInfo of this object's position in it's container if this is a valuetype.
        **           manager -- the ObjectManager being used to track these ObjectHolders.
        **Exceptions: None. Asserts only.
        ==============================================================================*/
        internal virtual void UpdateData(Object obj, SerializationInfo info, ISerializationSurrogate surrogate, long idOfContainer, FieldInfo field, int[] arrayIndex, ObjectManager manager) {
            BCLDebug.Assert(obj!=null,"obj!=null");
            BCLDebug.Assert(m_id>0,"m_id>0");
    
            //Record the fields that we can.
            SetObjectValue(obj, manager);
            m_serInfo = info;
            m_surrogate = surrogate;

            if (idOfContainer!=0 && ((field!=null && field.FieldType.IsValueType) || arrayIndex!=null)) {
                if (idOfContainer == m_id) {
                    throw new SerializationException(Environment.GetResourceString("Serialization_ParentChildIdentical"));
                }
                m_valueFixup = new ValueTypeFixupInfo(idOfContainer, field, arrayIndex);
            }

            SetFlags();
            
            if (RequiresValueTypeFixup) {
                UpdateDescendentDependencyChain(m_missingElementsRemaining, manager);
            }
        }
コード例 #53
0
 public static ISerializationSurrogate GetSurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
 {
     if (innerSurrogate == null)
     {
         throw new ArgumentNullException(nameof(innerSurrogate));
     }
     return new SurrogateForCyclicalReference(innerSurrogate);
 }
コード例 #54
0
ファイル: PUtil.cs プロジェクト: malacandrian/Piccolo.NET
		/// <summary>
		/// Adds a surrogate to the framework surrogate selector.
		/// </summary>
		/// <param name="type">The <see cref="Type"/> for which the surrogate is required.</param>
		/// <param name="context">The context-specific data.</param>
		/// <param name="surrogate">The surrogate to call for this type.</param>
		/// <remarks>
		/// Surrogates that are added in this way will be used by the piccolo framework for cloning
		/// operations.  For example, if several custom nodes reference a type that is not serializable,
		/// you might want to add a surrogate here for that type.  Alternatively, you could override
		/// <see cref="PNode.GetObjectData"/> in each custom node and specify how to serialize the type
		/// there. 
		/// </remarks>
		public static void AddFrameworkSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate) {
			FrameworkSurrogateSelector.AddSurrogate(type, context, surrogate);
		}
コード例 #55
0
		public static ISerializationSurrogate GetSurrogateForCyclicalReference (ISerializationSurrogate innerSurrogate)
		{
			return innerSurrogate;
		}
コード例 #56
0
ファイル: BinaryObjectInfo.cs プロジェクト: dotnet/corefx
        private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context)
        {
            if (objectType.IsArray)
            {
                InitNoMembers();
                return;
            }

            ISurrogateSelector surrogateSelectorTemp = null;
            if (surrogateSelector != null)
            {
                _serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);
            }

            if (_serializationSurrogate != null)
            {
                _isSi = true;
            }
            else if (!ReferenceEquals(objectType, Converter.s_typeofObject) && Converter.s_typeofISerializable.IsAssignableFrom(objectType))
            {
                _isSi = true;
            }

            if (_isSi)
            {
                InitSiRead();
            }
            else
            {
                InitMemberInfo();
            }
        }
コード例 #57
0
 public RemotingSurrogateSelector()
 {
     _messageSurrogate = new MessageSurrogate(this);
 }
コード例 #58
0
ファイル: BinaryObjectInfo.cs プロジェクト: dotnet/corefx
        // Write Constructor used for array types or null members
        internal void InitSerialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder)
        {
            _objectType = objectType;
            _context = context;
            _serObjectInfoInit = serObjectInfoInit;

            if (objectType.IsArray)
            {
                InitNoMembers();
                return;
            }

            InvokeSerializationBinder(binder);

            ISurrogateSelector surrogateSelectorTemp = null;
            if (surrogateSelector != null)
            {
                _serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);
            }

            if (_serializationSurrogate != null)
            {
                // surrogate does not have this problem since user has pass in through the BF's ctor
                _si = new SerializationInfo(objectType, converter);
                _cache = new SerObjectInfoCache(objectType);
                _isSi = true;
            }
            else if (!ReferenceEquals(objectType, Converter.s_typeofObject) && Converter.s_typeofISerializable.IsAssignableFrom(objectType))
            {
                _si = new SerializationInfo(objectType, converter);
                _cache = new SerObjectInfoCache(objectType);
                CheckTypeForwardedFrom(_cache, objectType, _binderAssemblyString);
                _isSi = true;
            }

            if (!_isSi)
            {
                InitMemberInfo();
                CheckTypeForwardedFrom(_cache, objectType, _binderAssemblyString);
            }
        }
コード例 #59
0
ファイル: BinaryObjectInfo.cs プロジェクト: dotnet/corefx
        // Write constructor
        internal void InitSerialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
        {
            _context = context;
            _obj = obj;
            _serObjectInfoInit = serObjectInfoInit;
            _objectType = obj.GetType();

            if (_objectType.IsArray)
            {
                _isArray = true;
                InitNoMembers();
                return;
            }

            InvokeSerializationBinder(binder);
            objectWriter.ObjectManager.RegisterObject(obj);

            ISurrogateSelector surrogateSelectorTemp;
            if (surrogateSelector != null && (_serializationSurrogate = surrogateSelector.GetSurrogate(_objectType, context, out surrogateSelectorTemp)) != null)
            {
                _si = new SerializationInfo(_objectType, converter);
                if (!_objectType.IsPrimitive)
                {
                    _serializationSurrogate.GetObjectData(obj, _si, context);
                }
                InitSiWrite();
            }
            else if (obj is ISerializable)
            {
                if (!_objectType.IsSerializable)
                {
                    throw new SerializationException(SR.Format(SR.Serialization_NonSerType, _objectType.FullName, _objectType.Assembly.FullName));
                }
                _si = new SerializationInfo(_objectType, converter);
                ((ISerializable)obj).GetObjectData(_si, context);
                InitSiWrite();
                CheckTypeForwardedFrom(_cache, _objectType, _binderAssemblyString);
            }
            else
            {
                InitMemberInfo();
                CheckTypeForwardedFrom(_cache, _objectType, _binderAssemblyString);
            }
        }
コード例 #60
0
        [System.Security.SecurityCritical]  // auto-generated
        internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
        {
            SerTrace.Log( this, objectInfoId," Constructor 1 ",obj);
            this.context = context;
            this.obj = obj;
            this.serObjectInfoInit = serObjectInfoInit;
            ISurrogateSelector surrogateSelectorTemp;

#if  FEATURE_REMOTING        
            if (RemotingServices.IsTransparentProxy(obj))
                objectType = Converter.typeofMarshalByRefObject;
            else
#endif
                objectType = obj.GetType();

            if (objectType.IsArray)
            {
                isArray = true;
                InitNoMembers();
                return;
            }

            InvokeSerializationBinder(binder);

            SerTrace.Log( this, objectInfoId," Constructor 1 trace 2");

            objectWriter.ObjectManager.RegisterObject(obj);
            if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null)
            {
                SerTrace.Log( this, objectInfoId," Constructor 1 trace 3");
                si = new SerializationInfo(objectType, converter);
                if (!objectType.IsPrimitive)
                    serializationSurrogate.GetObjectData(obj, si, context);
                InitSiWrite();
            }
            else if (obj is ISerializable)
            {
                if (!objectType.IsSerializable) {
                    throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType",
                                                                   objectType.FullName, objectType.Assembly.FullName));
                }
                si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled());
#if FEATURE_SERIALIZATION
                ((ISerializable)obj).GetObjectData(si, context);
#endif
                SerTrace.Log( this, objectInfoId," Constructor 1 trace 4 ISerializable "+objectType);
                InitSiWrite();
                CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
            }
            else
            {
                SerTrace.Log(this, objectInfoId," Constructor 1 trace 5");
                InitMemberInfo();
                CheckTypeForwardedFrom(cache, objectType, binderAssemblyString);
            }
        }