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();
 }

 internal SurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
 {
     if (innerSurrogate == null)
     {
         throw new ArgumentNullException("innerSurrogate");
     }
     this.innerSurrogate = innerSurrogate;
 }

     // 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.
     }

        /// <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;
        }

		// 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);
		}

        /// <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;
        }

        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);
        }

		/// <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));
		}

 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);
     }
 }

 public static ISerializationSurrogate GetSurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
 {
     if (innerSurrogate == null)
     {
         throw new ArgumentNullException(nameof(innerSurrogate));
     }
     return new SurrogateForCyclicalReference(innerSurrogate);
 }

        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;
            }
        }

        /// <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;
        }

	// 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);
			}

 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));
 }

 internal SurrogateDataContract(Type type, ISerializationSurrogate serializationSurrogate) : base(new SurrogateDataContractCriticalHelper(type, serializationSurrogate))
 {
     this.helper = base.Helper as SurrogateDataContractCriticalHelper;
 }

 public virtual new void AddSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate)
 {
 }

		public static ISerializationSurrogate GetSurrogateForCyclicalReference (ISerializationSurrogate innerSurrogate)
		{
			return innerSurrogate;
		}

		/// <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);
		}

        /*==================================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);
            }
        }

 internal SurrogateForCyclicalReference(ISerializationSurrogate innerSurrogate)
 {
     Debug.Assert(innerSurrogate != null);
     _innerSurrogate = innerSurrogate;
 }