public static MongoServerSettings GetReplicaSetSettings(string roleName)
        {
            var settings = new MongoServerSettings();
            var replicaSetName = RoleEnvironment.GetConfigurationSettingValue(ReplicaSetNameSetting);
            settings.ReplicaSetName = replicaSetName;

            ReadOnlyCollection<RoleInstance> workerRoleInstances;
            try
            {
                workerRoleInstances = RoleEnvironment.Roles[roleName].Instances;
            }
            catch (KeyNotFoundException ke)
            {
                throw new Exception(
                    string.Format("The MongoDB role should be called {0}", roleName),
                    ke);
            }

            var servers = new List<MongoServerAddress>();
            foreach (var instance in workerRoleInstances)
            {
                var endpoint = AzureRoleHelper.GetEndPoint(instance, MongodPortKey);
                var server = new MongoServerAddress(endpoint.Address.ToString(), endpoint.Port);
                servers.Add(server);
            }

            settings.Servers = servers;
            settings.ConnectionMode = ConnectionMode.ReplicaSet;
            return settings;
        }

        public void TestDefaults()
        {
            var localhost = new MongoServerAddress("localhost");

            var settings = new MongoServerSettings();
            Assert.AreEqual(ConnectionMode.Direct, settings.ConnectionMode);
            Assert.AreEqual(MongoDefaults.ConnectTimeout, settings.ConnectTimeout);
            Assert.AreEqual(null, settings.DefaultCredentials);
            Assert.AreEqual(MongoDefaults.GuidRepresentation, settings.GuidRepresentation);
            Assert.AreEqual(false, settings.IPv6);
            Assert.AreEqual(MongoDefaults.MaxConnectionIdleTime, settings.MaxConnectionIdleTime);
            Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, settings.MaxConnectionLifeTime);
            Assert.AreEqual(MongoDefaults.MaxConnectionPoolSize, settings.MaxConnectionPoolSize);
            Assert.AreEqual(MongoDefaults.MinConnectionPoolSize, settings.MinConnectionPoolSize);
            Assert.AreEqual(ReadPreference.Primary, settings.ReadPreference);
            Assert.AreEqual(null, settings.ReplicaSetName);
            Assert.AreEqual(SafeMode.False, settings.SafeMode);
            Assert.AreEqual(1, settings.Servers.Count());
            Assert.AreEqual(localhost, settings.Server);
            Assert.AreEqual(localhost, settings.Servers.First());
            Assert.AreEqual(MongoDefaults.SocketTimeout, settings.SocketTimeout);
            Assert.AreEqual(false, settings.UseSsl);
            Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, settings.WaitQueueSize);
            Assert.AreEqual(MongoDefaults.WaitQueueTimeout, settings.WaitQueueTimeout);

            Assert.IsFalse(settings.IsFrozen);
            var hashCode = settings.GetHashCode();
            var stringRepresentation = settings.ToString();
            Assert.AreEqual(settings, settings);

            settings.Freeze();
            Assert.IsTrue(settings.IsFrozen);
            Assert.AreEqual(hashCode, settings.GetHashCode());
            Assert.AreEqual(stringRepresentation, settings.ToString());
        }

        public void TestEquals()
        {
            var a = new MongoServerAddress("host1");
            var b = new MongoServerAddress("host1");
            var c = new MongoServerAddress("host2");
            var n = (MongoServerAddress)null;

            Assert.True(object.Equals(a, b));
            Assert.False(object.Equals(a, c));
            Assert.False(a.Equals(n));
            Assert.False(a.Equals(null));

            Assert.True(a == b);
            Assert.False(a == c);
            Assert.False(a == null);
            Assert.False(null == a);
            Assert.True(n == null);
            Assert.True(null == n);

            Assert.False(a != b);
            Assert.True(a != c);
            Assert.True(a != null);
            Assert.True(null != a);
            Assert.False(n != null);
            Assert.False(null != n);
        }

        // constructors
        /// <summary>
        /// Initializes a new instance of the <see cref="MongoServerInstance"/> class.
        /// </summary>
        /// <param name="settings">The settings.</param>
        /// <param name="address">The address.</param>
        internal MongoServerInstance(MongoServerSettings settings, MongoServerAddress address)
        {
            _settings = settings;
            _address = address;
            _sequentialId = Interlocked.Increment(ref __nextSequentialId);
            _state = MongoServerState.Disconnected;
            _serverInfo = new ServerInformation
            {
                MaxDocumentSize = MongoDefaults.MaxDocumentSize,
                MaxMessageLength = MongoDefaults.MaxMessageLength,
                InstanceType = MongoServerInstanceType.Unknown
            };
            _connectionPool = new MongoConnectionPool(this);
            _pingTimeAggregator = new PingTimeAggregator(5);
            _permanentlyDisconnected = false;
            // Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);

            _stateVerificationAcquireConnectionOptions = new MongoConnectionPool.AcquireConnectionOptions
            {
                OkToAvoidWaitingByCreatingNewConnection = false,
                OkToExceedMaxConnectionPoolSize = true,
                OkToExceedWaitQueueSize = true,
                WaitQueueTimeout = TimeSpan.FromSeconds(2)
            };
        }

 // constructors
 /// <summary>
 /// Initializes a new instance of the <see cref="MongoServerInstance" /> class.
 /// </summary>
 /// <param name="settings">The settings.</param>
 /// <param name="address">The address.</param>
 /// <param name="cluster">The cluster.</param>
 /// <param name="endPoint">The end point.</param>
 internal MongoServerInstance(MongoServerSettings settings, MongoServerAddress address, ICluster cluster, EndPoint endPoint)
 {
     _settings = settings;
     _address = address;
     _cluster = cluster;
     _sequentialId = Interlocked.Increment(ref __nextSequentialId);
     _endPoint = endPoint;
 }

 // constructors
 /// <summary>
 /// Initializes a new instance of the <see cref="MongoServerInstance"/> class.
 /// </summary>
 /// <param name="settings">The settings.</param>
 /// <param name="address">The address.</param>
 /// <param name="cluster">The cluster.</param>
 internal MongoServerInstance(MongoServerSettings settings, MongoServerAddress address, ICluster cluster)
 {
     _settings = settings;
     _address = address;
     _cluster = cluster;
     _sequentialId = Interlocked.Increment(ref __nextSequentialId);
     _endPoint = new DnsEndPoint(address.Host, address.Port);
 }

		/// <summary>
		///     通过连接名称获得Host信息
		/// </summary>
		/// <param name="ConnectionName"></param>
		/// <returns></returns>
		public static MongoServerAddress GetMongoSvrAddrByConnectionName(String ConnectionName)
		{
			MongoServerAddress mongosrvAddr = null;
			if (SystemManager.config.ConnectionList.ContainsKey(ConnectionName)) {
				mongosrvAddr = new MongoServerAddress(SystemManager.config.ConnectionList[ConnectionName].Host,
					SystemManager.config.ConnectionList[ConnectionName].Port);
			}
			return mongosrvAddr;
		}

 public void PrimaryIsAtAddress(MongoServerAddress address)
 {
     Config.Out.WriteLine("Forcing primary to be at address {0}.", address);
     Util.Timeout(TimeSpan.FromMinutes(5),
         string.Format("Unable to make member at address {0} primary.", address),
         TimeSpan.FromSeconds(10),
         remaining => TryMakePrimaryAtAddress(address));
     Config.Out.WriteLine("Primary is at address {0}.", address);
 }

        private MongoServerState state; // always use property to set value so event gets raised
        #endregion

        #region constructors
        internal MongoServerInstance(
            MongoServer server,
            MongoServerAddress address
        ) {
            this.server = server;
            this.address = address;
            this.maxDocumentSize = MongoDefaults.MaxDocumentSize;
            this.maxMessageLength = MongoDefaults.MaxMessageLength;
            this.state = MongoServerState.Disconnected;
        }

        private MongoServerState _state; // always use property to set value so event gets raised

        // constructors
        internal MongoServerInstance(MongoServer server, MongoServerAddress address)
        {
            _server = server;
            _address = address;
            _sequentialId = Interlocked.Increment(ref __nextSequentialId);
            _maxDocumentSize = MongoDefaults.MaxDocumentSize;
            _maxMessageLength = MongoDefaults.MaxMessageLength;
            _state = MongoServerState.Disconnected;
            _connectionPool = new MongoConnectionPool(this);
            // Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
        }

 // constructors
 internal MongoServerInstance(MongoServer server, MongoServerAddress address)
 {
     this.server = server;
     this.address = address;
     this.sequentialId = Interlocked.Increment(ref nextSequentialId);
     this.maxDocumentSize = MongoDefaults.MaxDocumentSize;
     this.maxMessageLength = MongoDefaults.MaxMessageLength;
     this.state = MongoServerState.Disconnected;
     this.connectionPool = new MongoConnectionPool(this);
     this.tags = new HashSet<string>();
     // Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
 }

        private IMongoCollection<Task> GetCollection() {
            var mongoCredential = MongoCredential.CreateMongoCRCredential(databaseName, mongoToken.Key, mongoToken.Secret);
            var serverAddress = new MongoServerAddress(serverName, serverPort);

            var mongoClientSettings = new MongoClientSettings {
                Credentials = new[] { mongoCredential },
                Server = serverAddress
            };

            var client = new MongoClient(mongoClientSettings);
            var database = client.GetDatabase(databaseName);
            var collection = database.GetCollection<Task>(collectionName);
            return collection;
        }

        public MongoDatabase GetDB()
        {
            MongoServerAddress address = new MongoServerAddress("127.0.0.1", 27017);

            MongoServerSettings settings = new MongoServerSettings();

            settings.Server = address;

            MongoServer server = new MongoServer(settings);

            MongoDatabase myDB = server.GetDatabase("MyDB");

            return myDB;
        }

 // constructors
 /// <summary>
 /// Initializes a new instance of the <see cref="MongoServerInstance"/> class.
 /// </summary>
 /// <param name="server">The server.</param>
 /// <param name="address">The address.</param>
 internal MongoServerInstance(MongoServer server, MongoServerAddress address)
 {
     _server = server;
     _address = address;
     _sequentialId = Interlocked.Increment(ref __nextSequentialId);
     _state = MongoServerState.Disconnected;
     _stateInfo = new ServerInformation
     {
         MaxDocumentSize = MongoDefaults.MaxDocumentSize,
         MaxMessageLength = MongoDefaults.MaxMessageLength,
         InstanceType = MongoServerInstanceType.Unknown
     };
     _connectionPool = new MongoConnectionPool(this);
     _pingTimeAggregator = new PingTimeAggregator(5);
     // Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
 }

 public static MongoUrlBuilder GetReplicaSetConnectionUri()
 {
     var connection = new MongoUrlBuilder();
     // TODO - Should only have 1 setting across both roles
     var replicaSetName = RoleEnvironment.GetConfigurationSettingValue(ReplicaSetNameSetting);
     connection.ReplicaSetName = replicaSetName;
     int replicaSetRoleCount = RoleEnvironment.Roles[MongoDBHelper.MongoRoleName].Instances.Count;
     var servers = new List<MongoServerAddress>();
     foreach (var instance in RoleEnvironment.Roles[MongoDBHelper.MongoRoleName].Instances)
     {
         var endpoint = instance.InstanceEndpoints[MongoDBHelper.MongodPortKey].IPEndpoint;
         int instanceId = ParseNodeInstanceId(instance.Id);
         var server = new MongoServerAddress(
             endpoint.Address.ToString(),
             (RoleEnvironment.IsEmulated ? endpoint.Port + instanceId : endpoint.Port)
             );
         servers.Add(server);
     }
     connection.Servers = servers;
     return connection;
 }

        public ApiResponse SetConnection(ConnectionModel model)
        {
            var builder = new MongoUrlBuilder();
            var server = new MongoServerAddress(model.Server, model.Port ?? 27017);
            builder.Server = server;

            var url = builder.ToMongoUrl();

            try
            {
                var conn = MongoServer.Create(url);
                conn.Connect();
                conn.Disconnect();
            }
            catch
            {
                return new ApiResponse(false, string.Format("Connection to {0} failed.", url));
            }

            HttpContext.Current.Response.Cookies.Add(new HttpCookie("Mongo.Manager.Connection", url.ToString()));
            return new ApiResponse();
        }

 static void Main(string[] args)
 {
     var mongoServerAddress = new MongoServerAddress("127.0.0.1", 27017);
     var mongoServerSettings = new MongoServerSettings();
     mongoServerSettings.Server = mongoServerAddress;
     var mongoServer = new MongoServer(mongoServerSettings);
     mongoServer.Connect();
     IEnumerable<string> databases = mongoServer.GetDatabaseNames();
     var mongoDatabase = mongoServer.GetDatabase("classfrogdb");
     var classCollection = mongoDatabase.GetCollection("classes");
     classCollection.RemoveAll();
     var documents = classCollection.FindAll();
     ClassInstance instance = new ClassInstance();
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     classCollection.Insert(instance.NewDocument());
     mongoServer.Disconnect();
 }

 /// <summary>
 /// 通过连接名称获得Host信息
 /// </summary>
 /// <param name="ConnectionName"></param>
 /// <returns></returns>
 public MongoServerAddress GetMongoSvrAddrByConnectionName(String ConnectionName)
 {
     MongoServerAddress mongosrvAddr = null;
     if (ConnectionList.ContainsKey(ConnectionName))
     {
         mongosrvAddr = new MongoServerAddress(ConnectionList[ConnectionName].IpAddr, ConnectionList[ConnectionName].Port);
     }
     return mongosrvAddr;
 }

 public void TestConstructor_with_host_and_port(string host, int port)
 {
     var address = new MongoServerAddress(host, port);
     Assert.Equal(host, address.Host);
     Assert.Equal(port, address.Port);
 }

 public void TestConstructor_with_host(string host)
 {
     var address = new MongoServerAddress(host);
     Assert.Equal(host, address.Host);
     Assert.Equal(27017, address.Port);
 }