Наследование: IRemotingFormatter, IFormatter
Пример #1
3
 /// <summary>
 /// 将一个对象序列化为字节数组
 /// </summary>
 /// <param name="data">要序列化的对象</param>
 /// <returns>序列化好的字节数组</returns>
 public static byte[] ToBytes(Object data)
 {
     MemoryStream ms = new MemoryStream();
     BinaryFormatter bf = new BinaryFormatter();
     bf.Serialize(ms, data);
     return ms.ToArray();
 }
        protected override void Show(IDialogVisualizerService windowService, IVisualizerObjectProvider provider)
        {
            using (Form form1 = new Form())
            {
                form1.Text = "FormCollection Visualizer";
                form1.StartPosition = FormStartPosition.WindowsDefaultLocation;
                form1.SizeGripStyle = SizeGripStyle.Auto;
                form1.ShowInTaskbar = false;
                form1.ShowIcon = false;

                DataTable dt;

                using (Stream stream = provider.GetData())
                {
                    BinaryFormatter bformatter = new BinaryFormatter();

                    dt = (DataTable)bformatter.Deserialize(stream);

                    stream.Close();
                }

                DataGridView gridView = new DataGridView();
                gridView.Dock = DockStyle.Fill;

                form1.Controls.Add(gridView);

                gridView.DataSource = dt;

                windowService.ShowDialog(form1);
            }
        }
 public void LoadFromFile(string aPath)
 {
     using (Stream stream = File.Open(aPath, FileMode.Open))
     {
         Clear();
         BinaryFormatter bin = new BinaryFormatter();
         Configuration deserialized = bin.Deserialize(stream) as Configuration;
         foreach (var prof in deserialized.Professors)
         {
             Professors.Add(prof);
         }
         foreach (var room in deserialized.Rooms)
         {
             Rooms.Add(room);
         }
         foreach (var group in deserialized.Groups)
         {
             Groups.Add(group);
         }
         foreach (var course in deserialized.Courses)
         {
             Courses.Add(course);
         }
         foreach (var constraint in deserialized.Constraints)
         {
             Constraints.Add(constraint);
         }
         foreach (var classcont in deserialized.Classes)
         {
             Classes.Add(classcont.Key, classcont.Value);
         }
     }
 }
Пример #4
0
 // Serialize and Save all Template list
 private void SerializeAndSave(string fileName, Template templejt)
 {
     System.IO.Stream stream = System.IO.File.Open(fileName, System.IO.FileMode.Truncate);
     BinaryFormatter bFormatter = new BinaryFormatter();
     bFormatter.Serialize(stream, templejt);
     stream.Close();
 }
Пример #5
0
        /// <summary>
        /// Opens a bin-file and converts it to a SaveFile that gets returned.
        /// </summary>
        public SaveFile LoadState()
        {

            SaveFile tmpFile = new SaveFile();

            Stream fileStreamer;
            BinaryFormatter bf;

            try
            {
                using(fileStreamer = File.Open("state.bin", FileMode.Open))
                {
                    bf = new BinaryFormatter();
                    var tmpState = bf.Deserialize(fileStreamer);
                    tmpFile = (SaveFile)tmpState;

                    return tmpFile;
                }
            }

            catch
            {
                return tmpFile;
            }       
        }
Пример #6
0
        public void Constructor_InitializesSerializer()
        {
            serializer = new BinaryFormatter();

            Assert.IsTrue(serverStream.IsConnected);
            Assert.IsTrue(clientStream.IsConnected);
        }
 /// <summary>
 /// Encode value into a stream
 /// </summary>
 /// <param name="value">Value to encode</param>
 /// <param name="destination">Stream to write the serialized object to.</param>
 public void Encode(object value, Stream destination)
 {
     if (value == null) throw new ArgumentNullException("value");
     if (destination == null) throw new ArgumentNullException("destination");
     var formatter = new BinaryFormatter();
     formatter.Serialize(destination, value);
 }
Пример #8
0
 public void Save(string path)
 {
     BinaryFormatter binaryFormatter = new BinaryFormatter();
     FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.Write);
     binaryFormatter.Serialize(fileStream, this);
     fileStream.Close();
 }
Пример #9
0
 public static object DeserializeFromStream(MemoryStream stream)
 {
     IFormatter formatter = new BinaryFormatter();
     stream.Seek(0, SeekOrigin.Begin);
     object o = formatter.Deserialize(stream);
     return o;
 }
Пример #10
0
 static MethodEvaluator()
 {
     BinaryFormatter formatter = new BinaryFormatter {
         AssemblyFormat = FormatterAssemblyStyle.Simple
     };
     s_Formatter = formatter;
 }
 /// <summary>
 /// Save the specified object.
 /// </summary>
 /// <param name="filename">The filename to save to.</param>
 /// <param name="obj">The object to save.</param>
 public static void Save(string filename, object obj)
 {
     Stream s = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None);
     var b = new BinaryFormatter();
     b.Serialize(s, obj);
     s.Close();
 }
Пример #12
0
 public static void saveToFile(Mesh mesh, string _filename)
 {
     Stream stream = File.Open(_filename, FileMode.Create);
     BinaryFormatter bFormatter = new BinaryFormatter();
     bFormatter.Serialize(stream, mesh);
     stream.Close();
 }
Пример #13
0
 public bool talk()
 {
     try
     {
         if (null != sendPro)
         {
             TcpClient client = new TcpClient();
             client.Connect(IPAddress.Parse(ClientInfo.confMap.value(strClientConfKey.ServerIP)),
                 int.Parse(ClientInfo.confMap.value(strClientConfKey.ServerPort)));
             NetworkStream ns = client.GetStream();
             IFormatter formatter = new BinaryFormatter();
             formatter.Serialize(ns, sendPro);
             reseivePro = (Protocol)formatter.Deserialize(ns);
             client.Close();
         }
         else
         {
             return false;
         }
         return true;
     }
     catch (Exception)
     {
         return false;
     }
 }
Пример #14
0
        public void TestVFSException()
        {
            var e1 = new VFSException();
            Assert.IsTrue(e1.Message.Contains("VFSException"));

            var e2 = new VFSException("a");
            Assert.AreEqual("a", e2.Message);

            var e3 = new VFSException("a", new Exception("x"));
            Assert.AreEqual("a", e3.Message);
            Assert.AreEqual("x", e3.InnerException.Message);

            using (var ms = new MemoryStream())
            {
                var serializer = new BinaryFormatter();
                serializer.Serialize(ms, e3);
                ms.Seek(0, SeekOrigin.Begin);

                var e4 = serializer.Deserialize(ms) as VFSException;

                Assert.IsNotNull(e4);
                Assert.AreEqual("a", e4.Message);
                Assert.AreEqual("x", e4.InnerException.Message);
            }
        }
        private bool SetValue(object currentValue, out object newValue)
        {
            DTE dte = this.GetService<DTE>(true);
            IDictionaryService dictionaryService = (IDictionaryService)ServiceHelper.GetService(this, typeof(IDictionaryService));

            try
            {
                if (!string.IsNullOrEmpty(RecipeArgument))
                {

                    string argumentvalue = dictionaryService.GetValue(RecipeArgument).ToString();
                    Version v = new Version(argumentvalue);
                    if (v != null)
                    {
                        byte[] bytes;
                        long length = 0;
                        MemoryStream ws = new MemoryStream();
                        BinaryFormatter sf = new BinaryFormatter();
                        sf.Serialize(ws, v);
                        length = ws.Length;
                        bytes = ws.GetBuffer();
                        newValue = Convert.ToBase64String(bytes, 0, bytes.Length, Base64FormattingOptions.None);
                        return true;
                    }
                }
            }
            catch { }
            //string projectId = currentProject.

            newValue = "";
            return false;
        }
Пример #16
0
        public Guid SendJob(Base activity)
        {
            if (_ConnectionToManager == null || !_ConnectionToManager.IsConnected()) throw new Exception("Not connected to the manager");

            while (true)
            {
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                MemoryStream datastream = new MemoryStream();
                binaryFormatter.Serialize(datastream, activity);
                Packet p = new Packet(1000);
                Byte[] data= datastream.ToArray();
                p.Add(data,true);
                _ConnectionToManager.SendPacket(p);
                Stopwatch sendTime = new Stopwatch();
                sendTime.Start();
                while (sendTime.ElapsedMilliseconds < _CommsTimeout)
                {
                    if (_ConnectionToManager.GetPacketsToProcessCount() > 0)
                    {
                        foreach (Guid jobGuid in from packet in _ConnectionToManager.GetPacketsToProcess() where packet.Type == 1001 select new Guid((Byte[]) packet.GetObjects()[0]))
                        {

                            return jobGuid;
                        }
                    }
                    Thread.Sleep(1);
                }
                if (_ConnectionToManager.IsConnected()) _ConnectionToManager.Disconnect();
                _ConnectionToManager.Connect(_IpAddress, _Port, 20480 * 1024);
            }
            throw new Exception("Mananger unavailable or busy");
        }
Пример #17
0
 public static MemoryStream SerializeToStream(object o)
 {
     MemoryStream stream = new MemoryStream();
     IFormatter formatter = new BinaryFormatter();
     formatter.Serialize(stream, o);
     return stream;
 }
Пример #18
0
 static void Main(string[] args)
 {
     string quit = "n";
     while (quit == "n")
     {
         ITransport transport = TcpTransport.CreateTransport(45459);
         if (transport != null)
         {
             IEvent e = new TcpEvent((int)EventId.Media, null);
             BinaryFormatter bf = new BinaryFormatter();
             MemoryStream mem = new MemoryStream();
             bf.Serialize(mem, e);
             transport.Send(mem.GetBuffer());
             Console.WriteLine("Quit?(y/n)");
             quit = Console.ReadLine();
             transport.Close();
             //if (quit != "n")
             //{
             //    Console.WriteLine("send disconned event to Server to close the server");
             //    IEvent d = new TcpEvent((int)EventId.Disconnect, null);
             //    BinaryFormatter bfd = new BinaryFormatter();
             //    MemoryStream memd = new MemoryStream();
             //    bfd.Serialize(memd, d);
             //    transport.Send(memd.GetBuffer());
             //    transport.Close();
             //}
         }
     }
 }
Пример #19
0
        public ManufacturersForm(GXManufacturerCollection manufacturers, string selectedManufacturer)
        {
            InitializeComponent();
            NameCH.Width = -2;
            UpdateValues();
            InactivityModeTB.Enabled = StartProtocolTB.Enabled = NameTB.Enabled = ManufacturerIdTB.Enabled = UseLNCB.Enabled = UseIEC47CB.Enabled = false;
            ManufacturersOriginal = manufacturers;

            //Create clone from original items.
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(ms, manufacturers);
            ms.Position = 0;
            Manufacturers = (GXManufacturerCollection)bf.Deserialize(ms);
            ms.Close();
            bool bSelected = false;
            foreach (GXManufacturer it in Manufacturers)
            {
                if (!it.Removed)
                {
                    ListViewItem item = AddManufacturer(it);
                    if (it.Identification == selectedManufacturer)
                    {
                        bSelected = item.Selected = true;
                    }
                }
            }
            //Select first item
            if (ManufacturersList.Items.Count != 0 && !bSelected)
            {
                ManufacturersList.Items[0].Selected = true;
            }
        }
Пример #20
0
 private static Object DeserializeFromMemory(Stream stream)
 {
     //构造一个序列化格式化器来做所有辛苦的工作
     BinaryFormatter formatter = new BinaryFormatter();
     //告诉格式化器从流中反序列化对象
     return formatter.Deserialize(stream);
 }
Пример #21
0
        public void TestRoundTripElementSerialisation()
        {
            // Use a BinaryFormatter or SoapFormatter.
            IFormatter formatter = new BinaryFormatter();
            //IFormatter formatter = new SoapFormatter();

            // Create an instance of the type and serialize it.
            var elementId = new SerializableId
            {
                IntID = 42,
                StringID = "{BE507CAC-7F23-43D6-A2B4-13F6AF09046F}"
            };

            //Serialise to a test memory stream
            var m = new MemoryStream();
            formatter.Serialize(m, elementId);
            m.Flush();

            //Reset the stream
            m.Seek(0, SeekOrigin.Begin);

            //Readback
            var readback = (SerializableId)formatter.Deserialize(m);

            Assert.IsTrue(readback.IntID == 42);
            Assert.IsTrue(readback.StringID.Equals("{BE507CAC-7F23-43D6-A2B4-13F6AF09046F}"));
        }
Пример #22
0
        /// <summary>
        /// Creates the crash dump.
        /// </summary>
        public static void CreateCrashDump()
        {
            if (!Directory.Exists("Dumps"))
                Directory.CreateDirectory("Dumps");

            Log.Info("Creating crash dump...");

            try
            {
                using (var fs =
                    File.Open(
                        Path.Combine(Environment.CurrentDirectory, "Dumps",
                                     string.Format("{0}.acd", DateTime.Now.ToString("yyyy_MM_dd_HH_mm"))),
                        FileMode.Create))
                {

                    var formatter = new BinaryFormatter();

                    var bot = AlarisBot.Instance;

                    formatter.Serialize(fs, bot);

                }
            }
            catch(Exception x)
            {
                Log.Fatal("Failed to write crash dump. ({0})", x);
                return;
            }

            Log.Info("Crash dump created.");
        }
Пример #23
0
        //Méthode statique pour l'envoi et la réception
        public void Send(Paquet paquet, NetworkStream stream)
        {
            BinaryFormatter bf = new BinaryFormatter();

            bf.Serialize(stream, paquet);
            stream.Flush();
        }
 public void Save()
 {
     Stream stream = File.Open(filepath, FileMode.Create);
     BinaryFormatter bFormatter = new BinaryFormatter();
     bFormatter.Serialize(stream, this);
     stream.Close();
 }
		public Constants.LoginStatus logon(User user)
		{
			Constants.LoginStatus retval = Constants.LoginStatus.STATUS_SERVERNOTREACHED;
			byte[] message = new byte[Constants.WRITEBUFFSIZE];
			byte[] reply;
			MemoryStream stream = new MemoryStream(message);

			try
			{
				//Serialize data in memory so you can send them as a continuous stream
				BinaryFormatter serializer = new BinaryFormatter();
				
				NetLib.insertEntropyHeader(serializer, stream);

				serializer.Serialize(stream, Constants.MessageTypes.MSG_LOGIN);
				serializer.Serialize(stream, user.ringsInfo[0].ring.ringID);
				serializer.Serialize(stream, user.ringsInfo[0].userName);
				serializer.Serialize(stream, user.ringsInfo[0].password);
				serializer.Serialize(stream, user.node.syncCommunicationPoint);
				reply = NetLib.communicate(Constants.SERVER2,message, true);
				stream.Close();
				stream = new MemoryStream(reply);
				NetLib.bypassEntropyHeader(serializer, stream);
				Constants.MessageTypes replyMsg = (Constants.MessageTypes)serializer.Deserialize(stream);

				switch(replyMsg)
				{
					case Constants.MessageTypes.MSG_OK:
						ulong sessionID = (ulong)serializer.Deserialize(stream);
						uint numRings = (uint)serializer.Deserialize(stream);
						uint ringID;
						Ring ring;
						for(uint ringCounter = 0; ringCounter < numRings; ringCounter++)
						{
							LordInfo lordInfo = (LordInfo)serializer.Deserialize(stream);
							ring = RingInfo.findRingByID(user.ringsInfo, lordInfo.ringID);
							ring.lords = lordInfo.lords;
						}
						
						user.loggedIn = true;
						retval = Constants.LoginStatus.STATUS_LOGGEDIN;
						break;
					case Constants.MessageTypes.MSG_NOTAMEMBER:
						retval = Constants.LoginStatus.STATUS_NOTAMEMBER;
						break;
					case Constants.MessageTypes.MSG_ALREADYSIGNEDIN:
						retval = Constants.LoginStatus.STATUS_ALREADYSIGNEDIN;
						break;
					default:
						break;
				}
			}
			catch (Exception e)
			{
				
				int x = 2;
			}

			return retval;
		}
        public void Save(TelemetryLap lap, string fileName)
        {
            try
            {

                if (lap == null)
                    return;

                if (File.Exists(fileName))
                    File.Delete(fileName);

                using (Stream stream = File.Open(fileName, FileMode.Create))
                {
                    var binFormatter = new BinaryFormatter();
                    binFormatter.Serialize(stream, lap);
                    stream.Close();
                }
            } catch (Exception ex)
            {
                #if DEBUG
                logger.Error("Count not save binary telemetry lap", ex);
            #endif
                throw ex;
            }
        }
Пример #27
0
        public int Run()
        {
            try
            {
                Stream codeStream = LocateCode();
                var formatter = new BinaryFormatter();
                var reader = new ScriptEngine.Compiler.ModulePersistor(formatter);
                var moduleHandle = reader.Read(codeStream);
                var engine = new HostedScriptEngine();
                var src = new BinaryCodeSource(moduleHandle);

                var process = engine.CreateProcess(this, moduleHandle, src);
                return process.Start();
                
            }
            catch (ScriptInterruptionException e)
            {
                return e.ExitCode;
            }
            catch (Exception e)
            {
                this.ShowExceptionInfo(e);
                return 1;
            }

        }
Пример #28
0
 public static void LoadFromFile(string filePath, object options)
 {
     FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
     BinaryFormatter bf = new BinaryFormatter();
     options = bf.Deserialize(fs);
     fs.Close();
 }
Пример #29
0
        public Base GetCompletedWork(Guid jobGuid)
        {
            if (_ConnectionToManager == null || !_ConnectionToManager.IsConnected()) throw new Exception("Not connected to the manager");

            while (true)
            {
                Packet p = new Packet(1100);
                p.Add(jobGuid.ToByteArray(),true);
                _ConnectionToManager.SendPacket(p);
                Stopwatch sendTime = new Stopwatch();
                sendTime.Start();
                while (sendTime.ElapsedMilliseconds < _CommsTimeout)
                {
                    if (_ConnectionToManager.GetPacketsToProcessCount() > 0)
                    {
                        foreach (Packet packet in _ConnectionToManager.GetPacketsToProcess())
                        {
                            switch (packet.Type)
                            {
                                case 1101:
                                    return null;
                                case 1102:
                                    Object[] packetObjects = packet.GetObjects();
                                    BinaryFormatter binaryFormatter = new BinaryFormatter();
                                    return (Base) binaryFormatter.Deserialize(new MemoryStream((Byte[]) packetObjects[0]));
                            }
                        }
                        Thread.Sleep(100);
                    }
                }
                if (_ConnectionToManager.IsConnected())_ConnectionToManager.Disconnect();
                _ConnectionToManager.Connect(_IpAddress, _Port, 204800);
            }
            return null;
        }
Пример #30
0
        public override void OnSaveData()
        {
            LoggerUtilities.Log("Saving road names");

            BinaryFormatter binaryFormatter = new BinaryFormatter();
            MemoryStream memoryStream = new MemoryStream();

            try
            {
                RoadContainer[] roadNames = RoadNameManager.Instance().Save();

                if (roadNames != null)
                {
                    binaryFormatter.Serialize(memoryStream, roadNames);
                    serializableDataManager.SaveData(dataKey, memoryStream.ToArray());
                    LoggerUtilities.Log("Road names have been saved!");
                }
                else
                {
                    LoggerUtilities.LogWarning("Couldn't save road names, as the array is null!");
                }
            }
            catch (Exception ex)
            {
                LoggerUtilities.LogException(ex);
            }
            finally
            {
                memoryStream.Close();
            }
        }
        /// <summary>
        /// Deserializes a <see cref="Stream"/> to the specified <paramref name="instance"/>.
        /// </summary>
        /// <param name="instance">The instance that the <paramref name="stream"/> will be deserialized to.</param>
        /// <param name="stream">The <see cref="Stream"/> containing the data to deserialize.</param>
        /// <exception cref="ArgumentNullException"> thrown if the <paramref name="instance"/> or <paramref name="stream"/> is <c>Null</c>.</exception>
        public static void Deserialize(this IBinarySerializable instance, Stream stream)
        {
            if (instance.IsNull())
            {
                throw new ArgumentNullException("instance");
            }

            if (stream.IsNull())
            {
                throw new ArgumentNullException("stream");
            }

            Formatters.Binary.BinaryFormatter formatter = new Formatters.Binary.BinaryFormatter();
            formatter.Deserialize(stream).CopyTo(instance);
        }
Пример #32
0
    // 加载地图
    public void LoadMapBlockData(string path)
    {
        if (!File.Exists(path))
        {
            return;
        }

        using (FileStream stream = File.Open(path, FileMode.Open))
        {
            MapSaveData map_save_data   = new MapSaveData();
            var         binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            map_save_data = (MapSaveData)binaryFormatter.Deserialize(stream);

            map_width   = map_save_data.map_width;
            map_height  = map_save_data.map_height;
            map_step    = map_save_data.map_step;
            _grid_array = map_save_data.grid_array;

            InitMeshComponent();
            UpdateMesh();
        }
    }
Пример #33
0
 public static bool SaveSnapshotBin(string binFilePath, string binFileName, PackedMemorySnapshot packed)
 {
     try
     {
         string fullName = Path.Combine(binFilePath, binFileName);
         if (!File.Exists(fullName))
         {
             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
             using (Stream stream = File.Open(fullName, FileMode.Create))
             {
                 bf.Serialize(stream, packed);
             }
         }
         return(true);
     }
     catch (Exception ex)
     {
         Debug.LogError(string.Format("save snapshot error ! msg ={0}", ex.Message));
         Debug.LogException(ex);
         return(false);
     }
 }
Пример #34
0
    public void SaveIt()
    {
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
        System.IO.FileStream fs = new System.IO.FileStream(Application.dataPath + "SaveMesh.dat", System.IO.FileMode.Create);

        Serialize_Mesh Ser_Mesh = new Serialize_Mesh(filter.mesh);

        bf.Serialize(fs, Ser_Mesh);
        fs.Close();

        float red   = this.GetComponent <Renderer>().material.color.r;
        float green = this.GetComponent <Renderer>().material.color.g;
        float blue  = this.GetComponent <Renderer>().material.color.b;
        float alpha = this.GetComponent <Renderer>().material.color.a;

        string mycolor = red + " " + green + " " + blue + " " + alpha;

        Debug.Log(mycolor + "......................................");
        string path = Application.dataPath + "file.txt";

        System.IO.File.WriteAllText(path, mycolor);
    }
Пример #35
0
    public bool saveAllSnapshot(List <MemSnapshotInfo> snapshotInfos, eProfilerMode profilerMode, string ip = null)
    {
        if (snapshotInfos.Count <= 0)
        {
            return(false);
        }

        try
        {
            _basePath = combineBasepath(profilerMode, ip);

            if (!Directory.Exists(_basePath))
            {
                Directory.CreateDirectory(_basePath);
            }

            for (int index = 0; index < snapshotInfos.Count; index++)
            {
                var    packed   = snapshotInfos[index];
                string fileName = Path.Combine(_basePath, string.Format("{0}.memsnap", index));
                if (!File.Exists(fileName))
                {
                    saveSnapshotJson(index, packed);
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    using (Stream stream = File.Open(fileName, FileMode.Create))
                    {
                        bf.Serialize(stream, packed);
                    }
                }
            }
            return(true);
        }
        catch (Exception ex)
        {
            Debug.LogError(string.Format("save snapshot error ! msg ={0}", ex.Message));
            Debug.LogException(ex);
            return(false);
        }
    }
Пример #36
0
    static void Main(string[] args)
    {
        List <salesman> salesmanList      = new List <salesman>();
        string          dir               = @"c:\temp";
        string          serializationFile = Path.Combine(dir, "salesmen.bin");

        //serialize
        using (Stream stream = File.Open(serializationFile, FileMode.Create))
        {
            var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

            bformatter.Serialize(stream, salesmanList);
        }

        //deserialize
        using (Stream stream = File.Open(serializationFile, FileMode.Open))
        {
            var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

            List <salesman> salesman = (List <salesman>)bformatter.Deserialize(stream);
        }
    }
Пример #37
0
    static void construct_bulknpose_bundle()
    {
        //new version, serializes as a dictionary in one big file
        IEnumerable <Object> files = Selection.GetFiltered(typeof(Object), SelectionMode.DeepAssets).Where(e => is_text_file(e));

        Debug.Log("making a pose bundle out of " + files.Count() + " files");
        Dictionary <string, string> index = new Dictionary <string, string> ();

        foreach (var e in files)
        {
            index[e.name] = (e as TextAsset).text;
            Debug.Log("set data for " + e.name);
        }


        AssetDatabase.ImportAsset("Assets/POSEDICT.txt");
        TextAsset cdtxt = (TextAsset)AssetDatabase.LoadAssetAtPath("Assets/POSEDICT.txt", typeof(TextAsset));

        System.IO.Stream stream = System.IO.File.Open(AssetDatabase.GetAssetPath(cdtxt), System.IO.FileMode.Create);
        //System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(Dictionary<string,string>));
        //xs.Serialize(stream, index);
        var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

        bf.Serialize(stream, index);
        stream.Close();
        AssetDatabase.ImportAsset("Assets/POSEDICT.txt");
        cdtxt = (TextAsset)AssetDatabase.LoadAssetAtPath("Assets/POSEDICT.txt", typeof(TextAsset));

        List <Object> assets = new List <Object> ();

        assets.Add(cdtxt);

        BuildPipeline.BuildAssetBundle(
            Selection.activeObject, assets.ToArray(),
            "Assets/Resources/BULKPOSES.unity3d",
            BuildAssetBundleOptions.CollectDependencies | BuildAssetBundleOptions.CompleteAssets,
            EditorUserBuildSettings.activeBuildTarget);            //, BuildOptions.UncompressedAssetBundle);//, BuildAssetBundleOptions.CollectDependencies | BuildAssetBundleOptions.CompleteAssets);
    }
Пример #38
0
    private DataSet decom(byte[] data)
    {
        var dt = new DataSet();

        try
        {
            var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            formatter.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
            //formatter.Binder = new MyBinder();
            using (var ms = new MemoryStream(data))
            {
                using (var desr = new GZipStream(ms, CompressionMode.Decompress, true))
                {
                    dt = formatter.Deserialize(desr) as DataSet;
                }
            }
        }
        catch (Exception ex)
        {
            dt = null;   // removed error handling logic!
        }
        return(dt);
    }
Пример #39
0
    /// <summary>
    /// Saves the given settings object to the standard location
    /// </summary>
    /// <param name="settings"></param>
    public static void saveSettings(SettingsObj settings)
    {
        if (settings == null)           // can't save the object if there is no object
        {
            throw new System.ArgumentException("Parameter \"settings\" cannot be null");
        }
        Stream stream = null;

        try {           // crashing due to file access issues is a bitch, so don't crash
            System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            //Debug.Log("Saving to File: \"" + Application.persistentDataPath + "\\Settings.txt\"");
            stream = new FileStream(Application.persistentDataPath + "\\Settings.txt", FileMode.Create, FileAccess.Write);
            formatter.Serialize(stream, settings);
            stream.Close();
        } catch (System.Exception e) {
            Debug.Log(e.Message);               // notify me about any exceptions.
            if (stream != null)                 // make sure the stream is closed if an exception was generated.
            {
                stream.Close();
            }
        }
        return;
    }
Пример #40
0
    public static StaticVariables Load(string filename, ref List <string> messages)
    {
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
        FileStream      fromStream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
        StaticVariables sv         = null;

        try {
            sv = (StaticVariables)formatter.Deserialize(fromStream);
            sv.verifyPrimitiveDataTypesExist();
        } catch (Exception ex) {
            //Interaction.MsgBox("Oops, we could not load the variables due to the following error: "
            messages.Add("Oops, we could not load the variables due to the following error: " + ex.Message);
        } finally {
            if (fromStream != null)
            {
                fromStream.Close();
                fromStream.Dispose();
            }
        }


        return(sv);
    }
Пример #41
0
        public void Layout()
        {
            string decision;

            do
            {
                Console.WriteLine("\t ===============================");
                Console.WriteLine("\t|\t1.Manage To-do List\t|");
                Console.WriteLine("\t|\t2.Manage My-day List\t|");
                Console.WriteLine("\t|\t3.Exit\t\t\t|");
                Console.WriteLine("\t ===============================");
                Console.Write("\t\tPlease choose: ");

                decision = Console.ReadLine();

                if (decision != "1" && decision != "2" && decision != "3")
                {
                    Console.WriteLine("\nWrong input. Please choose again.\n");
                }
            } while (decision != "1" && decision != "2" && decision != "3");

            switch (decision)
            {
            case "1":
                menutodoList();
                break;

            case "2":
                //menumyDayList();
                break;

            case "3":
                break;
            }

            void menutodoList()
            {
                string dir = @"c:\temp";
                string serializationFile = Path.Combine(dir, "salesmen.bin");

                while (true)
                {
                    string menuTaskDecision = "";

                    //Menu Student
                    while (menuTaskDecision != "1" && menuTaskDecision != "2" && menuTaskDecision != "3" && menuTaskDecision != "4" && menuTaskDecision != "5" && menuTaskDecision != "6")
                    {
                        Console.WriteLine("\t*****************************************");
                        Console.WriteLine("\t*\t\tTask in List: \t\t*");
                        foreach (var it in todoList)
                        {
                            Console.Write("\t*\t");
                            it.DisplayList();
                        }
                        Console.WriteLine("\t*****************************************");
                        Console.WriteLine("");
                        Console.WriteLine("\t ===============================");
                        Console.WriteLine("\t|\t1.Add new item\t\t|");
                        Console.WriteLine("\t|\t2.Delete item\t\t|");
                        Console.WriteLine("\t|\t3.Update item\t\t|");
                        Console.WriteLine("\t|\t4.Back to main menu\t|");
                        Console.WriteLine("\t|\t5.Save List\t\t|");
                        Console.WriteLine("\t|\t6.Load List\t\t|");
                        Console.WriteLine("\t ===============================");
                        Console.Write("\t\tPlease choose: ");
                        menuTaskDecision = Console.ReadLine();
                        if (menuTaskDecision != "1" && menuTaskDecision != "2" && menuTaskDecision != "3" && menuTaskDecision != "4" && menuTaskDecision != "5" && menuTaskDecision != "6")
                        {
                            Console.WriteLine("Wrong Input! Please try again");
                        }
                    }

                    switch (Convert.ToInt32(menuTaskDecision))
                    {
                    case 1:
                        Input(todoList, 0);
                        break;

                    case 2:
                        Console.WriteLine("Please enter task name that you want to delete: ");
                        String TaskDeleteValue = Console.ReadLine();
                        Console.WriteLine(CheckDelete(TaskDeleteValue, todoList));
                        NumberTask(todoList);
                        menutodoList();

                        break;

                    case 3:
                        Console.WriteLine("Please enter task Name that you want to update: ");
                        String studentUpdateValue = Console.ReadLine();
                        CheckUpdate(studentUpdateValue, todoList);
                        menutodoList();
                        break;

                    case 4:
                        Layout();
                        break;

                    case 5:
                        //serialize
                        using (Stream stream = File.Open(serializationFile, FileMode.Create))
                        {
                            var bformatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

                            bformatter.Serialize(stream, todoList);
                        }

                        /*var fileName = @"E:\Desktop\wordss.txt";
                         * if(!File.Exists(fileName))
                         * {
                         *      FileStream fsCreate = new FileStream(fileName, FileMode.Create);
                         *      fsCreate.Close();
                         *      Console.Write($"File has been created and the Path is {fileName}");
                         * }
                         * FileStream fs = new FileStream(fileName, FileMode.Append);
                         * byte[] bdata = Encoding.Default.GetBytes("Hello File Handling!");
                         * fs.Write(bdata, 0, bdata.Length);
                         * fs.Close();*/
                        break;

                    case 6:
                        try
                        {
                            using (Stream stream = File.Open(serializationFile, FileMode.Open))
                            {
                                BinaryFormatter bin = new BinaryFormatter();

                                var tasklist = (List <TaskItem>)bin.Deserialize(stream);
                                foreach (var taskload in tasklist)
                                {
                                    todoList.Add(taskload);
                                }
                            }
                        }
                        catch (IOException)
                        {
                        }

                        break;
                    }
                }
            }
        }
Пример #42
0
    private void setTypeValue(string fieldname, string type, string Value)
    {
        FieldInfo info = obj.GetType().GetField(fieldname, flags);

        if (info == null)
        {
            try
            {
                Type type1 = obj.GetType().BaseType;
                while (type1 != null)
                {
                    info = type1.GetField(fieldname, flags);
                    if (info == null)
                    {
                        try
                        {
                            type1 = type1.BaseType;
                        }
                        catch { type = null; }
                    }
                    else
                    {
                        break;
                    }
                }
            }
            catch
            {
            }
        }
        Type valueType = info.FieldType;

        if (valueType == typeof(string))
        {
            info.SetValue(obj, Value);
        }
        else if (valueType == typeof(char))
        {
            info.SetValue(obj, char.Parse(Value));
        }
        else if (valueType == typeof(bool))
        {
            info.SetValue(obj, Boolean.Parse(Value));
        }
        else if (valueType == typeof(sbyte))
        {
            info.SetValue(obj, sbyte.Parse(Value));
        }
        else if (valueType == typeof(byte))
        {
            info.SetValue(obj, byte.Parse(Value));
        }
        else if (valueType == typeof(ushort))
        {
            info.SetValue(obj, ushort.Parse(Value));
        }
        else if (valueType == typeof(short))
        {
            info.SetValue(obj, short.Parse(Value));
        }
        else if (valueType == typeof(uint))
        {
            info.SetValue(obj, uint.Parse(Value));
        }
        else if (valueType == typeof(int))
        {
            info.SetValue(obj, int.Parse(Value));
        }
        else if (valueType == typeof(ulong))
        {
            info.SetValue(obj, ulong.Parse(Value));
        }
        else if (valueType == typeof(long))
        {
            info.SetValue(obj, long.Parse(Value));
        }
        else if (valueType == typeof(float))
        {
            info.SetValue(obj, float.Parse(Value));
        }
        else if (valueType == typeof(Single))
        {
            info.SetValue(obj, Single.Parse(Value));
        }
        else if (valueType == typeof(double))
        {
            info.SetValue(obj, double.Parse(Value));
        }
        else if (valueType == typeof(decimal))
        {
            info.SetValue(obj, decimal.Parse(Value));
        }
        else if (valueType == typeof(DateTime))
        {
            info.SetValue(obj, DateTime.Parse(Value));
        }
        else if (valueType.BaseType == typeof(Array))
        {
            setArrayValue(info, Value);
        }
        else if (valueType.BaseType == typeof(XmlSerializer))
        {
            string xmlcode = System.Text.Encoding.Default.GetString(Convert.FromBase64String(Value));
            object o       = Activator.CreateInstance(valueType);
            info.SetValue(obj, ((XmlSerializer)o).DeSerialize(xmlcode));
        }
        else
        {
            byte[]       bytes = Convert.FromBase64String(Value);
            MemoryStream ms    = new MemoryStream();
            ms.Write(bytes, 0, bytes.Length);
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            object obj3 = bf.Deserialize(ms);
            info.SetValue(obj, obj3);
        }
    }
Пример #43
0
 /*******************************/
 public static void Serialize(System.IO.BinaryWriter binaryWriter, System.Object obj)
 {
     System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
     formatter.Serialize(binaryWriter.BaseStream, obj);
 }
Пример #44
0
 /*******************************/
 public static System.Object Deserialize(System.IO.BinaryReader binaryReader)
 {
     System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
     return(formatter.Deserialize(binaryReader.BaseStream));
 }
Пример #45
0
    public void Enable(AudioClip _loadedClip)
    {
        if (!Serializer.IsExtratingClip && Serializer.ClipExtratedComplete)
        {
            audioSource.clip  = _loadedClip;
            audioSourceLoaded = true;
            m_Slider.maxValue = audioSource.clip.length;
            m_Slider.value    = 0;
            if (IsSpectrumCached())
            {
                try {
                    using (FileStream file = File.OpenRead(spectrumCachePath + Serializer.CleanInput(Serializer.ChartData.AudioName + spc_ext))) {
                        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        preProcessedSpectralFluxAnalyzer = (SpectralFluxAnalyzer)bf.Deserialize(file);
                    }

                    EndSpectralAnalyzer();
                    Debug.Log("Spectrum loaded from cached");
                } catch (Exception ex) {
                    Miku_DialogManager.ShowDialog(Miku_DialogManager.DialogType.Alert,
                                                  "Error while dezerializing Spectrum " + ex.ToString()
                                                  );
                    Debug.Log(ex.ToString());
                }
            }
            else
            {
                Debug.Log("Spectrum data not cached!");
            }
        }
    }
Пример #46
0
    public void LoadSession()
    {
        string pathName = EditorUtility.OpenFolderPanel("Load Snapshot Folder", MemUtil.SnapshotsDir, "");

        if (string.IsNullOrEmpty(pathName))
        {
            return;
        }

        List <object> packeds = new List <object>();

        try
        {
            DirectoryInfo TheFolder = new DirectoryInfo(pathName);
            if (!TheFolder.Exists)
            {
                throw new Exception(string.Format("bad path: {0}", TheFolder.ToString()));
            }

            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            foreach (var file in TheFolder.GetFiles())
            {
                var fileName = file.FullName;
                if (fileName.EndsWith(".memsnap"))
                {
                    using (Stream stream = File.Open(fileName, FileMode.Open))
                    {
                        packeds.Add(bf.Deserialize(stream));
                    }
                }
            }

            if (packeds.Count == 0)
            {
                MemUtil.NotifyError("no snapshots found.");
                return;
            }
        }
        catch (Exception ex)
        {
            Debug.LogError(string.Format("load snapshot error ! msg ={0}", ex.Message));
            return;
        }

        Clear();

        foreach (var obj in packeds)
        {
            MemSnapshotInfo memInfo = new MemSnapshotInfo();
            if (memInfo.AcceptSnapshot(obj as PackedMemorySnapshot))
            {
                _snapshots.Add(memInfo);
            }
        }

        if (_snapshots.Count == 0)
        {
            MemUtil.NotifyError("empty snapshot list, ignored.");
            return;
        }

        RefreshIndices();
        _selected = _snapshots.Count - 1;
    }
Пример #47
0
 public void Save(MemoryStream stream)
 {
     System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
     formatter.Serialize(stream, this);
     stream.Close();
 }
Пример #48
0
    private void setArrayValue(FieldInfo info, string Value)
    {
        Match  regex;
        string xmlcodes = System.Text.Encoding.Default.GetString(Convert.FromBase64String(Value));

        string[] strings  = xmlcodes.Split('\n');
        string   regexstr = @"<List Length='(.*)' Type='(.*)'>";
        int      length   = 0;
        Type     listType = null;

        foreach (string str in strings)
        {
            if (str == "" || str == "<nullreferance>")
            {
                continue;
            }
            try
            {
                regex = Regex.Match(str, regexstr);
                if (regex.Groups[1].Value != "")
                {
                    length   = Convert.ToInt32(regex.Groups[1].Value);
                    listType = Type.GetType(regex.Groups[2].Value);
                }
            }
            catch {
            }
        }
        Array arr       = null;
        int   selectval = -1;

        regexstr = @"<Arr_(.*) Type='(.*)'>(.*)</Arr_(.*)>";
        foreach (string str in strings)
        {
            if (str == "" || str == "<nullreferance>")
            {
                continue;
            }
            try
            {
                regex = Regex.Match(str, regexstr);
                if (regex.Groups[1].Value != "" |
                    regex.Groups[2].Value != "" |
                    regex.Groups[3].Value != "")
                {
                    selectval++;
                    Type valueType = Type.GetType(regex.Groups[2].Value);
                    if (arr == null)
                    {
                        arr = Array.CreateInstance(valueType, length);
                    }
                    if (valueType == typeof(string))
                    {
                        arr.SetValue(regex.Groups[3].Value, selectval);
                    }
                    else if (valueType == typeof(char))
                    {
                        arr.SetValue(char.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(bool))
                    {
                        arr.SetValue(Boolean.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(sbyte))
                    {
                        arr.SetValue(sbyte.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(byte))
                    {
                        arr.SetValue(byte.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(ushort))
                    {
                        arr.SetValue(ushort.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(short))
                    {
                        arr.SetValue(short.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(uint))
                    {
                        arr.SetValue(uint.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(int))
                    {
                        arr.SetValue(int.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(ulong))
                    {
                        arr.SetValue(ulong.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(long))
                    {
                        arr.SetValue(long.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(float))
                    {
                        arr.SetValue(float.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(Single))
                    {
                        arr.SetValue(Single.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(double))
                    {
                        arr.SetValue(double.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(decimal))
                    {
                        arr.SetValue(decimal.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(DateTime))
                    {
                        arr.SetValue(DateTime.Parse(regex.Groups[3].Value), selectval);
                    }
                    else if (valueType == typeof(Array))
                    {
                        setArrayValue(info, regex.Groups[3].Value);
                    }
                    else if (valueType.BaseType == typeof(XmlSerializer))
                    {
                        string xmlcode = System.Text.Encoding.Default.GetString(Convert.FromBase64String(regex.Groups[3].Value));
                        object o       = Activator.CreateInstance(valueType);
                        arr.SetValue(((XmlSerializer)o).DeSerialize(xmlcode), selectval);
                    }
                    else
                    {
                        byte[]       bytes = Convert.FromBase64String(regex.Groups[3].Value);
                        MemoryStream ms    = new MemoryStream();
                        ms.Write(bytes, 0, bytes.Length);
                        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        object obj3 = bf.Deserialize(ms);
                        arr.SetValue(obj3, selectval);
                    }
                }
            }
            catch {
            }
        }
        info.SetValue(obj, arr);
    }
    static PackedMemorySnapshot LoadFromFile(string filePath)
    {
#if UNITY_5_OR_NEWER
        PackedMemorySnapshot result = null;
        string fileExtension        = Path.GetExtension(filePath);

        if (string.Equals(fileExtension, ".memsnap2", System.StringComparison.OrdinalIgnoreCase))
        {
            UnityEngine.Profiling.Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(json)");

            var json = File.ReadAllText(filePath);
            result = JsonUtility.FromJson <PackedMemorySnapshot>(json);

            UnityEngine.Profiling.Profiler.EndSample();
        }
        else if (string.Equals(fileExtension, ".memsnap", System.StringComparison.OrdinalIgnoreCase))
        {
            UnityEngine.Profiling.Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(binary)");

            var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            using (Stream stream = File.Open(filePath, FileMode.Open))
            {
                result = binaryFormatter.Deserialize(stream) as PackedMemorySnapshot;
            }

            UnityEngine.Profiling.Profiler.EndSample();
        }
        else
        {
            Debug.LogErrorFormat("MemoryProfiler: Unrecognized memory snapshot format '{0}'.", filePath);
        }

        return(result);
#else
        PackedMemorySnapshot result = null;
        string fileExtension        = Path.GetExtension(filePath);

        if (string.Equals(fileExtension, ".memsnap2", System.StringComparison.OrdinalIgnoreCase))
        {
            Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(json)");

            var json = File.ReadAllText(filePath);
            result = JsonUtility.FromJson <PackedMemorySnapshot>(json);

            Profiler.EndSample();
        }
        else if (string.Equals(fileExtension, ".memsnap", System.StringComparison.OrdinalIgnoreCase))
        {
            Profiler.BeginSample("PackedMemorySnapshotUtility.LoadFromFile(binary)");

            var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            using (Stream stream = File.Open(filePath, FileMode.Open))
            {
                result = binaryFormatter.Deserialize(stream) as PackedMemorySnapshot;
            }

            Profiler.EndSample();
        }
        else
        {
            Debug.LogErrorFormat("MemoryProfiler: Unrecognized memory snapshot format '{0}'.", filePath);
        }

        return(result);
#endif
    }