C# ISerializer类代码示例

        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);
        }