C# MongoServerInstance类代码示例

        internal void Connect(
            TimeSpan timeout
        ) {
            server.ClearInstances();

            var exceptions = new List<Exception>();
            foreach (var address in server.Settings.Servers) {
                try {
                    var serverInstance = new MongoServerInstance(server, address);
                    server.AddInstance(serverInstance);
                    try {
                        serverInstance.Connect(server.Settings.SlaveOk); // TODO: what about timeout?
                    } catch {
                        server.RemoveInstance(serverInstance);
                        throw;
                    }

                    return;
                } catch (Exception ex) {
                    exceptions.Add(ex);
                }
            }

            var innerException = exceptions.FirstOrDefault();
            var connectionException = new MongoConnectionException("Unable to connect to server", innerException);
            if (exceptions.Count > 1) {
                connectionException.Data.Add("exceptions", exceptions);
            }
            throw connectionException;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="DirectMongoServerProxy"/> class.
 /// </summary>
 /// <param name="sequentialId">The sequential id.</param>
 /// <param name="serverSettings">The server settings.</param>
 /// <param name="instance">The instance.</param>
 /// <param name="connectionAttempt">The connection attempt.</param>
 public DirectMongoServerProxy(int sequentialId, MongoServerProxySettings serverSettings, MongoServerInstance instance, int connectionAttempt)
 {
     _sequentialId = sequentialId;
     _settings = serverSettings;
     _instance = instance;
     _connectionAttempt = connectionAttempt;
 }

 /// <summary>
 /// Indicates if the instance exists in the chooser.
 /// </summary>
 /// <param name="instance">The instance.</param>
 /// <returns>
 ///   <c>true</c> if [contains] [the specified instance]; otherwise, <c>false</c>.
 /// </returns>
 public bool Contains(MongoServerInstance instance)
 {
     lock (_lock)
     {
         return _instances.Contains(instance);
     }
 }

        internal MongoConnectionPool(
            MongoServerInstance serverInstance
        ) {
            this.server = serverInstance.Server;
            this.serverInstance = serverInstance;

            poolSize = 0;
            timer = new Timer(TimerCallback, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(10));
        }

        // constructors
        internal MongoConnectionPool(MongoServerInstance serverInstance)
        {
            _server = serverInstance.Server;
            _serverInstance = serverInstance;
            _poolSize = 0;

            var dueTime = TimeSpan.FromSeconds(0);
            var period = TimeSpan.FromSeconds(10);
            _timer = new Timer(TimerCallback, null, dueTime, period);
        }

 /// <summary>
 /// Gets a list of primary and secondary instances.
 /// </summary>
 /// <param name="primary">The current primary.</param>
 /// <returns>The list of primary and secondary instances.</returns>
 public List<InstanceWithPingTime> GetPrimaryAndSecondaries(MongoServerInstance primary)
 {
     lock (_connectedInstancesLock)
     {
         // note: make copies of InstanceWithPingTime values because they can change after we return
         return _instances
             .Where(x => x.Instance == primary || x.Instance.IsSecondary)
             .Select(x => new InstanceWithPingTime { Instance = x.Instance, CachedAveragePingTime = x.CachedAveragePingTime })
             .ToList();
     }
 }

        // constructors
        internal MongoConnectionPool(MongoServerInstance serverInstance)
        {
            _settings = serverInstance.Settings;
            _serverInstance = serverInstance;
            _poolSize = 0;

            _defaultAcquireConnectionOptions = new AcquireConnectionOptions
            {
                OkToAvoidWaitingByCreatingNewConnection = true,
                OkToExceedMaxConnectionPoolSize = false,
                OkToExceedWaitQueueSize = false,
                WaitQueueTimeout = _settings.WaitQueueTimeout
            };
        }

 // public methods
 /// <summary>
 /// Adds the specified instance.
 /// </summary>
 /// <param name="instance">The instance.</param>
 public void Add(MongoServerInstance instance)
 {
     lock (_lock)
     {
         var index = _instances.FindIndex(x => x.AveragePingTime >= instance.AveragePingTime);
         if (index == -1)
         {
             _instances.Add(instance);
         }
         else
         {
             _instances.Insert(index + 1, instance);
         }
         instance.AveragePingTimeChanged += InstanceAveragePingTimeChanged;
     }
 }

 /// <summary>
 /// Determines whether the instance is a valid.  If not, the instance is removed.
 /// </summary>
 /// <param name="instance">The instance.</param>
 /// <returns>
 ///   <c>true</c> if the instance is valid; otherwise, <c>false</c>.
 /// </returns>
 protected abstract bool IsValidInstance(MongoServerInstance instance);

 /// <summary>
 /// Determines whether the instance is a valid.  If not, the instance is removed.
 /// </summary>
 /// <param name="instance">The instance.</param>
 /// <returns>
 ///   <c>true</c> if the instance is valid; otherwise, <c>false</c>.
 /// </returns>
 protected override bool IsValidInstance(MongoServerInstance instance)
 {
     return instance.InstanceType == MongoServerInstanceType.ShardRouter;
 }

        /// <summary>
        /// Ensures that an instance with the address exists.
        /// </summary>
        /// <param name="address">The address.</param>
        protected void EnsureInstanceWithAddress(MongoServerAddress address)
        {
            if (address == null)
            {
                throw new ArgumentNullException("address");
            }

            lock (_lock)
            {
                if (!_instances.Any(x => x.Address == address))
                {
                    var instance = new MongoServerInstance(_server, address);
                    AddInstance(instance);
                    if (_state != MongoServerState.Disconnecting && _state != MongoServerState.Disconnected)
                    {
                        _state = MongoServerState.Connecting;
                        ConnectInstance(instance);
                    }
                }
            }
        }

 private void ProcessConnectedSecondaryStateChange(MongoServerInstance instance)
 {
     var address = instance.ReplicaSetInformation.Primary;
     if (address != null)
     {
         // make sure the primary exists in the instance list
         EnsureInstanceWithAddress(address);
     }
 }

        private void ProcessInstanceStateChange(MongoServerInstance instance)
        {
            lock (_lock)
            {
                if (instance.State == MongoServerState.Connected && _instances.Contains(instance))
                {
                    if (!IsValidInstance(instance))
                    {
                        RemoveInstance(instance);
                        // TODO: log this...
                        return;
                    }

                    if (instance.IsMasterResult.MyAddress != null && instance.Address != instance.IsMasterResult.MyAddress)
                    {
                        // NOTE: if this gets set inside the MongoServerInstance, then there is a race condition that could cause
                        // the instance to get added more than once to the list because the changes occur under different locks.
                        // I don't like this and would rather it be in the MongoServerInstance, but haven't figured out how to do
                        // it yet.
                        // One solution is for every instance change to check to see if two instances exist in the list and remove
                        // the other one, as the current one is more up-to-date.
                        instance.Address = instance.IsMasterResult.MyAddress;
                    }

                    if (!_connectedInstances.Contains(instance))
                    {
                        _connectedInstances.Add(instance);
                    }

                    ProcessConnectedInstanceStateChange(instance);
                }
                else
                {
                    _connectedInstances.Remove(instance);
                }

                SetState(DetermineServerState(_state, _instances));
            }
        }

 private void ConnectInstance(MongoServerInstance instance)
 {
     Interlocked.Increment(ref _outstandingInstanceConnections);
     ThreadPool.QueueUserWorkItem(_ =>
     {
         try
         {
             instance.Connect();
         }
         catch
         {
             // instance is keeping it's last ConnectionException
         }
         finally
         {
             Interlocked.Decrement(ref _outstandingInstanceConnections);
         }
     });
 }

 private void RemoveInstance(MongoServerInstance instance)
 {
     _connectedInstances.Remove(instance);
     lock (_lock)
     {
         _instances.Remove(instance);
         instance.StateChanged -= InstanceStateChanged;
         instance.DisconnectPermanently();
         ProcessInstanceStateChange(instance);
     }
 }