SQLBytes.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Data / System / Data / SQLTypes / SQLBytes.cs / 1305376 / SQLBytes.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
//  																
// junfang 
// [....]
// [....] 
//----------------------------------------------------------------------------- 

//************************************************************************* 
// @File: SqlBytes.cs
// @Owner: junfang
//
// Created by:	JunFang 
//
// Description: Class SqlBytes is used to represent a binary/varbinary/image 
//		data from SQL Server. It contains a byte array buffer, which can 
//		be refilled. For example, in data access, user could use one instance
//		of sqlbytes to bind to a binary column, and we will just keep copying 
//		the data into the same instance, and avoid allocation per row.
//		It is also used to construct a UDT from on-disk binary value.
//
// Notes: 
//	
// History: 
// 
//     @Version: Yukon
//     120214 JXF  09/23/02 SqlBytes/SqlChars class indexer 
//     112296 AZA  07/06/02 Seal SqlAccess classes.
//     107151 AZA  04/18/02 Track byte array buffer as well as SqlBytes in
//                          sqlaccess.
//     107216 JXF  04/17/02 Bug 514927 
//     106854 JXF  04/15/02 Fix http suites due to SqlChars
//     106448 JXF  04/12/02 Bugs on sqlchars 
//     106242 JXF  04/09/02 Bugs on SqlBytes/SqlChars 
//     105715 JXF  04/05/02 Handle NULL properly in SqlBytes.SetLength
//     91128 JXF  10/17/01 Make SqlBytes not unsafe 
//
//   04/20/01  JunFang	Created.
//
// @EndHeader@ 
//*************************************************************************
 
namespace System.Data.SqlTypes { 
    using System;
 	using System.Diagnostics; 
    using System.Data.Common;
    using System.Data.Sql;
    using System.Data.SqlClient;
	using System.Data.SqlTypes; 
	using System.IO;
	using System.Runtime.InteropServices; 
 	using System.Runtime.Serialization; 
	using System.Security.Permissions;
 	using System.Xml; 
 	using System.Xml.Schema;
	using System.Xml.Serialization;

 	[Serializable] 
	internal enum SqlBytesCharsState {
		Null = 0, 
		Buffer = 1, 
 		//IntPtr = 2,
		Stream = 3, 
#if WINFSFunctionality
 		Delayed = 4
#endif
 	} 

	[Serializable,XmlSchemaProvider("GetXsdType")] 
    public sealed class SqlBytes : System.Data.SqlTypes.INullable, IXmlSerializable, ISerializable { 
 		// --------------------------------------------------------------
		//	  Data members 
		// -------------------------------------------------------------

		// SqlBytes has five possible states
 		// 1) SqlBytes is Null 
		//		- m_pbData, and m_stream must be null, m_lCuLen must be x_lNull.
 		// 2) SqlBytes contains a valid buffer, 
 		//		- m_rgbBuf must not be null, m_pbData and m_stream must be null 
		// 3) SqlBytes contains a valid pointer
 		//		- m_pbData must not be null, m_rgbBuf could be null or not, 
		//			if not null, content is garbage, should never look into it.
		//      - m_stream must be null.
		// 4) SqlBytes contains a Stream
 		//      - m_stream must not be null 
		//      - m_rgbBuf could be null or not. if not null, content is garbage, should never look into it.
 		//      - m_pbData must be null. 
 		//		- m_lCurLen must be x_lNull. 
		// 5) SqlBytes contains a Lazy Materialized Blob (ie, StorageState.Delayed)
 		// 
		internal byte[]	            m_rgbBuf;	// Data buffer
		private  long	            m_lCurLen;	// Current data length
#pragma warning disable 169
        // this field is no longer used, hence the warning was disabled 
        // however, it can not be removed or it will break serialization with pre-release builds of V2.0
		private  IntPtr	            m_pbData;	// Pointer to data in unmanaged memory. We don't own this memory, should never free 
#pragma warning restore 169 
 		internal Stream             m_stream;
		private  SqlBytesCharsState m_state; 

 		private  byte[]	            m_rgbWorkBuf;	// A 1-byte work buffer.

 		// The max data length that we support at this time. 
		private  const long x_lMaxLen = (long)System.Int32.MaxValue;
 
 		private  const long x_lNull = -1L; 

		// -------------------------------------------------------------- 
		//	  Constructor(s)
		// --------------------------------------------------------------

 		// Public default constructor used for XML serialization 
		public SqlBytes() {
 			SetNull(); 
 		} 

		// Create a SqlBytes with an in-memory buffer 
 		public SqlBytes(byte[] buffer) {
			m_rgbBuf = buffer;
			m_stream = null;
			if (m_rgbBuf == null) { 
 				m_state = SqlBytesCharsState.Null;
				m_lCurLen = x_lNull; 
            } 
 			else {
 				m_state = SqlBytesCharsState.Buffer; 
				m_lCurLen = (long)m_rgbBuf.Length;
            }

 			m_rgbWorkBuf = null; 

			AssertValid(); 
		} 

		// Create a SqlBytes from a SqlBinary 
 		public SqlBytes(SqlBinary value) : this(value.IsNull ? (byte[])null : value.Value)	{
        }

		public SqlBytes(Stream s) { 
    		// Create a SqlBytes from a Stream
 			m_rgbBuf = null; 
 			m_lCurLen = x_lNull; 
			m_stream = s;
 			m_state = (s == null) ? SqlBytesCharsState.Null : SqlBytesCharsState.Stream; 

			m_rgbWorkBuf = null;

			AssertValid(); 
        }
 
#if WINFSFunctionality 
        // Internal constructor to be called by UdtExtensions.dll for LazyMat
        internal SqlBytes(byte[] cookie, bool lazyMat) : this(cookie) { 
            Debug.Assert(lazyMat, "FAILURE - lazyMat argument should not be false!");
            m_state = SqlBytesCharsState.Delayed;
        }
#endif 

		// Constructor required for serialization. Deserializes as a Buffer. If the bits have been tampered with 
 		// then this will throw a SerializationException or a InvalidCastException. 
		private SqlBytes(SerializationInfo info, StreamingContext context)
 			{ 
 			m_stream = null;
			m_rgbWorkBuf = null;

 			if (info.GetBoolean("IsNull")) 
				{
				m_state = SqlBytesCharsState.Null; 
				m_rgbBuf = null; 
 				}
			else 
 				{
 				m_state = SqlBytesCharsState.Buffer;
				m_rgbBuf = (byte[]) info.GetValue("data", typeof(byte[]));
 				m_lCurLen = m_rgbBuf.Length; 
				}
 
			AssertValid(); 
			}
 

 		// -------------------------------------------------------------
		//	  Public properties
 		// -------------------------------------------------------------- 

#if WINFSFunctionality 
 
        public bool IsFilled {
            get { 
                return (m_state != SqlBytesCharsState.Delayed);
            }
        }
#endif 

 		// INullable 
		public bool IsNull { 
 			get {
#if WINFSFunctionality 
				AssertFilled();
#endif
				return m_state == SqlBytesCharsState.Null;
			} 
 		}
 
		// Property: the in-memory buffer of SqlBytes 
 		//		Return Buffer even if SqlBytes is Null.
 		public byte[] Buffer { 
			get {
#if WINFSFunctionality
 				AssertFilled();
#endif 
				if (FStream())	{
					CopyStreamToBuffer(); 
				} 
 				return m_rgbBuf;
			} 
 		}

 		// Property: the actual length of the data
		public long Length { 
 			get {
#if WINFSFunctionality 
				AssertFilled(); 
#endif
				switch (m_state) { 
					case SqlBytesCharsState.Null:
                        throw new SqlNullValueException();

 					case SqlBytesCharsState.Stream: 
						return m_stream.Length;
 
 					default: 
 						return m_lCurLen;
				} 
 			}
		}

		// Property: the max length of the data 
		//		Return MaxLength even if SqlBytes is Null.
 		//		When the buffer is also null, return -1. 
		//		If containing a Stream, return -1. 
 		public long MaxLength {
 			get { 
#if WINFSFunctionality
				AssertFilled();
#endif
 				switch (m_state) { 
					case SqlBytesCharsState.Stream:
						return -1L; 
 
					default:
 						return (m_rgbBuf == null) ? -1L : (long)m_rgbBuf.Length; 
                }
            }
        }
 
		// Property: get a copy of the data in a new byte[] array.
 		public byte[] Value { 
 			get { 
#if WINFSFunctionality
				AssertFilled(); 
#endif
 				byte[] buffer;

				switch (m_state) { 
					case SqlBytesCharsState.Null:
						throw new SqlNullValueException(); 
 
 					case SqlBytesCharsState.Stream:
						if (m_stream.Length > x_lMaxLen) 
                                            throw new SqlTypeException(Res.GetString(Res.SqlMisc_BufferInsufficientMessage));
 						buffer = new byte[m_stream.Length];
 						if (m_stream.Position != 0)
							m_stream.Seek(0, SeekOrigin.Begin); 
 						m_stream.Read(buffer, 0, checked((int)m_stream.Length));
						break; 
 
					default:
						buffer = new byte[m_lCurLen]; 
 						Array.Copy(m_rgbBuf, buffer, (int)m_lCurLen);
						break;
                }
 
 				return buffer;
            } 
        } 

 		// class indexer 
		public byte this[long offset] {
 			get {
#if WINFSFunctionality
				AssertFilled(); 
#endif
                if (offset < 0 || offset >= this.Length) 
                    throw new ArgumentOutOfRangeException("offset"); 

                if (m_rgbWorkBuf == null) 
					m_rgbWorkBuf = new byte[1];

                Read(offset, m_rgbWorkBuf, 0, 1);
				return m_rgbWorkBuf[0]; 
            }
 			set { 
#if WINFSFunctionality 
				AssertFilled();
#endif 
 				if (m_rgbWorkBuf == null)
 					m_rgbWorkBuf = new byte[1];
				m_rgbWorkBuf[0] = value;
 				Write(offset, m_rgbWorkBuf, 0, 1); 
            }
        } 
 
		public StorageState Storage {
			get { 
#if WINFSFunctionality
				AssertFilled();
#endif
 				switch (m_state) { 
					case SqlBytesCharsState.Null:
 						throw new SqlNullValueException(); 
 					case SqlBytesCharsState.Stream: 
					    return StorageState.Stream;
 
 					case SqlBytesCharsState.Buffer:
					    return StorageState.Buffer;

#if WINFSFunctionality 
					case SqlBytesCharsState.Delayed:
					    return StorageState.Delayed; 
#endif 

 					default: 
					    return StorageState.UnmanagedBuffer;
 				}
 			}
		} 

        public Stream Stream { 
            get { 
#if WINFSFunctionality
                AssertFilled(); 
#endif
    			return FStream() ? m_stream : new StreamOnSqlBytes(this);
            }
            set { 
    			m_lCurLen = x_lNull;
    			m_stream = value; 
    			m_state = (value == null) ? SqlBytesCharsState.Null : SqlBytesCharsState.Stream; 
    			AssertValid();
            } 
        }

 		// -------------------------------------------------------------
		//	  Public methods 
		// -------------------------------------------------------------
 
#if WINFSFunctionality 

        public void Fill(SqlConnection connection) { 
            Fill(connection, null);
        }

        internal void Fill(SqlConnection connection, SqlTransaction transaction) { 
            AssertNotFilled();
 
            Object result = SQLUtility.GetLOBFromCookie(m_rgbBuf, connection, transaction); 
            m_rgbBuf = null;
 
            if ((result == null) || (result is DBNull))
                SetNull();
            else
                SetBuffer((byte[])result); 
        }
#endif 
 
		public void SetNull() {
#if WINFSFunctionality 
    		// Clear the buffer only if it was a cookie.
    		if (!IsFilled)
    			m_rgbBuf = null;
#endif 
    		m_lCurLen = x_lNull;
    		m_stream = null; 
    		m_state = SqlBytesCharsState.Null; 

    		AssertValid(); 
 		}

		// Set the current length of the data
 		// If the SqlBytes is Null, setLength will make it non-Null. 
 		public void SetLength(long value) {
#if WINFSFunctionality 
			AssertFilled(); 
#endif
 
 			if (value < 0)
				throw new ArgumentOutOfRangeException("value");

			if (FStream()) { 
				m_stream.SetLength(value);
 			} 
			else { 
 				// If there is a buffer, even the value of SqlBytes is Null,
 				// still allow setting length to zero, which will make it not Null. 
				// If the buffer is null, raise exception
 				//
				if (null == m_rgbBuf)
                    throw new SqlTypeException(Res.GetString(Res.SqlMisc_NoBufferMessage)); 

				if (value > (long)m_rgbBuf.Length) 
					throw new ArgumentOutOfRangeException("value"); 

 				else if (IsNull) 
					// At this point we know that value is small enough
 					// Go back in buffer mode
 					m_state = SqlBytesCharsState.Buffer;
 
				m_lCurLen = value;
            } 
 
 			AssertValid();
        } 

		// Read data of specified length from specified offset into a buffer
		public long Read(long offset, byte[] buffer, int offsetInBuffer, int count) {
#if WINFSFunctionality 
			AssertFilled();
#endif 
 
 			if (IsNull)
                throw new SqlNullValueException(); 

			// Validate the arguments
 			if (buffer == null)
 				throw new ArgumentNullException("buffer"); 

			if (offset > this.Length || offset < 0) 
 				throw new ArgumentOutOfRangeException("offset"); 

			if (offsetInBuffer > buffer.Length || offsetInBuffer < 0) 
				throw new ArgumentOutOfRangeException("offsetInBuffer");

			if (count < 0 || count > buffer.Length - offsetInBuffer)
 				throw new ArgumentOutOfRangeException("count"); 

			// Adjust count based on data length 
 			if (count > this.Length - offset) 
 				count = (int)(this.Length - offset);
 
			if (count != 0)	{
 				switch (m_state) {
                    case SqlBytesCharsState.Stream:
						if (m_stream.Position != offset) 
							m_stream.Seek(offset, SeekOrigin.Begin);
						m_stream.Read(buffer, offsetInBuffer, count); 
 						break; 

					default: 
 						Array.Copy(m_rgbBuf, offset, buffer, offsetInBuffer, count);
 						break;
    			}
			} 
 			return count;
		} 
 
		// Write data of specified length into the SqlBytes from specified offset
		public void Write(long offset, byte[] buffer, int offsetInBuffer, int count) { 
#if WINFSFunctionality
 			AssertFilled();
#endif
 
			if (FStream()) {
 				if (m_stream.Position != offset) 
 					m_stream.Seek(offset, SeekOrigin.Begin); 
				m_stream.Write(buffer, offsetInBuffer, count);
            } 
 			else {
				// Validate the arguments
				if (buffer == null)
					throw new ArgumentNullException("buffer"); 

 				if (m_rgbBuf == null) 
                    throw new SqlTypeException(Res.GetString(Res.SqlMisc_NoBufferMessage)); 

				if (offset < 0) 
 					throw new ArgumentOutOfRangeException("offset");
 				if (offset > m_rgbBuf.Length)
                                    throw new SqlTypeException(Res.GetString(Res.SqlMisc_BufferInsufficientMessage));
 
				if (offsetInBuffer < 0 || offsetInBuffer > buffer.Length)
 					throw new ArgumentOutOfRangeException("offsetInBuffer"); 
 
				if (count < 0 || count > buffer.Length - offsetInBuffer)
					throw new ArgumentOutOfRangeException("count"); 

				if (count > m_rgbBuf.Length - offset)
                    throw new SqlTypeException(Res.GetString(Res.SqlMisc_BufferInsufficientMessage));
 
 				if (IsNull) {
					// If NULL and there is buffer inside, we only allow writing from 
 					// offset zero. 
 					//
					if (offset != 0) 
                        throw new SqlTypeException(Res.GetString(Res.SqlMisc_WriteNonZeroOffsetOnNullMessage));

 					// treat as if our current length is zero.
					// Note this has to be done after all inputs are validated, so that 
					// we won't throw exception after this point.
					// 
 					m_lCurLen = 0; 
                    m_state = SqlBytesCharsState.Buffer;
				} 
 				else if (offset > m_lCurLen) {
 					// Don't allow writing from an offset that this larger than current length.
					// It would leave uninitialized data in the buffer.
 					// 
                    throw new SqlTypeException(Res.GetString(Res.SqlMisc_WriteOffsetLargerThanLenMessage));
				} 
 
				if (count != 0)	{
					Array.Copy(buffer, offsetInBuffer, m_rgbBuf, offset, count); 

 					// If the last position that has been written is after
					// the current data length, reset the length
 					if (m_lCurLen < offset + count) 
 						m_lCurLen = offset + count;
				} 
 			} 

    		AssertValid(); 
		}

		public SqlBinary ToSqlBinary() {
#if WINFSFunctionality 
			AssertFilled();
#endif 
 			return IsNull ? SqlBinary.Null : new SqlBinary(Value); 
		}
 
 		// -------------------------------------------------------------
 		//	  Conversion operators
		// --------------------------------------------------------------
 
 		// Alternative method: ToSqlBinary()
		public static explicit operator SqlBinary(SqlBytes value) { 
			return value.ToSqlBinary(); 
		}
 
 		// Alternative method: constructor SqlBytes(SqlBinary)
		public static explicit operator SqlBytes(SqlBinary value) {
 			return new SqlBytes(value);
 		} 

		// ------------------------------------------------------------- 
 		//	  Private utility functions 
		// --------------------------------------------------------------
 
		[System.Diagnostics.Conditional("DEBUG")]
		private void AssertValid() {
    		Debug.Assert(m_state >= SqlBytesCharsState.Null && m_state <= SqlBytesCharsState.Stream);
 
 			if (IsNull) {
			} 
 			else { 
 				Debug.Assert((m_lCurLen >= 0 && m_lCurLen <= x_lMaxLen) || FStream());
				Debug.Assert(FStream() || (m_rgbBuf != null && m_lCurLen <= m_rgbBuf.Length)); 
 				Debug.Assert(!FStream() || (m_lCurLen == x_lNull));
			}
			Debug.Assert(m_rgbWorkBuf == null || m_rgbWorkBuf.Length == 1);
		} 

#if WINFSFunctionality 
 		// User is not allowed to use any methods until this SqlBytes has been filled 
		// except Fill()
 		private void AssertFilled() { 
 			if (!IsFilled)
				throw new SqlNotFilledException();
 		}
 
        private void AssertNotFilled() {
            if (IsFilled) 
                throw new SqlAlreadyFilledException(); 
        }
 
        internal byte[] Cookie {
            get {
                Debug.Assert(!IsFilled, "Unexpected state on Cookie getter!");
                return m_rgbBuf; 
            }
        } 
#endif 

		// Copy the data from the Stream to the array buffer. 
		// If the SqlBytes doesn't hold a buffer or the buffer
		// is not big enough, allocate new byte array.
 		private void CopyStreamToBuffer() {
			Debug.Assert(FStream()); 

 			long lStreamLen = m_stream.Length; 
 			if (lStreamLen >= x_lMaxLen) 
                           throw new SqlTypeException(Res.GetString(Res.SqlMisc_WriteOffsetLargerThanLenMessage));
 
			if (m_rgbBuf == null || m_rgbBuf.Length < lStreamLen)
 				m_rgbBuf = new byte[lStreamLen];

			if (m_stream.Position != 0) 
				m_stream.Seek(0, SeekOrigin.Begin);
 
			m_stream.Read(m_rgbBuf, 0, (int)lStreamLen); 
 			m_stream = null;
			m_lCurLen = lStreamLen; 
 			m_state = SqlBytesCharsState.Buffer;

 			AssertValid();
        } 

		// whether the SqlBytes contains a pointer 
 		// whether the SqlBytes contains a Stream 
		internal bool FStream()	{
			return m_state == SqlBytesCharsState.Stream; 
        }

		private void SetBuffer(byte[] buffer) {
 			m_rgbBuf = buffer; 
			m_lCurLen = (m_rgbBuf == null) ? x_lNull : (long)m_rgbBuf.Length;
 			m_stream = null; 
 			m_state = (m_rgbBuf == null) ? SqlBytesCharsState.Null : SqlBytesCharsState.Buffer; 

			AssertValid(); 
        }

 		// --------------------------------------------------------------
		// 		XML Serialization 
		// -------------------------------------------------------------
 
		XmlSchema IXmlSerializable.GetSchema() { 
 			return null;
        } 
		
 		void IXmlSerializable.ReadXml(XmlReader r) {
#if WINFSFunctionality
 			AssertFilled(); 
#endif
			byte[] value = null; 
 			 
			string isNull = r.GetAttribute("nil", XmlSchema.InstanceNamespace);
			 
			if (isNull != null && XmlConvert.ToBoolean(isNull)) {
                // VSTFDevDiv# 479603 - SqlTypes read null value infinitely and never read the next value. Fix - Read the next value.
                r.ReadElementString();
                SetNull(); 
 			}
			else { 
 				string base64 = r.ReadElementString(); 
 				if (base64 == null) {
					value = new byte[0]; 
 				}
				else {
					base64 = base64.Trim();
					if (base64.Length == 0) 
 						value = new byte[0];
					else 
 						value = Convert.FromBase64String(base64); 
 				}
			} 
 			
            SetBuffer(value);
		}
 
		void IXmlSerializable.WriteXml(XmlWriter writer) {
#if WINFSFunctionality 
			AssertFilled(); 
#endif
 			if (IsNull) { 
				writer.WriteAttributeString("xsi", "nil", XmlSchema.InstanceNamespace, "true");
 			}
 			else {
				byte[] value = this.Buffer; 
 				writer.WriteString(Convert.ToBase64String(value, 0, (int)(this.Length)));
            } 
        } 

		public static XmlQualifiedName GetXsdType(XmlSchemaSet schemaSet) { 
			return new XmlQualifiedName("base64Binary", XmlSchema.Namespace);
		}

 
 		// --------------------------------------------------------------
		// 		Serialization using ISerializable 
 		// ------------------------------------------------------------- 

 		// State information is not saved. The current state is converted to Buffer and only the underlying 
		// array is serialized, except for Null, in which case this state is kept.
 		[SecurityPermissionAttribute(SecurityAction.LinkDemand,SerializationFormatter=true)]
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
			{ 
#if WINFSFunctionality
			AssertFilled(); 
#endif 

 			switch (m_state) 
				{
 				case SqlBytesCharsState.Null:
 					info.AddValue("IsNull", true);
					break; 

 				case SqlBytesCharsState.Buffer: 
					info.AddValue("IsNull", false); 
					info.AddValue("data", m_rgbBuf);
					break; 

 				case SqlBytesCharsState.Stream:
					CopyStreamToBuffer();
 					goto case SqlBytesCharsState.Buffer; 

 				default: 
					Debug.Assert(false); 
 					goto case SqlBytesCharsState.Null;
					 
				}
			}

 		// ------------------------------------------------------------- 
		//	  Static fields, properties
 		// ------------------------------------------------------------- 
 
 		// Get a Null instance.
		// Since SqlBytes is mutable, have to be property and create a new one each time. 
 		public static SqlBytes Null {
			get	{
				return new SqlBytes((byte[])null);
			} 
 		}
	} // class SqlBytes 
 
 	// StreamOnSqlBytes is a stream build on top of SqlBytes, and
 	// provides the Stream interface. The purpose is to help users 
	// to read/write SqlBytes object. After getting the stream from
 	// SqlBytes, users could create a BinaryReader/BinaryWriter object
	// to easily read and write primitive types.
	internal sealed class StreamOnSqlBytes : Stream 
		{
 		// -------------------------------------------------------------- 
		//	  Data members 
 		// -------------------------------------------------------------
 
 		private SqlBytes	m_sb;		// the SqlBytes object
		private long		m_lPosition;

 		// -------------------------------------------------------------- 
		//	  Constructor(s)
		// -------------------------------------------------------------- 
 
		internal StreamOnSqlBytes(SqlBytes sb) {
 			m_sb = sb; 
			m_lPosition = 0;
 		}

 		// ------------------------------------------------------------- 
		//	  Public properties
 		// -------------------------------------------------------------- 
 
		// Always can read/write/seek, unless sb is null,
		// which means the stream has been closed. 

		public override bool CanRead {
 			get	{
				return m_sb != null && !m_sb.IsNull; 
 			}
 		} 
 
		public override bool CanSeek {
 			get { 
				return m_sb != null;
			}
		}
 
 		public override bool CanWrite {
			get	{ 
 				return m_sb != null && (!m_sb.IsNull || m_sb.m_rgbBuf != null); 
 			}
		} 

 		public override long Length	{
			get	{
    			CheckIfStreamClosed("get_Length"); 
	    		return m_sb.Length;
            } 
        } 

		public override long Position { 
 			get	{
				CheckIfStreamClosed("get_Position");
 				return m_lPosition;
 			} 
			set	{
 				CheckIfStreamClosed("set_Position"); 
				if (value < 0 || value > m_sb.Length) 
					throw new ArgumentOutOfRangeException("value");
				else 
 					m_lPosition = value;
			}
 		}
 
 		// -------------------------------------------------------------
		//	  Public methods 
 		// ------------------------------------------------------------- 

		public override long Seek(long offset, SeekOrigin origin) { 
			CheckIfStreamClosed("Seek");

			long lPosition = 0;
 
 			switch(origin) {
				case SeekOrigin.Begin: 
 					if (offset < 0 || offset > m_sb.Length) 
 						throw new ArgumentOutOfRangeException("offset");
					m_lPosition = offset; 
 					break;
					
				case SeekOrigin.Current:
					lPosition = m_lPosition + offset; 
 					if (lPosition < 0 || lPosition > m_sb.Length)
						throw new ArgumentOutOfRangeException("offset"); 
 					m_lPosition = lPosition; 
 					break;
					 
 				case SeekOrigin.End:
					lPosition = m_sb.Length + offset;
					if (lPosition < 0 || lPosition > m_sb.Length)
						throw new ArgumentOutOfRangeException("offset"); 
 					m_lPosition = lPosition;
					break; 
 					 
 				default:
                                throw ADP.InvalidSeekOrigin("offset"); 
			}

 			return m_lPosition;
		} 

		// The Read/Write/ReadByte/WriteByte simply delegates to SqlBytes 
		public override int Read(byte[] buffer, int offset, int count) { 
 			CheckIfStreamClosed("Read");
 
			if (buffer==null)
 				throw new ArgumentNullException("buffer");
 			if (offset < 0 || offset > buffer.Length)
				throw new ArgumentOutOfRangeException("offset"); 
 			if (count < 0 || count > buffer.Length - offset)
				throw new ArgumentOutOfRangeException("count"); 
 
			int iBytesRead = (int)m_sb.Read(m_lPosition, buffer, offset, count);
			m_lPosition += iBytesRead; 

 			return iBytesRead;
		}
 
 		public override void Write(byte[] buffer, int offset, int count) {
 			CheckIfStreamClosed("Write"); 
 
			if (buffer==null)
 				throw new ArgumentNullException("buffer"); 
			if (offset < 0 || offset > buffer.Length)
				throw new ArgumentOutOfRangeException("offset");
			if (count < 0 || count > buffer.Length - offset)
 				throw new ArgumentOutOfRangeException("count"); 

			m_sb.Write(m_lPosition, buffer, offset, count); 
 			m_lPosition += count; 
 		}
 
		public override int ReadByte() {
 			CheckIfStreamClosed("ReadByte");

			// If at the end of stream, return -1, rather than call SqlBytes.ReadByte, 
			// which will throw exception. This is the behavior for Stream.
			// 
 			if (m_lPosition >= m_sb.Length) 
				return -1;
 
 			int ret = m_sb[m_lPosition];
 			m_lPosition ++;
			return ret;
 		} 

		public override void WriteByte(byte value) { 
			CheckIfStreamClosed("WriteByte"); 

			m_sb[m_lPosition] = value; 
 			m_lPosition ++;
		}

 		public override void SetLength(long value) { 
 			CheckIfStreamClosed("SetLength");
 
			m_sb.SetLength(value); 
 			if (m_lPosition > value)
				m_lPosition = value; 
		}

		// Flush is a no-op for stream on SqlBytes, because they are all in memory
 		public override void Flush() { 
			if (m_sb.FStream())
 				m_sb.m_stream.Flush(); 
 		} 

		protected override void Dispose(bool disposing) { 
 			// When m_sb is null, it means the stream has been closed, and
			// any opearation in the future should fail.
			// This is the only case that m_sb is null.
            try { 
			m_sb = null;
 		} 
            finally { 
                base.Dispose(disposing);
            } 
		}

 		// -------------------------------------------------------------
 		//	  Private utility functions 
		// --------------------------------------------------------------
 
 		private bool FClosed() { 
			return m_sb == null;
		} 

        private void CheckIfStreamClosed(string methodname) {
			if (FClosed())
                throw ADP.StreamClosed(methodname); 
        }
    } // class StreamOnSqlBytes 
} // namespace System.Data.SqlTypes 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK