C# SerializationInfo.AddChild方法代码示例

 void IMobileObject.GetChildren(SerializationInfo info, MobileFormatter formatter)
 {
   foreach (string key in this.Keys)
   {
     object value = this[key];
     IMobileObject mobile = value as IMobileObject;
     if (mobile != null)
     {
       SerializationInfo si = formatter.SerializeObject(mobile);
       info.AddChild(key, si.ReferenceId);
     }
   }
 }

		/// <summary>
		/// Read a data from a stream, typically MemoryStream, and convert it into 
		/// a list of SerializationInfo objects
		/// </summary>
		/// <param name="serializationStream">Stream to read the data from</param>
		/// <returns>List of SerializationInfo objects</returns>
		public List<SerializationInfo> Read(Stream serializationStream)
		{
			var returnValue = new List<SerializationInfo>();
			int childCount, valueCount, referenceId;
			string systemName, enumTypeName;
			bool isDirty;
			object value;
			keywordsDictionary.Clear();
			using (var reader = new BinaryReader(serializationStream))
			{
				int totalCount = reader.ReadInt32();
				for (int counter = 0; counter < totalCount; counter++)
				{
					var info = new SerializationInfo();
					info.ReferenceId = reader.ReadInt32();
					info.TypeName = (string)ReadObject(reader);

					childCount = reader.ReadInt32();
					for (int childCounter = 0; childCounter < childCount; childCounter++)
					{
						systemName = (string)ReadObject(reader);
						isDirty = (bool)ReadObject(reader);
						referenceId = (int)ReadObject(reader);
						info.AddChild(systemName, referenceId, isDirty);
					}

					valueCount = reader.ReadInt32();
					for (int valueCounter = 0; valueCounter < valueCount; valueCounter++)
					{
						systemName = (string)ReadObject(reader);
						enumTypeName = (string)ReadObject(reader);
						isDirty = (bool)ReadObject(reader);
						value = ReadObject(reader);
						info.AddValue(systemName, value, isDirty, string.IsNullOrEmpty(enumTypeName) ? null : enumTypeName);
					}
					returnValue.Add(info);
				}
			}

			return returnValue;
		}

    /// <summary>
    /// Override this method to insert your child object
    /// references into the MobileFormatter serialzation stream.
    /// </summary>
    /// <param name="info">
    /// Object containing the data to serialize.
    /// </param>
    /// <param name="formatter">
    /// Reference to MobileFormatter instance. Use this to
    /// convert child references to/from reference id values.
    /// </param>
    protected override void OnGetChildren(SerializationInfo info, MobileFormatter formatter)
    {
      if (_brokenRules != null && _brokenRules.Count > 0)
      {
        SerializationInfo brInfo = formatter.SerializeObject(_brokenRules);
        info.AddChild("_brokenRules", brInfo.ReferenceId);
      }

      base.OnGetChildren(info, formatter);
    }

        /// <summary>
        /// Method called by MobileFormatter when an object should serialize its child references. The data should be serialized into the SerializationInfo parameter.
        /// </summary>
        /// <param name="info">Object to contain the serialized data.</param>
        /// <param name="formatter">Reference to the formatter performing the serialization.</param>
        public void GetChildren(SerializationInfo info, MobileFormatter formatter)
        {
            if (info == null)
                throw new ArgumentNullException("info");

            if (formatter == null)
                throw new ArgumentNullException("formatter");

            if (BuildFailure != null)
            {
                var childInfo = formatter.SerializeObject(BuildFailure);
                info.AddChild("BuildFailure", childInfo.ReferenceId);
            }
        }