C# IFormatter.Serialize方法代码示例

        public SimpleIterativeRouter2(Key self, ushort tcpPort, IMessagingSocket sock, IKeyBasedRoutingAlgorithm algo, IFormatter formatter, bool isStrictMode)
        {
            _selfId = self;
            _tcpPort = tcpPort;
            _sock = sock;
            _algo = algo;
            _strict_mode = isStrictMode;

            // メッセージに含むことの出来る大体の最大NodeHandle数を計算
            int overhead, nodeHandleBytes;
            {
                using (MemoryStream ms = new MemoryStream ()) {
                    formatter.Serialize (ms, new NextHopResponse (self, _tcpPort, true, new NodeHandle[0]));
                    overhead = (int)ms.Length;
                }
                using (MemoryStream ms = new MemoryStream ()) {
                    formatter.Serialize (ms, new NodeHandle (self, new IPEndPoint (IPAddress.Loopback, 0), tcpPort));
                    nodeHandleBytes = (int)ms.Length;
                }
            }
            _maxNodeHandlesPerResponse = (dgramMaxSize - overhead) / nodeHandleBytes;

            algo.Setup (self, this);
            sock.AddInquiredHandler (typeof (NextHopQuery), MessagingSocket_Inquired_NextHopQuery);
            sock.AddInquiredHandler (typeof (CloseNodeQuery), MessagingSocket_Inquired_CloseNodeQuery);
        }

 static void Serialize(string filename,IFormatter formatter)
 {
     MyItemType obj = new MyItemType(1, "food");
     FileStream fs = new FileStream(filename,FileMode.OpenOrCreate) ;
     formatter.Serialize(fs, obj);
     fs.Close();
 }

 /// <summary>
 /// Clone a object with via Serializing/Deserializing
 /// using a implementation of IFormatter. 
 /// <seealso cref="IFormatter"/> 
 /// </summary>
 /// <param name="obj">Object to clone</param>
 /// <param name="formatter">IFormatter implementation in order to Serialize/Deserialize</param>
 /// <returns>Clone object</returns>
 public static object Clone(object obj, IFormatter formatter)
 {
     using (MemoryStream buffer = new MemoryStream())
     {
         formatter.Serialize(buffer, obj);
         buffer.Position = 0;
         return formatter.Deserialize(buffer);
     }
 }

        public static void SerializeItem( string fileName, IFormatter formatter )
        {
            // Create an instance of the type and serialize it.
            MyItemType t = new MyItemType();
            t.MyProperty = "Hello World";

            System.IO.FileStream s = new System.IO.FileStream( fileName, FileMode.Create );
            formatter.Serialize( s, t );
            s.Close();
        }

        public static void SerializeItem(string fileName, IFormatter formatter)
        {
            Author a = new Author();
            a.Name = "Gosho";
            a.Email = "[email protected]";

            FileStream s = new FileStream(fileName, FileMode.Create);
            formatter.Serialize(s, a);
            s.Close();
        }

                void Driver (IFormatter formatter, A a)
                {
                        MemoryStream stream = new MemoryStream();
                        formatter.Serialize(stream, a);
                        stream.Position = 0;

                        a.CheckSerializationStatus ();
                        a = (A) formatter.Deserialize (stream);
                        a.CheckDeserializationStatus ();
                }

        private static Stats ProfileSerialization( IFormatter formatter, Stream stream, object objToStore, int numIterations )
        {
            long startTime = TinyTime.CurrentTime;

            for ( int count = 0; count < numIterations; ++count )
            {
                formatter.Serialize( stream, objToStore );
            }

            long endTime = TinyTime.CurrentTime;
            stream.Flush( );

            return new Stats( TinyTime.ToSeconds( startTime, endTime ), stream );
        }

		public static string Serialize (object o, IFormatter f)
		{
			if (o == null)
				return string.Empty;
			using (MemoryStream ms = new MemoryStream ()) {
				try {
					f.Serialize (ms, o);
				}
				catch (Exception ex) {
					Exception inner = o as Exception;
					if (inner != null)
						RethrowException (inner);
					else
						throw;
				}
				return HttpUtility.UrlEncode (ms.ToArray ());
			}
		}

 public void SerializeMovies(String filePath)
 {
     formatter = new BinaryFormatter();
     using (fs = new FileStream(filePath, FileMode.Create, FileAccess.Write)) {
         formatter.Serialize(fs, movieInfo.Values.ToArray());
         fs.Close();
     }
     //form.DisplayMsg("Saved movies database to " + filePath); (!)
 }

 public void Serialize(String filePath, Dictionary<String, Movie> d)
 {
     formatter = new BinaryFormatter();
     using (fs = new FileStream(filePath, FileMode.Create, FileAccess.Write)) {
         formatter.Serialize(fs, d.Values.ToArray());
         fs.Close();
     }
 }

        // WriteValue takes a value and writes it to stream.  It 
        // can take some specific action based on the type, such as write out a compact
        // version of the object if it's a type recognized by this ResourceWriter, or 
        // use Serialization to write out the object using the objFormatter.
        // For instance, the default implementation recognizes primitives such as Int32
        // as special types and calls WriteInt32(int) with the value of the object.  This
        // can be much more compact than serializing the same object.
        // 
        /*
        private void WriteValueV1(Type type, Object value, BinaryWriter writer, IFormatter objFormatter)
        {
            // For efficiency reasons, most of our primitive types will be explicitly
            // recognized here.  Some value classes are also special cased here.
            if (type == typeof(String))
                writer.Write((String) value);
            else if (type == typeof(Int32))
                writer.Write((int)value);
            else if (type == typeof(Byte))
                writer.Write((byte)value);
            else if (type == typeof(SByte))
                writer.Write((sbyte)value);
            else if (type == typeof(Int16))
                writer.Write((short)value);
            else if (type == typeof(Int64))
                writer.Write((long)value);
            else if (type == typeof(UInt16))
                writer.Write((ushort)value);
            else if (type == typeof(UInt32))
                writer.Write((uint)value);
            else if (type == typeof(UInt64))
                writer.Write((ulong)value);
            else if (type == typeof(Single))
                writer.Write((float)value);
            else if (type == typeof(Double))
                writer.Write((double)value);
            else if (type == typeof(DateTime)) {
                // Ideally we should use DateTime's ToBinary & FromBinary,
                // but we can't for compatibility reasons.
                writer.Write(((DateTime)value).Ticks);
            }
            else if (type == typeof(TimeSpan))
                writer.Write(((TimeSpan)value).Ticks);
            else if (type == typeof(Decimal)) {
                int[] bits = Decimal.GetBits((Decimal)value);
                BCLDebug.Assert(bits.Length == 4, "ResourceReader::LoadObject assumes Decimal's GetBits method returns an array of 4 ints");
                for(int i=0; i<bits.Length; i++)
                    writer.Write(bits[i]);
            }
            else if (type == null) {
                BCLDebug.Assert(value == null, "Type is null iff value is null");
#if RESOURCE_FILE_FORMAT_DEBUG
                writer.Write("<null value>");
#endif
            }
            else
                objFormatter.Serialize(writer.BaseStream, value);
        }
        */

        private void WriteValue(ResourceTypeCode typeCode, Object value, BinaryWriter writer, IFormatter objFormatter)
        {
            switch(typeCode) {
            case ResourceTypeCode.Null:
                break;

            case ResourceTypeCode.String:
                writer.Write((String) value);
                break;

            case ResourceTypeCode.Boolean:
                writer.Write((bool) value);
                break;

            case ResourceTypeCode.Char:
                writer.Write((UInt16) (char) value);
                break;

            case ResourceTypeCode.Byte:
                writer.Write((byte) value);
                break;

            case ResourceTypeCode.SByte:
                writer.Write((sbyte) value);
                break;
                
            case ResourceTypeCode.Int16:
                writer.Write((Int16) value);
                break;
                
            case ResourceTypeCode.UInt16:
                writer.Write((UInt16) value);
                break;

            case ResourceTypeCode.Int32:
                writer.Write((Int32) value);
                break;
                
            case ResourceTypeCode.UInt32:
                writer.Write((UInt32) value);
                break;
//.........这里部分代码省略.........

 /// <summary>
 /// Serialize all the nodes of this tree to the stream provided, using the formatter provided.
 /// </summary>
 /// <param name="stream">The stream to serialize to.</param>
 /// <param name="formatter">The formatter used to serialize.</param>
 public void Serialize(Stream stream, IFormatter formatter)
 {
     formatter.Serialize(stream, this);
 }

    	// WriteValue takes a value and writes it to stream.  It 
    	// can take some specific action based on the type, such as write out a compact
    	// version of the object if it's a type recognized by this ResourceWriter, or 
    	// use Serialization to write out the object using the objFormatter.
    	// For instance, the default implementation recognizes primitives such as Int32
    	// as special types and calls WriteInt32(int) with the value of the object.  This
    	// can be much more compact than serializing the same object.
    	// 
    	private void WriteValue(Type type, Object value, BinaryWriter writer, IFormatter objFormatter)
    	{
    		// For efficiency reasons, most of our primitive types will be explicitly
    		// recognized here.  Some value classes are also special cased here.
    		if (type == typeof(String))
    			writer.Write((String) value);
    		else if (type == typeof(Int32))
    			writer.Write((int)value);
    		else if (type == typeof(Byte))
    			writer.Write((byte)value);
    		else if (type == typeof(SByte))
    			writer.Write((sbyte)value);
    		else if (type == typeof(Int16))
    			writer.Write((short)value);
    		else if (type == typeof(Int64))
    			writer.Write((long)value);
    		else if (type == typeof(UInt16))
    			writer.Write((ushort)value);
    		else if (type == typeof(UInt32))
    			writer.Write((uint)value);
    		else if (type == typeof(UInt64))
    			writer.Write((ulong)value);
    		else if (type == typeof(Single))
    			writer.Write((float)value);
    		else if (type == typeof(Double))
    			writer.Write((double)value);
    		else if (type == typeof(DateTime))
    			writer.Write(((DateTime)value).Ticks);
    		else if (type == typeof(TimeSpan))
    			writer.Write(((TimeSpan)value).Ticks);
    		else if (type == typeof(Decimal)) {
    			int[] bits = Decimal.GetBits((Decimal)value);
                BCLDebug.Assert(bits.Length == 4, "ResourceReader::LoadObject assumes Decimal's GetBits method returns an array of 4 ints");
    			for(int i=0; i<bits.Length; i++)
    				writer.Write(bits[i]);
    		}
    		else if (type == null) {
                BCLDebug.Assert(value == null, "Type is null iff value is null");
#if RESOURCE_FILE_FORMAT_DEBUG
                write.WriteString("<null value>");
#endif
            }
            else
    			objFormatter.Serialize(writer.BaseStream, value);
    	}

 /// <summary>
 /// The write external.
 /// </summary>
 /// <param name="formatter">
 /// The formatter. 
 /// </param>
 /// <param name="stream">
 /// The stream. 
 /// </param>
 public void WriteExternal(IFormatter formatter, Stream stream)
 {
     formatter.Serialize(stream, this);
 }

/*
#if !MONO
  public Object[] remove_instance_from_hash (String instance)
  {
    Object[] ret = new Object[1];

//    assem_perm_list.Remove (instance);
    instances.Remove (instance);

    ret[0]=(Boolean) true;
    return ret;
  }

  public Object[] add_assem_to_sec_hash (String assem_name)
  {
    Object[] ret = new Object[1];

//    assem_perm_list [assem_name] = 1;

    ret[0]=(Boolean) true;
    return ret;
  }
#endif
*/

  #endregion

  #region helper funcs
  private static byte[] obj_serialize_int (Object new_instance, IFormatter bf)
  {
    Object [] ret = new Object[2];

    System.IO.MemoryStream mem_strim = new System.IO.MemoryStream ();
    bf.Serialize(mem_strim, new_instance);
    mem_strim.Flush();

    byte [] byte_array = new byte []{};
    byte_array = mem_strim.ToArray();

    return byte_array;
  }