TryGetBuffer() public method

public TryGetBuffer ( ArraySegment &buffer ) : bool
buffer ArraySegment
return bool
    public static void TryGetBuffer_Constructor_ByteArray_Bool_AlwaysReturnsFalse()
    {
        var stream = new MemoryStream(new byte[512], writable: true);

        ArraySegment<byte> segment;
        Assert.False(stream.TryGetBuffer(out segment));
    }
    public static void TryGetBuffer_Constructor_ByteArray_Int32_Int32_AlwaysReturnsFalse()
    {
        var stream = new MemoryStream(new byte[512], index: 0, count: 512);

        ArraySegment<byte> segment;
        Assert.False(stream.TryGetBuffer(out segment));
    }
Example #3
0
        private async Task TestReader(string input, string[] expected)
        {
            var stream = new MemoryStream(Encoding.UTF8.GetBytes(input));
            var reader = new ReceiveMessageReader(stream);
            var messages = await reader.ReadMessages();
            Assert.Equal(expected.Length, messages.Count);
            // this is a small buffer to test overflow
            byte[] buffer = new byte[10];
            for (int i = 0; i < expected.Length; i++)
            {
                var decodedStream = new MemoryStream();
                do
                {
                    int length = messages[i].Decode(new ArraySegment<byte>(buffer, 0, buffer.Length));
                    decodedStream.Write(buffer, 0, length);
                } while (!messages[i].IsEmpty);
#if NET451
                ArraySegment<byte> streamBuffer = new ArraySegment<byte>(decodedStream.GetBuffer(), 0, (int)decodedStream.Length);
#else
                ArraySegment<byte> streamBuffer;
                decodedStream.TryGetBuffer(out streamBuffer);
#endif
                var s = Encoding.UTF8.GetString(streamBuffer.Array, streamBuffer.Offset, streamBuffer.Count);
                Assert.Equal(expected[i], s);
            }
        }
    public static void TryGetBuffer_Constructor_ByteArray_Int32_Int32_Bool_Bool_FalseAsPubliclyVisible_ReturnsFalse()
    {
        var stream = new MemoryStream(new byte[512], index: 0, count: 512, writable: true, publiclyVisible: false);

        ArraySegment<byte> segment;
        Assert.False(stream.TryGetBuffer(out segment));
    }
        public static byte[] GetBuffer(this MemoryStream stream)
        {
            ArraySegment <byte> result;

            if (!stream.TryGetBuffer(out result))
            {
                throw new InvalidOperationException("Buffer not available.");
            }
            return(result.Array);
        }
Example #6
0
            public static byte[] GetBuffer(this MemoryStream ms)
            {
                ArraySegment <byte> tmp;

                if (!ms.TryGetBuffer(out tmp))
                {
                    throw new InvalidOperationException("Unable to get buffer");
                }
                return(tmp.Array);
            }
    public static void TryGetBuffer_Constructor_AlwaysReturnsTrue()
    {
        var stream = new MemoryStream();

        ArraySegment<byte> segment;
        Assert.True(stream.TryGetBuffer(out segment));

        Assert.NotNull(segment.Array);
        Assert.Equal(0, segment.Offset);
        Assert.Equal(0, segment.Count);
    }
    public static void TryGetBuffer_Constructor_Int32_AlwaysReturnsTrue()
    {
        var stream = new MemoryStream(512);

        ArraySegment<byte> segment;
        Assert.True(stream.TryGetBuffer(out segment));

        Assert.Equal(512, segment.Array.Length);
        Assert.Equal(0, segment.Offset);
        Assert.Equal(0, segment.Count);
    }
Example #9
0
        private static bool CanApplyReadMemoryStreamOptimization(Stream stream)
        {
            MemoryStream memStream = stream as MemoryStream;

            if (memStream == null)
            {
                return(false);
            }

            ArraySegment <byte> arrSeg;

            return(memStream.TryGetBuffer(out arrSeg));
        }
Example #10
0
        private static byte[] MemoryStreamToArrayFast(MemoryStream memoryStream)
        {
            // Use the internal buffer when it has the correct length. Otherwise, use .ToArray() which creates a copy of the buffer.

            byte[] buffer = null;
            ArraySegment<byte> bufferSegment;
            if (memoryStream.TryGetBuffer(out bufferSegment))
            {
                buffer = bufferSegment.Array;
            }
            if (buffer == null || buffer.Length != memoryStream.Length)
            {
                buffer = memoryStream.ToArray();
            }
            return buffer;
        }
Example #11
0
        public async Task<List<JsonString>> ReadMessages()
        {
            var messages = new List<JsonString>();
            using (var memoryStream = new MemoryStream())
            {
                await _body.CopyToAsync(memoryStream);
#if NET451
                var buffer = memoryStream.GetBuffer();
#else
                ArraySegment<byte> segment;
                memoryStream.TryGetBuffer(out segment);
                var buffer = segment.Array;
#endif
                if (buffer.Length == 0)
                {
                    throw new Exception("Payload expected.");
                }
                bool inString = false;
                int startIndex = 0;
                for (int i = 0; i < buffer.Length; i++)
                {
                    byte b = buffer[i];
                    if (!inString && b == (byte)'\"')
                    {
                        inString = true;
                        startIndex = i + 1;
                    }
                    else if (inString && b == (byte)'\\')
                    {
                        i++; // next character is escaped, ignore it
                    }
                    else if (inString && b == (byte)'\"')
                    {
                        inString = false;
                        messages.Add(new JsonString(buffer, startIndex, i));
                    }
                }
                if (inString)
                {
                    throw new Exception("Broken JSON encoding.");
                }
            }
            return messages;
        }
Example #12
0
        /// <summary>
        ///     Creates a sample stream from an MP3, MP2, MP1, OGG, WAV, AIFF or plug-in supported memory stream.
        /// </summary>
        /// <param name="stream">Memory stream.</param>
        /// <param name="configs">Configure of <see cref="AudioFileStream" />.</param>
        public AudioFileStream(MemoryStream stream, StreamCreateFileConfig configs)
        {
            ArraySegment<byte> bufferSegment;
            byte[] buffer = null;
            if (stream.TryGetBuffer(out bufferSegment))
            {
                buffer = bufferSegment.Array;
            }
            else
            {
                buffer = stream.ToArray();
            }

            GCHandle bufferHandle = GCHandle.Alloc(buffer);

            Handle = AudioStreamModule.StreamCreateFileFunction.CheckResult(
                AudioStreamModule.StreamCreateFileFunction.Delegate(true,
                    bufferHandle.AddrOfPinnedObject(), 0, (uint) stream.Length, configs));

            bufferHandle.Free();
        }
    public static void TryGetBuffer_Constructor_ByteArray_AlwaysReturnsEmptyArraySegment(byte[] array)
    {
        var stream = new MemoryStream(array);

        ArraySegment<byte> result;
        Assert.False(stream.TryGetBuffer(out result));

        // publiclyVisible = false;
        Assert.True(default(ArraySegment<byte>).Equals(result));
    }
    public static void TryGetBuffer_Constructor_ByteArray_Int32_Int32_Bool_Bool_TrueAsPubliclyVisible_ReturnsTrue()
    {
        var stream = new MemoryStream(new byte[512], index: 0, count: 512, writable: true, publiclyVisible: true);

        ArraySegment<byte> segment;
        Assert.True(stream.TryGetBuffer(out segment));

        Assert.NotNull(segment.Array);
        Assert.Equal(512, segment.Array.Length);
        Assert.Equal(0, segment.Offset);
        Assert.Equal(512, segment.Count);
    }
        public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
        {
            ArraySegment<byte> messageBuffer;
            int messageLength;
            using (MemoryStream stream = new MemoryStream())
            {
                using (XmlWriter writer = XmlWriter.Create(stream, _writerSettings))
                {
                    message.WriteMessage(writer);
                }

                stream.TryGetBuffer(out messageBuffer);
                messageLength = (int)stream.Position;
            }

            int totalLength = messageLength + messageOffset;
            byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
            Array.Copy(messageBuffer.Array, 0, totalBytes, messageOffset, messageLength);

            ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
            return byteArray;
        }
    public static void TryGetBuffer_Constructor_ByteArray_Int32_Int32_Bool_Bool_FalseAsPubliclyVisible_ReturnsEmptyArraySegment(ArraySegment<byte> array)
    {
        var stream = new MemoryStream(array.Array, index: array.Offset, count: array.Count, writable: true, publiclyVisible: false);

        ArraySegment<byte> result;
        Assert.False(stream.TryGetBuffer(out result));

        // publiclyVisible = false;
        Assert.True(default(ArraySegment<byte>).Equals(result));
    }
        protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest)
        {
            try
            {
                XmlSerializer serializer;
                MessageHeaderDescriptionTable headerDescriptionTable;
                MessageHeaderDescription unknownHeaderDescription;
                if (isRequest)
                {
                    serializer = _requestMessageInfo.HeaderSerializer;
                    headerDescriptionTable = _requestMessageInfo.HeaderDescriptionTable;
                    unknownHeaderDescription = _requestMessageInfo.UnknownHeaderDescription;
                }
                else
                {
                    serializer = _replyMessageInfo.HeaderSerializer;
                    headerDescriptionTable = _replyMessageInfo.HeaderDescriptionTable;
                    unknownHeaderDescription = _replyMessageInfo.UnknownHeaderDescription;
                }
                MessageHeaders headers = message.Headers;
                ArrayList unknownHeaders = null;
                XmlDocument xmlDoc = null;
                if (unknownHeaderDescription != null)
                {
                    unknownHeaders = new ArrayList();
                    xmlDoc = new XmlDocument();
                }
                if (serializer == null)
                {
                    if (unknownHeaderDescription != null)
                    {
                        for (int headerIndex = 0; headerIndex < headers.Count; headerIndex++)
                            AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, null/*bufferWriter*/, headers[headerIndex], headers.GetReaderAtHeader(headerIndex));
                        parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader<XmlElement>) : typeof(XmlElement));
                    }
                    return;
                }


                MemoryStream memoryStream = new MemoryStream();
                XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream);
                message.WriteStartEnvelope(bufferWriter);
                message.WriteStartHeaders(bufferWriter);
                MessageHeaderOfTHelper messageHeaderOfTHelper = null;
                for (int headerIndex = 0; headerIndex < headers.Count; headerIndex++)
                {
                    MessageHeaderInfo header = headers[headerIndex];
                    XmlDictionaryReader headerReader = headers.GetReaderAtHeader(headerIndex);
                    MessageHeaderDescription matchingHeaderDescription = headerDescriptionTable.Get(header.Name, header.Namespace);
                    if (matchingHeaderDescription != null)
                    {
                        if (header.MustUnderstand)
                            headers.UnderstoodHeaders.Add(header);
                        if (matchingHeaderDescription.TypedHeader)
                        {
                            if (messageHeaderOfTHelper == null)
                                messageHeaderOfTHelper = new MessageHeaderOfTHelper(parameters.Length);
                            messageHeaderOfTHelper.SetHeaderAttributes(matchingHeaderDescription, header.MustUnderstand, header.Relay, header.Actor);
                        }
                    }
                    if (matchingHeaderDescription == null && unknownHeaderDescription != null)
                        AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, bufferWriter, header, headerReader);
                    else
                        bufferWriter.WriteNode(headerReader, false);
                    headerReader.Dispose();
                }
                bufferWriter.WriteEndElement();
                bufferWriter.WriteEndElement();
                bufferWriter.Flush();

                /*
                XmlDocument doc = new XmlDocument();
                memoryStream.Position = 0;
                doc.Load(memoryStream);
                doc.Save(Console.Out);
                */

                memoryStream.Position = 0;
                ArraySegment<byte> memoryBuffer;
                memoryStream.TryGetBuffer(out memoryBuffer);
                XmlDictionaryReader bufferReader = XmlDictionaryReader.CreateTextReader(memoryBuffer.Array, 0, (int)memoryStream.Length, XmlDictionaryReaderQuotas.Max);

                bufferReader.ReadStartElement();
                bufferReader.MoveToContent();
                if (!bufferReader.IsEmptyElement)
                {
                    bufferReader.ReadStartElement();
                    object[] headerValues = (object[])serializer.Deserialize(bufferReader);
                    int headerIndex = 0;
                    foreach (MessageHeaderDescription headerDescription in messageDescription.Headers)
                    {
                        if (!headerDescription.IsUnknownHeaderCollection)
                        {
                            object parameterValue = headerValues[headerIndex++];
                            if (headerDescription.TypedHeader && parameterValue != null)
                                parameterValue = messageHeaderOfTHelper.CreateMessageHeader(headerDescription, parameterValue);
                            parameters[headerDescription.Index] = parameterValue;
                        }
                    }
                    bufferReader.Dispose();
                }
                if (unknownHeaderDescription != null)
                    parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader<XmlElement>) : typeof(XmlElement));
            }
            catch (InvalidOperationException e)
            {
                // all exceptions from XmlSerializer get wrapped in InvalidOperationException,
                // so we must be conservative and never turn this into a fault
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
                    SR.Format(SR.SFxErrorDeserializingHeader, messageDescription.MessageName), e));
            }
        }
    public static void TryGetBuffer_Constructor_Int32_WhenWritingPastCapacity_ReturnsDifferentArrays()
    {
        var stream = new MemoryStream(512);

        ArraySegment<byte> result1;
        Assert.True(stream.TryGetBuffer(out result1));

        // Force the stream to resize the underlying array
        stream.Write(new byte[1024], 0, 1024);

        ArraySegment<byte> result2;
        Assert.True(stream.TryGetBuffer(out result2));

        Assert.NotSame(result1.Array, result2.Array);
    }
    public static void TryGetBuffer_Constructor_Int32_MultipleCallsReturnSameArray()
    {
        var stream = new MemoryStream(512);

        ArraySegment<byte> result1;
        ArraySegment<byte> result2;
        Assert.True(stream.TryGetBuffer(out result1));
        Assert.True(stream.TryGetBuffer(out result2));

        Assert.Same(result1.Array, result2.Array);
    }
        private async Task ExtractFilesFromArchive(Stream strm)
        {
            var arch = ArchiveFactory.Open(strm);
            foreach (var entry in arch.Entries)
            {
                if (!entry.IsDirectory)
                {
                    using (var ms = new MemoryStream())
                    {
                        try
                        {
                            entry.WriteTo(ms);
                        }
                        catch (Exception ex) { }
                        ms.Seek(0, SeekOrigin.Begin);
                        var buffer = new ArraySegment<byte>();
                        ms.TryGetBuffer(out buffer);

                        Files.Add(new FileEntry(entry.Key, buffer.Array));
                    }
                }
            }
            
        }
Example #21
0
        /// <summary>
        ///     Create a sample form a  WAV, AIFF, MP3, MP2, MP1, OGG or plug-in supported file sample stream.
        /// </summary>
        /// <param name="stream">A .NET memory stream. </param>
        /// <param name="max">
        ///     Maximum number of simultaneous playbacks... 1 (min) - 65535 (max)... use one of the
        ///     SampleConfig.OverXX flags to choose the override decider, in the case of there being no free channel available for
        ///     playback (ie. the sample is already playing max times).
        /// </param>
        /// <param name="config">Some configures of sample.</param>
        public AudioSample(MemoryStream stream, uint max, SampleLoadConfig config) : this()
        {
            ArraySegment<byte> bufferSegment;
            byte[] buffer = null;
            if (stream.TryGetBuffer(out bufferSegment))
            {
                buffer = bufferSegment.Array;
            }
            else
            {
                buffer = stream.ToArray();
            }

            GCHandle bufferHandle = GCHandle.Alloc(buffer);

            Handle = AudioSampleModule.SampleLoadFunction.CheckResult(
                AudioSampleModule.SampleLoadFunction.Delegate(true, bufferHandle.AddrOfPinnedObject(), 0,
                    (uint) stream.Length, max, config));

            bufferHandle.Free();
        }
    public static void TryGetBuffer_Constructor_Int32_ReturnsCountSetToWrittenLength(byte[] array)
    {
        var stream = new MemoryStream(512);
        stream.Write(array, 0, array.Length);

        ArraySegment<byte> result;
        Assert.True(stream.TryGetBuffer(out result));

        Assert.Equal(array.Length, result.Count);
    }
    public static void TryGetBuffer_Constructor_Int32_ByDefaultReturnsCountSetToZero()
    {
        var stream = new MemoryStream(512);

        ArraySegment<byte> result;
        Assert.True(stream.TryGetBuffer(out result));

        Assert.Equal(0, result.Offset);
    }
    public static void TryGetBuffer_Constructor_AlwaysReturnsOffsetSetToZero()
    {
        var stream = new MemoryStream();

        ArraySegment<byte> result;
        Assert.True(stream.TryGetBuffer(out result));

        Assert.Equal(0, result.Offset);

    }
    public static void TryGetBuffer_Constructor_ByteArray_Int32_Int32_Bool_Bool_ValueAsBufferAndTrueAsPubliclyVisible_AlwaysReturnsArraySetToBuffer(ArraySegment<byte> array)
    {
        var stream = new MemoryStream(array.Array, index: array.Offset, count: array.Count, writable: true, publiclyVisible: true);

        ArraySegment<byte> result;
        Assert.True(stream.TryGetBuffer(out result));

        Assert.Same(array.Array, result.Array);
    }
Example #26
0
    public static void CustomTextMessageEncoder_Http_RequestReply_Streamed()
    {
        // 84K, larger than any buffers, but won't allocate in LOH
        int streamKBytes = 84;
        int streamLength = 1024 * streamKBytes;
        int lowestPrintable = ' ';
        int printableRange = '~' - lowestPrintable;
        ChannelFactory<IWcfService> factory = null;
        IWcfService serviceProxy = null;
        Stream stream = null;

        try
        {
            // *** SETUP *** \\
            CustomBinding binding = new CustomBinding(new CustomTextMessageBindingElement(Encoding.UTF8.WebName),
                new HttpTransportBindingElement
                {
                    MaxReceivedMessageSize = ScenarioTestHelpers.SixtyFourMB,
                    MaxBufferSize = ScenarioTestHelpers.SixtyFourMB,
                    TransferMode = TransferMode.Streamed
                });

            factory = new ChannelFactory<IWcfService>(binding, new EndpointAddress(Endpoints.CustomTextEncoderStreamed_Address));
            serviceProxy = factory.CreateChannel();
            byte[] requestBytes = new byte[streamLength];
            RandomNumberGenerator rnd = RandomNumberGenerator.Create();
            int pos = 0;
            for (int i = 0; i < streamKBytes; i++)
            {
                byte[] tempBuffer = new byte[1024];
                rnd.GetBytes(tempBuffer);
                for (int j = 0; j < 1024; j++)
                {
                    byte val = tempBuffer[j];
                    if (val < ' ' || val > '~')
                    {
                        // Force the value to be between ' ' and '~'
                        int temp1 = val % printableRange;
                        val = (byte)(temp1 + lowestPrintable);
                    }

                    requestBytes[pos++] = val;
                }
            }
            stream = new MemoryStream(requestBytes);

            // *** EXECUTE *** \\
            var returnStream = serviceProxy.EchoStream(stream);

            // *** VALIDATE *** \\
            MemoryStream ms = new MemoryStream(streamLength);
            returnStream.CopyTo(ms);

            Assert.True(streamLength == ms.Length,
                        String.Format("Expected returned stream length = {0}, actual = {1}",
                                        streamLength, ms.Length));

            ArraySegment<byte> returnedByteArraySegment;
            ms.TryGetBuffer(out returnedByteArraySegment);
            Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes");

            // *** CLEANUP *** \\
            ((ICommunicationObject)serviceProxy).Close();
            factory.Close();
        }
        finally
        {
            // *** ENSURE CLEANUP *** \\
            ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
        }
    }
    public static void TryGetBuffer_WhenDisposed_ReturnsArraySetToBuffer(ArraySegment<byte> array)
    {
        var stream = new MemoryStream(array.Array, index: array.Offset, count: array.Count, writable: true, publiclyVisible: true);
        stream.Dispose();

        ArraySegment<byte> result;
        Assert.True(stream.TryGetBuffer(out result));

        Assert.Same(array.Array, result.Array);
    }
    public static void TryGetBuffer_Constructor_ReturnsArray()
    {
        var stream = new MemoryStream();

        ArraySegment<byte> result;
        Assert.True(stream.TryGetBuffer(out result));

        Assert.NotNull(result.Array);
    }
Example #29
0
        internal byte[] jsonSerializer(object obj)
        {
            if (obj == null)
                return null;

            var serializer = new DataContractJsonSerializer(typeof(JsonObject));

            using (MemoryStream stream = new MemoryStream())
            {
                serializer.WriteObject(stream, obj);
            #if NET45
                byte[] buffer = stream.GetBuffer();
                long len = stream.Position;
                var rv = new byte[len];
                Array.Copy(buffer, rv, (int)len);
                return rv;
            #else
                ArraySegment<byte> buffer;
                if (stream.TryGetBuffer(out buffer))
                {
                    long len = stream.Position;
                    var rv = new byte[len];
                    Array.Copy(buffer.Array, rv, (int)len);
                    return rv;
                }
                else
                {
                    throw new Exception("Unable to serialize - buffer error");
                }
            #endif
            }
        }
        /// <summary>
        /// Converts an <see cref="XElement"/> to a <see cref="Secret"/> so that it can be kept in memory
        /// securely or run through the DPAPI routines.
        /// </summary>
        public static Secret ToSecret(this XElement element)
        {
            const int DEFAULT_BUFFER_SIZE = 16 * 1024; // 16k buffer should be large enough to encrypt any realistic secret
            var memoryStream = new MemoryStream(DEFAULT_BUFFER_SIZE);
            element.Save(memoryStream);

#if !DNXCORE50
            byte[] underlyingBuffer = memoryStream.GetBuffer();
            fixed (byte* __unused__ = underlyingBuffer) // try to limit this moving around in memory while we allocate
            {
                try
                {
                    return new Secret(new ArraySegment<byte>(underlyingBuffer, 0, checked((int)memoryStream.Length)));
                }
                finally
                {
                    Array.Clear(underlyingBuffer, 0, underlyingBuffer.Length);
                }
            }
#else
            ArraySegment<byte> underlyingBuffer;
            CryptoUtil.Assert(memoryStream.TryGetBuffer(out underlyingBuffer), "Underlying buffer isn't exposable.");
            fixed (byte* __unused__ = underlyingBuffer.Array) // try to limit this moving around in memory while we allocate
            {
                try
                {
                    return new Secret(underlyingBuffer);
                }
                finally
                {
                    Array.Clear(underlyingBuffer.Array, underlyingBuffer.Offset, underlyingBuffer.Count);
                }
            }
#endif
        }
Example #31
0
        public static RuntimeTypeModel BuildMeta()
        {
            
            RuntimeTypeModel model;
#if !FX11
            model = TypeModel.Create();
            model.Add(typeof(Order), false)
                .Add(1, "OrderID")
                .Add(2, "CustomerID")
                .Add(3, "EmployeeID")
                .Add(4, "OrderDate")
                .Add(5, "RequiredDate")
                .Add(6, "ShippedDate")
                .Add(7, "ShipVia")
                .Add(8, "Freight")
                .Add(9, "ShipName")
                .Add(10, "ShipAddress")
                .Add(11, "ShipCity")
                .Add(12, "ShipRegion")
                .Add(13, "ShipPostalCode")
                .Add(14, "ShipCountry");
            model.Add(typeof(Product), false)
                .Add(1, "ProductID")
                .Add(2, "ProductName")
                .Add(3, "SupplierID")
                .Add(4, "CategoryID")
                .Add(5, "QuantityPerUnit")
                .Add(6, "UnitPrice")
                .Add(7, "UnitsInStock")
                .Add(8, "UnitsOnOrder")
                .Add(9, "ReorderLevel")
                .Add(10, "Discontinued")
                .Add(11, "LastEditDate")
                .Add(12, "CreationDate");

            TypeModel compiled = model.Compile();
            Type type = typeof(Product);
            PropertyInfo[] props = type.GetProperties();

            Product prod = new Product();
            prod.ProductID = 123;
            prod.ProductName = "abc devil";
            prod.SupplierID = 456;
            prod.CategoryID = 13;
            prod.QuantityPerUnit = "1";
            prod.UnitPrice = 12.99M;
            prod.UnitsInStock = 96;
            prod.UnitsOnOrder = 12;
            prod.ReorderLevel = 30;
            prod.Discontinued = false;
            prod.LastEditDate = new DateTime(2009, 5, 7);
            prod.CreationDate = new DateTime(2009, 1, 3);

            DumpObject("Original", props, prod);
            
            const int loop = 100000;
            Console.WriteLine("Iterations: " + loop);
            Stopwatch watch;
            MemoryStream reuseDump = new MemoryStream(100 * 1024);
#if FX30
            System.Runtime.Serialization.DataContractSerializer dcs = new System.Runtime.Serialization.DataContractSerializer(type);
            
            using (MemoryStream ms = new MemoryStream()) {
                dcs.WriteObject(ms, prod);
                Console.WriteLine("DataContractSerializer: {0} bytes", ms.Length);
            }
            
            watch = Stopwatch.StartNew();
            for (int i = 0; i < loop; i++)
            {
                reuseDump.SetLength(0);
                dcs.WriteObject(reuseDump, prod);                
            }
            watch.Stop();
            Console.WriteLine("DataContractSerializer serialize: {0} ms", watch.ElapsedMilliseconds);
            watch = Stopwatch.StartNew();
            for (int i = 0; i < loop; i++)
            {
                reuseDump.Position = 0;
                dcs.ReadObject(reuseDump);
            }
            watch.Stop();
            Console.WriteLine("DataContractSerializer deserialize: {0} ms", watch.ElapsedMilliseconds);

            {
            reuseDump.Position = 0;
            Product p1 = (Product) dcs.ReadObject(reuseDump);
            DumpObject("DataContractSerializer", props, p1);
            }

            System.Runtime.Serialization.NetDataContractSerializer ndcs = new System.Runtime.Serialization.NetDataContractSerializer();
            
            using (MemoryStream ms = new MemoryStream()) {
                ndcs.Serialize(ms, prod);
                Console.WriteLine("NetDataContractSerializer: {0} bytes", ms.Length);
            }
            
            watch = Stopwatch.StartNew();
            for (int i = 0; i < loop; i++)
            {
                reuseDump.SetLength(0);
                ndcs.Serialize(reuseDump, prod);                
            }
            watch.Stop();
            Console.WriteLine("NetDataContractSerializer serialize: {0} ms", watch.ElapsedMilliseconds);
            watch = Stopwatch.StartNew();
            for (int i = 0; i < loop; i++)
            {
                reuseDump.Position = 0;
                ndcs.Deserialize(reuseDump);
            }
            watch.Stop();
            Console.WriteLine("NetDataContractSerializer deserialize: {0} ms", watch.ElapsedMilliseconds);

            {
            reuseDump.Position = 0;
            Product p1 = (Product) ndcs.Deserialize(reuseDump);
            DumpObject("NetDataContractSerializer", props, p1);
            }
#endif

            using (MemoryStream ms = new MemoryStream())
            {
                compiled.Serialize(ms, prod);
#if COREFX
                ArraySegment<byte> tmp;
                if (!ms.TryGetBuffer(out tmp))
                    throw new Exception("oops");
                byte[] buffer = tmp.Array;
#else
                byte[] buffer = ms.GetBuffer();
#endif
                int len = (int)ms.Length;
                Console.WriteLine("protobuf-net v2: {0} bytes", len);
                for (int i = 0; i < len; i++)
                {
                    Console.Write(buffer[i].ToString("x2"));                    
                }
                Console.WriteLine();
            }
            watch = Stopwatch.StartNew();
            for (int i = 0; i < loop; i++)
            {
                reuseDump.SetLength(0);
                compiled.Serialize(reuseDump, prod);
            }
            watch.Stop();
            Console.WriteLine("protobuf-net v2 serialize: {0} ms", watch.ElapsedMilliseconds);
            
            watch = Stopwatch.StartNew();
            for (int i = 0; i < loop; i++)
            {
                reuseDump.Position = 0;
                compiled.Deserialize(reuseDump, null, type);
            }
            watch.Stop();
            
            Console.WriteLine("protobuf-net v2 deserialize: {0} ms", watch.ElapsedMilliseconds);
            {
            reuseDump.Position = 0;
            Product p1 = (Product)compiled.Deserialize(reuseDump, null, type);
            DumpObject("protobuf-net v2", props, p1);
            }

            
            // 080d 1203(616263) 207b
            // 3205(08b9601804)
            // 5000 6204(08cede01)

            // 00   08 = 1|000 = field 1, variant
            // 01   0d = 13

            // 02   12 = 10|010 = field 2, string
            // 03   03 = length 3
            // 04   616263 = "abc"

            // 07   20 = 100|000 = field 4, variant
            // 08   7B = 123

            // 09   32 = 110|010 = field 6, string
            // 10   05 = length 5
            // 11     08 = 1|000 = field 1, variant
            // 12     b960 (le) = 1100000:0111001 = 12345
            // 14     18 = 11|000 = field 3, variant
            // 15     04 = 4 (signScale = scale 2, +ve)

            // 16   50 = 1010|000 = field 10, variant
            // 17   00 = false

            // 18   62 = 1100|010 = field 12, string
            // 19   04 = length 4
            // 20    08 = 1|000 = field 1, variant
            // 21    cede01 = 1:1011110:1001110 = 28494 (days, signed) = 14247 = 03/01/2009

            Product clone = (Product)compiled.DeepClone(prod);
            Console.WriteLine(clone.CategoryID);
            Console.WriteLine(clone.ProductName);
            Console.WriteLine(clone.CreationDate);
            Console.WriteLine(clone.ProductID);
            Console.WriteLine(clone.UnitPrice);



#endif
                model = TypeModel.Create();
            model.Add(typeof(Customer), false)
               .Add(1, "Id")
               .Add(3, "Name")
#if !FX11
               .Add(5, "HowMuch")
               .Add(6, "HasValue")
#endif
               ;
        ;
            model.Add(typeof(CustomerStruct), false)
                .Add(1, "Id")
                .Add(3, "Name")
#if !FX11
                .Add(5, "HowMuch")
                .Add(6, "HasValue")
#endif
                ;
            return model;
        }