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 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 SerializationContext(SerializationStrategy strategy) { this.strategy = strategy; }