Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.ServiceModel/System/ServiceModel/Channels/BodyWriter.cs

@@ -0,0 +1,176 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+namespace System.ServiceModel.Channels
+{
+    using System.Xml;
+    using System.Diagnostics;
+    using System.Runtime;
+    using System.Threading;
+
+    public abstract class BodyWriter
+    {
+        bool isBuffered;
+        bool canWrite;
+        object thisLock;
+
+        protected BodyWriter(bool isBuffered)
+        {
+            this.isBuffered = isBuffered;
+            this.canWrite = true;
+            if (!this.isBuffered)
+            {
+                this.thisLock = new object();
+            }
+        }
+
+        public bool IsBuffered
+        {
+            get { return this.isBuffered; }
+        }
+
+        internal virtual bool IsEmpty
+        {
+            get { return false; }
+        }
+
+        internal virtual bool IsFault
+        {
+            get { return false; }
+        }
+
+        public BodyWriter CreateBufferedCopy(int maxBufferSize)
+        {
+            if (maxBufferSize < 0)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxBufferSize", maxBufferSize,
+                                                    SR.GetString(SR.ValueMustBeNonNegative)));
+            if (this.isBuffered)
+            {
+                return this;
+            }
+            else
+            {
+                lock (this.thisLock)
+                {
+                    if (!this.canWrite)
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BodyWriterCanOnlyBeWrittenOnce)));
+                    this.canWrite = false;
+                }
+                BodyWriter bodyWriter = OnCreateBufferedCopy(maxBufferSize);
+                if (!bodyWriter.IsBuffered)
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BodyWriterReturnedIsNotBuffered)));
+                return bodyWriter;
+            }
+        }
+
+        protected virtual BodyWriter OnCreateBufferedCopy(int maxBufferSize)
+        {
+            return OnCreateBufferedCopy(maxBufferSize, XmlDictionaryReaderQuotas.Max);
+        }
+
+        internal BodyWriter OnCreateBufferedCopy(int maxBufferSize, XmlDictionaryReaderQuotas quotas)
+        {
+            XmlBuffer buffer = new XmlBuffer(maxBufferSize);
+            using (XmlDictionaryWriter writer = buffer.OpenSection(quotas))
+            {
+                writer.WriteStartElement("a");
+                OnWriteBodyContents(writer);
+                writer.WriteEndElement();
+            }
+            buffer.CloseSection();
+            buffer.Close();
+            return new BufferedBodyWriter(buffer);
+        }
+
+        protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer);
+
+        protected virtual IAsyncResult OnBeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, object state)
+        {
+            return new OnWriteBodyContentsAsyncResult(writer, this, callback, state);
+        }
+
+        protected virtual void OnEndWriteBodyContents(IAsyncResult result)
+        {
+            OnWriteBodyContentsAsyncResult.End(result);
+        }
+
+        void EnsureWriteBodyContentsState(XmlDictionaryWriter writer)
+        {
+            if (writer == null)
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
+            if (!this.isBuffered)
+            {
+                lock (this.thisLock)
+                {
+                    if (!this.canWrite)
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BodyWriterCanOnlyBeWrittenOnce)));
+                    this.canWrite = false;
+                }
+            }
+        }
+
+        public void WriteBodyContents(XmlDictionaryWriter writer)
+        {
+            EnsureWriteBodyContentsState(writer);
+            OnWriteBodyContents(writer);
+        }
+
+        public IAsyncResult BeginWriteBodyContents(XmlDictionaryWriter writer, AsyncCallback callback, object state)
+        {
+            EnsureWriteBodyContentsState(writer);
+            return OnBeginWriteBodyContents(writer, callback, state);
+        }
+
+        public void EndWriteBodyContents(IAsyncResult result)
+        {
+            OnEndWriteBodyContents(result);
+        }
+
+        class BufferedBodyWriter : BodyWriter
+        {
+            XmlBuffer buffer;
+
+            public BufferedBodyWriter(XmlBuffer buffer)
+                : base(true)
+            {
+                this.buffer = buffer;
+            }
+
+            protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
+            {
+                XmlDictionaryReader reader = this.buffer.GetReader(0);
+                using (reader)
+                {
+                    reader.ReadStartElement();
+                    while (reader.NodeType != XmlNodeType.EndElement)
+                    {
+                        writer.WriteNode(reader, false);
+                    }
+                    reader.ReadEndElement();
+                }
+            }
+        }
+
+        class OnWriteBodyContentsAsyncResult : ScheduleActionItemAsyncResult
+        {
+            BodyWriter bodyWriter;
+            XmlDictionaryWriter writer;
+
+            public OnWriteBodyContentsAsyncResult(XmlDictionaryWriter writer, BodyWriter bodyWriter, AsyncCallback callback, object state)
+                : base(callback, state)
+            {
+                Fx.Assert(bodyWriter != null, "bodyWriter should never be null");
+
+                this.writer = writer;
+                this.bodyWriter = bodyWriter;
+
+                Schedule();
+            }
+
+            protected override void OnDoWork()
+            {
+                this.bodyWriter.OnWriteBodyContents(this.writer);
+            }
+        }
+    }
+}