C# ClusterDescription类代码示例

 /// <summary>
 /// Initializes a new instance of the <see cref="ClusterSelectedServerEvent" /> struct.
 /// </summary>
 /// <param name="clusterDescription">The cluster description.</param>
 /// <param name="serverSelector">The server selector.</param>
 /// <param name="selectedServer">The selected server.</param>
 /// <param name="duration">The duration of time it took to select the server.</param>
 public ClusterSelectedServerEvent(ClusterDescription clusterDescription, IServerSelector serverSelector, ServerDescription selectedServer, TimeSpan duration)
 {
     _clusterDescription = clusterDescription;
     _serverSelector = serverSelector;
     _selectedServer = selectedServer;
     _duration = duration;
 }

 // methods
 /// <inheritdoc/>
 public IEnumerable<ServerDescription> SelectServers(ClusterDescription cluster, IEnumerable<Servers.ServerDescription> servers)
 {
     return servers.Where(x =>
         x.Type == ServerType.ReplicaSetPrimary ||
         x.Type == ServerType.ShardRouter ||
         x.Type == ServerType.Standalone);
 }

        // methods
        /// <inheritdoc/>
        public IEnumerable<ServerDescription> SelectServers(ClusterDescription cluster, IEnumerable<ServerDescription> servers)
        {
            if (_maxStaleness.HasValue)
            {
                if (cluster.Servers.Any(s => s.Type != ServerType.Unknown && !Feature.MaxStaleness.IsSupported(s.Version)))
                {
                    throw new NotSupportedException("All servers must be version 3.4 or newer to use max staleness.");
                }
            }

            if (cluster.ConnectionMode == ClusterConnectionMode.Direct)
            {
                return servers;
            }

            switch (cluster.Type)
            {
                case ClusterType.ReplicaSet: return SelectForReplicaSet(cluster, servers);
                case ClusterType.Sharded: return SelectForShardedCluster(servers);
                case ClusterType.Standalone: return SelectForStandaloneCluster(servers);
                case ClusterType.Unknown: return __noServers;
                default:
                    var message = string.Format("ReadPreferenceServerSelector is not implemented for cluster of type: {0}.", cluster.Type);
                    throw new NotImplementedException(message);
            }
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ClusterSelectingServerFailedEvent" /> struct.
 /// </summary>
 /// <param name="clusterDescription">The cluster description.</param>
 /// <param name="serverSelector">The server selector.</param>
 /// <param name="exception">The exception.</param>
 /// <param name="operationId">The operation identifier.</param>
 public ClusterSelectingServerFailedEvent(ClusterDescription clusterDescription, IServerSelector serverSelector, Exception exception, long? operationId)
 {
     _clusterDescription = clusterDescription;
     _serverSelector = serverSelector;
     _exception = exception;
     _operationId = operationId;
 }

 // methods
 public IEnumerable<ServerDescription> SelectServers(ClusterDescription cluster, IEnumerable<ServerDescription> servers)
 {
     var selectedServers = servers;
     foreach (var selector in _selectors)
     {
         selectedServers = selector.SelectServers(cluster, selectedServers);
     }
     return selectedServers;
 }

 public void TestFixtureSetup()
 {
     var clusterId = new ClusterId(1);
     var clusterType = ClusterType.Standalone;
     var endPoint = new DnsEndPoint("localhost", 27017);
     var serverId = new ServerId(clusterId, endPoint);
     var server = new ServerDescription(serverId, endPoint);
     var servers = new[] { server };
     _clusterDescription = new ClusterDescription(clusterId, clusterType, servers);
 }

        // constructors
        protected Cluster(ClusterSettings settings, IClusterableServerFactory serverFactory, IClusterListener listener)
        {
            _settings = Ensure.IsNotNull(settings, "settings");
            _serverFactory = Ensure.IsNotNull(serverFactory, "serverFactory");
            _listener = listener;
            _state = new InterlockedInt32(State.Initial);

            _clusterId = new ClusterId();
            _description = ClusterDescription.CreateInitial(_clusterId, _settings.ConnectionMode.ToClusterType());
            _descriptionChangedTaskCompletionSource = new TaskCompletionSource<bool>();
        }

 public void Constructor_should_initialize_instance()
 {
     var subject = new ClusterDescription(
         __clusterId,
         ClusterType.ReplicaSet,
         new[] { __serverDescription1, __serverDescription2 });
     subject.ClusterId.Should().Be(__clusterId);
     subject.Servers.Should().ContainInOrder(new[] { __serverDescription1, __serverDescription2 });
     subject.State.Should().Be(ClusterState.Disconnected);
     subject.Type.Should().Be(ClusterType.ReplicaSet);
 }

 public MongoIncompatibleDriverExceptionTests()
 {
     var clusterId = new ClusterId(1);
     var connectionMode = ClusterConnectionMode.Standalone;
     var clusterType = ClusterType.Standalone;
     var endPoint = new DnsEndPoint("localhost", 27017);
     var serverId = new ServerId(clusterId, endPoint);
     var server = new ServerDescription(serverId, endPoint);
     var servers = new[] { server };
     _clusterDescription = new ClusterDescription(clusterId, connectionMode, clusterType, servers);
 }

        public void Setup()
        {
            var clusterId = new ClusterId();
            _primary = ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27017), ServerType.ReplicaSetPrimary, new TagSet(new [] { new Tag("a", "1") }));
            _secondary1 = ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27018), ServerType.ReplicaSetSecondary, new TagSet(new [] { new Tag("a", "1") }));
            _secondary2 = ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27019), ServerType.ReplicaSetSecondary, new TagSet(new[] { new Tag("a", "2") }));

            _description = new ClusterDescription(
                clusterId,
                ClusterType.ReplicaSet,
                new[] { _primary, _secondary1, _secondary2 });
        }

 // methods
 public IEnumerable<ServerDescription> SelectServers(ClusterDescription cluster, IEnumerable<ServerDescription> servers)
 {
     var list = servers.ToList();
     switch (list.Count)
     {
         case 0:
         case 1:
             return list;
         default:
             var index = ThreadStaticRandom.Next(list.Count);
             return new[] { list[index] };
     }
 }

 public void Setup()
 {
     var clusterId = new ClusterId();
     _description = new ClusterDescription(
         clusterId,
         ClusterType.Unknown,
         new[]
         {
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27017), averageRoundTripTime: TimeSpan.FromMilliseconds(10)),
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27018), averageRoundTripTime: TimeSpan.FromMilliseconds(30)),
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27019), averageRoundTripTime: TimeSpan.FromMilliseconds(20))
         });
 }

 public void Setup()
 {
     var clusterId = new ClusterId();
     _description = new ClusterDescription(
         clusterId,
         ClusterType.Unknown,
         new[]
         {
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27017)),
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27018)),
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27019)),
         });
 }

 // methods
 /// <inheritdoc/>
 public IEnumerable<ServerDescription> SelectServers(ClusterDescription cluster, IEnumerable<ServerDescription> servers)
 {
     switch (cluster.Type)
     {
         case ClusterType.ReplicaSet: return SelectForReplicaSet(servers);
         case ClusterType.Sharded: return SelectForShardedCluster(servers);
         case ClusterType.Standalone: return SelectForStandaloneCluster(servers);
         case ClusterType.Unknown: return __noServers;
         default:
             var message = string.Format("ReadPreferenceServerSelector is not implemented for cluster of type: {0}.", cluster.Type);
             throw new NotImplementedException(message);
     }
 }

 public LatencyLimitingServerSelectorTests()
 {
     var clusterId = new ClusterId();
     _description = new ClusterDescription(
         clusterId,
         ClusterConnectionMode.Automatic,
         ClusterType.Unknown,
         new[]
         {
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27017), averageRoundTripTime: TimeSpan.FromMilliseconds(10)),
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27018), averageRoundTripTime: TimeSpan.FromMilliseconds(30)),
             ServerDescriptionHelper.Connected(clusterId, new DnsEndPoint("localhost", 27019), averageRoundTripTime: TimeSpan.FromMilliseconds(20))
         });
 }