public WithEncryptionRegistry(ISerializationRegistry registry, IKeyStore store)
 {
     _registry             = registry;
     _store                = store;
     _postprocessorFactory = s => d => store.Encrypt(s, d);
     _preprocessorFactory  = store.DecryptFactory;
 }
        public static ISerializationRegistry RegisterEventSerializer <T>(
            this ISerializationRegistry registry,
            string typeName,
            int version,
            Func <T, IMetadata, JObject> serializer,
            CreatePostprocessor postprocessor = null
            ) where T : Event
        {
            var r = (IRegisterEventSerializers)registry;

            r.Register(typeName, version, serializer, postprocessor);
            return(registry);
        }
示例#3
0
        void IRegisterEventSerializers.Register <T>(string typeName, int version, Func <T, IMetadata, JObject> serializer, CreatePostprocessor postProcessor)
        {
            postProcessor = postProcessor ?? DefaultPostprocessor;
            byte[] Serialize(string id, Event e, Metadata m)
            {
                m.Type    = typeName;
                m.Version = version;
                var json  = serializer((T)e, m);
                var bytes = json.ToBytes();

                return(postProcessor(id)(bytes));
            }

            if (_eventSerializers.ContainsKey(typeof(T)))
            {
                throw new InvalidOperationException($"Serializer already registered for {typeof(T)}");
            }

            _eventSerializers.Add(typeof(T), Serialize);
        }
        public static ISerializationRegistry DefaultForEvent <T>(this ISerializationRegistry registry, CreatePostprocessor postSerialization = null, CreatePreprocessor preDeserialization = null)
            where T : Event
        {
            bool prePostIsValidEnough = (postSerialization != null && preDeserialization != null) ||
                                        (postSerialization == null && preDeserialization == null);

            if (!prePostIsValidEnough)
            {
                throw new ArgumentException("Both pre and post serialization must be specified or neither");
            }
            return(registry
                   .RegisterEventSerializer <T>(CamelCase(typeof(T).Name), 1,
                                                (e, m) => JObject.FromObject(e, SerializationRegistry.DefaultSerializer), postSerialization)
                   .RegisterEventDeserializer(typeof(object), CamelCase(typeof(T).Name), 1,
                                              (json, m) => {
                var e = json.ToObject <T>(SerializationRegistry.DefaultSerializer);
                var em = (IEvent)e;
                em.Metadata = (IMetadata)m;
                return e;
            }, preDeserialization));
        }
 public void Register <T>(string typeName, int version, Func <T, IMetadata, JObject> serializer, CreatePostprocessor postProcessor) where T : Event
 {
     _registry.Register(typeName, version, serializer, _postprocessorFactory);
 }