//------------------------------------------------------------------------------ static public T StringToObject <T>(string stringValue) { using (var ms = new MemoryStream()) { var byteValue = Convert.FromBase64String(stringValue); ms.Write(byteValue, 0, byteValue.Length); ms.Seek(0, SeekOrigin.Begin); var settings = SettingsBaseConfiguration.AdvancedConfigurationInternal.SharpSerializerSettings; var old_tnc = settings.AdvancedSettings.TypeNameConverter; try { var tnc = new TypeNameConverter(old_tnc); settings.AdvancedSettings.TypeNameConverter = tnc; var serializer = new SharpSerializer(settings); var result = serializer.Deserialize(ms); return((T)result); } finally { settings.AdvancedSettings.TypeNameConverter = old_tnc; } } }
public object Deserialize(string obj, Type type) { var bytes = Convert.FromBase64String(obj); var mem = new MemoryStream(bytes); return(_complexSerializer.Deserialize(mem)); }
public static object DeserializeObject(string xmlOfAnObject) { if (xmlOfAnObject.StartsWith("?")) { xmlOfAnObject = xmlOfAnObject.Remove(0, 1); } if (xmlOfAnObject.Equals("<null/>")) { return(null); } xmlOfAnObject = xmlOfAnObject.Replace("System.Linq.Expressions.TypedParameterExpression, System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" , "NeuroSystem.VirtualMachine.Serializacja.NsTypedParameterExpression, NeuroSystem.VirtualMachine, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"); var serializer = new SharpSerializer(); serializer.PropertyProvider.AttributesToIgnore.Clear(); // remove default ExcludeFromSerializationAttribute for performance gain //serializer.PropertyProvider.AttributesToIgnore.Add(typeof(XmlIgnoreAttribute)); byte[] bajty = Encoding.UTF8.GetBytes(xmlOfAnObject); using (var ms = new MemoryStream(bajty)) { object obiekt = serializer.Deserialize(ms); return(obiekt); } }
static void Main(string[] args) { TestClass t = new TestClass() { ID = Guid.NewGuid(), Name = "睡觉了快递费", Number = 123, Values = new List <int>() { 1, 2, 3, 4, 5 }, Values2 = new List <float>() { 1, 2, 3, 4, 5 }, Values3 = new byte[] { 1, 2, 3, 4, 5 }, Value4 = new Dictionary <string, int>() { { "1", 1 }, { "2", 2 } } }; SharpSerializer s = new SharpSerializer(); string path = Path.Combine(Environment.CurrentDirectory, "test.xml"); s.Serialize(t, path); var t1 = s.Deserialize(path); }
private static void TrySharpSerializer(object obj) { var serializer = new SharpSerializer(); serializer.Serialize(obj, "test.xml"); var obj2 = serializer.Deserialize("test.xml"); }
public static IEnumerable <TwitterStatus> GetFromCache(TwitterResource resource) { string fileName = GetCacheName(resource); var serializer = new SharpSerializer(SerializerSettings); IEnumerable <TwitterStatus> statuses = null; MutexUtil.DoWork("OCELL_FILE_MUTEX" + fileName, () => { try { using (var stream = FileAbstractor.GetFileStream(fileName)) { if (stream.Length != 0) { statuses = serializer.Deserialize(stream) as IEnumerable <TwitterStatus>; } } } catch (Exception ex) { Debug.WriteLine(ex); } }); return(statuses ?? new List <TwitterStatus>()); }
public static AppFileTemplate DeSerialize(string fileName) { SharpSerializer serializer = new SharpSerializer(); return ((AppFileTemplate)(serializer.Deserialize(fileName))); }
public void load() { // availanle availble.Add(new fnctn(1, filters.morphoArea.Run, null, "Calculate area")); availble.Add(new fnctn(2, filters.morphoPerimeter.Run, null, "Calculate perimeter")); availble.Add(new fnctn(3, filters.morphoRoundness.Run, null, "Calculate roundness ")); availble.Add(new fnctn(4, filters.morphoElongation.Run, null, "Calculate elongation (eccentricity) ")); availble.Add(new fnctn(5, filters.morphoMinEncloseCircle.Run, null, "Calculate Rmax/min, enclosing circle")); availble.Add(new fnctn(7, filters.morphoConvexity.Run, null, "Calculate convexity (area,perimeter)")); availble.Add(new fnctn(8, filters.morphoOrientation.Run, null, "Calculate orientation & max/min axis")); availble.Add(new fnctn(9, filters.morphoMoment.Run, null, "Calculate moments")); availble.Add(new fnctn(10, filters.colorRED.Run, filters.colorRED.GetIntensity, "Detect RED color")); availble.Add(new fnctn(11, filters.colorBLUE.Run, filters.colorBLUE.GetIntensity, "Detect BLUE color")); availble.Add(new fnctn(13, filters.colorGREEN.Run, filters.colorGREEN.GetIntensity, "Detect GREEN color")); availble.Add(new fnctn(14, filters.colorYELLOW.Run, filters.colorYELLOW.GetIntensity, "Detect YELLOW color")); availble.Add(new fnctn(99, filters.checkAll.Run, filters.checkAll.GetIntensity, "Detect ALL (for test)")); // activs if (File.Exists(file_name)) { var serializer = new SharpSerializer(); var list = serializer.Deserialize(file_name); activs = (List <fnctn4save>)list; } else { save(); } }
public static T Load <T>(SharpSerializer serializer, string prefix) where T : User, new() { T user = null; try { if (!File.Exists(SAVE_FILE_PATH)) { throw new Exception("There is no user data saved at " + SAVE_FILE_PATH); } Debug.Log("Loading user from " + SAVE_FILE_PATH); FileStream fileStream = File.Open(SAVE_FILE_PATH, FileMode.Open); using (var stream = fileStream) { user = serializer.Deserialize(stream) as T; } } catch (Exception e) { Debug.LogError("There was an error loading user data at " + string.Format("{0}{1}", prefix, UserServiceUtils.USER_DATA_KEY) + ": \n" + e); user = new T(); user.UID = SystemInfo.deviceUniqueIdentifier; } return(user); }
public static object DeserializeObject(string xmlOfAnObject) { if (xmlOfAnObject.StartsWith("?")) { xmlOfAnObject = xmlOfAnObject.Remove(0, 1); } if (xmlOfAnObject.Equals("<null/>")) { return(null); } //return JsonConvert.DeserializeObject(xmlOfAnObject); var settings = new SharpSerializerXmlSettings(); settings.IncludeAssemblyVersionInTypeName = false; settings.IncludeCultureInTypeName = false; settings.IncludePublicKeyTokenInTypeName = false; var serializer = new SharpSerializer(settings); serializer.PropertyProvider.AttributesToIgnore.Clear(); // remove default ExcludeFromSerializationAttribute for performance gain //serializer.PropertyProvider.AttributesToIgnore.Add(typeof(XmlIgnoreAttribute)); byte[] bajty = Encoding.UTF8.GetBytes(xmlOfAnObject); using (var ms = new MemoryStream(bajty)) { object obiekt = serializer.Deserialize(ms); return(obiekt); } }
public static async Task <T> Load <T>(string file) { IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication(); T obj = Activator.CreateInstance <T>(); if (storage.FileExists(file)) { IsolatedStorageFileStream stream = null; try { stream = storage.OpenFile(file, FileMode.Open); var serializer = new SharpSerializer(); obj = (T)serializer.Deserialize(stream); } catch { } finally { if (stream != null) { stream.Close(); stream.Dispose(); } } return(obj); } await obj.Save(file); return(obj); }
/// <summary> /// Deserialize an object from a byte array /// </summary> /// <typeparam name="T">The type of object to deserialize</typeparam> /// <param name="buff">The byte array to deserialize from</param> /// <returns>The deserialized object</returns> protected virtual T Deserialize <T>(byte[] buff) { try { #if SILVERLIGHT var settings = new SharpSerializerBinarySettings(BinarySerializationMode.Burst); var ms = new MemoryStream(buff); var ser = new SharpSerializer(settings); var deserialized = ser.Deserialize(ms); return((T)deserialized); #else if (typeof(IBinarySerializable).IsAssignableFrom(typeof(T))) { var instance = Activator.CreateInstance <T>(); using (var srcStream = new MemoryStream(buff)) { (instance as IBinarySerializable).Read(srcStream); } return(instance); } var ms = new MemoryStream(buff); var bf = new BinaryFormatter(); return((T)bf.Deserialize(ms)); #endif } catch (Exception ex) { Logging.LogError(BrightstarEventId.CacheError, "Error deserializing cached object: {0}", ex); return(default(T)); } }
protected void ReadDataFromXMLFile(string fileName) { var serializer = new SharpSerializer(); var importArgs = new ImportArgs(); importArgs = (ImportArgs)serializer.Deserialize(fileName); var fieldDelimiter = importArgs.FieldDelimiter.ToString(); if (fieldDelimiter != null) { txtDelimiter.Text = fieldDelimiter; } var importOptions = importArgs.CurrentImportOptions.ToString(); var io = importOptions.Split(new[] { ',' }, StringSplitOptions.None); foreach (var i in io) { switch (i.Trim()) { case "None": txtimportSelected.Text += "None" + " "; break; case "CreateMissingSkus": txtimportSelected.Text += "CreateMissingSkus" + " "; break; case "CreateMissingTaxonomies": txtimportSelected.Text += "CreateMissingTaxonomies" + " "; break; case "CreateMissingAttributes": txtimportSelected.Text += "CreateMissingAttributes" + " "; break; case "CreateMissingMetaAttributes": txtimportSelected.Text += "CreateMissingMetaAttributes" + " "; break; case "CreateMissingValues": txtimportSelected.Text += "CreateMissingValues" + " "; break; } } dict = importArgs.FieldMappings; gv_mapping.DataSource = (from dictitem in dict select new { HeaderColumn = "Column" + ' ' + dictitem.Value, MappingFields = dictitem.Key }); gv_mapping.DataBind(); var filename = importArgs.InputFilePath; var file = filename.Substring(filename.LastIndexOf('\\') + 1); txtinputfileName.Text = file; }
private void SharpDeserialization(EntityType _type, ref Hashtable idObjCollection) { string fileName = _type.ToString() + ".xml"; SharpSerializer serializer = new SharpSerializer(); idObjCollection = (Hashtable)serializer.Deserialize(fileName); }
public static SortedDictionary <string, DrinkMultiple> GetSavedData() { var serilizer = new SharpSerializer(); repository = (SortedDictionary <string, DrinkMultiple>)serilizer.Deserialize(fileName); return(repository); }
/// <summary> /// Reads a string value from the Octgn registry /// </summary> /// <param name="valName"> The name of the value </param> /// <returns> A string value </returns> public T ReadValue <T>(string valName, T def) { lock (this.LockObject) { var ret = def; Stream f = null; try { if (File.Exists(GetConfigPath())) { var serializer = new SharpSerializer(); Hashtable config = new Hashtable(); if (OpenFile(GetConfigPath(), FileMode.OpenOrCreate, FileShare.None, TimeSpan.FromSeconds(20), out f)) { config = (Hashtable)serializer.Deserialize(f); } if (config.ContainsKey(valName)) { if (config[valName] is T) { return((T)config[valName]); } else { var conv = TypeDescriptor.GetConverter(typeof(T)); var val = (T)conv.ConvertFromInvariantString(config[valName].ToString()); config[valName] = val; f.SetLength(0); serializer.Serialize(config, f); return(val); } } } } catch (Exception e) { Trace.WriteLine("[SimpleConfig]ReadValue Error: " + e.Message); try { File.Delete(GetConfigPath()); } catch (Exception) { Trace.WriteLine("[SimpleConfig]ReadValue Error: Couldn't delete the corrupt config file."); } } finally { if (f != null) { f.Close(); f = null; } } return(ret); } }
public static void Load() { var s = new SharpSerializer(); if (File.Exists("settings.dat")) { _data = (UndoRedoDictionary <string, object>)s.Deserialize("settings.dat"); } }
/// <summary> /// Deserializes an XML SharpSerializer payload object. /// </summary> /// <param name="serializedData">The raw serialized object.</param> /// <returns>The serialized object.</returns> public static object SharpSerializer_ObjectDataProvider_Xml_Deserialize(string serializedData) { SharpSerializer serializer = new SharpSerializer(false); using (MemoryStream memoryStream = new MemoryStream(Encoding.Default.GetBytes(serializedData))) { return(serializer.Deserialize(memoryStream)); } }
/// <summary> /// Deserializes a binary SharpSerializer object. /// </summary> /// <param name="serializedData">The raw serialized object.</param> /// <returns>The deserialized object</returns> public static object SharpSerializer_ObjectDataProvider_Binary_Deserialize(object serializedData) { SharpSerializer serializer = new SharpSerializer(true); using (MemoryStream memoryStream = new MemoryStream((byte[])serializedData)) { return(serializer.Deserialize(memoryStream)); } }
public static object SharpSerializer_XML_deserialize_FromByteArray(byte[] serializedData) { SharpSerializer serializer = new SharpSerializer(false); // false -> XML using (MemoryStream memoryStream = new MemoryStream(serializedData)) { return(serializer.Deserialize(memoryStream)); } }
public static T Deserialize <T>(byte[] b) { var s = new SharpSerializer(true); using (var m = new MemoryStream(b)) { return((T)s.Deserialize(m)); } }
/// <summary> /// Deserializes the specified byte array to an object. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="byteArray">The byte array to deserialize.</param> /// <returns>Deserialized object from bytes.</returns> /// <exception cref="ArgumentNullException"><paramref name="byteArray" /> is <see langword="null" />.</exception> public T Deserialize <T>(byte[] byteArray) { if (byteArray == null) { throw new ArgumentNullException(nameof(byteArray)); } using var mStream = new MemoryStream(byteArray); return((T)BinarySerializer.Deserialize(mStream)); }
public static SMuFLFontProfile CreateFromBinaryStream(Stream binaryStream) { var settings = new SharpSerializerBinarySettings(BinarySerializationMode.SizeOptimized); var serializer = new SharpSerializer(settings); var metadata = serializer.Deserialize(binaryStream) as ISMuFLFontMetadata; return(new SMuFLFontProfile(metadata)); }
public static object SharpSerializer_Binary_deserialize_FromByteArray(byte[] serializedData) { SharpSerializer serializer = new SharpSerializer(true); // true -> binary using (MemoryStream memoryStream = new MemoryStream(serializedData)) { return(serializer.Deserialize(memoryStream)); } }
public Effect Copy() { using (MemoryStream ms = new MemoryStream()) { SharpSerializer s = new SharpSerializer(true); s.Serialize(this, ms); ms.Position = 0; return((Effect)s.Deserialize(ms)); } }
public static T Deserialize <T>(string path) { SharpSerializerXmlSettings settings = new SharpSerializerXmlSettings(); settings.IncludeAssemblyVersionInTypeName = false; settings.IncludePublicKeyTokenInTypeName = false; SharpSerializer serializer = new SharpSerializer(settings); return((T)serializer.Deserialize(path)); }
//private void NetSerializerBenchmark<T>(T obj, int count) //{ // try // { // Stopwatch sw; // //----------------------------------- // var pbuffMem = new MemoryStream(); // if (!_netSerializer) // { // NetSerializer.Serializer.Initialize(new Type[] { typeof(T) }); // _netSerializer = true; // } // NetSerializer.Serializer.Serialize(pbuffMem, obj); // using (var mem = new MemoryStream()) // { // sw = Stopwatch.StartNew(); // for (int i = 0; i < count; i++) // { // NetSerializer.Serializer.Serialize(mem, obj); // mem.SetLength(0); // } // } // sw.Stop(); // Log("NetSerializer.Serialize took: " + ToString(sw.Elapsed) + " data-size: " + pbuffMem.Length); // sw = Stopwatch.StartNew(); // for (int i = 0; i < count; i++) // { // pbuffMem.Seek(0, SeekOrigin.Begin); // NetSerializer.Serializer.Deserialize(pbuffMem); // } // sw.Stop(); // Log("NetSerializer.Deserialize took: " + ToString(sw.Elapsed)); // } // catch (Exception ex) // { // Log("NetSerializer failed, " + ex.Message); // } //} private void SharpSerializerBenchmark <T>(T obj, int count) { try { long initlength = 0; Stopwatch sw; //----------------------------------- var sharper = new SharpSerializer(new SharpSerializerBinarySettings(BinarySerializationMode.SizeOptimized)); var mem = new MemoryStream(); sharper.Serialize(obj, mem); initlength = mem.Length; mem.Seek(0, SeekOrigin.Begin); sharper.Deserialize(mem); using (var sharperMem = new MemoryStream()) { sw = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { sharper.Serialize(obj, sharperMem); } } sw.Stop(); Log("SharpSerializer Serialize took: "+ ToString(sw.Elapsed) + " data-size: " + initlength); sw = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { mem.Seek(0, SeekOrigin.Begin); sharper.Deserialize(mem); } sw.Stop(); Log("SharpSerializer Deserialize took: "+ ToString(sw.Elapsed)); } catch (Exception ex) { Log("SharpSerializer failed, " + ex.Message); } }
public static SyncHistory Deserialize(string path) { try { SharpSerializer serializer = new SharpSerializer(); return((SyncHistory)serializer.Deserialize(path)); } catch (Exception ex) { Log.Error($"Loading history from {path} failed", ex); return(new SyncHistory()); } }
public static T Deserialize <T>(string path) { var settings = new SharpSerializerXmlSettings(); settings.IncludeAssemblyVersionInTypeName = false; settings.IncludePublicKeyTokenInTypeName = false; settings.AdvancedSettings.TypeNameConverter = new LegacyTypeNameConverter(); var serializer = new SharpSerializer(settings); return((T)serializer.Deserialize(path)); }
/// <summary> /// Tests the XML SharpSerializer deserialization. /// </summary> /// <param name="myobj">The object to deserialize.</param> /// <returns>The deserialized object.</returns> public static object SharpSerializer_Xml_test(object myobj) { SharpSerializer serializer = new SharpSerializer(false); using (var memoryStream = new MemoryStream()) { serializer.Serialize(myobj, memoryStream); memoryStream.Position = 0; return(serializer.Deserialize(memoryStream)); } }