diff --git a/lib/csharp/Makefile.am b/lib/csharp/Makefile.am
index c7c9d7f..9b07f4f 100644
--- a/lib/csharp/Makefile.am
+++ b/lib/csharp/Makefile.am
@@ -53,6 +53,7 @@
             src/Transport/TTransportFactory.cs \
             src/Transport/THttpClient.cs \
             src/Transport/THttpHandler.cs \
+            src/Transport/TMemoryBuffer.cs \
             src/TProcessor.cs \
             src/TApplicationException.cs
 
diff --git a/lib/csharp/src/Thrift.csproj b/lib/csharp/src/Thrift.csproj
index e34f250..0263d72 100644
--- a/lib/csharp/src/Thrift.csproj
+++ b/lib/csharp/src/Thrift.csproj
@@ -114,6 +114,7 @@
     <Compile Include="Transport\TTransport.cs" />
     <Compile Include="Transport\TTransportException.cs" />
     <Compile Include="Transport\TTransportFactory.cs" />
+    <Compile Include="Transport\TMemoryBuffer.cs" />
   </ItemGroup>
   <ItemGroup>
     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
diff --git a/lib/csharp/src/Transport/TMemoryBuffer.cs b/lib/csharp/src/Transport/TMemoryBuffer.cs
new file mode 100644
index 0000000..c6e72f1
--- /dev/null
+++ b/lib/csharp/src/Transport/TMemoryBuffer.cs
@@ -0,0 +1,92 @@
+﻿/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+using System.IO;
+using System.Reflection;
+using Thrift.Protocol;
+
+namespace Thrift.Transport {
+	public class TMemoryBuffer : TTransport {
+
+		private readonly MemoryStream byteStream;
+
+		public TMemoryBuffer() {
+			byteStream = new MemoryStream();
+		}
+
+		public TMemoryBuffer(byte[] buf) {
+			byteStream = new MemoryStream(buf);
+		}
+
+		public override void Open() {
+			/** do nothing **/
+		}
+
+		public override void Close() {
+			/** do nothing **/
+		}
+
+		public override int Read(byte[] buf, int off, int len) {
+			return byteStream.Read(buf, off, len);
+		}
+
+		public override void Write(byte[] buf, int off, int len) {
+			byteStream.Write(buf, off, len);
+		}
+
+		public byte[] GetBuffer() {
+			return byteStream.ToArray();
+		}
+
+
+		public override bool IsOpen {
+			get { return true; }
+		}
+
+		public static byte[] Serialize(TBase s) {
+			var t = new TMemoryBuffer();
+			var p = new TBinaryProtocol(t);
+
+			s.Write(p);
+
+			return t.GetBuffer();
+		}
+
+		public static T DeSerialize<T>(byte[] buf) where T : TBase, new() {
+		       var t = new T();
+		       var trans = new TMemoryBuffer(buf);
+		       var p = new TBinaryProtocol(trans);
+		       t.Read(p);
+		       return t;
+		}
+
+		private bool _IsDisposed;
+
+		// IDisposable
+		protected override void Dispose(bool disposing) {
+			if (!_IsDisposed) {
+				if (disposing) {
+					if (byteStream != null)
+						byteStream.Dispose();
+				}
+			}
+			_IsDisposed = true;
+		}
+	}
+}
\ No newline at end of file
