Как я сериализирую большой график объекта.NET в SQL Server BLOB, не создавая большой буфер?

Нет встроенного функциональности ADO.NET, чтобы действительно решить это изящно для больших данных. Проблема два раза:

• Нет API для «запись» в команду SQL или параметры в виде потока. Типы параметров, которые принимают поток (вроде FileStream ), принимают поток в считывание , который не согласен с семиантамизации семантики , напишите в поток Отказ Независимо от того, каким образом вы поверните это, вы в конечном итоге с копией памяти всего сериализованного объекта, плохого.
• Даже если точка выше будет решена (и она не может быть), протокол TDS и то, как SQL Server принимает параметры, не работают хорошо с большими параметрами, так как весь запрос должен быть впервые получен до того, как он будет запущен в выполнение И это создаст дополнительные копии объекта внутри SQL Server.

Так что вы действительно должны подходить к этому из другого угла. К счастью, есть довольно простое решение. Хитрость состоит в том, чтобы использовать высокоэффективное обновление .write Синтаксис и пропустите кусочки данных по одному, в серии операторов T-SQL. Это рекомендуется MSDN Way, см. Модифицирование данных большого значения (MAX) данных в Ado.net . Это выглядит сложно, но на самом деле тривиально делать и подключить в класс поток.

Класс Blobstream

Это хлеб и масло раствора. Класс производного потока, который реализует метод записи в качестве вызова на синтаксис T-SQL BLOB. Прямо вперед, единственное, что интересно в том, что он должен отслеживать первое обновление, потому что обновление ... Установить BLOB.WRITE (...) Синтаксис провалится в неверном поле:

class BlobStream: Stream
{
    private SqlCommand cmdAppendChunk;
    private SqlCommand cmdFirstChunk;
    private SqlConnection connection;
    private SqlTransaction transaction;

    private SqlParameter paramChunk;
    private SqlParameter paramLength;

    private long offset;

    public BlobStream(
        SqlConnection connection,
        SqlTransaction transaction,
        string schemaName,
        string tableName,
        string blobColumn,
        string keyColumn,
        object keyValue)
    {
        this.transaction = transaction;
        this.connection = connection;
        cmdFirstChunk = new SqlCommand(String.Format(@"
UPDATE [{0}].[{1}]
    SET [{2}] = @firstChunk
    WHERE [{3}] = @key"
            ,schemaName, tableName, blobColumn, keyColumn)
            , connection, transaction);
        cmdFirstChunk.Parameters.AddWithValue("@key", keyValue);
        cmdAppendChunk = new SqlCommand(String.Format(@"
UPDATE [{0}].[{1}]
    SET [{2}].WRITE(@chunk, NULL, NULL)
    WHERE [{3}] = @key"
            , schemaName, tableName, blobColumn, keyColumn)
            , connection, transaction);
        cmdAppendChunk.Parameters.AddWithValue("@key", keyValue);
        paramChunk = new SqlParameter("@chunk", SqlDbType.VarBinary, -1);
        cmdAppendChunk.Parameters.Add(paramChunk);
    }

    public override void Write(byte[] buffer, int index, int count)
    {
        byte[] bytesToWrite = buffer;
        if (index != 0 || count != buffer.Length)
        {
            bytesToWrite = new MemoryStream(buffer, index, count).ToArray();
        }
        if (offset == 0)
        {
            cmdFirstChunk.Parameters.AddWithValue("@firstChunk", bytesToWrite);
            cmdFirstChunk.ExecuteNonQuery();
            offset = count;
        }
        else
        {
            paramChunk.Value = bytesToWrite;
            cmdAppendChunk.ExecuteNonQuery();
            offset += count;
        }
    }

    // Rest of the abstract Stream implementation
 }

Использование Blobstream

Использовать этот вновь созданный класс класса BLOB-потока в буферном потрачении . Класс имеет тривиальный дизайн, который обрабатывает только писать поток в столбец таблицы. Я повторно повторно использую таблицу с другого примера:

CREATE TABLE [dbo].[Uploads](
    [Id] [int] IDENTITY(1,1) NOT NULL,
    [FileName] [varchar](256) NULL,
    [ContentType] [varchar](256) NULL,
    [FileData] [varbinary](max) NULL)

Я добавлю купочный объект, чтобы быть сериализованным:

[Serializable]
class HugeSerialized
{
    public byte[] theBigArray { get; set; }
}

Наконец, фактическая сериализация. Сначала мы введем новую запись в таблицу загрузки , затем создайте Blobstream на вновь вставленном идентификаторе и вызовете сериализацию прямо в этот поток:

using (SqlConnection conn = new SqlConnection(Settings.Default.connString))
{
    conn.Open();
    using (SqlTransaction trn = conn.BeginTransaction())
    {
        SqlCommand cmdInsert = new SqlCommand(
@"INSERT INTO dbo.Uploads (FileName, ContentType)
VALUES (@fileName, @contentType);
SET @id = SCOPE_IDENTITY();", conn, trn);
        cmdInsert.Parameters.AddWithValue("@fileName", "Demo");
        cmdInsert.Parameters.AddWithValue("@contentType", "application/octet-stream");
        SqlParameter paramId = new SqlParameter("@id", SqlDbType.Int);
        paramId.Direction = ParameterDirection.Output;
        cmdInsert.Parameters.Add(paramId);
        cmdInsert.ExecuteNonQuery();

        BlobStream blob = new BlobStream(
            conn, trn, "dbo", "Uploads", "FileData", "Id", paramId.Value);
        BufferedStream bufferedBlob = new BufferedStream(blob, 8040);

        HugeSerialized big = new HugeSerialized { theBigArray = new byte[1024 * 1024] };
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(bufferedBlob, big);

        trn.Commit();
    }
}

, если вы контролируете Выполнение этого простого образец вы увидите, что нигде не является большим потоком сериализации. Образец выделит массив [1024 * 1024], но это для демонстрационных целей, чтобы иметь что-то для сериализации. Этот код сериализуется в буферизованном порядке, кусок кусочком, используя BLOB SQL Server, рекомендуемый размер обновления 8040 байтов за раз.