C# DbDataReader.GetBytes方法代码示例

 /// <summary>
 /// The default constructor.
 /// </summary>
 /// <param name="reader">The reader to use to read from the database.</param>
 /// <param name="ordinal">The column ordinal to read from.</param>
 public OrleansRelationalDownloadStream(DbDataReader reader, int ordinal)
 {            
     this.reader = reader;
     this.ordinal = ordinal;
                 
     //This return the total length of the column pointed by the ordinal.
     totalBytes = reader.GetBytes(ordinal, 0, null, 0, 0);
 }

        /// <summary>
        /// Liest sequenziell den Inhalt eines binären Datenfeldes und gibt ihn als object zurück.
        /// </summary>
        /// <param name="reader">Der DatenReader.</param>
        /// <param name="ordinal">0-basierter Spaltenindex.</param>
        /// <returns>Binärer Inhalt des Datenfeldes als Objekttyp.</returns>
        /// <remarks>
        /// Die Methode ist für sequenzielles Einlesen (CommandBehavior.SequentialAccess) ausgelegt.
        /// </remarks>
        public static byte[] ReadBlob(DbDataReader reader, int ordinal)
        {
            byte[] blobContent;                     // Inhalt des BLOB
            int bufferSize = 1024;                  // Größe des BLOB buffer.
            byte[] outByte = new byte[bufferSize];  // Der BLOB byte[] buffer, der mit Hilfe von GetBytes gefüllt wird.
            long retval;                            // Anzahl bytes, welche von GetBytes zurückgegeben wird.
            long startIndex = 0;                    // Startposition der BLOB-Ausgabe.

            //if (!reader.IsDBNull(ordinal))
            //{
            MemoryStream memStream = new MemoryStream();
            using (BinaryWriter writer = new BinaryWriter(memStream))
            {
                // Lese die Bytes und erhalte die Anzahl zurückgegebener Bytes.
                retval = reader.GetBytes(ordinal, startIndex, outByte, 0, bufferSize);

                // Lese solange zusätzliche Bytes bis der Buffer nicht mehr komplett gefüllt wurde.
                while (retval == bufferSize)
                {
                    writer.Write(outByte);
                    writer.Flush();

                    // Setze den nächsten start index an das Ende des letzen Buffers und fülle den Buffer erneut.
                    startIndex += bufferSize;
                    retval = reader.GetBytes(ordinal, startIndex, outByte, 0, bufferSize);
                }

                // Schreibe den letzen Bufferinhalt.
                //writer.Write(outByte, 0, (int)retval - 1);
                writer.Write(outByte, 0, (int)retval);
                writer.Flush();

                memStream.Position = 0;
                blobContent = memStream.ToArray();
            }

            return blobContent;
        }

        private static void SetBytes_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset) {
            int length = 0;

            // Deal with large values by sending bufferLength of NoLengthLimit (== assume 
            //  CheckXetParameters will ignore requested-length checks in this case)
            length = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, NoLengthLimit /* actual */, 0, NoLengthLimit /* buffer length */, offset, NoLengthLimit /* requested length */ );

            // Use fixed chunk size for all cases to avoid inquiring from reader.
            int chunkSize = __maxByteChunkSize;

            byte[] buffer = new byte[ chunkSize ];
            long bytesRead;
            long bytesWritten = 1;  // prime value to get into write loop
            long currentOffset = offset;
            long lengthWritten = 0;

            while ((length < 0  || lengthWritten < length) &&
                    0 != (bytesRead = reader.GetBytes(ordinal, currentOffset, buffer, 0, chunkSize)) &&
                    0 != bytesWritten) {
                bytesWritten = setters.SetBytes(sink, ordinal, currentOffset, buffer, 0, checked((int) bytesRead));
                sink.ProcessMessagesAndThrow();
                checked{ currentOffset += bytesWritten; }
                checked{ lengthWritten += bytesWritten; }
            }

            // Make sure to trim any left-over data (remember to trim at end of offset, not just the amount written
            setters.SetBytesLength(sink, ordinal, currentOffset);
            sink.ProcessMessagesAndThrow();
        }

 private static void SetBytes_FromReader(SmiEventSink_Default sink, SmiTypedGetterSetter setters, int ordinal, SmiMetaData metaData, DbDataReader reader, int offset)
 {
     long num6;
     int num4 = 0;
     num4 = CheckXetParameters(metaData.SqlDbType, metaData.MaxLength, -1L, 0L, -1, offset, -1);
     int length = 0x1f40;
     byte[] buffer = new byte[length];
     long num2 = 1L;
     long dataOffset = offset;
     for (long i = 0L; ((num4 < 0) || (i < num4)) && ((0L != (num6 = reader.GetBytes(ordinal, dataOffset, buffer, 0, length))) && (0L != num2)); i += num2)
     {
         num2 = setters.SetBytes(sink, ordinal, dataOffset, buffer, 0, (int) num6);
         sink.ProcessMessagesAndThrow();
         dataOffset += num2;
     }
     setters.SetBytesLength(sink, ordinal, dataOffset);
     sink.ProcessMessagesAndThrow();
 }

		static int ReadBinaryBlob (DbDataReader reader, int column, ref byte[] buffer)
		{
			long nread;

			// first, get the length of the buffer needed
			if ((nread = reader.GetBytes (column, 0, null, 0, buffer.Length)) > buffer.Length)
				Array.Resize (ref buffer, (int) nread);

			// read the certificate data
			return (int) reader.GetBytes (column, 0, buffer, 0, (int) nread);
		}

        /// <summary>
        /// Gets the bytes contained in the column of the specified reader.
        /// </summary>
        /// <param name="reader">The reader.</param>
        /// <param name="columnName">Name of the column.</param>
        /// <returns></returns>
        public static byte[] GetBytes(DbDataReader reader, string columnName)
        {
            const int CHUNK_SIZE = 2 * 1024;
            byte[] buffer = new byte[CHUNK_SIZE];
            long bytesRead;
            long fieldOffset = 0;
            int col = reader.GetOrdinal(columnName);

            using (MemoryStream stream = new MemoryStream())
            {
                while ((bytesRead = reader.GetBytes(col, fieldOffset, buffer, 0, buffer.Length)) > 0)
                {
                    byte[] actualRead = new byte[bytesRead];
                    Buffer.BlockCopy(buffer, 0, actualRead, 0, (int)bytesRead);
                    stream.Write(actualRead, 0, actualRead.Length);
                    fieldOffset += bytesRead;
                }
                return stream.ToArray();
            }
        }