public void TestCreateWithRemoteFileNameAndCreateOptions()
 {
     var aliases = new string[] { "a", "b" };
     var uploadDate = new DateTime(2011, 11, 10, 19, 57, 0, DateTimeKind.Utc);
     var metadata = new BsonDocument("x", 1);
     var createOptions = new MongoGridFSCreateOptions()
     {
         Aliases = aliases,
         ChunkSize = 123,
         ContentType = "content",
         Id = 1,
         Metadata = metadata,
         UploadDate = uploadDate
     };
     var info = new MongoGridFSFileInfo(_gridFS, "filename", createOptions);
     Assert.IsTrue(aliases.SequenceEqual(info.Aliases));
     Assert.AreEqual(123, info.ChunkSize);
     Assert.AreEqual("content", info.ContentType);
     Assert.AreEqual(_gridFS, info.GridFS);
     Assert.AreEqual(1, info.Id.AsInt32);
     Assert.AreEqual(0, info.Length);
     Assert.AreEqual(null, info.MD5);
     Assert.AreEqual(metadata, info.Metadata);
     Assert.AreEqual("filename", info.Name);
     Assert.AreEqual(uploadDate, info.UploadDate);
 }

        public void TestEquals()
        {
            var createOptions = new MongoGridFSCreateOptions { ChunkSize = 123 };
            var a1 = new MongoGridFSFileInfo(_gridFS, "f", createOptions);
            var a2 = new MongoGridFSFileInfo(_gridFS, "f", createOptions);
            var a3 = a2;
            var b = new MongoGridFSFileInfo(_gridFS, "g", createOptions);
            var null1 = (MongoGridFSFileInfo)null;
            var null2 = (MongoGridFSFileInfo)null;

            Assert.AreNotSame(a1, a2);
            Assert.AreSame(a2, a3);
            Assert.IsTrue(a1.Equals((object)a2));
            Assert.IsFalse(a1.Equals((object)null));
            Assert.IsFalse(a1.Equals((object)"x"));

            Assert.IsTrue(a1 == a2);
            Assert.IsTrue(a2 == a3);
            Assert.IsFalse(a1 == b);
            Assert.IsFalse(a1 == null1);
            Assert.IsFalse(null1 == a1);
            Assert.IsTrue(null1 == null2);

            Assert.IsFalse(a1 != a2);
            Assert.IsFalse(a2 != a3);
            Assert.IsTrue(a1 != b);
            Assert.IsTrue(a1 != null1);
            Assert.IsTrue(null1 != a1);
            Assert.IsFalse(null1 != null2);

            Assert.AreEqual(a1.GetHashCode(), a2.GetHashCode());
        }

        public void TestEquals()
        {
            var createOptions = new MongoGridFSCreateOptions { ChunkSize = 123 };
            var a = new MongoGridFSFileInfo(gridFS, "f", createOptions);
            var b = new MongoGridFSFileInfo(gridFS, "f", createOptions);
            var c = new MongoGridFSFileInfo(gridFS, "g", createOptions);
            var n = (MongoCredentials) null;

            Assert.IsTrue(object.Equals(a, b));
            Assert.IsFalse(object.Equals(a, c));
            Assert.IsFalse(a.Equals(n));
            Assert.IsFalse(a.Equals(null));

            Assert.IsTrue(a == b);
            Assert.IsFalse(a == c);
            Assert.IsFalse(a == null);
            Assert.IsFalse(null == a);
            Assert.IsTrue(n == null);
            Assert.IsTrue(null == n);

            Assert.IsFalse(a != b);
            Assert.IsTrue(a != c);
            Assert.IsTrue(a != null);
            Assert.IsTrue(null != a);
            Assert.IsFalse(n != null);
            Assert.IsFalse(null != n);
        }

 public MongoGridFSStream(
     MongoGridFSFileInfo fileInfo,
     FileMode mode
 )
     : this(fileInfo, mode, FileAccess.ReadWrite)
 {
 }

        public void TestEquals()
        {
            var settings = new MongoGridFSSettings();
            var createOptions = new MongoGridFSCreateOptions { ChunkSize = 123 };
            var a1 = new MongoGridFSFileInfo(_server, _server.Primary, _database.Name, settings, "f", createOptions);
            var a2 = new MongoGridFSFileInfo(_server, _server.Primary, _database.Name, settings, "f", createOptions);
            var a3 = a2;
            var b = new MongoGridFSFileInfo(_server, _server.Primary, _database.Name, settings, "g", createOptions);
            var null1 = (MongoGridFSFileInfo)null;
            var null2 = (MongoGridFSFileInfo)null;

            Assert.NotSame(a1, a2);
            Assert.Same(a2, a3);
            Assert.True(a1.Equals((object)a2));
            Assert.False(a1.Equals((object)null));
            Assert.False(a1.Equals((object)"x"));

            Assert.True(a1 == a2);
            Assert.True(a2 == a3);
            Assert.False(a1 == b);
            Assert.False(a1 == null1);
            Assert.False(null1 == a1);
            Assert.True(null1 == null2);

            Assert.False(a1 != a2);
            Assert.False(a2 != a3);
            Assert.True(a1 != b);
            Assert.True(a1 != null1);
            Assert.True(null1 != a1);
            Assert.False(null1 != null2);

            Assert.Equal(a1.GetHashCode(), a2.GetHashCode());
        }

        internal MongoStorageFile(MongoGridFSFileInfo fileInfo )
        {
            if (fileInfo == null)
                throw new ArgumentNullException("fileInfo");

            this.fileInfo = fileInfo;
        }

        public GridFsBlobDescriptor(BlobId blobId, MongoGridFSFileInfo mongoGridFsFileInfo)
        {
            if (mongoGridFsFileInfo == null) throw new ArgumentNullException("mongoGridFsFileInfo");
            _mongoGridFsFileInfo = mongoGridFsFileInfo;
            BlobId = blobId;

            FileNameWithExtension = new FileNameWithExtension(_mongoGridFsFileInfo.Name);
        }

        public static FileModel FileModelFromGridFSMetadata(MongoGridFSFileInfo gfs_entry)
        {
            var file_model = new FileModel();

            file_model.Filename = gfs_entry.Metadata["Filename"].AsString;
            file_model.PatientID = gfs_entry.Metadata["PatientID"].AsString;
            file_model.ID = gfs_entry.Id.AsObjectId;

            return file_model;
        }

 /// <summary>
 /// Sets the metadata for an existing GridFS file.
 /// </summary>
 /// <param name="fileInfo">The GridFS file.</param>
 /// <param name="metadata">The metadata.</param>
 public void SetMetadata(MongoGridFSFileInfo fileInfo, BsonValue metadata)
 {
     var database = GetDatabase(ReadPreference.Primary);
     var filesCollection = GetFilesCollection(database);
     var query = Query.EQ("_id", fileInfo.Id);
     var update = (metadata == null) ? Update.Unset("metadata") : Update.Set("metadata", metadata);
     filesCollection.Update(query, update, _settings.WriteConcern);
 }

 /// <summary>
 /// Creates or opens a GridFS file for writing UTF-8 encoded text.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <param name="createOptions">The create options.</param>
 /// <returns>A stream writer.</returns>
 public StreamWriter CreateText(string remoteFileName, MongoGridFSCreateOptions createOptions)
 {
     if (_settings.ReadPreference != ReadPreference.Primary)
     {
         var gridFS = GetPrimaryGridFSSettings();
         return gridFS.CreateText(remoteFileName, createOptions);
     }
     using (_server.RequestStart(null, ReadPreference.Primary))
     {
         var serverInstance = _server.RequestConnection.ServerInstance;
         var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName, createOptions);
         return fileInfo.CreateText();
     }
 }

 /// <summary>
 /// Sets the content type for an existing GridFS file.
 /// </summary>
 /// <param name="fileInfo">The GridFS file.</param>
 /// <param name="contentType">The content type.</param>
 public void SetContentType(MongoGridFSFileInfo fileInfo, string contentType)
 {
     var database = GetDatabase(ReadPreference.Primary);
     var filesCollection = GetFilesCollection(database);
     var query = Query.EQ("_id", fileInfo.Id);
     var update = (contentType == null) ? Update.Unset("contentType") : Update.Set("contentType", contentType);
     filesCollection.Update(query, update, _settings.WriteConcern);
 }

 /// <summary>
 /// Opens an existing GridFS file for writing.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <param name="createOptions">The create options.</param>
 /// <returns>A stream.</returns>
 public MongoGridFSStream OpenWrite(
     string remoteFileName,
     MongoGridFSCreateOptions createOptions
 ) {
     var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
     return fileInfo.OpenWrite();
 }

 /// <summary>
 /// Sets the content type for an existing GridFS file.
 /// </summary>
 /// <param name="fileInfo">The GridFS file.</param>
 /// <param name="contentType">The content type.</param>
 public void SetContentType(
     MongoGridFSFileInfo fileInfo,
     string contentType
 ) {
     var query = Query.EQ("_id", fileInfo.Id);
     var update = (contentType == null) ? Update.Unset("contentType") : Update.Set("contentType", contentType);
     files.Update(query, update);
 }

 /// <summary>
 /// Opens an existing UTF-8 encoded text GridFS file for reading.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <returns>A stream reader.</returns>
 public StreamReader OpenText(
     string remoteFileName
 ) {
     var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
     return fileInfo.OpenText();
 }

 /// <summary>
 /// Opens a GridFS file with the specified mode.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <param name="mode">The mode.</param>
 /// <returns>A stream.</returns>
 public MongoGridFSStream Open(
     string remoteFileName,
     FileMode mode
 ) {
     var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
     return fileInfo.Open(mode);
 }

        /// <summary>
        /// Downloads a GridFS file.
        /// </summary>
        /// <param name="stream">The destination stream.</param>
        /// <param name="fileInfo">The GridFS file.</param>
        public void Download(
            Stream stream,
            MongoGridFSFileInfo fileInfo
        ) {
            using (database.RequestStart(database.Settings.SlaveOk)) {
                EnsureIndexes();

                string md5Client;
                using (var md5Algorithm = MD5.Create()) {
                    var numberOfChunks = (fileInfo.Length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize;
                    for (int n = 0; n < numberOfChunks; n++) {
                        var query = Query.And(
                            Query.EQ("files_id", fileInfo.Id),
                            Query.EQ("n", n)
                        );
                        var chunk = chunks.FindOne(query);
                        if (chunk == null) {
                            string errorMessage = string.Format("Chunk {0} missing for GridFS file '{1}'.", n, fileInfo.Name);
                            throw new MongoGridFSException(errorMessage);
                        }
                        var data = chunk["data"].AsBsonBinaryData;
                        if (data.Bytes.Length != fileInfo.ChunkSize) {
                            // the last chunk only has as many bytes as needed to complete the file
                            if (n < numberOfChunks - 1 || data.Bytes.Length != fileInfo.Length % fileInfo.ChunkSize) {
                                string errorMessage = string.Format("Chunk {0} for GridFS file '{1}' is the wrong size.", n, fileInfo.Name);
                                throw new MongoGridFSException(errorMessage);
                            }
                        }
                        stream.Write(data.Bytes, 0, data.Bytes.Length);
                        md5Algorithm.TransformBlock(data.Bytes, 0, data.Bytes.Length, null, 0);
                    }

                    md5Algorithm.TransformFinalBlock(new byte[0], 0, 0);
                    md5Client = BsonUtils.ToHexString(md5Algorithm.Hash);
                }

                if (!md5Client.Equals(fileInfo.MD5, StringComparison.OrdinalIgnoreCase)) {
                    throw new MongoGridFSException("Download client and server MD5 hashes are not equal.");
                }
            }
        }

 /// <summary>
 /// Appends UTF-8 encoded text to an existing GridFS file.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <returns>A StreamWriter.</returns>
 public StreamWriter AppendText(
     string remoteFileName
 ) {
     var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
     return fileInfo.AppendText();
 }

 /// <summary>
 /// Opens an existing GridFS file for writing.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <returns>A stream.</returns>
 public MongoGridFSStream OpenWrite(string remoteFileName)
 {
     if (_settings.ReadPreference != ReadPreference.Primary)
     {
         var gridFS = GetPrimaryGridFSSettings();
         return gridFS.OpenWrite(remoteFileName);
     }
     using (_server.RequestStart(null, ReadPreference.Primary))
     {
         var serverInstance = _server.RequestConnection.ServerInstance;
         var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
         return fileInfo.OpenWrite();
     }
 }

 /// <summary>
 /// Creates or opens a GridFS file for writing UTF-8 encoded text.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <param name="createOptions">The create options.</param>
 /// <returns>A stream writer.</returns>
 public StreamWriter CreateText(
     string remoteFileName,
     MongoGridFSCreateOptions createOptions
 ) {
     var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
     return fileInfo.CreateText();
 }

 /// <summary>
 /// Creates or opens a GridFS file for writing UTF-8 encoded text.
 /// </summary>
 /// <param name="remoteFileName">The remote file name.</param>
 /// <returns>A stream writer.</returns>
 public StreamWriter CreateText(string remoteFileName)
 {
     using (_server.RequestStart(null, ReadPreference.Primary))
     {
         var serverInstance = _server.RequestConnection.ServerInstance;
         var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
         return fileInfo.CreateText();
     }
 }