C# DataContractSerializer.ReadObject方法代码示例

        public string Translate(string text, string from, string to)
        {
            using (var client = new HttpClient())
            {
                var url = string.Format(
                        _translatorApiUrlFormat,
                        HttpUtility.UrlEncode(text),
                        HttpUtility.UrlEncode(from),
                        HttpUtility.UrlEncode(to));

                using (var message = new HttpRequestMessage(HttpMethod.Get, url))
                {
                    message.Headers.Authorization = new AuthenticationHeaderValue("Bearer", GetAccessToken());

                    using (var result = client.SendAsync(message).Result)
                    {
                        if (!result.IsSuccessStatusCode)
                        {
                            throw new TrosiTranslationException(result.Content.ReadAsStringAsync().Result);
                        }

                        using (var responseStream = result.Content.ReadAsStreamAsync().Result)
                        {
                            var serializer = new DataContractSerializer(typeof(string));

                            return serializer.ReadObject(responseStream) as string;
                        }
                    }
                }
            }
        }

        static void Main(string[] args)
        {
            Person p = new Person() { Name = "曾小丹", Age = 18 };
            var ds = new DataContractSerializer(typeof(Person));
            var s = new MemoryStream();
            using (XmlDictionaryWriter w = XmlDictionaryWriter.CreateBinaryWriter(s))
            {
                ds.WriteObject(w, p);
            }

            var s2 = new MemoryStream(s.ToArray());
            Person p2;
            using (XmlDictionaryReader r = XmlDictionaryReader.CreateBinaryReader(s2, XmlDictionaryReaderQuotas.Max))
            {
                p2 = (Person)ds.ReadObject(r);
            }
            //XmlWriterSettings settings = new XmlWriterSettings() { Indent = true };
            //using (XmlWriter w = XmlWriter.Create(@"D:\WebPage\Img\perosn.xml", settings))
            //{
            //    ds.WriteObject(w, p);
            //}
            System.Diagnostics.Process.Start(@"D:\WebPage\Img\perosn.xml");
            // 使用程序打开该文件？！
            //using (Stream s = File.Create(@"D:\WebPage\Img\perosn.xml"))
            //{
            //    ds.WriteObject(s, p);
            //}

            Person p2;
            using (Stream s = File.OpenRead(@"D:\WebPage\Img\perosn.xml"))
            {
                p2 = (Person)ds.ReadObject(s);
            }
            Console.WriteLine(p2.Name + "" + p2.Age);
        }

        public DesignUnitInfoRepository()
        {
            var ser = new DataContractSerializer(typeof(UnitesInfo));

            natoList = new SortedList<ushort, UnitInfo>();

            // TODO find a better way to design time this
            using ( var reader = new FileStream(Path.Combine(@"F:\Dev\RedReplay\RedReplay\Release", "NATO.xml"), FileMode.Open) )
            {
                UnitesInfo natoUnits = ser.ReadObject(reader) as UnitesInfo;

                foreach ( var unit in natoUnits )
                {
                    natoList.Add(unit.ShowRoomID, unit);
                }
            }

            pactList = new SortedList<ushort, UnitInfo>();

            // TODO find a better way to design time this
            using ( var reader = new FileStream(Path.Combine(@"F:\Dev\RedReplay\RedReplay\Release", "PACT.xml"), FileMode.Open) )
            {
                UnitesInfo pactUnits = ser.ReadObject(reader) as UnitesInfo;

                foreach ( var unit in pactUnits )
                {
                    pactList.Add(unit.ShowRoomID, unit);
                }
            }
        }

        public UnitInfoRepository()
        {
            var ser = new DataContractSerializer(typeof(UnitesInfo));

            natoList = new SortedList<ushort, UnitInfo>();

            using ( var reader = new FileStream(Path.Combine(Settings.Default.exeFolder, "NATO.xml"), FileMode.Open) )
            {
                UnitesInfo natoUnits = ser.ReadObject(reader) as UnitesInfo;

                foreach ( var unit in natoUnits )
                {
                    natoList.Add(unit.ShowRoomID, unit);
                }
            }

            pactList = new SortedList<ushort, UnitInfo>();

            using ( var reader = new FileStream(Path.Combine(Settings.Default.exeFolder, "PACT.xml"), FileMode.Open) )
            {
                UnitesInfo pactUnits = ser.ReadObject(reader) as UnitesInfo;

                foreach ( var unit in pactUnits)
                {
                    pactList.Add(unit.ShowRoomID, unit);
                }
            }
        }

        static void Main(string[] args)
        {
            /* Data contract serialization typically reads and writes XML data. You use a
             * DataContractSerializer object for data contract serialization. Its 
             * WriteObject() method can write to a stream, or it can write to an object that
             * extends XmlDictionaryWriter, an abstract class that controls XML output and 
             * can be extended to change the way the XML output is written. Objects are
             * deserialized using the ReadObject() method, which can read XML data from
             * a stream or an XmlDictionaryReader.
             */
            DataContractSerializer serializer = new DataContractSerializer(typeof(SerializableGuy));

            // We’ll create a new SerializableGuy object and serialize it using a FileStream.
            SerializableGuy guyToWrite = new SerializableGuy("Joe", 37, 150);
            using (FileStream writer = new FileStream("serialized_guy.xml", FileMode.Create))
            {
                serializer.WriteObject(writer, guyToWrite);
            }

            // We can open the file we just wrote and deserialize it into a new guy using ReadObject().
            // We’ll use the XmlDictionaryReader.CreateTextReader() method to create an object that
            // reads XML data from a stream. 
            SerializableGuy guyToRead = null;
            using (FileStream inputStream = new FileStream("serialized_guy.xml", FileMode.Open))
            using (XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(inputStream, new XmlDictionaryReaderQuotas()))
            {
                guyToRead = serializer.ReadObject(reader, true) as SerializableGuy;
            }
            Console.WriteLine(guyToRead);
            // Output: Joe is 37 years old and has 150 bucks [1461194451,0]


            string xmlGuy = @"
<Guy xmlns=""http://www.headfirstlabs.com"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">
   <Age>43</Age> 
   <Cash>225</Cash> 
   <Name>Bob</Name> 
   <secretNumberOne>54321</secretNumberOne>
</Guy>";
            byte[] buffer = UnicodeEncoding.UTF8.GetBytes(xmlGuy);

            using (XmlDictionaryReader reader =
                XmlDictionaryReader.CreateTextReader(buffer, new XmlDictionaryReaderQuotas()))
            {
                guyToRead = serializer.ReadObject(reader, true) as SerializableGuy;
            }
            Console.WriteLine(guyToRead);
            // Output: Bob is 43 years old and has 225 bucks [54321,0]

            Console.ReadKey();
        }

 public static void Load()
 {
     DataContractSerializer dcs = new DataContractSerializer(typeof(TagDB));
     XmlReader xmlr = XmlReader.Create("TagDBase.xml");
     dcs.ReadObject(xmlr);
     xmlr.Close();
 }

        public void Client_writeToFileTest()
        {
            Client testUser = new Client("testUser","5555");

            testUser.writeToFile();

            #region ReadClientObjectFromFile

                string pathToDir = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
                string USER_LOCATION = "\\users\\";
                string XML_EXT = ".xml";
                string writePath = pathToDir + USER_LOCATION + testUser.Name + XML_EXT;

            Client tempObj;

            //Reads from the xml file for the client.
            using (FileStream reader = new FileStream(writePath, FileMode.Open, FileAccess.Read))
            {
                DataContractSerializer ser = new DataContractSerializer(typeof(Client));
                tempObj = (Client)ser.ReadObject(reader);
            }

            Assert.AreEqual(testUser.Name, tempObj.Name);
            Assert.AreEqual(testUser.Online, tempObj.Online);
            Assert.AreEqual(testUser.Password, tempObj.Password);

            #endregion
        }

    protected void OnTranslateButtonClicked(object sender, EventArgs e)
    {
        string fromText = fromTextInput.Buffer.Text;
        string toText = "";

        AdmAuthentication admAuth = new AdmAuthentication("", "");
        AdmAccessToken admToken = admAuth.GetAccessToken();

        string encodedFromText = System.Web.HttpUtility.UrlEncode(fromText);
        string uri = "http://api.microsofttranslator.com/v2/Http.svc/Translate?text=" + System.Web.HttpUtility.UrlEncode(fromText) + "&from=" + "en" + "&to=" + "ru";
        string authToken = "Bearer" + " " + admToken.access_token;

        HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(uri);
        httpWebRequest.Headers.Add("Authorization", authToken);

        WebResponse response = httpWebRequest.GetResponse();
        //		try
        //		{
            response = httpWebRequest.GetResponse();
            using (Stream stream = response.GetResponseStream())
            {
            System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(System.Type.GetType("System.String"));
                toText = (string)dcs.ReadObject(stream);
            }
        //		}

        toTextInput.Buffer.Text = toText;
    }

        //Methods
        public MemberList LoadMemberList()
        {
            try
            {
                MemberList loaded = null;

                if (System.IO.File.Exists(this.fullFilePath))
                {
                    using (FileStream readFileStream = new FileStream(this.fullFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        DataContractSerializer deserializer = new DataContractSerializer(typeof(MemberList));
                        loaded = (MemberList)deserializer.ReadObject(readFileStream);
                    }

                    if (loaded != null)
                    {
                        //setup subscriptions
                        loaded.SetupSubscriptions();
                    }

                    return loaded;
                }
            }
            catch { }

            return null;
        }

 private List<Benutzer> GetBenutzer()
 {
     HttpWebRequest webrequest = (HttpWebRequest)WebRequest.Create(uri + "benutzer/");
     webrequest.Method = "GET";
     HttpWebResponse webresponse = null;
     try
     {
         webresponse = (HttpWebResponse)webrequest.GetResponse();
         HttpStatusCode rc = webresponse.StatusCode;
         DataContractSerializer serl = new DataContractSerializer(typeof(List<Benutzer>));
         return (List<Benutzer>)serl.ReadObject(webresponse.GetResponseStream());
     }
     catch (WebException we)
     {
         if (we.Response != null)
         {
             webresponse = (HttpWebResponse)we.Response;
             MessageBox.Show(webresponse.StatusDescription + "!", "Fehler");
         }
         else
         {
             MessageBox.Show("Server nicht erreichbar!", "Fehler");
         }
         return new List<Benutzer>();
     }
     finally
     {
         if (webresponse != null)
             webresponse.Close();
     }
 }

        static void Main()
        {
            Record record1 = new Record(1, 2, "+", 3);
            Console.WriteLine("Original record: {0}", record1.ToString());

            MemoryStream stream1 = new MemoryStream();

            //Serialize the Record object to a memory stream using DataContractSerializer.
            System.Runtime.Serialization.DataContractSerializer serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(Record));
            serializer.WriteObject(stream1, record1);

            stream1.Position = 0;

            //Deserialize the Record object back into a new record object
            Record record2 = (Record)serializer.ReadObject(stream1);

            Console.WriteLine("Deserialized record: {0}", record2.ToString());

            MemoryStream stream2 = new MemoryStream();

            XmlDictionaryWriter binaryDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(stream2);
            serializer.WriteObject(binaryDictionaryWriter, record1);
            binaryDictionaryWriter.Flush();

            //report the length of the streams
            Console.WriteLine("Text Stream is {0} bytes long", stream1.Length);
            Console.WriteLine("Binary Stream is {0} bytes long", stream2.Length);

            Console.WriteLine();
            Console.WriteLine("Press <ENTER> to terminate client.");
            Console.ReadLine();
        }

        public static object LoadFromFile(string fileName, Type t)
        {
            object o = null;
            try
            {
                byte[] fileContents = File.ReadAllBytes(fileName);

                byte[] decryptedData = Encryption.DecryptData(fileContents);

                using (MemoryStream stream = new MemoryStream())
                {
                    stream.Write(decryptedData, 0, decryptedData.Length);

                    stream.Position = 0;

                    DataContractSerializer serializer = new DataContractSerializer(t);

                    o = serializer.ReadObject(stream);
                }
            }
            catch (Exception ex)
            {
            }
            return o;
        }

        public void Data_contract_serialization_will_change_the_type_of_a_collection()
        {
            using (var session = DataAccess.OpenSession())
            {
                var forum = session.Get<ForumModel>(1);

            Assert.AreEqual(typeof(NHibernate.Collection.Generic.PersistentGenericBag<TopicModel>), forum.Topics.GetType());

            var knownTypes = new List<Type>
                                 {
                                     typeof (TopicModel),
                                     typeof (NHibernate.Collection.Generic.PersistentGenericBag<TopicModel>),
                                     typeof (NHibernate.Impl.CollectionFilterImpl)
                                 };
                var serializer = new   DataContractSerializer(typeof(ForumModel), knownTypes);

            //serialize company to a memory stream
            Stream stream = new MemoryStream();
            serializer.WriteObject(stream, forum);
            Console.WriteLine();
            //deserialize the memory stream back to a company
            stream.Position = 0;
            forum = (ForumModel)serializer.ReadObject(stream);

            Assert.AreNotEqual(typeof(NHibernate.Collection.Generic.PersistentGenericBag<TopicModel>), forum.Topics.GetType());
            Assert.AreEqual(typeof(TopicModel[]), forum.Topics.GetType());
            }
        }

        public static async Task RestoreAsync()
        {
            _sessionState = new Dictionary<String, Object>();

            try
            {
                StorageFile file = await ApplicationData.Current.LocalFolder.GetFileAsync(sessionStateFilename);
                using (IInputStream inStream = await file.OpenSequentialReadAsync())
                {
                    DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary<string, object>), _knownTypes);
                    _sessionState = (Dictionary<string, object>)serializer.ReadObject(inStream.AsStreamForRead());
                }

                foreach (var weakFrameReference in _registeredFrames)
                {
                    Frame frame;
                    if (weakFrameReference.TryGetTarget(out frame))
                    {
                        frame.ClearValue(FrameSessionStateProperty);
                        RestoreFrameNavigationState(frame);
                    }
                }
            }
            catch (Exception e)
            {
                throw new SuspensionManagerException(e);
            }
        }

        public async Task RequiredDataIsProvided_AndModelIsBound_NoValidationErrors()
        {
            // Arrange
            var server = TestHelper.CreateServer(_app, SiteName, _configureServices);
            var client = server.CreateClient();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml-dcs"));
            var input = "<Store xmlns=\"http://schemas.datacontract.org/2004/07/XmlFormattersWebSite\" " +
                        "xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\"><Address><State>WA</State><Zipcode>" +
                        "98052</Zipcode></Address><Id>10</Id></Store>";
            var content = new StringContent(input, Encoding.UTF8, "application/xml-dcs");

            // Act
            var response = await client.PostAsync("http://localhost/Validation/CreateStore", content);

            //Assert
            var dcsSerializer = new DataContractSerializer(typeof(ModelBindingInfo));
            var responseStream = await response.Content.ReadAsStreamAsync();
            var modelBindingInfo = dcsSerializer.ReadObject(responseStream) as ModelBindingInfo;
            Assert.NotNull(modelBindingInfo);
            Assert.NotNull(modelBindingInfo.Store);
            Assert.Equal(10, modelBindingInfo.Store.Id);
            Assert.NotNull(modelBindingInfo.Store.Address);
            Assert.Equal(98052, modelBindingInfo.Store.Address.Zipcode);
            Assert.Equal("WA", modelBindingInfo.Store.Address.State);
            Assert.Empty(modelBindingInfo.ModelStateErrorMessages);
        }