OracleLob.Read(Byte[], Int32, Int32) Método

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

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

override this.Read : byte[] * int * int -> int

Public Overrides Function Read (buffer As Byte(), offset As Integer, count As Integer) As Integer

Parâmetros

Devoluções

O número total de bytes lidos no buffer. Isto pode ser inferior ao número de bytes solicitados se esse número de bytes não estiverem atualmente disponíveis, ou zero (0) se o fim do fluxo for atingido.

Exceções

Observações

O Read método lê um máximo de count bytes do fluxo atual e armazena-os buffer a partir de .offset A posição atual dentro do fluxo é avançada pelo número de bytes lidos; no entanto, se ocorrer uma exceção, a posição atual dentro do fluxo mantém-se inalterada. Read devolve o número de bytes lidos. O valor de retorno é zero apenas se a posição estiver atualmente no final do fluxo. Read bloqueará até que pelo menos um byte de dados possa ser lido, caso não haja dados disponíveis.Read devolve 0 se tentar ler de a LOB quando a posição atual está no final de LOB. Read pode devolver menos bytes do que o solicitado, mesmo que o fim do fluxo não tenha sido atingido.

O Data Provider do .NET Framework para Oracle trata todos os dados CLOB e NCLOB como Unicode. Portanto, ao aceder CLOB a tipos de dados, NCLOB está sempre a lidar com o número de bytes, onde cada carácter tem 2 bytes. Por exemplo, se uma cadeia de texto contendo três caracteres for guardada num NCLOB servidor Oracle onde o conjunto de caracteres é de 4 bytes por carácter, e realizar uma Read operação, especifica o comprimento da cadeia como 6 bytes, embora esteja armazenada como 12 bytes no servidor.

O exemplo seguinte demonstra como ler OracleLob objetos.

public static void ReadLobExample(OracleCommand command)
{
    int actual = 0;

    // Select some data.
    // Table Schema:
    //  "CREATE TABLE TableWithLobs (a int, b BLOB, c CLOB, d NCLOB)";
    //  "INSERT INTO TableWithLobs values (1, 'AA', 'AAA', N'AAAA')";
    command.CommandText = "SELECT * FROM TableWithLobs";
    OracleDataReader reader = command.ExecuteReader();
    using(reader)
    {
        // Obtain the first row of data.
        reader.Read();
        // Obtain the LOBs (all 3 varieties).
        OracleLob BLOB = reader.GetOracleLob(1);
        OracleLob CLOB  = reader.GetOracleLob(2);
        OracleLob NCLOB = reader.GetOracleLob(3);

        // Example - Reading binary data (in chunks).
        var buffer = new byte[100];
        while((actual = BLOB.Read(buffer, 0, buffer.Length)) > 0)
            Console.WriteLine(BLOB.LobType + ".Read(" + buffer + ", " + buffer.Length + ") => " + actual);

        // Example - Reading CLOB/NCLOB data (in chunks).
        // Note: You can read character data as raw Unicode bytes (using OracleLob.Read as in the above example).
        // However, because the OracleLob object inherits directly from the.NET stream object,
        // all the existing classes that manipulate streams can also be used. For example, the
        // .NET StreamReader makes converting the raw bytes into actual characters easier.
        var streamreader = new StreamReader(CLOB, Encoding.Unicode);
        var cbuffer = new char[100];
        while((actual = streamreader.Read(cbuffer, 0, cbuffer.Length)) >0)
            Console.WriteLine(CLOB.LobType + ".Read(" + new string(cbuffer, 0, actual) + ", " + cbuffer.Length + ") => " + actual);

        //Example - Reading data (all at once).
        //You could use StreamReader.ReadToEnd to obtain all the string data,or simply
        //call OracleLob.Value to obtain a contiguous allocation of all the data.
        Console.WriteLine(NCLOB.LobType + ".Value => " + NCLOB.Value);
    }
}

Pode construir um OracleLob que é NULL usando este formato:

OracleLob myLob = OracleLob.Null;

Esta técnica é usada principalmente para testar se um LOB retorno do servidor é NULL, como ilustra o exemplo seguinte.

if (myLob == OracleLob.Null)

Um NULL LOB comporta-se de forma semelhante a um zero byte LOB em que Read tem sucesso e retorna sempre zero bytes.