C# System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize方法代码示例

 public static void LoadFile()
 {
     try
     {
         recentProjects=new System.Collections.ArrayList(4);
         recentFiles=new System.Collections.ArrayList(4);
         System.IO.FileStream stream = new System.IO.FileStream("\\lastfiles.dat", System.IO.FileMode.Open);
         System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
         recentProjects = (System.Collections.ArrayList)formatter.Deserialize( stream );
         recentFiles = (System.Collections.ArrayList)formatter.Deserialize( stream );
         stream.Close();
     }
     catch{}
 }

		public void TestSerializeSchemaPropertyValueCollection()
		{
			System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
			System.IO.MemoryStream ms = new System.IO.MemoryStream();
			SchemaPropertyValueCollection obj1 = new SchemaPropertyValueCollection();

			SCGroup group = SCObjectGenerator.PrepareGroupObject();

			foreach (string key in group.Properties.GetAllKeys())
			{
				obj1.Add(group.Properties[key]);
			}

			bf.Serialize(ms, obj1);
			ms.Seek(0, System.IO.SeekOrigin.Begin);

			var obj2 = (SchemaPropertyValueCollection)bf.Deserialize(ms);

			Assert.AreEqual(obj1.Count, obj2.Count);

			var keys1 = obj1.GetAllKeys();

			foreach (var key in keys1)
			{
				Assert.IsTrue(obj2.ContainsKey(key));
				Assert.AreEqual(obj1[key].StringValue, obj2[key].StringValue);
			}
		}

        private const string PATH_TO_DAT_FILE = "./joueurs.dat"; //Répertoire courrant.

        #endregion Fields

        #region Methods

        /// <summary>
        /// Charge un fichier contenant tous les joueurs.
        /// </summary>
        /// <returns>La liste de joueurs s'il y en a, sinon null.</returns>
        public static List<Joueur> Load()
        {
            List<Joueur> joueurs = null;

            if (File.Exists(PATH_TO_DAT_FILE))
            {
                try
                {
                    using (Stream stream = File.Open(PATH_TO_DAT_FILE, FileMode.Open))
                    {
                        stream.Position = 0;
                        var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        joueurs = (List<Joueur>)bformatter.Deserialize(stream);
                    }
                }
                catch (ArgumentException)
                {
                    MessageBox.Show("Le fichier est invalide.");
                }
                catch (DirectoryNotFoundException)
                {
                    MessageBox.Show("Répertoire introuvable");
                }
                catch (FileNotFoundException)
                {
                    MessageBox.Show("Le fichier n'existe pas.");
                }
                catch (IOException)
                {
                    MessageBox.Show("Problème lors de la lecture du fichier.");
                }
            }

            return joueurs;
        }

 /// <summary>
 /// 扩展方法：将二进制byte[]数组反序列化为对象-通过系统提供的二进制流来完成反序列化
 /// </summary>
 /// <param name="SerializedObj">待反序列化的byte[]数组</param>
 /// <param name="ThrowException">是否抛出异常</param>
 /// <returns>返回结果</returns>
 public static object ByteArrayToObject(this byte[] SerializedObj, bool ThrowException)
 {
     if (SerializedObj == null)
     {
         return null;
     }
     else
     {
         try
         {
             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
             System.IO.MemoryStream stream = new System.IO.MemoryStream(SerializedObj);
             object obj = formatter.Deserialize(stream);
             return obj;
         }
         catch (System.Exception ex)
         {
             if (ThrowException)
             {
                 throw ex;
             }
             else
             {
                 return null;
             }
         }
     }
 }

 public void SyncFolderPairs(string ConfigFileName, int index, bool previewOnly)
 {
     SyncToy.SyncEngineConfig SEConfig = null;
     ArrayList EngineConfigs = new ArrayList();
     System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
     try
     {
         using (StreamReader sr = new StreamReader(ConfigFileName))
         {
             do
             {
                 SEConfig = (SyncToy.SyncEngineConfig)bf.Deserialize(sr.BaseStream);
                 EngineConfigs.Add(SEConfig);
             }
             while (sr.BaseStream.Position < sr.BaseStream.Length);
             sr.Close();
         }
         if (index != -1)
         {
             SyncFolderPair((SyncToy.SyncEngineConfig)EngineConfigs[index], previewOnly);
         }
         else
         {
             foreach (SyncToy.SyncEngineConfig Config in EngineConfigs)
             {
                 SyncFolderPair(Config, previewOnly);
             }
         }
        }
     catch (Exception ex)
     {
         Console.WriteLine("SyncFolderPairs Exception -> {0}", ex.Message);
     }
 }

        public MainWindow()
        {
            InitializeComponent();
            //if (System.IO.Directory.Exists(cardPath) == false)
            //{
            //    System.IO.Directory.CreateDirectory(cardPath);
            //}
            if (System.IO.File.Exists(cardPath + "cardList") == false)
            {
                DownloadAllCardSet();
            }
            else
            {
                try
                {
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter reader = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    System.IO.FileStream file = System.IO.File.OpenRead(cardPath + "cardList");
                    card.cardList = (List<card>)reader.Deserialize(file);
                    file.Close();
                }
                catch (Exception)
                {
                    MessageBox.Show("Your card database seems to be corrupted, we will redownload it");
                    DownloadAllCardSet();
                }

            }
            if (System.IO.File.Exists(cardPath + "cardCollection") == true)
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter reader = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                System.IO.FileStream file = System.IO.File.OpenRead(cardPath + "cardCollection");
                card.MyCollection = (List<card>)reader.Deserialize(file);
                file.Close();
            }
        }

        public Stock GetStock(StockName stockName, DateTime startDate, DateTime endDate)
        {
            string dir = String.Format(@"..\..\StockData\Yahoo");
            string filename = String.Format("{0}.stock", stockName);
            var fullPath = Path.Combine(dir, filename);

            List<IStockEntry> rates;
            if (!File.Exists(fullPath))
            {
                rates = GetStockFromRemote(stockName, startDate, endDate);
                Directory.CreateDirectory(dir);
                using (Stream stream = File.Open(fullPath, FileMode.Create))
                {
                    var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    bformatter.Serialize(stream, rates);
                }

            }
            else
            {
                using (Stream stream = File.Open(fullPath, FileMode.Open))
                {
                    var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    rates = (List<IStockEntry>) bformatter.Deserialize(stream);
                }
            }
            var stock = new Stock(stockName, rates);
            return stock;
        }

        public static Message Deserialize(NetworkStream ns)
        {
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

            object obj = bf.Deserialize(ns);
            return (Message)obj;
        }

        public static double[] GetSimilarity(double[] a, double[] b)
        {
            if (s_simi == null)
            {
                s_simi = new SimilarityAnalysis();
                s_simi.setOptions(new string[] { "-T", "first-1", "-e", "20", "-r", "3", "-f", "false" });

                if (System.IO.File.Exists(CacheFileName))
                {
                    using (var file = System.IO.File.Open(CacheFileName, System.IO.FileMode.Open))
                    {
                        var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        m_cache = bf.Deserialize(file) as Dictionary<double[], double[]>;
                    }
                }
                else
                {
                    m_cache = new Dictionary<double[], double[]>();
                }
            }

            //double[] c = new double[a.Length + b.Length];
            //a.CopyTo(c, 0);
            //b.CopyTo(c, a.Length);
            //if (m_cache.ContainsKey(c))
            //    return m_cache[c];

            Instances instance = CreateInstanceOnFly(a, b);
            s_simi.analyze(instance);

            double[] ret = new double[] { s_simi.m_distancesFreq[1][0], s_simi.m_distancesTime[1][0] };
            //m_cache[c] = ret;

            return ret;
        }

        //void global_asax_AcquireRequestState(object sender, EventArgs e)
        void Application_AcquireRequestState(object sender, EventArgs e)
        {
            // Code that runs when a new session is started
            // get the security cookie
            HttpCookie cookie = Request.Cookies.Get(FormsAuthentication.FormsCookieName);

            if (cookie != null)
            {
                // we got the cookie, so decrypt the value
                FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(cookie.Value);

                if (ticket.Expired)
                {
                    // the ticket has expired - force user to login
                    FormsAuthentication.SignOut();
                    //Response.Redirect("~/Security/Login.aspx");
                }
                else
                {
                    // ticket is valid, set HttpContext user value
                    System.IO.MemoryStream buffer = new System.IO.MemoryStream(Convert.FromBase64String(ticket.UserData));
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    HttpContext.Current.User = (System.Security.Principal.IPrincipal)formatter.Deserialize(buffer);
                }
            }
        }

 /// <summary>
 /// Get an existing business object.
 /// </summary>
 /// <param name="request">The request parameter object.</param>
 public byte[] Fetch(byte[] req)
 {
   var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
   Csla.Server.Hosts.WcfBfChannel.FetchRequest request;
   using (var buffer = new System.IO.MemoryStream(req))
   {
     request = (Csla.Server.Hosts.WcfBfChannel.FetchRequest)formatter.Deserialize(buffer);
   }
   Csla.Server.DataPortal portal = new Csla.Server.DataPortal();
   object result;
   try
   {
     result = portal.Fetch(request.ObjectType, request.Criteria, request.Context);
   }
   catch (Exception ex)
   {
     result = ex;
   }
   var response = new WcfResponse(result);
   using (var buffer = new System.IO.MemoryStream())
   {
     formatter.Serialize(buffer, response);
     return buffer.ToArray();
   }
 }

        public void TestBulkDeletionResultsSerializable()
        {
            var successfulObjects = new[] { "/container/object1", "/container/object2" };
            var failedObjects =
                new[]
                {
                    new BulkDeletionFailedObject("/badContainer/object3", new Status((int)HttpStatusCode.BadRequest, "invalidContainer")),
                    new BulkDeletionFailedObject("/container/badObject", new Status((int)HttpStatusCode.BadRequest, "invalidName"))
                };
            BulkDeletionResults results = new BulkDeletionResults(successfulObjects, failedObjects);
            BinaryFormatter formatter = new BinaryFormatter();
            using (Stream stream = new MemoryStream())
            {
                formatter.Serialize(stream, results);
                stream.Position = 0;
                BulkDeletionResults deserialized = (BulkDeletionResults)formatter.Deserialize(stream);
                Assert.IsNotNull(deserialized);

                Assert.IsNotNull(deserialized.SuccessfulObjects);
                Assert.AreEqual(successfulObjects.Length, deserialized.SuccessfulObjects.Count());
                for (int i = 0; i < successfulObjects.Length; i++)
                    Assert.AreEqual(successfulObjects[i], deserialized.SuccessfulObjects.ElementAt(i));

                Assert.IsNotNull(deserialized.FailedObjects);
                Assert.AreEqual(failedObjects.Length, deserialized.FailedObjects.Count());
                for (int i = 0; i < failedObjects.Length; i++)
                {
                    Assert.IsNotNull(deserialized.FailedObjects.ElementAt(i));
                    Assert.AreEqual(failedObjects[i].Object, deserialized.FailedObjects.ElementAt(i).Object);
                    Assert.IsNotNull(deserialized.FailedObjects.ElementAt(i).Status);
                    Assert.AreEqual(failedObjects[i].Status.Code, deserialized.FailedObjects.ElementAt(i).Status.Code);
                    Assert.AreEqual(failedObjects[i].Status.Description, deserialized.FailedObjects.ElementAt(i).Status.Description);
                }
            }
        }

        // Pelaajien lataaminen tiedostosta
        public List<Pelaaja> Load(string filepath)
        {
            // palautusarvo
            List<Pelaaja> players = new List<Pelaaja>();
            // haetaan pääte
            string ext = Path.GetExtension(filepath);

            using (Stream stream = File.Open(filepath, FileMode.Open))
            {
                // tarkastetaan tiedostopäätteen perusteella
                // miten sitä käsitellään
                // HOX HUONO TAPA, tiedostopäätteellä ei oikeasti ole merkitystä
                switch (ext)
                {
                    case ".xml":
                        XmlSerializer serializer = new XmlSerializer(typeof(List<Pelaaja>));
                        players = (List<Pelaaja>)serializer.Deserialize(stream);
                        break;

                    case ".bin":
                        var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        players = (List<Pelaaja>)bformatter.Deserialize(stream);
                        break;

                    default:
                        throw new Exception("Extension \"" + ext + "\" is not supported");
                }
            }

            return players;
        }

 public static void LoadFields()
 {
     IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
     Stream stream = new FileStream("FieldList.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
     FieldList = (List<Field>)formatter.Deserialize(stream);
     stream.Close();
 }

        private void LoadGrammar_ToolButton_Click( object sender, EventArgs e )
        {
            if( this.LoadGrammar_Dialog.ShowDialog(this) == System.Windows.Forms.DialogResult.OK )
            {
                try
                {
                    SyntacticAnalysis.Grammar grammar;
                    using( var stream = System.IO.File.OpenRead(this.LoadGrammar_Dialog.FileName) )
                    {
                        var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        grammar = (SyntacticAnalysis.Grammar)bf.Deserialize(stream);
                    }

                    this.Editor.Grammar = grammar;
                }
                catch( Exception ex )
                {
                    MessageBox.Show(
                        this,
                        ex.Message,
                        "Hiba nyelvtan betöltése közben",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Error);
                }
            }
        }