public override void Init(SerializerMode mode)
{
_mode = mode;
if (_cache != null)
{
_cache = new SerializerCache <Guid>(mode);
}
}
private static void _AddSample(Type type, JsonArray json, JsonSerializer serializer)
{
var elementType = _GetElementType(type);
var buildMethod = TemplateGenerator.GetBuildMethod(elementType);
var value = buildMethod.Invoke(null, new object[] { serializer.Options });
var serialize = SerializerCache.GetSerializeMethod(elementType);
json.Add((JsonValue)serialize(serializer, value));
}
/// <summary>
/// Сериализация объекта в строку XML
/// </summary>
/// <param name="obj">Объект</param>
/// <returns>Строку, содержащая в себе XML код сериализованного объекта</returns>
public static string SerializeObject(object obj)
{
XmlSerializer sr = SerializerCache.GetSerializer(obj.GetType());
StringBuilder sb = new StringBuilder();
StringWriter w = new StringWriter(sb, System.Globalization.CultureInfo.InvariantCulture);
sr.Serialize(w, obj, new XmlSerializerNamespaces(new XmlQualifiedName[] { new XmlQualifiedName(string.Empty) }));
return(sb.ToString());
}
public FactGraph Serialize(object prototype)
{
lock (this)
{
var collector = new Collector(serializerCache);
collector.Serialize(prototype);
serializerCache = collector.SerializerCache;
return(collector.Graph);
}
}
private static Dictionary <SerializationInfo, object> _DeserializeValues <T>(T obj, JsonValue json, JsonSerializer serializer, IEnumerable <SerializationInfo> members, bool ignoreCase)
{
var dict = new Dictionary <SerializationInfo, object>();
foreach (var memberInfo in members)
{
var name = memberInfo.SerializationName;
if (memberInfo.ShouldTransform)
{
name = serializer.Options.DeserializationNameTransform(name);
}
var visited = new HashSet <string>(ignoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
if (_TryGetKeyValue(json, name, ignoreCase, out var value) &&
visited.Add(name))
{
Func <JsonSerializer, JsonValue, object> deserialize;
if (memberInfo.MemberInfo is PropertyInfo info)
{
deserialize = SerializerCache.GetDeserializeMethod(info.PropertyType);
}
else
{
deserialize = SerializerCache.GetDeserializeMethod(((FieldInfo)memberInfo.MemberInfo).FieldType);
}
var valueObj = deserialize(serializer, value);
if (value.Type == JsonValueType.Object && value.Object.ContainsKey(Constants.RefKey))
{
var guid = new Guid(value.Object[Constants.RefKey].String);
var pair = serializer.SerializationMap[guid];
if (pair.DeserializationIsComplete)
{
dict.Add(memberInfo, valueObj);
}
else
{
if (memberInfo.MemberInfo is PropertyInfo property)
{
pair.AddReference(property, obj);
}
else
{
pair.AddReference((FieldInfo)memberInfo.MemberInfo, obj);
}
}
value.Object.Remove(Constants.RefKey);
}
else
{
dict.Add(memberInfo, valueObj);
}
}
}
return(dict);
}
public void AddSerializer_WithSerializer_DoesNotThrow()
{
// Arrange
var cache = new SerializerCache();
// Act
TestDelegate addSerializer = () => cache.AddSerializer(serializer);
// Assert
Assert.That(addSerializer, Throws.Nothing);
}
/// <summary>
/// Десериализация объекта
/// </summary>
/// <typeparam name="T">Тип объекта</typeparam>
/// <param name="xml">Строка, содержащая в себе XML код сериализованного объекта</param>
/// <returns>Объект</returns>
public static T DeserializeObject <T>(string xml)
{
if ((xml == string.Empty) || (xml == null))
{
return((T)Activator.CreateInstance(typeof(T)));
}
StringReader reader = new StringReader(xml);
XmlSerializer sr = SerializerCache.GetSerializer(typeof(T));
return((T)sr.Deserialize(reader));
}
public void AddSerializer_WithNullSerializer_ThrowsArgumentNullException()
{
// Arrange
var cache = new SerializerCache();
// Act
TestDelegate addSerializer = () => cache.AddSerializer(null);
// Assert
Assert.That(addSerializer, Throws.ArgumentNullException);
}
public void DefaultSerializer_WithNoneAdded_IsNull()
{
// Arrange
var cache = new SerializerCache();
// Act
var defaultSerializer = cache.DefaultSerializer;
// Assert
Assert.That(defaultSerializer, Is.Null);
}
public void AddSerializer_WithNoOtherSerializers_SetsToDefault()
{
// Arrange
var cache = new SerializerCache();
// Act
cache.AddSerializer(serializer);
var defaultSerializer = cache.DefaultSerializer;
// Assert
Assert.That(serializer, Is.EqualTo(defaultSerializer));
}
public void SerializerFor_WithoutSerializerAdded_ReturnsFalse()
{
// Arrange
var cache = new SerializerCache();
// Act
var hasSerializer = cache.SerializerFor("test", out var returnedSerializer);
// Assert
Assert.That(hasSerializer, Is.False);
Assert.That(returnedSerializer, Is.Null);
}
public async Task SenderReceiver_WhenBoundAndConnected_PassesMessage()
{
// Arrange
var responseStr = "Hello, World!";
var requestStr = "Hello";
var receivedRequest = string.Empty;
ushort port = 6555;
var called = false;
mockRequestDispatcher
.Setup(m => m.Handle(ref It.Ref <RequestTask> .IsAny))
.Callback(new Handler((ref RequestTask task) => {
called = true;
receivedRequest = (string)task.Request;
task.ResponseSender(responseStr);
}));
var packageFactory = new PackageFactory();
var serializer = new DotNetSerializer();
var serializerCache = new SerializerCache();
var messageFactory = new NetMQMessageFactory(serializerCache, packageFactory);
var sender = new NetMQSender(new DealerSocket(), messageFactory);
var receiver = new NetMQReceiver(new RouterSocket(), messageFactory, requestDispatcher);
var poller = new NetMQPoller();
serializerCache.AddSerializer(serializer);
sender.AddAddress(TcpAddress.Localhost(port));
sender.InitializeConnection();
receiver.AddAddress(TcpAddress.Wildcard(port));
receiver.InitializeConnection();
poller.Add(sender.PollableSocket);
poller.Add(receiver.PollableSocket);
poller.RunAsync();
var package = new DataPackage <string>(new GuidPackageId(), requestStr);
// Act
var response = await sender.SendAndReceive(package, TimeSpan.FromSeconds(5));
// Cleanup
poller.StopAsync();
sender.TerminateConnection();
receiver.TerminateConnection();
// Assert
Assert.That(called, Is.True);
Assert.That(receivedRequest, Is.EqualTo(requestStr));
Assert.That((string)response, Is.EqualTo(responseStr));
}
public void SerializerFor_WithSerializerAdded_ReturnsTrue()
{
// Arrange
var cache = new SerializerCache();
cache.AddSerializer(serializer);
// Act
var hasSerializer = cache.SerializerFor("test", out var returnedSerializer);
// Assert
Assert.That(hasSerializer, Is.True);
}
public void SerializerFor_WithSerializerAdded_ReturnsSameInstance()
{
// Arrange
var cache = new SerializerCache();
cache.AddSerializer(serializer);
// Act
var hasSerializer = cache.SerializerFor("test", out var returnedSerializer);
// Assert
Assert.That(returnedSerializer, Is.SameAs(serializer));
}
internal static XmlSerializer CreateXmlSerializer(Type self, string defaultNamespace, bool includeTypeInNamespace = false)
{
var usedNamespace = includeTypeInNamespace?SerializationHelper.BuildNamespace(defaultNamespace, self):defaultNamespace;
XmlSerializer serializer;
if (SerializerCache.TryGetValue(GetSerializerKey(self, usedNamespace), out serializer))
{
return(serializer);
}
serializer = new XmlSerializer(self, usedNamespace);
SerializerCache.TryAdd(GetSerializerKey(self, usedNamespace), serializer);
return(serializer);
}
public void AddSerializer_WithSameSerializerAlreadyInCache_DoesNotAddDuplicate()
{
// Arrange
var cache = new SerializerCache();
cache.AddSerializer(serializer);
// Act
cache.AddSerializer(serializer);
// Assert
Assert.That(cache.AllSerializers.Count(), Is.EqualTo(1));
}
public void SetDefaultSerializer_WithSerializer_AddsToCache()
{
// Arrange
var cache = new SerializerCache();
// Act
cache.SetDefaultSerializer(serializer);
var hasSerializer = cache.SerializerFor(descriptor, out var returnedSerializer);
// Assert
Assert.That(hasSerializer, Is.True);
Assert.That(returnedSerializer, Is.EqualTo(serializer));
}
public Task NotifyCanceled(string reason = null)
{
LogContext.Debug?.Log("Job Canceled: {JobId} {AttemptId} ({RetryAttempt})", JobId, AttemptId, RetryAttempt);
return(Notify <JobAttemptCanceled>(new
{
JobId,
AttemptId,
RetryAttempt,
InVar.Timestamp,
Job = SerializerCache.GetObjectAsDictionary(Job)
}));
}
private static Dictionary <SerializationInfo, JsonValue> _SerializeValues <T>(T obj, JsonSerializer serializer, IEnumerable <SerializationInfo> properties)
{
var dict = new Dictionary <SerializationInfo, JsonValue>();
foreach (var property in properties)
{
object value;
Type type;
if (property.MemberInfo is PropertyInfo propertyInfo)
{
if (propertyInfo.GetIndexParameters().Length > 0)
{
continue;
}
value = propertyInfo.GetValue(obj, null);
if (value == null && !serializer.Options.EncodeDefaultValues)
{
continue;
}
type = propertyInfo.PropertyType;
}
else
{
var fieldInfo = (FieldInfo)property.MemberInfo;
value = fieldInfo.GetValue(obj);
if (value == null && !serializer.Options.EncodeDefaultValues)
{
continue;
}
type = fieldInfo.FieldType;
}
var json = JsonValue.Null;
if (value != null)
{
var serialize = SerializerCache.GetSerializeMethod(type);
json = (JsonValue)serialize(serializer, value);
}
if ((json == JsonValue.Null) && !serializer.Options.EncodeDefaultValues)
{
continue;
}
if (serializer.Options.IncludeContentSample && json.Type == JsonValueType.Array)
{
_AddSample(type, json.Array, serializer);
}
dict.Add(property, json);
}
return(dict);
}
public Task NotifyStarted()
{
LogContext.Debug?.Log("Job Started: {JobId} {AttemptId} ({RetryAttempt})", JobId, AttemptId, RetryAttempt);
return(Notify <JobAttemptStarted>(new
{
JobId,
AttemptId,
RetryAttempt,
InVar.Timestamp,
InstanceAddress = _instanceAddress,
Job = SerializerCache.GetObjectAsDictionary(Job)
}));
}
public Task NotifyCompleted()
{
LogContext.Debug?.Log("Job Completed: {JobId} {AttemptId} ({RetryAttempt})", JobId, AttemptId, RetryAttempt);
return(Notify <JobAttemptCompleted>(new
{
JobId,
AttemptId,
RetryAttempt,
InVar.Timestamp,
Duration = ElapsedTime,
Job = SerializerCache.GetObjectAsDictionary(Job)
}));
}
public Task NotifyFaulted(Exception exception, TimeSpan?delay)
{
LogContext.Debug?.Log(exception, "Job Faulted: {JobId} {AttemptId} ({RetryAttempt})", JobId, AttemptId, RetryAttempt);
return(Notify <JobAttemptFaulted>(new
{
JobId,
AttemptId,
RetryAttempt,
RetryDelay = delay,
InVar.Timestamp,
Job = SerializerCache.GetObjectAsDictionary(Job),
Exceptions = exception
}));
}
public void AddSerializer_WithDifferentInstancePOfSerializerAlreadyInCache_DoesNotAddDuplicate()
{
// Arrange
var cache = new SerializerCache();
var otherMockSerializer = new Mock <ISerializer>();
otherMockSerializer.Setup(m => m.Descriptor).Returns(descriptor);
cache.AddSerializer(serializer);
// Act
cache.AddSerializer(otherMockSerializer.Object);
// Assert
Assert.That(cache.AllSerializers.Count(), Is.EqualTo(1));
}
async Task PublishJobSubmitted(ConsumeContext context, Guid jobId, TJob job, DateTime timestamp)
{
await context.Publish <JobSubmitted>(new
{
JobId = jobId,
JobTypeId = _jobTypeId,
Timestamp = timestamp,
Job = SerializerCache.GetObjectAsDictionary(job),
_options.JobTimeout
});
if (context.RequestId.HasValue && context.ResponseAddress != null)
{
await context.RespondAsync <JobSubmissionAccepted>(new { JobId = jobId });
}
}
public Builder(string name)
{
this.name = name;
TopicRouter = new TopicRouter();
MonitorCache = new MonitorCache();
RequestRouter = new RequestRouter();
PackageFactory = new PackageFactory();
TopicDispatcher = new TopicDispatcher();
RequestDispatcher = new RequestDispatcher();
SubscriptionsCache = new SubscriptionsCache();
SerializerCache = new SerializerCache();
SenderCache = new SenderCache(RequestRouter, MonitorCache);
ReceiverCache = new ReceiverCache(MonitorCache);
PublisherCache = new PublisherCache(MonitorCache);
SubscriberCache = new SubscriberCache(TopicRouter, MonitorCache, SubscriptionsCache);
}
private static Dictionary <SerializationInfo, JsonValue> _SerializeTypeValues(JsonSerializer serializer, IEnumerable <SerializationInfo> properties)
{
var dict = new Dictionary <SerializationInfo, JsonValue>();
foreach (var memberInfo in properties)
{
object value;
Type type;
if (memberInfo.MemberInfo is PropertyInfo propertyInfo)
{
if (propertyInfo.GetIndexParameters().Any())
{
continue;
}
value = propertyInfo.GetValue(null, null);
if (value == null)
{
continue;
}
type = propertyInfo.PropertyType;
}
else
{
var fieldInfo = (FieldInfo)memberInfo.MemberInfo;
value = fieldInfo.GetValue(null);
if (value == null)
{
continue;
}
type = fieldInfo.FieldType;
}
var serialize = SerializerCache.GetSerializeMethod(type);
var json = (JsonValue)serialize(serializer, value);
if ((json == JsonValue.Null) && !serializer.Options.EncodeDefaultValues)
{
continue;
}
dict.Add(memberInfo, json);
}
return(dict);
}
public override string Serialize(List <ISerializableRoot> roots, out List <SerializerError> errors)
{
errors = ListPool <SerializerError> .Get();
XDocument document = new XDocument();
XElement rootElement = new XElement(parameters.rootElementName);
document.Add(rootElement);
foreach (var root in roots)
{
var typeName = root.GetType().Name;
var element = new XElement(typeName);
element.SetAttributeValue(AttributeIdentifier, root.identifier);
var data = new SerializedData(SerializerCache.GetSerializableTypeCacheFor(typeName, parameters.standardNamespace), element);
data.WriteFromObject(root, errors, parameters);
rootElement.Add(element);
}
return(document.ToString());
}
public override void Init(SerializerMode mode)
{
_mode = mode;
if (_decimalCache != null)
{
_decimalCache = new SerializerCache <decimal>(mode);
}
if (_doubleCache != null)
{
_doubleCache = new SerializerCache <double>(mode);
}
if (_floatCache != null)
{
_floatCache = new SerializerCache <float>(mode);
}
if (_longCache != null)
{
_longCache = new SerializerCache <long>(mode);
}
if (_uLongCache != null)
{
_uLongCache = new SerializerCache <ulong>(mode);
}
if (_intCache != null)
{
_intCache = new SerializerCache <int>(mode);
}
if (_uIntCache != null)
{
_uIntCache = new SerializerCache <uint>(mode);
}
if (_shortCache != null)
{
_shortCache = new SerializerCache <short>(mode);
}
if (_uShortCache != null)
{
_uShortCache = new SerializerCache <ushort>(mode);
}
}
void SerializationDelegates(EndpointConfiguration endpointConfiguration)
{
#region BondSerializationDelegates
var serialization = endpointConfiguration.UseSerialization <BondSerializer>();
serialization.SerializationDelegates(
serializationDelegatesBuilder: messageType =>
{
var item = SerializerCache.GetSerializer(messageType);
return(new SerializationDelegates(
serialize: (buffer, message) =>
{
var writer = new CompactBinaryWriter <OutputBuffer>(buffer);
item.Serializer.Serialize(message, writer);
},
deserialize: buffer =>
{
var reader = new CompactBinaryReader <InputBuffer>(buffer);
return item.Deserializer.Deserialize(reader);
}));
});
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializationProvider"/> class.
/// </summary>
/// <param name="knownTypes">
/// The known types.
/// </param>
public SerializationProvider(IEnumerable<Type> knownTypes)
{
this.serializerCache = new SerializerCache(knownTypes);
}
private ISerializer <T> CreateExternal() => _customSerializer = (ISerializer <T>)SerializerCache.GetInstance(MetaType.SerializerType, typeof(T));
