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)); }
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); }
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); }
private static bool CanApplyReadMemoryStreamOptimization(Stream stream) { MemoryStream memStream = stream as MemoryStream; if (memStream == null) { return(false); } ArraySegment <byte> arrSeg; return(memStream.TryGetBuffer(out arrSeg)); }
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; }
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; }
/// <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)); } } } }
/// <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); }
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); }
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 }
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; }