protected async Task <T> Deserialize <T>(HttpResponseMessage responseMessage,
HttpStatusCode status = HttpStatusCode.OK)
{
if (CustomSerializer != null)
{
if (responseMessage.StatusCode == status)
{
return(await CustomSerializer.Deserialize <T>(await responseMessage.Content.ReadAsByteArrayAsync()));
}
throw new Exception(
$"Expected Status code {status} received {responseMessage.StatusCode}");
}
if (responseMessage.StatusCode == status)
{
string jsonString;
if (responseMessage.Content.Headers.TryGetValues("Content-Encoding", out var contentEncoding))
{
jsonString = await GetEncodingString(responseMessage, contentEncoding.ToArray());
}
else
{
jsonString = await responseMessage.Content.ReadAsStringAsync();
}
return(JsonSerializer.Deserialize <T>(jsonString, JsonSerializerOptions));
}
var message = await responseMessage.Content.ReadAsStringAsync();
throw new Exception(
$"Expected Status code {status} received {responseMessage.StatusCode}{Environment.NewLine}{message}");
}
public void XmlAttributeDeserializesIntoProperty()
{
var xml = @"<AttributeContainer SomeValue=""abc""></AttributeContainer>";
var serializer = new CustomSerializer<AttributeContainer>(null, null, null);
var container = serializer.Deserialize(xml);
Assert.That(container.SomeValue, Is.EqualTo("abc"));
}
public static void Test()
{
var obj = new CustomString {
Value = "Random string!"
};
var serializer = new CustomSerializer();
var xml = serializer.Serialize(obj);
Console.WriteLine(xml);
var obj2 = serializer.Deserialize <CustomString>(xml);
}
public void EnumAttributeDeserializesCorrectlyWhenExtraTypesArePassedIn()
{
var xml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<EnumAttributeContainer xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" MyEnum=""Value2"" />";
var serializer = new CustomSerializer<EnumAttributeContainer>(null, new[] { typeof(IFoo) }, null);
var container = serializer.Deserialize(xml);
Assert.That(container.MyEnum, Is.EqualTo(MyEnum.Value2));
}
public List <T> Open <T>(string filename)
{
CustomSerializer customSerializer = new CustomSerializer(typeof(List <T>));
List <T> objects = new List <T>();
using (FileStream fs = new FileStream(filename, FileMode.Open))
{
objects = customSerializer.Deserialize(fs) as List <T>;
}
return(objects);
}
private ICommand GetCommandFromMessage(ReceivedTransportMessage message)
{
if (UseCustomSerializer)
{
var deserializedMessage = CustomSerializer.Deserialize(message);
if (deserializedMessage != null && deserializedMessage.Messages.Length > 0)
{
var command = deserializedMessage.Messages[0] as ICommand;
if (command != null)
{
return(command);
}
}
}
string body;
switch (message.Headers["rebus-encoding"].ToString().ToLowerInvariant())
{
case "utf-7":
body = Encoding.UTF7.GetString(message.Body);
break;
case "utf-8":
body = Encoding.UTF8.GetString(message.Body);
break;
case "utf-32":
body = Encoding.UTF32.GetString(message.Body);
break;
case "ascii":
body = Encoding.ASCII.GetString(message.Body);
break;
case "unicode":
body = Encoding.Unicode.GetString(message.Body);
break;
default:
return(null);
}
var msg = JsonConvert.DeserializeObject(body, _jsonSerializerSettings);
var array = msg as Object[];
if (array != null)
{
return(array[0] as ICommand);
}
return(null);
}
public void DeserializeClassBObjectTest()
{
CustomSerializer serializer = new CustomSerializer();
using (FileStream fileStream = new FileStream(filePath, FileMode.Create))
{
serializer.Serialize(fileStream, classB);
}
CustomSerializer deserializer = new CustomSerializer();
ClassB resultObject = null;
using (Stream stream = File.Open(filePath, FileMode.Open))
{
resultObject = (ClassB)deserializer.Deserialize(stream);
}
Assert.IsNotNull(resultObject);
Assert.AreEqual(classB, resultObject);
Assert.AreSame(resultObject.C.A.B.C, resultObject.C);
Assert.AreSame(resultObject.C.A.B.C.A, resultObject.C.A);
}
public void DeserializeTest()
{
ClassA a = new ClassA("A", 77.77, null);
ClassB b = new ClassB("B", 2115, null);
ClassC c = new ClassC("C", false, null);
a.ExampleB = b;
b.ExampleC = c;
c.ExampleA = a;
using (FileStream fileStream = new FileStream("tests.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
IFormatter customSerializer = new CustomSerializer();
customSerializer.Serialize(fileStream, a);
}
ClassA deserializedA;
using (FileStream fileStream = new FileStream("tests.txt", FileMode.Open, FileAccess.ReadWrite))
{
IFormatter customSerializer = new CustomSerializer();
deserializedA = customSerializer.Deserialize(fileStream) as ClassA;
}
Assert.IsNotNull(deserializedA);
Assert.AreEqual(a.ClassName, deserializedA.ClassName);
Assert.AreEqual(a.ExampleDouble, deserializedA.ExampleDouble);
Assert.AreEqual(a.ExampleB, deserializedA.ExampleB);
Assert.AreEqual(a.ExampleB, deserializedA.ExampleB);
Assert.AreEqual(a.ExampleB.ClassName, deserializedA.ExampleB.ClassName);
Assert.AreEqual(a.ExampleB.ExampleInt, deserializedA.ExampleB.ExampleInt);
Assert.AreEqual(a.ExampleB.ExampleC, deserializedA.ExampleB.ExampleC);
Assert.AreEqual(a.ExampleB.ExampleC.ClassName, deserializedA.ExampleB.ExampleC.ClassName);
Assert.AreEqual(a.ExampleB.ExampleC.ExampleBool, deserializedA.ExampleB.ExampleC.ExampleBool);
Assert.AreSame(deserializedA, deserializedA.ExampleB.ExampleC.ExampleA);
File.Delete("tests.txt");
}
public static T Deserialize <T>(Stream stream)
{
return(CustomSerializer <DefaultResolver> .Deserialize <T>(stream));
}
public static T Deserialize <T>(byte[] bytes, int offset)
{
return(CustomSerializer <DefaultResolver> .Deserialize <T>(bytes, offset));
}
static void Main(string[] args)
{
ClassA classA = new ClassA("Anna", "Kowalska", 24, 160.5);
ClassB classB = new ClassB("Jan", "Kowalski", 54, 180.5);
ClassC classC = new ClassC("Hermenegilda", "Nowak", 66, 157.5);
classA.B = classB;
classB.C = classC;
classC.A = classA;
char choice;
do
{
Console.WriteLine("1. Custom serialization \n" +
"2. Custom deserialization \n" +
"3. Json serialization \n" +
"4. Json deserialization \n" +
"5. Finish \n");
choice = Console.ReadKey().KeyChar;
Console.ReadLine();
switch (choice)
{
case '1':
//CUSTOM serialize
string filePath1 = Directory.GetCurrentDirectory() + "\\customSerialized.txt";
CustomSerializer serializer1 = new CustomSerializer();
using (FileStream fileStream = new FileStream(filePath1, FileMode.Create))
{
serializer1.Serialize(fileStream, classA);
}
Console.WriteLine("\nSerialized to: " + filePath1);
break;
case '2':
//CUSTOM deserialize
string filePath2 = Directory.GetCurrentDirectory() + "\\customSerialized.txt";
CustomSerializer serializer2 = new CustomSerializer();
using (FileStream fileStream = new FileStream(filePath2, FileMode.Create))
{
serializer2.Serialize(fileStream, classA);
}
CustomSerializer deserializer = new CustomSerializer();
ClassA result2 = null;
using (Stream stream = File.Open(filePath2, FileMode.Open))
{
result2 = (ClassA)deserializer.Deserialize(stream);
}
Console.WriteLine("\nDeserialized (CUSTOM): \n" +
result2 + "\n" +
result2.B + "\n" +
result2.B.C + "\n");
break;
case '3':
//JSON serialize
string filePath3 = Directory.GetCurrentDirectory() + "\\jsonSerialized.json";
JsonSerializer jsonSerializer3 = new JsonSerializer();
using (FileStream fileStream = new FileStream(filePath3, FileMode.Create))
{
jsonSerializer3.JsonSerialize(fileStream, classA);
}
Console.WriteLine("\nSerialized to: " + filePath3);
break;
case '4':
//JSON deserialize
string filePath4 = Directory.GetCurrentDirectory() + "\\jsonSerialized.json";
JsonSerializer jsonSerializer4 = new JsonSerializer();
using (FileStream fileStream = new FileStream(filePath4, FileMode.Create))
{
jsonSerializer4.JsonSerialize(fileStream, classA);
}
ClassA result4 = null;
result4 = (ClassA)jsonSerializer4.JsonDeserialize(filePath4);
Console.WriteLine("\nDeserialized (JSON): \n" +
result4 + "\n" +
result4.B + "\n" +
result4.B.C + "\n");
break;
case '5':
Environment.Exit(0);
break;
}
Console.WriteLine("\nPress ENTER to continue...");
Console.ReadLine();
Console.Clear();
} while (choice != '5');
Console.ReadLine();
}