Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Data / System / Data / SQLTypes / SqlXml.cs / 1305376 / SqlXml.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
//*************************************************************************
// Copyright (c) 1988-2000 Microsoft Corporation.
//
// @File: SqlXml.cs
//
// @Owner: junfung
// @Test: jstowe
//
// Purpose: Implementation of SqlXml which is equivalent to
// data type "xml" in SQL Server
//
// Notes:
//
// History:
//
// @EndHeader@
//*************************************************************************
using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Data.Common;
using System.Diagnostics;
using System.Text;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Reflection;
namespace System.Data.SqlTypes
{
[Serializable, XmlSchemaProvider("GetXsdType")]
public sealed class SqlXml: System.Data.SqlTypes.INullable, IXmlSerializable {
private bool m_fNotNull; // false if null, the default ctor (plain 0) will make it Null
private Stream m_stream;
private bool firstCreateReader;
private MethodInfo createSqlReaderMethodInfo;
private readonly static Func sqlReaderDelegate = CreateSqlReaderDelegate();
public SqlXml() {
SetNull();
}
// constructor
// construct a Null
private SqlXml(bool fNull) {
SetNull();
}
public SqlXml(XmlReader value) {
// whoever pass in the XmlReader is responsible for closing it
if (value == null) {
SetNull();
}
else {
m_fNotNull = true;
firstCreateReader = true;
m_stream = CreateMemoryStreamFromXmlReader(value);
}
}
public SqlXml(Stream value) {
// whoever pass in the stream is responsible for closing it
// similar to SqlBytes implementation
if (value == null) {
SetNull();
}
else {
firstCreateReader = true;
m_fNotNull = true;
m_stream = value;
}
}
public XmlReader CreateReader() {
if (IsNull)
throw new SqlNullValueException();
SqlXmlStreamWrapper stream = new SqlXmlStreamWrapper(m_stream);
// if it is the first time we create reader and stream does not support CanSeek, no need to reset position
if ((!firstCreateReader || stream.CanSeek) && stream.Position != 0)
stream.Seek(0, SeekOrigin.Begin);
XmlReader r = null;
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ConformanceLevel = ConformanceLevel.Fragment;
// Call internal XmlReader.CreateSqlReader from System.Xml.
// Signature: internal static XmlReader CreateSqlReader(Stream input, XmlReaderSettings settings, XmlParserContext inputContext);
// NOTE: Maintaining createSqlReaderMethodInfo private field member to preserve the serialization of the class
if (createSqlReaderMethodInfo == null)
createSqlReaderMethodInfo = typeof(System.Xml.XmlReader).GetMethod("CreateSqlReader", BindingFlags.Static | BindingFlags.NonPublic);
Debug.Assert(createSqlReaderMethodInfo != null, "MethodInfo reference for XmlReader.CreateSqlReader should not be null.");
// VSTFDevDiv #748742 - Performance regression of 30% on dataset serialization test scenario
r = sqlReaderDelegate(stream, readerSettings, null);
firstCreateReader = false;
return r;
}
// NOTE: ReflectionPermission required here for accessing the non-public internal method CreateSqlReader() of System.Xml regardless of its grant set.
[ReflectionPermission(SecurityAction.Assert, MemberAccess = true)]
private static Func CreateSqlReaderDelegate()
{
MethodInfo methodInfo = typeof(System.Xml.XmlReader).GetMethod("CreateSqlReader", BindingFlags.Static | BindingFlags.NonPublic);
return (Func)Delegate.CreateDelegate(typeof(Func), methodInfo);
}
// INullable
public bool IsNull {
get { return !m_fNotNull;}
}
public string Value {
get {
if (IsNull)
throw new SqlNullValueException();
StringWriter sw = new StringWriter((System.IFormatProvider)null);
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.CloseOutput = false; // don't close the memory stream
writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
XmlWriter ww = XmlWriter.Create(sw, writerSettings);
XmlReader reader = this.CreateReader();
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF) {
ww.WriteNode(reader, true);
}
ww.Flush();
return sw.ToString();
}
}
public static SqlXml Null {
get {
return new SqlXml(true);
}
}
private void SetNull() {
m_fNotNull = false;
m_stream = null;
firstCreateReader = true;
}
private Stream CreateMemoryStreamFromXmlReader(XmlReader reader) {
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.CloseOutput = false; // don't close the memory stream
writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
writerSettings.Encoding = Encoding.GetEncoding("utf-16");
writerSettings.OmitXmlDeclaration = true;
MemoryStream writerStream = new MemoryStream();
XmlWriter ww = XmlWriter.Create(writerStream, writerSettings);
if (reader.ReadState == ReadState.Closed)
throw new InvalidOperationException(SQLResource.ClosedXmlReaderMessage);
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF) {
ww.WriteNode(reader, true);
}
ww.Flush();
// set the stream to the beginning
writerStream.Seek(0, SeekOrigin.Begin);
return writerStream;
}
XmlSchema IXmlSerializable.GetSchema() {
return null;
}
void IXmlSerializable.ReadXml(XmlReader r) {
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.ReadInnerXml();
SetNull();
}
else {
m_fNotNull = true;
firstCreateReader = true;
m_stream = new MemoryStream();
StreamWriter sw = new StreamWriter(m_stream);
sw.Write(r.ReadInnerXml());
sw.Flush();
if (m_stream.CanSeek)
m_stream.Seek(0, SeekOrigin.Begin);
}
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (IsNull)
{
writer.WriteAttributeString("xsi", "nil", XmlSchema.InstanceNamespace, "true");
}
else
{
// VSTFDevDiv Bug 197567 - [SqlXml Column Read from SQL Server 2005 Fails to XML Serialize (writes raw binary)]
// Instead of the WriteRaw use the WriteNode. As Tds sends a binary stream - Create a XmlReader to convert
// get the Xml string value from the binary and call WriteNode to pass that out to the XmlWriter.
XmlReader reader = this.CreateReader();
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF)
{
writer.WriteNode(reader, true);
}
}
writer.Flush();
}
public static XmlQualifiedName GetXsdType(XmlSchemaSet schemaSet) {
return new XmlQualifiedName("anyType", XmlSchema.Namespace);
}
} // SqlXml
// two purposes for this class
// 1) keep its internal position so one reader positions on the orginial stream
// will not interface with the other
// 2) when xmlreader calls close, do not close the orginial stream
//
internal sealed class SqlXmlStreamWrapper : Stream {
// --------------------------------------------------------------
// Data members
// -------------------------------------------------------------
private Stream m_stream;
private long m_lPosition;
bool m_isClosed;
// --------------------------------------------------------------
// Constructor(s)
// --------------------------------------------------------------
internal SqlXmlStreamWrapper(Stream stream) {
m_stream = stream;
Debug.Assert(m_stream != null, "stream can not be null");
m_lPosition = 0;
m_isClosed = false;
}
// -------------------------------------------------------------
// Public properties
// --------------------------------------------------------------
// Always can read/write/seek, unless stream is null,
// which means the stream has been closed.
public override bool CanRead {
get
{
if (IsStreamClosed())
return false;
return m_stream.CanRead;
}
}
public override bool CanSeek {
get {
if (IsStreamClosed())
return false;
return m_stream.CanSeek;
}
}
public override bool CanWrite {
get {
if (IsStreamClosed())
return false;
return m_stream.CanWrite;
}
}
public override long Length {
get {
ThrowIfStreamClosed("get_Length");
ThrowIfStreamCannotSeek("get_Length");
return m_stream.Length;
}
}
public override long Position {
get {
ThrowIfStreamClosed("get_Position");
ThrowIfStreamCannotSeek("get_Position");
return m_lPosition;
}
set {
ThrowIfStreamClosed("set_Position");
ThrowIfStreamCannotSeek("set_Position");
if (value < 0 || value > m_stream.Length)
throw new ArgumentOutOfRangeException("value");
else
m_lPosition = value;
}
}
// -------------------------------------------------------------
// Public methods
// -------------------------------------------------------------
public override long Seek(long offset, SeekOrigin origin) {
long lPosition = 0;
ThrowIfStreamClosed("Seek");
ThrowIfStreamCannotSeek("Seek");
switch(origin) {
case SeekOrigin.Begin:
if (offset < 0 || offset > m_stream.Length)
throw new ArgumentOutOfRangeException("offset");
m_lPosition = offset;
break;
case SeekOrigin.Current:
lPosition = m_lPosition + offset;
if (lPosition < 0 || lPosition > m_stream.Length)
throw new ArgumentOutOfRangeException("offset");
m_lPosition = lPosition;
break;
case SeekOrigin.End:
lPosition = m_stream.Length + offset;
if (lPosition < 0 || lPosition > m_stream.Length)
throw new ArgumentOutOfRangeException("offset");
m_lPosition = lPosition;
break;
default:
throw ADP.InvalidSeekOrigin("offset");
}
return m_lPosition;
}
public override int Read(byte[] buffer, int offset, int count) {
ThrowIfStreamClosed("Read");
ThrowIfStreamCannotRead("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");
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
int iBytesRead = (int) m_stream.Read(buffer, offset, count);
m_lPosition += iBytesRead;
return iBytesRead;
}
public override void Write(byte[] buffer, int offset, int count) {
ThrowIfStreamClosed("Write");
ThrowIfStreamCannotWrite("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");
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
m_stream.Write(buffer, offset, count);
m_lPosition += count;
}
public override int ReadByte() {
ThrowIfStreamClosed("ReadByte");
ThrowIfStreamCannotRead("ReadByte");
// If at the end of stream, return -1, rather than call ReadByte,
// which will throw exception. This is the behavior for Stream.
//
if (m_stream.CanSeek && m_lPosition >= m_stream.Length)
return -1;
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
int ret = m_stream.ReadByte();
m_lPosition ++;
return ret;
}
public override void WriteByte(byte value) {
ThrowIfStreamClosed("WriteByte");
ThrowIfStreamCannotWrite("WriteByte");
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
m_stream.WriteByte(value);
m_lPosition ++;
}
public override void SetLength(long value) {
ThrowIfStreamClosed("SetLength");
ThrowIfStreamCannotSeek("SetLength");
m_stream.SetLength(value);
if (m_lPosition > value)
m_lPosition = value;
}
public override void Flush() {
if (m_stream != null)
m_stream.Flush();
}
protected override void Dispose(bool disposing) {
try {
// does not close the underline stream but mark itself as closed
m_isClosed = true;
}
finally {
base.Dispose(disposing);
}
}
private void ThrowIfStreamCannotSeek(string method) {
if (!m_stream.CanSeek)
throw new NotSupportedException(SQLResource.InvalidOpStreamNonSeekable(method));
}
private void ThrowIfStreamCannotRead(string method) {
if (!m_stream.CanRead)
throw new NotSupportedException(SQLResource.InvalidOpStreamNonReadable(method));
}
private void ThrowIfStreamCannotWrite(string method) {
if (!m_stream.CanWrite)
throw new NotSupportedException(SQLResource.InvalidOpStreamNonWritable(method));
}
private void ThrowIfStreamClosed(string method) {
if (IsStreamClosed())
throw new ObjectDisposedException(SQLResource.InvalidOpStreamClosed(method));
}
private bool IsStreamClosed() {
// Check the .CanRead and .CanWrite and .CanSeek properties to make sure stream is really closed
if (m_isClosed || m_stream == null || (!m_stream.CanRead && !m_stream.CanWrite && !m_stream.CanSeek))
return true;
else
return false;
}
} // class SqlXmlStreamWrapper
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
// [....]
//-----------------------------------------------------------------------------
//*************************************************************************
// Copyright (c) 1988-2000 Microsoft Corporation.
//
// @File: SqlXml.cs
//
// @Owner: junfung
// @Test: jstowe
//
// Purpose: Implementation of SqlXml which is equivalent to
// data type "xml" in SQL Server
//
// Notes:
//
// History:
//
// @EndHeader@
//*************************************************************************
using System;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Data.Common;
using System.Diagnostics;
using System.Text;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Reflection;
namespace System.Data.SqlTypes
{
[Serializable, XmlSchemaProvider("GetXsdType")]
public sealed class SqlXml: System.Data.SqlTypes.INullable, IXmlSerializable {
private bool m_fNotNull; // false if null, the default ctor (plain 0) will make it Null
private Stream m_stream;
private bool firstCreateReader;
private MethodInfo createSqlReaderMethodInfo;
private readonly static Func sqlReaderDelegate = CreateSqlReaderDelegate();
public SqlXml() {
SetNull();
}
// constructor
// construct a Null
private SqlXml(bool fNull) {
SetNull();
}
public SqlXml(XmlReader value) {
// whoever pass in the XmlReader is responsible for closing it
if (value == null) {
SetNull();
}
else {
m_fNotNull = true;
firstCreateReader = true;
m_stream = CreateMemoryStreamFromXmlReader(value);
}
}
public SqlXml(Stream value) {
// whoever pass in the stream is responsible for closing it
// similar to SqlBytes implementation
if (value == null) {
SetNull();
}
else {
firstCreateReader = true;
m_fNotNull = true;
m_stream = value;
}
}
public XmlReader CreateReader() {
if (IsNull)
throw new SqlNullValueException();
SqlXmlStreamWrapper stream = new SqlXmlStreamWrapper(m_stream);
// if it is the first time we create reader and stream does not support CanSeek, no need to reset position
if ((!firstCreateReader || stream.CanSeek) && stream.Position != 0)
stream.Seek(0, SeekOrigin.Begin);
XmlReader r = null;
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ConformanceLevel = ConformanceLevel.Fragment;
// Call internal XmlReader.CreateSqlReader from System.Xml.
// Signature: internal static XmlReader CreateSqlReader(Stream input, XmlReaderSettings settings, XmlParserContext inputContext);
// NOTE: Maintaining createSqlReaderMethodInfo private field member to preserve the serialization of the class
if (createSqlReaderMethodInfo == null)
createSqlReaderMethodInfo = typeof(System.Xml.XmlReader).GetMethod("CreateSqlReader", BindingFlags.Static | BindingFlags.NonPublic);
Debug.Assert(createSqlReaderMethodInfo != null, "MethodInfo reference for XmlReader.CreateSqlReader should not be null.");
// VSTFDevDiv #748742 - Performance regression of 30% on dataset serialization test scenario
r = sqlReaderDelegate(stream, readerSettings, null);
firstCreateReader = false;
return r;
}
// NOTE: ReflectionPermission required here for accessing the non-public internal method CreateSqlReader() of System.Xml regardless of its grant set.
[ReflectionPermission(SecurityAction.Assert, MemberAccess = true)]
private static Func CreateSqlReaderDelegate()
{
MethodInfo methodInfo = typeof(System.Xml.XmlReader).GetMethod("CreateSqlReader", BindingFlags.Static | BindingFlags.NonPublic);
return (Func)Delegate.CreateDelegate(typeof(Func), methodInfo);
}
// INullable
public bool IsNull {
get { return !m_fNotNull;}
}
public string Value {
get {
if (IsNull)
throw new SqlNullValueException();
StringWriter sw = new StringWriter((System.IFormatProvider)null);
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.CloseOutput = false; // don't close the memory stream
writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
XmlWriter ww = XmlWriter.Create(sw, writerSettings);
XmlReader reader = this.CreateReader();
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF) {
ww.WriteNode(reader, true);
}
ww.Flush();
return sw.ToString();
}
}
public static SqlXml Null {
get {
return new SqlXml(true);
}
}
private void SetNull() {
m_fNotNull = false;
m_stream = null;
firstCreateReader = true;
}
private Stream CreateMemoryStreamFromXmlReader(XmlReader reader) {
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.CloseOutput = false; // don't close the memory stream
writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
writerSettings.Encoding = Encoding.GetEncoding("utf-16");
writerSettings.OmitXmlDeclaration = true;
MemoryStream writerStream = new MemoryStream();
XmlWriter ww = XmlWriter.Create(writerStream, writerSettings);
if (reader.ReadState == ReadState.Closed)
throw new InvalidOperationException(SQLResource.ClosedXmlReaderMessage);
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF) {
ww.WriteNode(reader, true);
}
ww.Flush();
// set the stream to the beginning
writerStream.Seek(0, SeekOrigin.Begin);
return writerStream;
}
XmlSchema IXmlSerializable.GetSchema() {
return null;
}
void IXmlSerializable.ReadXml(XmlReader r) {
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.ReadInnerXml();
SetNull();
}
else {
m_fNotNull = true;
firstCreateReader = true;
m_stream = new MemoryStream();
StreamWriter sw = new StreamWriter(m_stream);
sw.Write(r.ReadInnerXml());
sw.Flush();
if (m_stream.CanSeek)
m_stream.Seek(0, SeekOrigin.Begin);
}
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (IsNull)
{
writer.WriteAttributeString("xsi", "nil", XmlSchema.InstanceNamespace, "true");
}
else
{
// VSTFDevDiv Bug 197567 - [SqlXml Column Read from SQL Server 2005 Fails to XML Serialize (writes raw binary)]
// Instead of the WriteRaw use the WriteNode. As Tds sends a binary stream - Create a XmlReader to convert
// get the Xml string value from the binary and call WriteNode to pass that out to the XmlWriter.
XmlReader reader = this.CreateReader();
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF)
{
writer.WriteNode(reader, true);
}
}
writer.Flush();
}
public static XmlQualifiedName GetXsdType(XmlSchemaSet schemaSet) {
return new XmlQualifiedName("anyType", XmlSchema.Namespace);
}
} // SqlXml
// two purposes for this class
// 1) keep its internal position so one reader positions on the orginial stream
// will not interface with the other
// 2) when xmlreader calls close, do not close the orginial stream
//
internal sealed class SqlXmlStreamWrapper : Stream {
// --------------------------------------------------------------
// Data members
// -------------------------------------------------------------
private Stream m_stream;
private long m_lPosition;
bool m_isClosed;
// --------------------------------------------------------------
// Constructor(s)
// --------------------------------------------------------------
internal SqlXmlStreamWrapper(Stream stream) {
m_stream = stream;
Debug.Assert(m_stream != null, "stream can not be null");
m_lPosition = 0;
m_isClosed = false;
}
// -------------------------------------------------------------
// Public properties
// --------------------------------------------------------------
// Always can read/write/seek, unless stream is null,
// which means the stream has been closed.
public override bool CanRead {
get
{
if (IsStreamClosed())
return false;
return m_stream.CanRead;
}
}
public override bool CanSeek {
get {
if (IsStreamClosed())
return false;
return m_stream.CanSeek;
}
}
public override bool CanWrite {
get {
if (IsStreamClosed())
return false;
return m_stream.CanWrite;
}
}
public override long Length {
get {
ThrowIfStreamClosed("get_Length");
ThrowIfStreamCannotSeek("get_Length");
return m_stream.Length;
}
}
public override long Position {
get {
ThrowIfStreamClosed("get_Position");
ThrowIfStreamCannotSeek("get_Position");
return m_lPosition;
}
set {
ThrowIfStreamClosed("set_Position");
ThrowIfStreamCannotSeek("set_Position");
if (value < 0 || value > m_stream.Length)
throw new ArgumentOutOfRangeException("value");
else
m_lPosition = value;
}
}
// -------------------------------------------------------------
// Public methods
// -------------------------------------------------------------
public override long Seek(long offset, SeekOrigin origin) {
long lPosition = 0;
ThrowIfStreamClosed("Seek");
ThrowIfStreamCannotSeek("Seek");
switch(origin) {
case SeekOrigin.Begin:
if (offset < 0 || offset > m_stream.Length)
throw new ArgumentOutOfRangeException("offset");
m_lPosition = offset;
break;
case SeekOrigin.Current:
lPosition = m_lPosition + offset;
if (lPosition < 0 || lPosition > m_stream.Length)
throw new ArgumentOutOfRangeException("offset");
m_lPosition = lPosition;
break;
case SeekOrigin.End:
lPosition = m_stream.Length + offset;
if (lPosition < 0 || lPosition > m_stream.Length)
throw new ArgumentOutOfRangeException("offset");
m_lPosition = lPosition;
break;
default:
throw ADP.InvalidSeekOrigin("offset");
}
return m_lPosition;
}
public override int Read(byte[] buffer, int offset, int count) {
ThrowIfStreamClosed("Read");
ThrowIfStreamCannotRead("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");
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
int iBytesRead = (int) m_stream.Read(buffer, offset, count);
m_lPosition += iBytesRead;
return iBytesRead;
}
public override void Write(byte[] buffer, int offset, int count) {
ThrowIfStreamClosed("Write");
ThrowIfStreamCannotWrite("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");
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
m_stream.Write(buffer, offset, count);
m_lPosition += count;
}
public override int ReadByte() {
ThrowIfStreamClosed("ReadByte");
ThrowIfStreamCannotRead("ReadByte");
// If at the end of stream, return -1, rather than call ReadByte,
// which will throw exception. This is the behavior for Stream.
//
if (m_stream.CanSeek && m_lPosition >= m_stream.Length)
return -1;
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
int ret = m_stream.ReadByte();
m_lPosition ++;
return ret;
}
public override void WriteByte(byte value) {
ThrowIfStreamClosed("WriteByte");
ThrowIfStreamCannotWrite("WriteByte");
if (m_stream.CanSeek && m_stream.Position != m_lPosition)
m_stream.Seek(m_lPosition, SeekOrigin.Begin);
m_stream.WriteByte(value);
m_lPosition ++;
}
public override void SetLength(long value) {
ThrowIfStreamClosed("SetLength");
ThrowIfStreamCannotSeek("SetLength");
m_stream.SetLength(value);
if (m_lPosition > value)
m_lPosition = value;
}
public override void Flush() {
if (m_stream != null)
m_stream.Flush();
}
protected override void Dispose(bool disposing) {
try {
// does not close the underline stream but mark itself as closed
m_isClosed = true;
}
finally {
base.Dispose(disposing);
}
}
private void ThrowIfStreamCannotSeek(string method) {
if (!m_stream.CanSeek)
throw new NotSupportedException(SQLResource.InvalidOpStreamNonSeekable(method));
}
private void ThrowIfStreamCannotRead(string method) {
if (!m_stream.CanRead)
throw new NotSupportedException(SQLResource.InvalidOpStreamNonReadable(method));
}
private void ThrowIfStreamCannotWrite(string method) {
if (!m_stream.CanWrite)
throw new NotSupportedException(SQLResource.InvalidOpStreamNonWritable(method));
}
private void ThrowIfStreamClosed(string method) {
if (IsStreamClosed())
throw new ObjectDisposedException(SQLResource.InvalidOpStreamClosed(method));
}
private bool IsStreamClosed() {
// Check the .CanRead and .CanWrite and .CanSeek properties to make sure stream is really closed
if (m_isClosed || m_stream == null || (!m_stream.CanRead && !m_stream.CanWrite && !m_stream.CanSeek))
return true;
else
return false;
}
} // class SqlXmlStreamWrapper
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ClientTargetSection.cs
- CursorConverter.cs
- FilteredAttributeCollection.cs
- TreeNode.cs
- WebSysDefaultValueAttribute.cs
- DesignerRegion.cs
- FocusManager.cs
- StreamWithDictionary.cs
- WithStatement.cs
- InputManager.cs
- ZipPackagePart.cs
- BuildProvider.cs
- DockPanel.cs
- DockEditor.cs
- SoapAttributes.cs
- IssuerInformation.cs
- SwitchAttribute.cs
- HtmlInputHidden.cs
- XmlExpressionDumper.cs
- BaseValidator.cs
- DebugView.cs
- MultipartIdentifier.cs
- Error.cs
- SecurityDescriptor.cs
- MetadataStore.cs
- HtmlHistory.cs
- Visual3D.cs
- Utilities.cs
- MetadataItemEmitter.cs
- DrawListViewSubItemEventArgs.cs
- OpenTypeCommon.cs
- DataTable.cs
- bindurihelper.cs
- DataSourceControl.cs
- ToolStripKeyboardHandlingService.cs
- ExistsInCollection.cs
- EntityDesignerBuildProvider.cs
- StringCollectionMarkupSerializer.cs
- HtmlAnchor.cs
- SamlDelegatingWriter.cs
- DataServiceProviderMethods.cs
- WebHttpDispatchOperationSelector.cs
- Grant.cs
- Certificate.cs
- RegexCompiler.cs
- SweepDirectionValidation.cs
- ResourceReader.cs
- SignedXml.cs
- FixedSOMPageConstructor.cs
- InternalEnumValidator.cs
- WebUtil.cs
- Enum.cs
- TableProviderWrapper.cs
- BoundingRectTracker.cs
- Point4DValueSerializer.cs
- ComponentManagerBroker.cs
- RTLAwareMessageBox.cs
- SplitterEvent.cs
- Stack.cs
- InkCanvasInnerCanvas.cs
- SqlDataSourceCommandEventArgs.cs
- UserControl.cs
- Lease.cs
- SrgsElementList.cs
- BindingNavigator.cs
- VoiceChangeEventArgs.cs
- SqlWriter.cs
- DesignTimeXamlWriter.cs
- WebPartConnectionCollection.cs
- UpWmlPageAdapter.cs
- SystemInformation.cs
- Point3DAnimationBase.cs
- OpacityConverter.cs
- DataGridItemCollection.cs
- DataGridAutomationPeer.cs
- TransformGroup.cs
- ReflectionServiceProvider.cs
- DirectoryObjectSecurity.cs
- TreeIterators.cs
- DataGrid.cs
- SmiRecordBuffer.cs
- WebPartEventArgs.cs
- LocalizationComments.cs
- CacheHelper.cs
- CompilationRelaxations.cs
- ResourceCategoryAttribute.cs
- Label.cs
- SemaphoreSlim.cs
- ItemsPanelTemplate.cs
- DynamicResourceExtension.cs
- DataSvcMapFile.cs
- NavigationService.cs
- IntSecurity.cs
- IgnoreSection.cs
- Cursors.cs
- ContentType.cs
- AspNetSynchronizationContext.cs
- Range.cs
- IdentityModelDictionary.cs
- RadioButtonAutomationPeer.cs