//------------------------------------------------------------------------------
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));
}
}