C# IDataRecord.GetBytes方法代码示例

 /// <summary>
 /// Reads a byte array from the current <see cref="IDataRecord"/>.
 /// </summary>
 /// <param name="dataRecord">The target <see cref="IDataRecord"/>.</param>
 /// <param name="ordinal">The ordinal for the field that contains the stream data.</param>
 /// <returns>A new byte array.</returns>
 public static byte[] ReadByteArray(IDataRecord dataRecord, int ordinal)
 {
     long length = dataRecord.GetBytes(ordinal, 0, null, 0, int.MaxValue);
     var buffer = new byte[length];
     dataRecord.GetBytes(ordinal, 0, buffer, 0, (int)length);
     return buffer;
 }

 public static byte[] GetFromReader(IDataRecord record, int pos)
 {
     long n = record.GetBytes(pos, 0, null, 0, 0);
     byte[] buf = new byte[n];
     record.GetBytes(pos, 0, buf, 0, buf.Length);
     return buf;
 }

        public static Image GetFromReader(IDataRecord record, int pos)
        {
            long n = record.GetBytes(pos, 0, null, 0, 0);
            if (n <= 0)
                return null;

            byte[] buf = new byte[n];
            record.GetBytes(pos, 0, buf, 0, buf.Length);

            return ImageFromBytes(buf);
        }

        public static byte[] GetBytes(IDataRecord dataRecord, int ordinal)
        {
            var length = dataRecord.GetBytes(ordinal, 0, null, 0, 0);

            var buffer = new byte[length];

            int offset = 0;

            while (offset < length)
            {
                offset += (int)dataRecord.GetBytes(ordinal, offset, buffer, offset, (int)length);
            }

            return buffer;
        }

        /// <summary>
        /// Retrieves bytes from a datarecord, or null if null.
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="ordinal"></param>
        /// <returns></returns>
        protected static byte[] GetBytes(IDataRecord reader, int ordinal)
        {
            if (reader.IsDBNull(ordinal))
            {
                return null;
            }

            List<byte> bytes = new List<byte>();

            byte[] buffer = new byte[256];
            long readCount = 0;
            long readTotal = 0;

            do
            {
                readCount = reader.GetBytes(ordinal, readTotal, buffer, 0, buffer.Length);
                readTotal += readCount;

                if (readCount == 0)
                    break;

                bytes.AddRange(buffer);
            } while (readCount > 0);

            bytes = bytes.GetRange(0, (int) readTotal);  // in case the message byte array is not factorable by buffer.Length

            return bytes.ToArray();
        }

        private Gnosis.ITag ReadTag(IDataRecord record)
        {
            var id = record.GetInt64("Id");
            var target = record.GetUri("Target");
            var algorithm = record.GetInt32Lookup<IAlgorithm>("Algorithm", algorithmId => Algorithms.Algorithm.Parse(algorithmId));
            var type = record.GetInt32Lookup<ITagType>("Type", typeId => typeFactory.Create(typeId));
            var value = record.GetString("Value");
            var data = record.GetBytes("Data");

            return new Gnosis.Tags.Tag(target, type, value, algorithm, data, id);
        }

        public User(IDataRecord data)
        {
            Id = data.GetInt64(0);
            Username = data.GetString(1);
            ActivatedFlag = data.GetBoolean(2);

            Password = new byte[64];
            data.GetBytes(3, 0, Password, 0, 64);

            Salt = data.GetInt32(4);
        }

 // get raw bytes of data from a row (for reading blobs)
 // adapted from stackoverflow #625029
 public static byte[] GetBytes(IDataRecord row, int field)
 {
     const int CHUNK_SIZE = 2*1024;
     byte[] buffer = new byte[CHUNK_SIZE];
     long bytesRead;
     long fieldOffset = 0;
     using (MemoryStream stream = new MemoryStream())
     {
         while ((bytesRead = row.GetBytes(field, fieldOffset, buffer, 0, buffer.Length)) > 0)
         {
             stream.Write(buffer, 0, (int) bytesRead);
             fieldOffset += bytesRead;
         }
         return stream.ToArray();
     }
 }

		static int ReadBinaryBlob (IDataRecord 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>
        /// Creates a new <see cref="Commit"/>.
        /// </summary>
        /// <param name="record">The record from which to create the new <see cref="Commit"/>.</param>
        private Commit CreateCommit(IDataRecord record)
        {
            var id = record.GetInt64(Column.Id);
            var timestamp = record.GetDateTime(Column.Timestamp);
            var correlationId = record.GetGuid(Column.CorrelationId);
            var streamId = record.GetGuid(Column.StreamId);
            var version = record.GetInt32(Column.Version);
            var data = serializer.Deserialize<CommitData>(record.GetBytes(Column.Data));

            return new Commit(id, timestamp, correlationId, streamId, version, data.Headers, data.Events);
        }

        private static void ParseSettingsData(ICollection<SiteSettingsPropertyValue> collection, IEnumerable<SiteSettingsProperty> properties, IDataRecord reader)
        {
            var name = reader.GetString(0);

            var property = properties.SingleOrDefault(prop => String.Equals(name, prop.PropertyName, StringComparison.OrdinalIgnoreCase));

            if (property == null)
            {
                return;
            }

            byte[] data = null;

            if (!reader.IsDBNull(1))
            {
                var size = reader.GetBytes(1, 0, null, 0, 0);

                if (size > 0)
                {
                    data = new byte[size];

                    reader.GetBytes(1, 0, data, 0, (int)size);
                }
            }

            collection.Add(new SiteSettingsPropertyValue(property, MaterializeValue(property, data)));
        }

        /// <summary>
        /// Creates a new <see cref="Saga"/>.
        /// </summary>
        /// <param name="record">The record from which to create the new <see cref="Saga"/>.</param>
        private Saga CreateSaga(IDataRecord record)
        {
            var id = record.GetGuid(Column.Id);
            var version = record.GetInt32(Column.Version);
            var timeout = record.GetNullableDateTime(Column.Timeout);
            var saga = serializer.Deserialize<Saga>(record.GetBytes(Column.State));

            saga.CorrelationId = id;
            saga.Version = version;
            saga.Timeout = timeout;

            return saga;
        }

 /// <summary>
 /// Creates a new <see cref="Snapshot"/>.
 /// </summary>
 /// <param name="type">The snapshot type.</param>
 /// <param name="record">The record from which to create the new <see cref="Snapshot"/>.</param>
 private Snapshot CreateSnapshot(Type type, IDataRecord record)
 {
     return new Snapshot(record.GetGuid(Column.StreamId), record.GetInt32(Column.Version), serializer.Deserialize(record.GetBytes(Column.State), type));
 }