OracleLob.Write(Byte[], Int32, Int32) Metodo

Definizione

Spazio dei nomi:

System.Data.OracleClient

Assembly:

System.Data.OracleClient.dll

Consente di scrivere una sequenza di byte nel flusso OracleLob corrente e di fare avanzare la posizione corrente all'interno di questo flusso del numero di byte scritti.

public:
 override void Write(cli::array <System::Byte> ^ buffer, int offset, int count);

public override void Write (byte[] buffer, int offset, int count);

override this.Write : byte[] * int * int -> unit

Public Overrides Sub Write (buffer As Byte(), offset As Integer, count As Integer)

Parametri

buffer

Byte[]

Matrice di byte. Questo metodo consente di copiare il numero di byte specificato nel parametro count dal parametro buffer nel flusso corrente.

offset

Int32

Offset dei byte in base zero in buffer da cui iniziare la copia dei byte nel flusso corrente. Per i tipi di dati CLOB e NCLOB, deve trattarsi di un numero pari.

count

Int32

Numero di byte da scrivere nel flusso corrente. Per i tipi di dati CLOB e NCLOB, deve trattarsi di un numero pari.

Eccezioni

ArgumentNullException

Il parametro buffer è un riferimento Null (Nothing in Visual Basic).

ArgumentOutOfRangeException

Un valore nel parametro offset o count non è positivo.

-oppure-

La somma dei parametri offset e count è maggiore della lunghezza del parametrobuffer.

-oppure-

Un valore specificato nel parametro count o offset è minore di zero o maggiore di 4 GB.

-oppure-

È necessario specificare i tipi di dati CLOB e NCLOB come un numero pari di byte.

InvalidOperationException

L'operazione non è presente all'interno di una transazione, l'oggetto OracleLob è null oppure la connessione è chiusa.

ObjectDisposedException

L'oggetto è stato chiuso o eliminato.

OracleException

Si è verificato un errore Oracle.

Commenti

Se l'operazione di scrittura ha esito positivo, la posizione all'interno del flusso avanza in base al numero di byte scritti. Se si verifica un'eccezione, la posizione all'interno del flusso rimane invariata.

La scrittura oltre la fine di LOB è consentita e aumenta il LOB numero di byte scritti.

Il provider di dati .NET Framework per Oracle gestisce tutti i CLOB dati e NCLOB come Unicode. Pertanto, quando si accede CLOB ai tipi di dati e NCLOB si tratta sempre del numero di byte, in cui ogni carattere è 2 byte. Ad esempio, se una stringa di testo contenente tre caratteri viene salvata come un NCLOB server Oracle in cui il set di caratteri è di 4 byte per carattere e si esegue un'operazione Write , si specifica la lunghezza della stringa come 6 byte, anche se viene archiviata come 12 byte nel server.

Per scrivere in LOB, è necessario aver recuperato la LOB clausola FOR UPDATE nell'istruzione SQL SELECT e è necessario avviare una transazione locale.

Nell'esempio seguente viene illustrato come scrivere in OracleLob oggetti:

public static void WriteLobExample(OracleCommand command)  
{  
    // Note: Updating LOB data requires a transaction.  
    command.Transaction = command.Connection.BeginTransaction();  
    // Select some data.  
    //    Table Schema:  
    //        "CREATE TABLE tablewithlobs (a int, b BLOB, c BLOB)";  
    //        "INSERT INTO tablewithlobs values (1, 'AA', 'AAA')";  
    command.CommandText = "SELECT * FROM TableWithLobs FOR UPDATE";  
    OracleDataReader reader = command.ExecuteReader();  
    using(reader)  
    {  
        // Obtain the first row of data.  
        reader.Read();  
        // Obtain both LOBs.  
        OracleLob BLOB1 = reader.GetOracleLob(1);  
        OracleLob BLOB2 = reader.GetOracleLob(2);  
        // Perform any desired operations on the LOB, (read, position, and so on).  
        // ...  
        // Example - Writing binary data (directly to the backend).  
        // To write, you can use any of the stream classes, or write raw binary data using   
        // the OracleLob write method. Writing character vs. binary is the same;  
        // however note that character is always in terms of Unicode byte counts  
        // (for example: even number of bytes - 2 bytes for every Unicode character).  
        var buffer = new byte[100];  
        buffer[0] = 0xCC;  
        buffer[1] = 0xDD;  
        BLOB1.Write(buffer, 0, 2);  
        BLOB1.Position = 0;  
        Console.WriteLine(BLOB1.LobType + ".Write(" + buffer + ", 0, 2) => " + BLOB1.Value);  

        // Example - Copying data into another LOB.  
        long actual = BLOB1.CopyTo(BLOB2);  
        Console.WriteLine(BLOB1.LobType + ".CopyTo(" + BLOB2.Value + ") => " + actual);  

        // Commit the transaction now that everything succeeded.  
        // Note: On error, Transaction.Dispose is called (from the using statement)  
        // and will automatically roll-back the pending transaction.  
        command.Transaction.Commit();  
    }  
}  

Nota

Un'operazione di scrittura in una sola lettura LOB potrebbe avere esito positivo, ma non aggiorna l'oggetto LOB nel server. In questo caso, tuttavia, la copia locale dell'oggetto LOB viene aggiornata. Pertanto, le operazioni di lettura successive sull'oggetto OracleLob potrebbero restituire i risultati dell'operazione di scrittura.