/// <summary>
/// Serialize to file.
/// </summary>
/// <param name="filename"></param>
/// <param name="p"></param>
/// <returns></returns>
public static Result SerializeXml(string filename, object p)
{
try
{
// Create folder if not exists.
if (Directory.Exists(Path.GetDirectoryName(filename)) == false)
{
DirectoryInfo info = Directory.CreateDirectory(Path.GetDirectoryName(filename));
if (info == null || info.Exists == false)
{
return(Result.Fail(string.Format("Failed to create directory [{0}].", Path.GetDirectoryName(filename))));
}
}
using (XmlWriter xw = XmlWriter.Create(filename))
{
return(SerializationHelper.SerializeXml(xw, p));
}
}
catch (Exception ex)
{
CoreSystemMonitor.OperationError("Failed to serialize object [" + p.ToString() + "] to xml file [" + filename + "].", ex);
return(Result.Failure);
}
}
/// <summary>
/// Perform object serialization to a file.
/// </summary>
public static Result Serialize(string filename, object value)
{
try
{
// Create folder if not exists.
if (Directory.Exists(Path.GetDirectoryName(filename)) == false)
{
DirectoryInfo info = Directory.CreateDirectory(Path.GetDirectoryName(filename));
if (info == null || info.Exists == false)
{
return(Result.Fail(string.Format("Failed to create directory [{0}].", Path.GetDirectoryName(filename))));
}
}
byte[] data = SerializationHelper.Serialize(value);
File.WriteAllBytes(filename, data);
}
catch (Exception ex)
{
string message = string.Format("Failed to serialize to file [{0}]", filename);
CoreSystemMonitor.OperationError(message, ex);
return(Result.Fail(message));
}
return(Result.Success);
}
/// <summary>
/// Serialize to text writer.
/// </summary>
/// <param name="writer"></param>
/// <param name="p"></param>
/// <returns></returns>
public static Result SerializeXml(TextWriter writer, object p)
{
try
{
XmlSerializer serializer = new XmlSerializer(p.GetType());
serializer.Serialize(writer, p);
}
catch (Exception ex)
{
CoreSystemMonitor.Error("Failed to xml-serialize object [" + p.GetType().Name + "]", ex);
return(Result.Fail(ex));
}
return(Result.Success);
}
/// <summary>
/// Serialize to memory stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="p"></param>
/// <returns></returns>
public static Result SerializeXml(MemoryStream stream, object p)
{
try
{
using (XmlWriter xw = XmlWriter.Create(stream))
{
return(SerializationHelper.SerializeXml(xw, p));
}
}
catch (Exception ex)
{
CoreSystemMonitor.OperationError("Failed to serialize object [" + p.ToString() + "] to xml stream.", ex);
return(Result.Fail(ex));
}
}
/// <summary>
/// Perform deserialization of an object from a stream.
/// </summary>
public static Result Deserialize(MemoryStream stream, out object value)
{
try
{
IFormatter formatter = ObtainFormatter();
value = formatter.Deserialize(stream);
}
catch (Exception ex)
{
CoreSystemMonitor.Error("Failed to deserialize object.", ex);
value = null;
return(Result.Fail(ex));
}
return(Result.Success);
}
public static Result DeSerializeXml <TType>(TextReader reader, out TType output)
where TType : class
{
output = null;
try
{
XmlSerializer serializer = new XmlSerializer(typeof(TType));
output = (TType)serializer.Deserialize(reader);
}
catch (Exception ex)
{
CoreSystemMonitor.Error("Failed to xml-deserialize object [" + typeof(TType).Name + "]", ex);
return(Result.Fail(ex));
}
return(Result.Success);
}
/// <summary>
/// Throws.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
protected override object DeserializeData(Stream stream)
{
BinaryFormatter formatter = _formatter;
if (formatter == null)
{
return(null);
}
try
{
return(formatter.Deserialize(stream));
}
catch (Exception ex)
{
CoreSystemMonitor.OperationError("Failed to deserialize object", ex);
throw new InvalidDataException(ex.Message, ex);
}
}
/// <summary>
/// Serialize to memory stream.
/// </summary>
/// <param name="stream"></param>
/// <param name="p"></param>
/// <returns></returns>
public static Result Serialize(MemoryStream stream, object p)
{
try
{
IFormatter formatter = ObtainFormatter();
formatter.Serialize(stream, p);
if (stream.Position > SerializationWarningLimit)
{
CoreSystemMonitor.Warning("Serialialization of object [" + p.GetType().Name + "] has grown above the default serialization limit to [" + stream.Position.ToString() + "] bytes.");
}
return(Result.Success);
}
catch (Exception ex)
{
CoreSystemMonitor.Error("Failed to serialize object [" + p.GetType().Name + "," + ex.Message + "].");
return(Result.Fail(ex));
}
}
/// <summary>
/// Helper, overrides.
/// </summary>
public static TType Deserialize <TType>(string filename)
where TType : class
{
try
{
byte[] data = File.ReadAllBytes(filename);
if (data != null)
{
object dummy;
SerializationHelper.Deserialize(data, out dummy);
return((TType)dummy);
}
}
catch (Exception ex)
{
CoreSystemMonitor.OperationError("Failed to extract proxies manager.", ex);
}
return(null);
}
/// <summary>
/// Returns false if failed to serialize.
/// </summary>
/// <param name="stream"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool Serialize(MemoryStream stream, object message)
{
if (message == null)
{
return(false);
}
long startPosition = stream.Position;
// Placeholder.
byte[] sizeBytes = BitConverter.GetBytes(int.MaxValue);
stream.Write(sizeBytes, 0, sizeBytes.Length);
if (SerializeData(stream, message) == false)
{
stream.Seek(startPosition, SeekOrigin.Begin);
return(false);
}
int length = (int)stream.Position - (int)startPosition;
long lastPosition = stream.Position;
stream.Seek(startPosition, SeekOrigin.Begin);
if (length > MaxMessageSize)
{
CoreSystemMonitor.OperationError("Message size too big.");
return(false);
}
// Encoding (int.MaxValue - value); this helps diagnostics of message transport errors.
sizeBytes = BitConverter.GetBytes(int.MaxValue - length);
stream.Write(sizeBytes, 0, sizeBytes.Length);
stream.Seek(lastPosition, SeekOrigin.Begin);
return(true);
}
/// <summary>
/// Static constructor - create the default formatter.
/// </summary>
static SerializationHelper()
{
lock (_syncRoot)
{
if (_formatter != null)
{
CoreSystemMonitor.Error("Not expected, formatter already created.");
return;
}
// Create the formatter.
_formatter = new BinaryFormatter();
// 2. Construct a SurrogateSelector object
SurrogateSelector surrogateSelector = new SurrogateSelector();
// 3. Tell the surrogate selector to use our object when a
// object is serialized/deserialized.
List <ISerializationSurrogate> surrogates = ReflectionHelper.GetTypeChildrenInstances <ISerializationSurrogate>(
ReflectionHelper.GetAssemblies(true, true));
foreach (ISerializationSurrogate surrogate in surrogates)
{
SerializationSurrogateAttribute attribute = ReflectionHelper.GetTypeCustomAttributeInstance <SerializationSurrogateAttribute>(
surrogate.GetType(), false);
if (attribute != null)
{
surrogateSelector.AddSurrogate(attribute.Type, new StreamingContext(StreamingContextStates.All), surrogate);
}
else
{
CoreSystemMonitor.Info(string.Format("Surrogate type [{0}] not marked with SerializationSurrogateAttribute.", surrogate.GetType().Name));
}
}
_formatter.SurrogateSelector = surrogateSelector;
}
}
