/// <summary>
 /// Initializes a new instance of the MongoInsertOptions class.
 /// </summary>
 /// <param name="collection">The collection from which to get default settings for the options.</param>
 public MongoInsertOptions(
     MongoCollection collection
 ) {
     this.checkElementNames = true;
     this.flags = InsertFlags.None;
     this.safeMode = collection.Settings.SafeMode;
 }

 public MongoServerSettings(
     ConnectionMode connectionMode,
     TimeSpan connectTimeout,
     MongoCredentials defaultCredentials,
     TimeSpan maxConnectionIdleTime,
     TimeSpan maxConnectionLifeTime,
     int maxConnectionPoolSize,
     int minConnectionPoolSize,
     string replicaSetName,
     SafeMode safeMode,
     IEnumerable<MongoServerAddress> servers,
     bool slaveOk,
     TimeSpan socketTimeout,
     int waitQueueSize,
     TimeSpan waitQueueTimeout
 )
 {
     this.connectionMode = connectionMode;
     this.connectTimeout = connectTimeout;
     this.defaultCredentials = defaultCredentials;
     this.maxConnectionIdleTime = maxConnectionIdleTime;
     this.maxConnectionLifeTime = maxConnectionLifeTime;
     this.maxConnectionPoolSize = maxConnectionPoolSize;
     this.minConnectionPoolSize = minConnectionPoolSize;
     this.replicaSetName = replicaSetName;
     this.safeMode = safeMode;
     this.servers = servers;
     this.slaveOk = slaveOk;
     this.socketTimeout = socketTimeout;
     this.waitQueueSize = waitQueueSize;
     this.waitQueueTimeout = waitQueueTimeout;
 }

 public MongoDatabaseSettings()
 {
     this.databaseName = null;
     this.credentials = null;
     this.safeMode = SafeMode.False;
     this.slaveOk = false;
 }

        /// <summary>
        /// Creates a new instance of MongoDatabaseSettings.
        /// </summary>
        /// <param name="databaseName">The name of the database.</param>
        /// <param name="credentials">The credentials to access the database.</param>
        /// <param name="guidRepresentation">The representation for Guids.</param>
        /// <param name="readPreference">The read preference.</param>
        /// <param name="safeMode">The safe mode to use.</param>
        public MongoDatabaseSettings(
            string databaseName,
            MongoCredentials credentials,
            GuidRepresentation guidRepresentation,
            ReadPreference readPreference,
            SafeMode safeMode)
        {
            if (databaseName == null)
            {
                throw new ArgumentNullException("databaseName");
            }
            if (databaseName == "admin" && credentials != null && !credentials.Admin)
            {
                throw new ArgumentOutOfRangeException("Credentials for the admin database must have the admin flag set to true.");
            }
            if (readPreference == null)
            {
                throw new ArgumentNullException("readPreference");
            }
            if (safeMode == null)
            {
                throw new ArgumentNullException("safeMode");
            }

            _databaseName = databaseName;
            _credentials = credentials;
            _guidRepresentation = guidRepresentation;
            _readPreference = readPreference;
            _safeMode = safeMode;
        }

 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(string databaseName, MongoCredentials credentials, GuidRepresentation guidRepresentation, SafeMode safeMode, bool slaveOk)
 {
     _databaseName = databaseName;
     _credentials = credentials;
     _guidRepresentation = guidRepresentation;
     _safeMode = safeMode;
     _slaveOk = slaveOk;
 }

 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(string databaseName, MongoCredentials credentials, GuidRepresentation guidRepresentation, SafeMode safeMode, ReadPreference readPreference)
 {
     this.databaseName = databaseName;
     this.credentials = credentials;
     this.guidRepresentation = guidRepresentation;
     this.safeMode = safeMode;
     this.readPreference = readPreference;
 }

 public MongoCollectionSettings()
 {
     this.collectionName = null;
     this.assignIdOnInsert = true;
     this.defaultDocumentType = typeof(BsonDocument);
     this.safeMode = SafeMode.False;
     this.slaveOk = false;
 }

 // constructors
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="server">The server to inherit settings from.</param>
 /// <param name="databaseName">The name of the database.</param>
 public MongoDatabaseSettings(MongoServer server, string databaseName)
 {
     var serverSettings = server.Settings;
     _databaseName = databaseName;
     _credentials = serverSettings.DefaultCredentials;
     _guidRepresentation = serverSettings.GuidRepresentation;
     _safeMode = serverSettings.SafeMode;
     _slaveOk = serverSettings.SlaveOk;
 }

 // constructors
 /// <summary>
 /// Initializes a new instance of the MongoCollectionSettings class.
 /// </summary>
 /// <param name="database">The database that contains the collection (some collection settings will be inherited from the database settings).</param>
 /// <param name="collectionName">The name of the collection.</param>
 /// <param name="defaultDocumentType">The default document type for the collection.</param>
 protected MongoCollectionSettings(MongoDatabase database, string collectionName, Type defaultDocumentType)
 {
     var databaseSettings = database.Settings;
     _collectionName = collectionName;
     _assignIdOnInsert = MongoDefaults.AssignIdOnInsert;
     _defaultDocumentType = defaultDocumentType;
     _guidRepresentation = databaseSettings.GuidRepresentation;
     _safeMode = databaseSettings.SafeMode;
     _slaveOk = databaseSettings.SlaveOk;
 }

 public void TestCreateWithEnabledAndFSync()
 {
     var safeMode = new SafeMode(true, true);
     Assert.AreEqual(true, safeMode.Enabled);
     Assert.AreEqual(true, safeMode.FSync);
     Assert.AreEqual(false, safeMode.Journal);
     Assert.AreEqual(0, safeMode.W);
     Assert.AreEqual(null, safeMode.WMode);
     Assert.AreEqual(TimeSpan.Zero, safeMode.WTimeout);
 }

 public void TestCreateWithW()
 {
     var safeMode = new SafeMode(2);
     Assert.AreEqual(true, safeMode.Enabled);
     Assert.AreEqual(false, safeMode.FSync);
     Assert.AreEqual(false, safeMode.J);
     Assert.AreEqual(2, safeMode.W);
     Assert.AreEqual(null, safeMode.WMode);
     Assert.AreEqual(TimeSpan.Zero, safeMode.WTimeout);
 }

 public void TestCreateWithEnabledAndFSyncAndWAndWTimeout()
 {
     var safeMode = new SafeMode(true, true, 2, TimeSpan.FromSeconds(30));
     Assert.AreEqual(true, safeMode.Enabled);
     Assert.AreEqual(true, safeMode.FSync);
     Assert.AreEqual(false, safeMode.J);
     Assert.AreEqual(2, safeMode.W);
     Assert.AreEqual(null, safeMode.WMode);
     Assert.AreEqual(TimeSpan.FromSeconds(30), safeMode.WTimeout);
 }

 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings. Usually you would call MongoServer.CreateDatabaseSettings instead.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(
     string databaseName,
     MongoCredentials credentials,
     SafeMode safeMode,
     bool slaveOk
 ) {
     this.databaseName = databaseName;
     this.credentials = credentials;
     this.safeMode = safeMode;
     this.slaveOk = slaveOk;
 }

 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings. Usually you would call MongoServer.CreateDatabaseSettings instead.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(
     string databaseName,
     MongoCredentials credentials,
     GuidRepresentation guidRepresentation,
     SafeMode safeMode,
     bool slaveOk
 ) {
     this.databaseName = databaseName;
     this.credentials = credentials;
     this.guidRepresentation = guidRepresentation;
     this.safeMode = safeMode;
     this.slaveOk = slaveOk;
 }

 protected MongoCollectionSettings(
     string collectionName,
     bool assignIdOnInsert,
     Type defaultDocumentType,
     SafeMode safeMode,
     bool slaveOk
 ) {
     this.collectionName = collectionName;
     this.assignIdOnInsert = assignIdOnInsert;
     this.defaultDocumentType = defaultDocumentType;
     this.safeMode = safeMode;
     this.slaveOk = slaveOk;
 }

 public MongoUrl(
     string url
 )
 {
     var builder = new MongoUrlBuilder(url);
     this.url = builder.ToString(); // keep canonical form
     this.credentials = builder.Credentials;
     this.servers = builder.Servers;
     this.databaseName = builder.DatabaseName;
     this.connectionMode = builder.ConnectionMode;
     this.replicaSetName = builder.ReplicaSetName;
     this.safeMode = builder.SafeMode ?? SafeMode.False; // never null
     this.slaveOk = builder.SlaveOk;
 }

 /// <summary>
 /// Initializes a new instance of the MongoCollectionSettings class.
 /// </summary>
 /// <param name="collectionName">The name of the collection.</param>
 /// <param name="assignIdOnInsert">Whether to automatically assign a value to an empty document Id on insert.</param>
 /// <param name="defaultDocumentType">The default document type for the collection.</param>
 /// <param name="guidRepresentation">The GUID representation to use with this collection.</param>
 /// <param name="safeMode">The SafeMode to use with this collection.</param>
 /// <param name="slaveOk">Whether to route reads to secondaries for this collection.</param>
 protected MongoCollectionSettings(
     string collectionName,
     bool assignIdOnInsert,
     Type defaultDocumentType,
     GuidRepresentation guidRepresentation,
     SafeMode safeMode,
     bool slaveOk)
 {
     _collectionName = collectionName;
     _assignIdOnInsert = assignIdOnInsert;
     _defaultDocumentType = defaultDocumentType;
     _guidRepresentation = guidRepresentation;
     _safeMode = safeMode;
     _slaveOk = slaveOk;
 }

 /// <summary>
 /// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
 /// </summary>
 public MongoServerSettings() {
     connectionMode = ConnectionMode.Direct;
     connectTimeout = MongoDefaults.ConnectTimeout;
     defaultCredentials = null;
     ipv6 = false;
     maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
     maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
     maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
     minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
     replicaSetName = null;
     safeMode = MongoDefaults.SafeMode;
     servers = null;
     slaveOk = false;
     socketTimeout = MongoDefaults.SocketTimeout;
     waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
     waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
 }

 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(
     string databaseName,
     MongoCredentials credentials,
     GuidRepresentation guidRepresentation,
     SafeMode safeMode,
     bool slaveOk)
 {
     if (databaseName == "admin" && credentials != null && !credentials.Admin)
     {
         throw new ArgumentOutOfRangeException("Credentials for the admin database must have the admin flag set to true.");
     }
     _databaseName = databaseName;
     _credentials = credentials;
     _guidRepresentation = guidRepresentation;
     _safeMode = safeMode;
     _slaveOk = slaveOk;
 }

        public void SetData(string IdSession, string data, DateTime lastAccess)
        {
            MongoServer conn = GetConnection();
            MongoCollection sessionCollection = GetSessionCollection(conn);
            BsonDocument insertDoc = null;
            SafeMode _safeMode = new SafeMode(false);

            string sessItems = data;
            var ApplicationName = "IOL";
            Double timeout = this.GetTimeoutSet();
            object lockId = new object();

            try
            {
                if (!this.Exist(conn, IdSession, sessionCollection))
                {
                    insertDoc = new BsonDocument();
                    insertDoc.Add("_id", IdSession);
                    insertDoc.Add("ApplicationName", ApplicationName);
                    insertDoc.Add("Created", DateTime.Now.ToUniversalTime());
                    insertDoc.Add("Expires", DateTime.Now.AddMinutes((Double)timeout).ToUniversalTime());
                    insertDoc.Add("SessionItems", sessItems);

                    var query = Query.And(Query.EQ("_id", IdSession), Query.EQ("ApplicationName", ApplicationName), Query.LT("Expires", DateTime.Now.ToUniversalTime()));
                    sessionCollection.Remove(query, _safeMode);
                    sessionCollection.Insert(insertDoc, _safeMode);
                }
                else
                {
                    var query = Query.And(Query.EQ("_id", IdSession), Query.EQ("ApplicationName", ApplicationName));
                    var update = Update.Set("Expires", DateTime.Now.AddMinutes((Double)timeout).ToUniversalTime());
                    update.Set("SessionItems", sessItems);
                    sessionCollection.Update(query, update, _safeMode);
                }
            }
            catch (Exception e)
            {

            }
            finally
            {
                conn.Disconnect();
            }
        }