public void Init()
{
_registry = new RemoteEndpointRegistry();
_serialization = new ProtoBufSerializationStrategy();
_registry.ReRoute(TestHostName, "endpoint1");
}
private void SerializeMessage(IMessage <T> message)
{
var serializedMessage = SerializationStrategy.SerializeMessage(message);
msgProperties = serializedMessage.Properties;
body = serializedMessage.Body;
}
public static T DeepClone <T>(this T self, SerializationStrategy strategy)
{
switch (strategy)
{
case SerializationStrategy.Xml:
XmlSerializer xs = new XmlSerializer(typeof(T));
StringWriter os = new StringWriter();
xs.Serialize(os, self);
StringReader sr = new StringReader(os.ToString());
T retXml = (T)xs.Deserialize(sr);
os.Close();
sr.Close();
return(retXml);
case SerializationStrategy.Binary:
var bf = new BinaryFormatter();
var ms = new MemoryStream();
bf.Serialize(ms, self);
ms.Position = 0;
T retBin = (T)bf.Deserialize(ms);
ms.Close();
return(retBin);
}
return(default(T));
}
public void Init()
{
_registry = new RemoteEndpointRegistry();
_serialization = new ProtoBufSerializationStrategy();
_registry.ReRoute(TestHostName, "endpoint1");
}
public RemoteRequestListener2(IZmqContext context, string endpoint, int workers,
LocalInvocationDispatcher dispatcher,
SerializationStrategy serializationStrategy)
{
_endpoint = endpoint;
_dispatcher = dispatcher;
_serializationStrategy = serializationStrategy;
_reply = context.Rep();
}
public RemoteRequestListener2(IZmqContext context, string endpoint, int workers,
LocalInvocationDispatcher dispatcher,
SerializationStrategy serializationStrategy)
{
_endpoint = endpoint;
_dispatcher = dispatcher;
_serializationStrategy = serializationStrategy;
_reply = context.Rep();
}
public RemoteRequest(IZmqContext context, string endpoint,
RequestMessage requestMessage,
SerializationStrategy serializationStrategy) : base(context, endpoint)
{
this._endpoint = endpoint;
this._requestMessage = requestMessage;
this._serializationStrategy = serializationStrategy;
this.Timeout = 30 * 1000;
}
public RemoteRequestService(IZmqContext context,
RemoteEndpointRegistry endpointRegistry,
SerializationStrategy serializationStrategy,
RequestPoll requestPoll)
{
this._context = context;
this._endpointRegistry = endpointRegistry;
this._serializationStrategy = serializationStrategy;
this._requestPoll = requestPoll;
}
public void ApplyStrategy(SerializationStrategy serializationStrategy, ISerializationConfiguration serializationConfiguration)
{
var serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup;
var infoGraphNodes = serializationConfigurationGroup.Configurations.SelectMany(configuration => configuration.SerializationGraph);
var classInfoGraphNodes = infoGraphNodes.Where(node => node.TypeName == serializationConfiguration.TypeToSerialize.Name);
foreach (var classInfoGraphNode in classInfoGraphNodes)
{
classInfoGraphNode.SerializationStrategy = serializationStrategy;
}
}
public async Task <bool> TrySetAsync <T>(string key, T value)
{
try
{
var result = SerializationStrategy.Serialize(value);
await PersistenceStrategy.SaveAsync(key, result);
return(true);
}
catch
{
return(false);
}
}
public RemoteRequestListener(IZmqContext context, string endpoint, int workers,
LocalInvocationDispatcher dispatcher,
SerializationStrategy serializationStrategy)
{
this._context = context;
this._endpoint = endpoint;
this._workers = workers;
this._dispatcher = dispatcher;
this._serializationStrategy = serializationStrategy;
var count = Interlocked.Increment(ref localAddUseCounter);
this._localEndpoint = "inproc://rrworker_" + count;
}
SerializationStrategy GetSerializationStrategy(IMemberInfo memberInfo, SerializationStrategy serializationStrategy)
{
if (memberInfo.MemberTypeInfo.IsPersistent)
{
var attribute = memberInfo.MemberTypeInfo.FindAttribute <SerializationStrategyAttribute>();
if (attribute != null)
{
return(attribute.SerializationStrategy);
}
}
var serializationStrategyAttribute = memberInfo.FindAttribute <SerializationStrategyAttribute>();
return(serializationStrategyAttribute != null ? serializationStrategyAttribute.SerializationStrategy : serializationStrategy);
}
public IDisposable Consume(
IQueue queue,
Action <IHandlerRegistration> addHandlers,
Action <IConsumerConfiguration> configure = null)
{
var handlerCollection = new HandlerCollection();
addHandlers(handlerCollection);
return(Consume(queue, (body, properties, messageReceivedInfo) =>
{
var deserializedMessage = SerializationStrategy.DeserializeMessage(properties, body);
var handler = handlerCollection.GetHandler(deserializedMessage.MessageType);
return handler(deserializedMessage, messageReceivedInfo);
}, configure));
}
private static IJsonSerializerStrategy CreateStrategy(SerializationStrategy strategyType)
{
switch (strategyType)
{
case SerializationStrategy.SnakeCase:
return(new SnakeCaseSerializationStrategy());
case SerializationStrategy.SnakeCaseIgnoreNull:
return(new SnakeCaseSerializationStrategy {
IgnoreNullProperties = true
});
default:
throw new ArgumentException($"Unknown serialization strategy type {strategyType.ToString()}");
}
}
public LocalInvocationDispatcher(IKernel kernel, SerializationStrategy serialization)
{
this._resolver = t =>
{
Type type = null;
lock (_typeResCache)
{
if (!_typeResCache.TryGetValue(t, out type))
{
type = Type.GetType(t, true);
_typeResCache[t] = type;
}
}
return Tuple.Create(kernel.Resolve(type), type);
};
this._serialization = serialization;
}
public LocalInvocationDispatcher(IKernel kernel, SerializationStrategy serialization)
{
this._resolver = t =>
{
Type type = null;
lock (_typeResCache)
{
if (!_typeResCache.TryGetValue(t, out type))
{
type = Type.GetType(t, true);
_typeResCache[t] = type;
}
}
return(Tuple.Create(kernel.Resolve(type), type));
};
this._serialization = serialization;
}
public async Task <TryResult <T> > TryGetAsync <T>(string key)
{
var keys = await PersistenceStrategy.GetKeysAsync();
if (!(keys).Contains(key))
{
return(new TryResult <T>());
}
try
{
var result = await PersistenceStrategy.LoadAsync(key);
var value = SerializationStrategy.Deserialize <T>(result);
return(new TryResult <T> {
Success = true, Value = value
});
}
catch
{
return(new TryResult <T>());
}
}
public static IEnumerable <XElement> SerializedObjectRefs(this IEnumerable <XElement> elements, SerializationStrategy serializationStrategy, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(elements.Where(element => element.GetAttributeValue(elementSchema.Strategy) == serializationStrategy.ToString()));
}
public LocalInvocationDispatcher(Func <string, Tuple <object, Type> > resolver, SerializationStrategy serialization)
{
this._resolver = resolver;
this._serialization = serialization;
}
public static IEnumerable<XElement> SerializedObjectRefs(this IEnumerable<XElement> elements, SerializationStrategy serializationStrategy) {
return elements.Where(element => element.GetAttributeValue("strategy")==serializationStrategy.ToString());
}
public LocalInvocationDispatcher(Func<string, Tuple<object, Type>> resolver, SerializationStrategy serialization)
{
this._resolver = resolver;
this._serialization = serialization;
}
public static string SerializeObject(object obj, SerializationStrategy strategyType)
{
var strategy = CreateStrategy(strategyType);
return(SimpleJson.SimpleJson.SerializeObject(obj, strategy));
}
public SerializationStrategyAttribute(SerializationStrategy serializationStrategy)
{
_serializationStrategy = serializationStrategy;
}
public RemoteInternetSalesService(string baseUrl, SerializationStrategy strategy = SerializationStrategy.Xml, bool compression = false)
{
_compression = compression;
_baseUrl = baseUrl;
_strategy = strategy;
}
public static IEnumerable <XElement> SerializedObjectRefs(this IEnumerable <XElement> elements, SerializationStrategy serializationStrategy)
{
return(elements.Where(element => element.GetAttributeValue("strategy") == serializationStrategy.ToString()));
}
SerializationStrategy GetSerializationStrategy(IMemberInfo memberInfo, SerializationStrategy serializationStrategy) {
if (memberInfo.MemberTypeInfo.IsPersistent) {
var attribute = memberInfo.MemberTypeInfo.FindAttribute<SerializationStrategyAttribute>();
if (attribute != null) {
return attribute.SerializationStrategy;
}
}
var serializationStrategyAttribute = memberInfo.FindAttribute<SerializationStrategyAttribute>();
return serializationStrategyAttribute != null ? serializationStrategyAttribute.SerializationStrategy : serializationStrategy;
}
public RemoteRequestListener(IZmqContext context, string endpoint, int workers,
LocalInvocationDispatcher dispatcher,
SerializationStrategy serializationStrategy)
{
this._context = context;
this._endpoint = endpoint;
this._workers = workers;
this._dispatcher = dispatcher;
this._serializationStrategy = serializationStrategy;
var count = Interlocked.Increment(ref localAddUseCounter);
this._localEndpoint = "inproc://rrworker_" + count;
}
public void ApplyStrategy(SerializationStrategy serializationStrategy, ISerializationConfiguration serializationConfiguration) {
var serializationConfigurationGroup = serializationConfiguration.SerializationConfigurationGroup;
var infoGraphNodes = serializationConfigurationGroup.Configurations.SelectMany(configuration => configuration.SerializationGraph);
var classInfoGraphNodes = infoGraphNodes.Where(node => node.TypeName == serializationConfiguration.TypeToSerialize.Name);
foreach (var classInfoGraphNode in classInfoGraphNodes) {
classInfoGraphNode.SerializationStrategy = serializationStrategy;
}
}
public SerializationContext(SerializationStrategy strategy)
{
this.strategy = strategy;
}
public SerializationStrategyAttribute(SerializationStrategy serializationStrategy) {
_serializationStrategy = serializationStrategy;
}
