使用 SqlDataReader 时，如何使 BLOB 流在普通旧 C# 对象中可用？

Question

场景如下：

• 我们将文件（例如相对较大的文档 (10-300MB)）存储在 MSSQL 数据库中的 blob 中。
• 我们有一个非常小的域模型，因此我们对存储库使用干净的 SqlDataReader 方法，而不是 ORM，以避免不必要的依赖关系。
• 我们想要在 ASP.NET/ASP.NET MVC 网页上的服务器上下文中使用对象。
• 我们不想将 blob 临时存储在 byte[] 中，以避免服务器上的内存使用率过高

，所以我一直在做的是实现我自己的 SqlBlobReader。它继承了 Stream 和 IDisposable，在实例化期间，我们必须提供一个 SqlCommand，其中包含一个返回一行一列的查询，当然，这就是我们想要流式传输的 blob。然后，我的 C# 域对象可以具有 Stream 类型的属性，该属性返回 SqlBlobReader 实现。然后，当流式传输到 ASP.net MVC 等中的 FileContentStream 时，可以使用此流。

它将立即使用 SequentialAccess 执行 ExecuteReader，以启用来自 MSSQL 服务器的 Blob 流式传输。这意味着我们在使用流时必须小心地尽快处理它，并且我们总是在需要时延迟实例化 SqlBlobReader，例如在域对象内使用存储库调用。

我的问题是：

• 当使用 SqlDataReader 而不是 ORM 时，这是在普通旧域对象上实现 blob 流的明智方法吗？
• 我不是 ADO.NET 专家，该实现看起来合理吗？

SqlBlobReader.cs：

using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;

namespace Foo
{
   /// <summary>
   /// There must be a SqlConnection that works inside the SqlCommand. Remember to dispose of the object after usage.
   /// </summary>
   public class SqlBlobReader : Stream
   {
      private readonly SqlCommand command;
      private readonly SqlDataReader dataReader;
      private bool disposed = false;
      private long currentPosition = 0;

      /// <summary>
      /// Constructor
      /// </summary>
      /// <param name="command">The supplied <para>sqlCommand</para> must only have one field in select statement, or else the stream won't work. Select just one row, all others will be ignored.</param>
      public SqlBlobReader(SqlCommand command)
      {
         if (command == null)
            throw new ArgumentNullException("command");
         if (command.Connection == null)
            throw new ArgumentException("The internal Connection cannot be null", "command");
         if (command.Connection.State != ConnectionState.Open)
            throw new ArgumentException("The internal Connection must be opened", "command");
         dataReader = command.ExecuteReader(CommandBehavior.SequentialAccess);
         dataReader.Read();
         this.command = command; // only stored for disposal later
      }

      /// <summary>
      /// Not supported
      /// </summary>
      public override long Seek(long offset, SeekOrigin origin)
      {
         throw new NotSupportedException();
      }

      /// <summary>
      /// Not supported
      /// </summary>
      public override void SetLength(long value)
      {
         throw new NotSupportedException();
      }

      public override int Read(byte[] buffer, int index, int count)
      {
         long returned = dataReader.GetBytes(0, currentPosition, buffer, 0, buffer.Length);
         currentPosition += returned;
         return Convert.ToInt32(returned);
      }

      /// <summary>
      /// Not supported
      /// </summary>
      public override void Write(byte[] buffer, int offset, int count)
      {
         throw new NotSupportedException();
      }

      public override bool CanRead
      {
         get { return true; }
      }

      public override bool CanSeek
      {
         get { return false; }
      }

      public override bool CanWrite
      {
         get { return false; }
      }

      public override long Length
      {
         get { throw new NotSupportedException(); }
      }

      public override long Position
      {
         get { throw new NotSupportedException(); }
         set { throw new NotSupportedException(); }
      }

      protected override void Dispose(bool disposing)
      {
         if (!disposed)
         {
            if (disposing)
            {
               if (dataReader != null)
                  dataReader.Dispose();
               SqlConnection conn = null;
               if (command != null)
               {
                  conn = command.Connection;
                  command.Dispose();
               }
               if (conn != null)
                  conn.Dispose();
               disposed = true;
            }
         }
         base.Dispose(disposing);
      }

      public override void Flush()
      {
         throw new NotSupportedException();
      }

   }

}

在 Repository.cs 中：

  public virtual Stream GetDocumentFileStream(int fileId)
  {
     var conn = new SqlConnection {ConnectionString = configuration.ConnectionString};
     var cmd = new SqlCommand
                  {
                     CommandText =
                        "select DocumentFile " +
                        "from MyTable " +
                        "where Id = @Id",
                     Connection = conn,
                  };


     cmd.Parameters.Add("@Id", SqlDbType.Int).Value = fileId;
     conn.Open();
     return new SqlBlobReader(cmd);
  }

在 DocumentFile.cs 中：

  public Stream GetStream()
  {
     return repository.GetDocumentFileStream(Id);
  }

在 DocumentController.cs 中：

  // A download controller in ASP.net MVC 2

  [OutputCache(CacheProfile = "BigFile")]
  public ActionResult Download(int id)
  {
     var document = repository.GetDocument(id);
     return new FileStreamResult(document.DocumentFile.GetStream(), "application/pdf")
               {
                  FileDownloadName = "Foo.pdf";
               };
  }

Answer 1

有一个错误；您忽略了用户的参数，并且您可能应该保护 -ve returned:

  public override int Read(byte[] buffer, int index, int count)
  {
     long returned = dataReader.GetBytes(0, currentPosition,
         buffer, 0, buffer.Length);
     currentPosition += returned;
     return Convert.ToInt32(returned);
  }

可能应该是：（

  public override int Read(byte[] buffer, int index, int count)
  {
     long returned = dataReader.GetBytes(0, currentPosition,
         buffer, index, count);
     if(returned > 0) currentPosition += returned;
     return (int)returned;
  }

否则您将写入缓冲区的错误部分）

但通常看起来不错。

Answer 2

请注意，.net 4.5 现在执行此 OOB - SqlDataReader.GetStream()

http://msdn.microsoft.com/en-us/library/system.data.sqlclient.sqldatareader.getstream(v=vs.110).aspx

Answer 3

太漂亮了！感谢这个内存保护程序。除了 Marc 的修复之外，我还修改了构造函数以打开连接并进行处置，以防打开或执行失败以减少调用者中的代码/异常处理。 （不知道可以从构造函数调用 Dispose）。构造函数模式：

try
{
    this.command = command;     // store for disposal

    if (command.Connection.State != ConnectionState.Open)
        command.Connection.Open();

    dataReader = command.ExecuteReader(CommandBehavior.SequentialAccess);
    dataReader.Read();            
}
catch (Exception ex)
{
    Dispose();
    throw;
}