//------------------------------------------------------------------------------
public static String ObjectToString(Object objectValue)
{
using (var ms = new MemoryStream())
{
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);
serializer.Serialize(objectValue, ms);
}
finally
{
settings.AdvancedSettings.TypeNameConverter = old_tnc;
}
var byteValue = ms.ToArray();
var stringValue = Convert.ToBase64String(byteValue);
return(stringValue);
}
}
private void serializeBurstBinary_Click(object sender, EventArgs e)
{
// create fake obj
var obj = RootContainer.CreateFakeRoot();
// create instance of sharpSerializer
var settings = new SharpSerializerBinarySettings(BinarySerializationMode.Burst);
var serializer = new SharpSerializer(settings);
// *************************************************************************************
// For advanced serialization you create SharpSerializer with an overloaded constructor
//
// SharpSerializerBinarySettings settings = createBinarySettings();
// serializer = new SharpSerializer(settings);
//
// Scroll the page to the createBinarySettings() method for more details
// *************************************************************************************
// set the filename
var filename = "sharpSerializerExample.burst";
// serialize
serialize(obj, serializer, filename);
}
/// <summary>
/// Serialize an object to a byte array
/// </summary>
/// <param name="o">The object to be serialized</param>
/// <returns>The serialized form of the object</returns>
protected virtual byte[] Serialize(object o)
{
try
{
#if SILVERLIGHT
var settings = new SharpSerializerBinarySettings(BinarySerializationMode.Burst);
var ser = new SharpSerializer(settings);
var ms = new MemoryStream();
ser.Serialize(o, ms);
ms.Close();
return(ms.GetBuffer());
#else
var ms = new MemoryStream();
var bf = new BinaryFormatter();
bf.Serialize(ms, o);
ms.Close();
return(ms.GetBuffer());
#endif
}
catch (Exception ex)
{
Logging.LogError(BrightstarEventId.CacheError, "Error serializing object for cache: {0}", ex);
return(null);
}
}
public void SerializeMetadataAsBinary(Stream outputStream)
{
var settings = new SharpSerializerBinarySettings(BinarySerializationMode.SizeOptimized);
var serializer = new SharpSerializer(settings);
serializer.Serialize(SMuFLMetadata, outputStream);
}
public IList <IListField> GetFields(int listId)
{
return(cacheManager.Get("Fields_GetFields_" + listId, ctx =>
{
ctx.Monitor(signals.When("FieldsOfList_Changed"));
var records = Repository.Table.Where(x => x.ListId == listId).OrderBy(x => x.Position).ToList();
var result = new List <IListField>();
var settings = new SharpSerializerXmlSettings
{
IncludeAssemblyVersionInTypeName = false,
IncludeCultureInTypeName = false,
IncludePublicKeyTokenInTypeName = false
};
var sharpSerializer = new SharpSerializer(settings);
foreach (var record in records)
{
if (string.IsNullOrEmpty(record.FieldProperties))
{
continue;
}
var field = (IListField)sharpSerializer.DeserializeFromString(record.FieldProperties);
field.Id = record.Id;
result.Add(field);
}
return result;
}));
}
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);
}
public static byte[] SharpSerializer_XML_serialize_WithExclusion_ToByteArray(object myobj, List <KeyValuePair <Type, List <String> > > excludedProperties)
{
var settings = new SharpSerializerXmlSettings();
settings.Encoding = System.Text.Encoding.ASCII;
settings.AdvancedSettings.RootName = "r"; // to keep it short
SharpSerializer serializer = new SharpSerializer(settings);
using (var memoryStream = new MemoryStream())
{
if (excludedProperties != null)
{
foreach (KeyValuePair <Type, List <String> > excKVP in excludedProperties)
{
foreach (string excPropertyName in excKVP.Value)
{
serializer.PropertyProvider.PropertiesToIgnore.Add(excKVP.Key, excPropertyName);
}
}
}
serializer.Serialize(myobj, memoryStream);
return(memoryStream.ToArray());
}
}
void C_OnReceivedMessage(byte[] rawMessage)
{
SharpSerializer ser = SharpSerializer.Create(rawMessage);
SharpConnectionMessages incomingType = (SharpConnectionMessages)ser.ReadByte();
if (incomingType == SharpConnectionMessages.ClientConnected)
{
SharpClient incomingClient = new SharpClient(ref ser);
this.room.AssignClient(incomingClient);
C_OnClientConnected(incomingClient);
}
else if (incomingType == SharpConnectionMessages.ClientDisconnected)
{
short netID = ser.ReadInt16();
C_OnClientDisconnected(this.room.Get(netID));
}
else if (incomingType == SharpConnectionMessages.DirectData)
{
short sender = ser.ReadShort();
int channel = ser.ReadInt32();
int packageSize = ser.ReadInt32();
byte[] rawData = ser.ReadBytes(packageSize);
C_OnReceivedData(this.room.Get(sender), channel, rawData);
}
ser.Post();
}
public static AppFileTemplate DeSerialize(string fileName)
{
SharpSerializer serializer = new SharpSerializer();
return
((AppFileTemplate)(serializer.Deserialize(fileName)));
}
private WorkerArguments SaveParameters()
{
var taskId = Guid.NewGuid();
var argFilePath = PrepareDirectory(taskId);
WorkerArguments args;
if (ExportType == typeof(CustomExportWorker))
{
args = CustomExportArgs(argFilePath);
}
else
{
args = StandardExportArgs(argFilePath);
}
if (args == null)
{
return(null);
}
args.Id = taskId;
var eaFileName = Path.Combine(argFilePath, WorkerArguments.ArgumentsFileName);
var settings = args.GetSharpSerializerXmlSettings(WorkerArguments.ArgumentsFileRootName);
var serializer = new SharpSerializer(settings);
serializer.Serialize(args, eaFileName);
return(args);
}
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 string SerializeObject(object obj)
{
if (obj == null)
{
return("<null/>");
}
//string preserveReferenacesAll = JsonConvert.SerializeObject(obj, Formatting.Indented, new JsonSerializerSettings
//{
// PreserveReferencesHandling = PreserveReferencesHandling.All
//});
//return preserveReferenacesAll;
//return JsonConvert.SerializeObject(obj);
var serializer = new SharpSerializer();
serializer.PropertyProvider.AttributesToIgnore.Clear();
// remove default ExcludeFromSerializationAttribute for performance gain
serializer.PropertyProvider.AttributesToIgnore.Add(typeof(XmlIgnoreAttribute));
using (var ms = new MemoryStream())
{
serializer.Serialize(obj, ms);
ms.Position = 0;
byte[] bajty = ms.ToArray();
return(Encoding.UTF8.GetString(bajty, 0, bajty.Length));
}
}
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);
}
//------------------------------------------------------------------------------
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 SimulationService() : base()
{
_serializer = new SharpSerializer();
_worldSimulationStateService = Game.Instance.GetService <WorldSimulationStateService>();
_worldDataAccessService = Game.Instance.GetService <WorldDataAccessService>();
_worldSimulationStateService.Load(OnSimulationStateLoaded, () => { });
}
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 async Task Save <T>(this T obj, string file)
{
await Task.Run(() =>
{
IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication();
IsolatedStorageFileStream stream = null;
try
{
stream = storage.CreateFile(file);
var serializer = new SharpSerializer();
serializer.Serialize(obj, stream);
}
catch (Exception)
{
}
finally
{
if (stream != null)
{
stream.Close();
stream.Dispose();
}
}
});
}
private static void TrySharpSerializer(object obj)
{
var serializer = new SharpSerializer();
serializer.Serialize(obj, "test.xml");
var obj2 = serializer.Deserialize("test.xml");
}
public virtual RetCode SaveDatabase(string fileName)
{
RetCode rc;
if (string.IsNullOrWhiteSpace(fileName))
{
rc = RetCode.InvalidArg;
// PrintError
goto Cleanup;
}
rc = RetCode.Success;
if (DbStackTop < 0)
{
rc = RetCode.IsEmpty;
goto Cleanup;
}
SharpSerializer.Serialize(Database, fileName);
Cleanup:
return(rc);
}
void HandleAcceptedConnection(TcpClient client, SharpClient sclient)
{
SharpSerializer syncPack = SharpSerializer.Create();
syncPack.Write((byte)IncomingConnectionResponse.Approved);
short netID = this.room.NextFreeID;
sclient.AssingNetID(netID);
syncPack.Write(netID);
this.room.Write(ref syncPack);
TCPMessageHandler.Write(client, syncPack.DataAndPost());
this.room.AssignClient(sclient);
Thread t = new Thread(() => ListenClient(sclient));
sclient.ListeningThread = t;
sclient.Connection = client;
t.Start();
S_OnClientConnected(sclient);
}
public static string ToSharpXml(this object o)
{
#if VS2013
// create the settings
//var settings = new SharpSerializerBinarySettings(); // for binary mode
var settings = new SharpSerializerXmlSettings(); // for xml mode
// configure the type serialization
settings.IncludeAssemblyVersionInTypeName = false;
settings.IncludeCultureInTypeName = false;
settings.IncludePublicKeyTokenInTypeName = false;
// instantiate sharpSerializer
using (var ms = new MemoryStream())
{
var serializer = new SharpSerializer(settings);
serializer.Serialize(o, ms);
ms.Flush();
ms.Position = 0;
var sr = new StreamReader(ms);
return(sr.ReadToEnd());
}
#else
throw new NotImplementedException();
#endif
}
public void SendMessage(int Channel, byte[] data, SharpClient client)
{
SharpSerializer ser = SharpSerializer.Create();
ser.Write((byte)SharpConnectionMessages.DirectData);
ser.Write((short)0);
ser.Write(Channel);
ser.Write(data.Length);
ser.Write(data);
if (client.isMine)
{
S_OnReceivedData(serverclient, Channel, data);
}
else
{
client.SendMessage(ser.DataAndPost());
}
if (ser.inUse)
{
ser.Post();
}
}
private void CopyUrlAddress_Click(object sender, RoutedEventArgs e)
{
var tableName = (ListGridTab.SelectedItem as TabItem).Tag.ToString();
this.SearchCondition.SelectedTableName = tableName;
var ud = new UrlData
{
Condition = this.SearchCondition,
Type = "List",
};
MemoryStream ms = new MemoryStream();
var serializer = new SharpSerializer(true);
serializer.Serialize(ud, ms);
byte[] array = ms.ToArray();
ms.Close();
string data = Convert.ToBase64String(array);
var url = HtmlPage.Document.DocumentUri;
var urlstring = url.ToString();
if (url.Query.Length > 0)
{
urlstring = urlstring.Replace(url.Query, "");
}
Clipboard.SetText(string.Format("{0}?url={1}", urlstring, data));
}
public void SendMessage(int Channel, byte[] data, List <SharpClient> clients)
{
SharpSerializer ser = SharpSerializer.Create();
ser.Write((byte)SharpConnectionMessages.DirectData);
ser.Write((short)0);
ser.Write(Channel);
ser.Write(data.Length);
ser.Write(data);
byte[] rawData = ser.DataAndPost();
foreach (var item in clients)
{
if (item.isMine)
{
S_OnReceivedData(serverclient, Channel, data);
}
else
{
item.SendMessage(rawData);
}
}
}
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);
}
void S_OnClientDisconnected(SharpClient client)
{
#region Broadcasting Other Clients
SharpSerializer ser = SharpSerializer.Create();
ser.Write((byte)SharpConnectionMessages.ClientDisconnected);
ser.Write(client.NetworkID);
Broadcast(ser.DataAndPost(), client);
#endregion
SharpNetworking.Instance.OnClientDisconnected(client);
room.RemoveClient(client);
#region Closing Socket & Thread
try
{
TCPMessageHandler.CloseConnection(client.Connection);
}
catch { }
try
{
client.ListeningThread.Abort();
}
catch { }
client.ListeningThread = null;
#endregion
}
/// <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));
}
}
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 string ToXml(this object obj, Func <Type, PropertyInfo, bool> propertyHandlerCallback, Func <Type, bool> collectionItemHandlerCallback)
{
var settings = new SharpSerializerXmlSettings
{
AdvancedSettings = new AdvancedSharpSerializerXmlSettings
{
TypeNameConverter = new TypeNameConverter()
},
IncludeAssemblyVersionInTypeName = false,
IncludeCultureInTypeName = false,
IncludePublicKeyTokenInTypeName = false,
};
var propertySerializer = new PropertySerializer(obj, propertyHandlerCallback, collectionItemHandlerCallback);
var serializer = new SharpSerializer()
{
PropertyProvider = propertySerializer, RootName = obj.GetType().Name
};
using (var stream = new MemoryStream())
{
var text = string.Empty;
string xml;
serializer.Serialize(obj, stream);
stream.Seek(0, SeekOrigin.Begin);
xml = stream.ToText();
return(xml);
}
}
protected override void ThreadFunction()
{
foreach (SaveAreaRequest saveAreaRequest in _requests)
{
FileStream areaFileStream = File.Open(saveAreaRequest.filename, FileMode.Create);
switch (_worldIndex.SerializationType)
{
case SerializationType.Binary:
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(areaFileStream, saveAreaRequest.area);
break;
case SerializationType.SharpSerializer:
SharpSerializer serializer = new SharpSerializer();
using (var stream = areaFileStream)
{
serializer.Serialize(saveAreaRequest.area, areaFileStream);
}
break;
}
areaFileStream.Close();
}
}