Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

207 lines
8.2 KiB
C#

//----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System;
using System.IO;
using System.Runtime;
using System.ServiceModel;
using System.Xml;
using DiagnosticUtility = System.ServiceModel.DiagnosticUtility;
public abstract class StreamBodyWriter : BodyWriter
{
// if isQuirkedTo40Behavior = true, does not try to write out <Binary> tags
// this maintains compatibility for 4.0 implementers of a derived StreamBodyWriter if they
// depended on behaviour where StreamBodyWriter isn't ByteStreamEncoder aware.
// e.g., if they wrote their own <Binary> tags and relied on StreamBodyWriter to only write out the body.
//
// if isQuirkedTo40Behavior = false, XmlWriterBackedStream will write out <Binary> tags (default in 4.5)
readonly bool isQuirkedTo40Behavior;
// externally accessible constructor quirked:
// if version < 4.5, XmlWriterBackedStream does not try to write out <Binary> tags
// if version >= 4.5, XmlWriterBackedStream will write out <Binary> tags
protected StreamBodyWriter(bool isBuffered)
: this(isBuffered, !OSEnvironmentHelper.IsApplicationTargeting45)
{ }
// internally accessible constructor allows derived types to determine whether StreamBodyWriter should be ByteStream aware
// internal implementations SHOULD use isQuirkedTo40Behavior = false.
internal StreamBodyWriter(bool isBuffered, bool isQuirkedTo40Behavior)
: base(isBuffered)
{
this.isQuirkedTo40Behavior = isQuirkedTo40Behavior;
}
internal static StreamBodyWriter CreateStreamBodyWriter(Action<Stream> streamAction)
{
if (streamAction == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actionOfStream");
}
return new ActionOfStreamBodyWriter(streamAction);
}
protected abstract void OnWriteBodyContents(Stream stream);
protected override BodyWriter OnCreateBufferedCopy(int maxBufferSize)
{
using (BufferManagerOutputStream bufferedStream = new BufferManagerOutputStream(SR2.MaxReceivedMessageSizeExceeded, maxBufferSize))
{
this.OnWriteBodyContents(bufferedStream);
int size;
byte[] bytesArray = bufferedStream.ToArray(out size);
return new BufferedBytesStreamBodyWriter(bytesArray, size);
}
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
using (XmlWriterBackedStream stream = new XmlWriterBackedStream(writer, this.isQuirkedTo40Behavior))
{
OnWriteBodyContents(stream);
}
}
class XmlWriterBackedStream : Stream
{
private const string StreamElementName = "Binary";
private readonly bool isQuirkedTo40Behavior;
XmlWriter writer;
public XmlWriterBackedStream(XmlWriter writer, bool isQuirkedTo40Behavior)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
this.writer = writer;
this.isQuirkedTo40Behavior = isQuirkedTo40Behavior;
}
public override bool CanRead
{
get { return false; }
}
public override bool CanSeek
{
get { return false; }
}
public override bool CanWrite
{
get { return true; }
}
public override void Flush()
{
this.writer.Flush();
}
public override long Length
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamPropertyGetNotSupported, "Length")));
}
}
public override long Position
{
get
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamPropertyGetNotSupported, "Position")));
}
set
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamPropertySetNotSupported, "Position")));
}
}
public override int Read(byte[] buffer, int offset, int count)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "Read")));
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "BeginRead")));
}
public override int EndRead(IAsyncResult asyncResult)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "EndRead")));
}
public override int ReadByte()
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "ReadByte")));
}
public override long Seek(long offset, SeekOrigin origin)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "Seek")));
}
public override void SetLength(long value)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR2.GetString(SR2.XmlWriterBackedStreamMethodNotSupported, "SetLength")));
}
public override void Write(byte[] buffer, int offset, int count)
{
if (writer.WriteState == WriteState.Content || this.isQuirkedTo40Behavior)
{
// if isQuirkedTo40Behavior == true, maintains compatibility for 4.0 implementers of a derived StreamBodyWriter
// if they depended on behaviour without state checks, e.g., if they wrote their own <Binary> tags
this.writer.WriteBase64(buffer, offset, count);
}
else if (writer.WriteState == WriteState.Start)
{
writer.WriteStartElement(StreamElementName, string.Empty);
this.writer.WriteBase64(buffer, offset, count);
}
}
}
class BufferedBytesStreamBodyWriter : StreamBodyWriter
{
byte[] array;
int size;
public BufferedBytesStreamBodyWriter(byte[] array, int size)
: base(true, false)
{
this.array = array;
this.size = size;
}
protected override void OnWriteBodyContents(Stream stream)
{
stream.Write(this.array, 0, this.size);
}
}
class ActionOfStreamBodyWriter : StreamBodyWriter
{
Action<Stream> actionOfStream;
public ActionOfStreamBodyWriter(Action<Stream> actionOfStream)
: base(false, false)
{
this.actionOfStream = actionOfStream;
}
protected override void OnWriteBodyContents(Stream stream)
{
actionOfStream(stream);
}
}
}
}