public static void SerializeToFile(this IStreamSerializer serializer, string path, object graph, bool overwrite = false)
{
using (var stream = File.Open(path, overwrite ? FileMode.Create : FileMode.CreateNew))
{
serializer.SerializeToStream(stream, graph);
}
}
public static T DeserializeFromBytes <T>(this IStreamSerializer serializer, byte[] data)
{
using (var stream = new MemoryStream(data))
{
return(serializer.Deserialize <T>(stream));
}
}
/// <summary>
/// Deserializes from bytes.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="data">The data.</param>
/// <param name="type">The type.</param>
/// <returns>System.Object.</returns>
public static object DeserializeFromBytes(this IStreamSerializer serializer, byte[] data, Type type)
{
using (var stream = new MemoryStream(data))
{
return(serializer.Deserialize(stream, type));
}
}
public static object DeserializeFromFile(this IStreamSerializer serializer, Type type, string path)
{
using (var stream = File.OpenRead(path))
{
return(serializer.DeserializeFromStream(type, stream));
}
}
public static void Serialize <T>(string filePath, T value, IStreamSerializer <T> streamSerializer, bool overwrite = true)
{
using (var fileStream = FileStreamHelper.NewWrite(filePath, overwrite))
{
streamSerializer.Serialize(fileStream, value);
}
}
private static void StreamNonGenericNullTest(IStreamSerializer serializer)
{
var type = typeof(TestModel);
var stream = serializer.ToStream(type, null);
var deserializeModel = serializer.FromStream(type, stream);
Assert.Null(deserializeModel);
}
public static byte[] GetSerializedBytes(this IStreamSerializer serializer, object obj)
{
using (var stream = new MemoryStream())
{
serializer.Serialize(obj, stream);
return(stream.ToArray());
}
}
public static T Deserialize <T>(string filePath, IStreamSerializer <T> streamSerializer)
{
using (var fileStream = FileStreamHelper.NewRead(filePath))
{
var value = streamSerializer.Deserialize(fileStream);
return(value);
}
}
private static void StreamGenericNullTest(IStreamSerializer serializer)
{
TestModel?model = null;
var stream = serializer.ToStream(model);
var deserializeModel = serializer.FromStream <TestModel>(stream);
Assert.Null(deserializeModel);
}
/// <summary>
/// Deserializes from string.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="value">The value.</param>
/// <param name="type">The type.</param>
/// <param name="encoding">The encoding.</param>
/// <returns>System.Object.</returns>
public static object DeserializeFromString(this IStreamSerializer serializer, string value, Type type, Encoding encoding = null)
{
var bytes = encoding == null?Convert.FromBase64String(value) : encoding.GetBytes(value);
using (var stream = new MemoryStream(bytes))
{
return(serializer.Deserialize(stream, type));
}
}
public static void RegisterStreamSerializer <T>(IStreamSerializer <T> serializer)
{
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
lock (_streamSerializers) {
_streamSerializers[typeof(T)] = serializer;
}
}
private static void StreamGenericTest(IStreamSerializer serializer, TestModel model)
{
var stream = serializer.ToStream(model);
var deserializeModel = serializer.FromStream <TestModel>(stream) !;
Assert.Equal(
Tuple.Create(model.Id, model.Age, model.CreateTime, model.Name, model.Gender),
Tuple.Create(deserializeModel.Id, deserializeModel.Age, deserializeModel.CreateTime,
deserializeModel.Name, deserializeModel.Gender));
}
private async Task StreamGenericNullAsyncTest(IStreamSerializer serializer, IStreamSerializerAsync serializerAsync)
{
TestModel?model = null;
var stream = new MemoryStream();
await serializerAsync.PackAsync(model, stream);
var deserializeModel = await serializerAsync.FromStreamAsync <TestModel>(stream);
Assert.Null(deserializeModel);
}
private async Task StreamNonGenericNullAsyncTest(IStreamSerializer serializer,
IStreamSerializerAsync serializerAsync)
{
var type = typeof(TestModel);
var stream = new MemoryStream();
await serializerAsync.PackAsync(type, null, stream);
var deserializeModel = await serializerAsync.FromStreamAsync(type, stream);
Assert.Null(deserializeModel);
}
private static void StreamNonGenericTest(IStreamSerializer serializer, TestModel model)
{
var type = typeof(TestModel);
var ms = serializer.ToStream(type, model);
var deserializeModel = (TestModel)serializer.FromStream(type, ms) !;
Assert.Equal(
Tuple.Create(model.Id, model.Age, model.CreateTime, model.Name, model.Gender),
Tuple.Create(deserializeModel.Id, deserializeModel.Age, deserializeModel.CreateTime,
deserializeModel.Name, deserializeModel.Gender));
}
public static bool CanSerializeStream <T>(this IStreamSerializer serializer, T item)
{
var encoder = Encoding.UTF8;
using (var stream = new StreamReader(new MemoryStream(), encoder))
{
serializer.Serialize <T>(item, stream.BaseStream);
stream.BaseStream.Position = 0;
var obj = serializer.Deserialize <T>(stream.BaseStream);
return(obj.Equals(item));
}
}
public async Task StreamFormatterNullAsync(IStreamSerializer streamSerializer, string mediaType)
{
var httpRequestMessage = CreateHttpRequestMessage(
new StreamContent(streamSerializer.ToStream <List <TestDto> >(null)),
mediaType);
var response = await _server.CreateClient().SendAsync(httpRequestMessage);
var result = streamSerializer.FromStream <List <TestDto> >(await response.Content.ReadAsStreamAsync());
Assert.Null(result);
}
/// <summary>
/// Serializes to string.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="serializer">The serializer.</param>
/// <param name="obj">The object.</param>
/// <param name="encoding">The encoding.</param>
/// <returns>System.String.</returns>
public static string SerializeToString <T>(this IStreamSerializer serializer, T obj, Encoding encoding = null)
{
using (var stream = new MemoryStream())
{
serializer.Serialize(obj, stream);
stream.Position = 0;
var bytes = new byte[stream.Length];
stream.Read(bytes, 0, (int)stream.Length);
return(encoding == null?Convert.ToBase64String(bytes) : encoding.GetString(bytes, 0, bytes.Length));
}
}
public static T DeserializeFromString <T>(this IStreamSerializer serializer, string value, Encoding encoding = null)
{
//var encoder = encoding ?? Encoding.UTF8;
//var bytes = encoder.GetBytes(value);
var bytes = Convert.FromBase64String(value);
using (var stream = new MemoryStream(bytes))
{
return(serializer.Deserialize <T>(stream));
}
}
private async Task StreamGenericAsyncTest(IStreamSerializer serializer, IStreamSerializerAsync serializerAsync,
TestModel model)
{
var stream = new MemoryStream();
await serializerAsync.PackAsync(model, stream);
var deserializeModel = await serializerAsync.FromStreamAsync <TestModel>(stream);
Assert.Equal(
Tuple.Create(model.Id, model.Age, model.CreateTime, model.Name, model.Gender),
Tuple.Create(deserializeModel !.Id, deserializeModel.Age, deserializeModel.CreateTime,
deserializeModel.Name, deserializeModel.Gender));
}
private async Task StreamNonGenericAsyncTest(IStreamSerializer serializer, IStreamSerializerAsync streamSerializerAsync,
TestModel model)
{
var type = typeof(TestModel);
var stream = new MemoryStream();
await streamSerializerAsync.PackAsync(model, stream);
var deserializeModel = (TestModel)(await streamSerializerAsync.FromStreamAsync(type, stream)) !;
Assert.Equal(
Tuple.Create(model.Id, model.Age, model.CreateTime, model.Name, model.Gender),
Tuple.Create(deserializeModel.Id, deserializeModel.Age, deserializeModel.CreateTime,
deserializeModel.Name, deserializeModel.Gender));
}
public async Task StreamFormatterAsync(IStreamSerializer streamSerializer, string mediaType)
{
var dtos = GetDtos();
var httpRequestMessage = CreateHttpRequestMessage(
new StreamContent(streamSerializer.ToStream(dtos)),
mediaType);
var response = await _server.CreateClient().SendAsync(httpRequestMessage);
var result = streamSerializer.FromStream <List <TestDto> >(await response.Content.ReadAsStreamAsync());
Assert.True(CompareDtos(dtos, result));
}
public static string SerializeToString <T>(this IStreamSerializer serializer, T obj, Encoding encoding = null)
{
var encoder = encoding ?? Encoding.UTF8;
using (var stream = new MemoryStream())
{
serializer.Serialize <T>(obj, stream);
stream.Position = 0;
var bytes = new byte[stream.Length];
stream.Read(bytes, 0, (int)stream.Length);
return(Convert.ToBase64String(bytes));
}
}
public void SaveAsSimpleFont(Stream stream)
{
if (stream == null)
{
throw new PdfArgumentNullException("stream");
}
if (!stream.CanWrite)
{
throw new PdfArgumentException("stream");
}
CT_SimpleFont font = new CT_SimpleFont {
Name = this.GetPostScriptName()
};
PdfRectangle fontBoundingBox = this.GetFontBoundingBox();
font.BBox0 = fontBoundingBox.LowerLeftX;
font.BBox1 = fontBoundingBox.LowerLeftY;
font.BBox2 = fontBoundingBox.UpperRightX;
font.BBox3 = fontBoundingBox.UpperRightY;
font.Flags = (int)this.GetFlag();
font.ItalicAngle = this.GetItalicAngle();
font.Ascent = this.GetAscent();
font.Descent = this.GetDescent();
font.CapHeight = this.GetCapitalLetterHeight();
font.StemV = this.GetVerticalStem();
List <CT_Width> list = new List <CT_Width>();
foreach (KeyValuePair <int, int> pair in this.CMap.CurrentMap)
{
CT_Width width;
width = new CT_Width {
Index = pair.Key,
Value = this.GetWidth(pair.Value)
};
list.Add(width);
}
font.Widths = list.ToArray();
IStreamSerializer serializerByType = SerializerBuilder.GetSerializerByType(typeof(CT_SimpleFont));
MemoryStream stream2 = new MemoryStream();
serializerByType.Serialize(stream2, font);
stream2.Seek(0L, SeekOrigin.Begin);
PdfFilter.FlateFilter.Encode(stream2, stream, null);
}
public virtual GlobalSerializerConfig SetImplementation <T>(IStreamSerializer <T> implementation)
{
_implementation = implementation;
return(this);
}
public IsolatedStreamStorage(IStreamSerializer <T> sessionsProtoSerializer)
{
this._serializer = sessionsProtoSerializer;
}
public StreamFileSerializer(IStreamSerializer <T> streamSerializer)
{
this.StreamSerializer = streamSerializer;
}
public StreamSerializerAdapter(IStreamSerializer <T> serializer)
{
_serializer = serializer;
}
public MySerializerTests(IStreamSerializer serializer)
{
_serializer = serializer;
}
public ZaabyClientFormatterOptions(IStreamSerializer serializer, string mediaType)
{
Serializer = serializer;
MediaType = mediaType;
}
