public CommandCoordinator(ISerializer serializer, IHubProxyManager hubProxyFactory)
        {
            _serializer = serializer;

            _proxy = hubProxyFactory.Get<Proxies.ICommandCoordinator>();
            _proxy.EventsProcessed += EventsProcessed;
        }

 internal ConsumedMessage ToConsumedMessage(ISerializer serializer, MessageBinding messageBinding)
 {
     return new ConsumedMessage(serializer.Deserialize(_args.Body,
                                                       messageBinding.RuntimeType,
                                                       _args.BasicProperties.CreateEncoding()),
                                _args);
 }

 public DefaultEndpointCircuitBreaker(IPipelineTransport transport, ISerializer serializer, EndpointDefinition definitioin)
 {
     this.ErrorStrategy = new EndpointPostConsumeStrategy.ErrorEndpointPerEndpoint(transport, serializer, definitioin);
     this.RetryStrategy = new EndpointPostConsumeStrategy.RetryEndpointPerEndpoint(transport, serializer, definitioin);
     this.SuccessStrategy = new EndpointPostConsumeStrategy.NoSuccessStrategy();
     this.MaximumMessageAge = 5;
 }

 public void RegisterSerilizer(ISerializer serializer)
 {
     int id = nextID++;
     this.idToType.Add(id, serializer.SerializeType);
     this.typeToID.Add(serializer.SerializeType, id);
     this.serializerByType.Add(serializer.SerializeType, serializer);
 }

 public ExpressionSerializer(ISerializer serializer, FactorySettings factorySettings = null)
 {
     if (serializer == null)
         throw new ArgumentNullException("serializer");
     _serializer = serializer;
     _factorySettings = factorySettings;
 }

        public ContainmentWhereFragment(ISerializer serializer, BinaryExpression binary)
        {
            _serializer = serializer;

            var visitor = new FindMembers();
            visitor.Visit(binary.Left);

            var members = visitor.Members;

            if (members.Count > 1)
            {
                var dict = new Dictionary<string, object>();
                var member = members.Last();
                var value = MartenExpressionParser.Value(binary.Right);
                dict.Add(member.Name, value);

                members.Reverse().Skip(1).Each(m =>
                {
                    dict = new Dictionary<string, object> { { m.Name, dict}};
                });

                _dictionary = dict;
            }
            else
            {
                _dictionary = new Dictionary<string, object>();

                var member = members.Single();
                var value = MartenExpressionParser.Value(binary.Right);
                _dictionary.Add(member.Name, value);

            }
        }

 public StatefullAggregateRepository(AggregateStore store, IDataFactory dataFactory, ISerializer serializer, AggregateRegistry aggregateRegistry, ITransitionStore transitionStore, AggregateDefinition definition)
     : base(store, dataFactory, definition)
 {
     _serializer = serializer;
     _aggregateRegistry = aggregateRegistry;
     _transitionStore = transitionStore;
 }

 public NewtonsoftJsonSerializer( ISerializer serializer )
 {
     ContentType = serializer.ContentType;
     DateFormat = serializer.DateFormat;
     Namespace = serializer.Namespace;
     RootElement = serializer.RootElement;
 }

        public GameCreationManager(IPluginClient pluginClient, ISerializer serializer)
        {
            this.createGameService = new PluginService<CreateGameClientMessage, GameInviteReceivedServerMessage>(GamifyClientMessageType.CreateGame, GamifyServerMessageType.GameInviteReceived, pluginClient, serializer);
            this.acceptGameService = new PluginService<AcceptGameClientMessage, GameCreatedServerMessage>(GamifyClientMessageType.AcceptGame, GamifyServerMessageType.GameCreated, pluginClient, serializer);
            this.rejectGameService = new PluginService<RejectGameClientMessage, GameRejectedServerMessage>(GamifyClientMessageType.RejectGame, GamifyServerMessageType.GameRejected, pluginClient, serializer);

            this.createGameService.NotificationReceived += (sender, args) =>
            {
                if (this.GameInviteNotificationReceived != null)
                {
                    this.GameInviteNotificationReceived(this, args);
                }
            };

            this.acceptGameService.NotificationReceived += (sender, args) =>
            {
                if (this.GameCreatedNotificationReceived != null)
                {
                    this.GameCreatedNotificationReceived(this, args);
                }
            };

            this.rejectGameService.NotificationReceived += (sender, args) =>
            {
                if (this.GameRejectedNotificationReceived != null)
                {
                    this.GameRejectedNotificationReceived(this, args);
                }
            };
        }

 public InProcessQueueSender(ISerializer serializer, Queue queue, InProcessMessageStore messageStore, ILogger logger)
 {
     _serializer = serializer;
     _queue = queue;
     _messageStore = messageStore;
     _logger = logger;
 }

        internal XDIOStreamListener(ISerializer serializer)
        {
            serializer.Requires().IsNotNull();

            this.serializer = serializer;
            watcherList = new Dictionary<string, FileSystemWatcher>(StringComparer.InvariantCultureIgnoreCase);
        }

     public WorkerEngine(ISerializer serializer, IHandler handler, string loadbalancerAddress)
     {
         m_serializer = serializer;
         m_loadbalancerAddress = loadbalancerAddress;
         m_handler = handler;
         m_nextMessageId = 0;
 }

 public ConfigurationStore(IZipper zipper, IDeserializer deserializer, ISerializer serializer, IDialog dialog)
 {
     _zipper = zipper;
     _deserializer = deserializer;
     _serializer = serializer;
     _dialog = dialog;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ProtoBufRestClient"/> class.
 /// </summary>
 /// <param name="serializer">
 /// The serializer.
 /// </param>
 /// <param name="client">
 /// The client.
 /// </param>
 /// <exception cref="Exception">
 /// Throws an exception if the serializer does not support ProtoBuffer
 /// </exception>
 public ProtoBufRestClient(ISerializer serializer, HttpClient client = null) : base(serializer, client)
 {
     if (serializer.Format != SerializationFormat.Json)
     {
         throw new Exception(string.Format("Invalid serializer type: {0}. Valid type is: {1}", serializer.Format, SerializationFormat.ProtoBuffer));
     }
 }

        public AttachmentResponseFactory(ISerializer serializer)
        {
            Ensure.That(serializer, "serializer").IsNotNull();

            SuccessfulResponseMaterializer = new AttachmentResponseMaterializer();
            FailedResponseMaterializer = new FailedResponseMaterializer(serializer);
        }

 private void MakeIsgdWebRequestAsync(ISerializer responseDeserializer, string relativeUrl, Action<IsgdExpandResponse> webRequestCallback)
 {
     this.MakeWebRequestAsync(
         responseDeserializer,
         new Uri(IsgdApiBaseUri, relativeUrl + string.Format("&format=json")),
         webRequestCallback);
 }

        public static IWhereFragment SimpleArrayContains(ISerializer serializer, QueryModel queryModel, ContainsResultOperator contains)
        {
            var from = queryModel.MainFromClause.FromExpression;
            var visitor = new FindMembers();
            visitor.Visit(from);

            var members = visitor.Members;

            var constant = contains.Item as ConstantExpression;

            if (constant != null)
            {
                var array = Array.CreateInstance(constant.Type, 1);
                array.SetValue(constant.Value, 0);

                var dict = new Dictionary<string, object>();
                dict.Add(members.Last().Name, array);

                members.Reverse().Skip(1).Each(m =>
                {
                    dict = new Dictionary<string, object>() { {m.Name, dict} };
                });

                return new ContainmentWhereFragment(serializer, dict);
            }

            throw new NotSupportedException();
        }

 public ZooKeeperServiceRouteManager(ZookeeperConfigInfo configInfo, ISerializer serializer, ILogger<ZooKeeperServiceRouteManager> logger)
 {
     _configInfo = configInfo;
     _serializer = serializer;
     _logger = logger;
     CreateZooKeeper();
 }

        public void Serialize(ISerializer serializer, string name, Vector2 v)
        {
            ISerializer subSer = serializer.SubSerializer(name);

            subSer.SerializeString(tagX, v.X);
            subSer.SerializeString(tagY, v.Y);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ResourceResultContext" /> class.
 /// </summary>
 /// <param name="logger">The logger.</param>
 /// <param name="frameworkProvider">The framework provider.</param>
 /// <param name="serializer">The serializer.</param>
 /// <param name="htmlEncoder">The HTML encoder.</param>
 public ResourceResultContext(ILogger logger, IFrameworkProvider frameworkProvider, ISerializer serializer, IHtmlEncoder htmlEncoder)
 {
     Logger = logger;
     FrameworkProvider = frameworkProvider;
     Serializer = serializer;
     HtmlEncoder = htmlEncoder;
 }