First part of dotnet library

committer: Jon Skeet <skeet@pobox.com>

csharp/ProtocolBuffers.Test/ByteStringTest.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework;
+
+namespace Google.ProtocolBuffers {
+  [TestFixture]
+  public class ByteStringTest {
+    [Test]
+    public void EmptyByteStringHasZeroSize() {
+      Assert.AreEqual(0, ByteString.Empty.Length);
+    }
+
+    [Test]
+    public void CopyFromStringWithExplicitEncoding() {
+      ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode);
+      Assert.AreEqual(4, bs.Length);
+      Assert.AreEqual(65, bs[0]);
+      Assert.AreEqual(0, bs[1]);
+      Assert.AreEqual(66, bs[2]);
+      Assert.AreEqual(0, bs[3]);
+    }
+
+    [Test]
+    public void IsEmptyWhenEmpty() {
+      Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty);
+    }
+
+    [Test]
+    public void IsEmptyWhenNotEmpty() {
+      Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty);
+    }
+
+    [Test]
+    public void CopyFromByteArrayCopiesContents() {
+      byte[] data = new byte[1];
+      data[0] = 10;
+      ByteString bs = ByteString.CopyFrom(data);
+      Assert.AreEqual(10, bs[0]);
+      data[0] = 5;
+      Assert.AreEqual(10, bs[0]);
+    }
+
+    [Test]
+    public void ToByteArrayCopiesContents() {
+      ByteString bs = ByteString.CopyFromUtf8("Hello");
+      byte[] data = bs.ToByteArray();
+      Assert.AreEqual('H', data[0]);
+      Assert.AreEqual('H', bs[0]);
+      data[0] = 0;
+      Assert.AreEqual(0, data[0]);
+      Assert.AreEqual('H', bs[0]);
+    }
+
+    [Test]
+    public void CopyFromUtf8UsesUtf8() {
+      ByteString bs = ByteString.CopyFromUtf8("\u20ac");
+      Assert.AreEqual(3, bs.Length);
+      Assert.AreEqual(0xe2, bs[0]);
+      Assert.AreEqual(0x82, bs[1]);
+      Assert.AreEqual(0xac, bs[2]);
+    }
+
+    [Test]
+    public void CopyFromPortion() {
+      byte[] data = new byte[]{0, 1, 2, 3, 4, 5, 6};
+      ByteString bs = ByteString.CopyFrom(data, 2, 3);
+      Assert.AreEqual(3, bs.Length);
+      Assert.AreEqual(2, bs[0]);
+      Assert.AreEqual(3, bs[1]);
+    }
+
+    [Test]
+    public void ToStringUtf8() {
+      ByteString bs = ByteString.CopyFromUtf8("\u20ac");
+      Assert.AreEqual("\u20ac", bs.ToStringUtf8());
+    }
+
+    [Test]
+    public void ToStringWithExplicitEncoding() {
+      ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode);
+      Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode));
+    }
+  }
+}

csharp/ProtocolBuffers.Test/CodedInputStreamTest.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using NUnit.Framework;
+
+namespace Google.ProtocolBuffers {
+  [TestFixture]
+  public class CodedInputStreamTest {
+    
+    [Test]
+    public void DecodeZigZag32() {
+      Assert.AreEqual( 0, CodedInputStream.DecodeZigZag32(0));
+      Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(1));
+      Assert.AreEqual( 1, CodedInputStream.DecodeZigZag32(2));
+      Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3));
+      Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE));
+      Assert.AreEqual(unchecked((int)0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF));
+      Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE));
+      Assert.AreEqual(unchecked((int)0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF));
+    }
+
+    [Test]
+    public void DecodeZigZag64() {
+      Assert.AreEqual( 0, CodedInputStream.DecodeZigZag64(0));
+      Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(1));
+      Assert.AreEqual( 1, CodedInputStream.DecodeZigZag64(2));
+      Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3));
+      Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL));
+      Assert.AreEqual(unchecked((long)0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL));
+      Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL));
+      Assert.AreEqual(unchecked((long)0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL));
+      Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL));
+      Assert.AreEqual(unchecked((long)0x8000000000000000L),CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL));
+    }
+  }
+}

csharp/ProtocolBuffers.Test/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ProtocolBuffers.Test")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ProtocolBuffers.Test")]
+[assembly: AssemblyCopyright("Copyright ©  2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("54e627c3-daaa-4850-82cf-f25b7f097e78")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

csharp/ProtocolBuffers.Test/ProtocolBuffers.Test.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{DD01ED24-3750-4567-9A23-1DB676A15610}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Google.ProtocolBuffers</RootNamespace>
+    <AssemblyName>Google.ProtocolBuffers.Test</AssemblyName>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework, Version=2.2.8.0, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.5.0.2, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>lib\Rhino.Mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ByteStringTest.cs" />
+    <Compile Include="CodedInputStreamTest.cs" />
+    <Compile Include="CodedOutputStreamTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ProtocolBuffers\ProtocolBuffers.csproj">
+      <Project>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</Project>
+      <Name>ProtocolBuffers</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

csharp/ProtocolBuffers/ByteString.cs

+using System.Text;
+using System;
+
+namespace Google.ProtocolBuffers {
+  /// <summary>
+  /// Immutable array of bytes.
+  /// TODO(jonskeet): Implement the common collection interfaces?
+  /// </summary>
+  public sealed class ByteString {
+
+    private static readonly ByteString empty = new ByteString(new byte[0]);
+
+    private byte[] bytes;
+
+    /// <summary>
+    /// Constructs a new ByteString from the given byte array. The array is
+    /// *not* copied, and must not be modified after this constructor is called.
+    /// </summary>
+    private ByteString(byte[] bytes) {
+      this.bytes = bytes;
+    }
+
+    /// <summary>
+    /// Returns an empty ByteString.
+    /// </summary>
+    public static ByteString Empty {
+      get { return empty; }
+    }
+
+    /// <summary>
+    /// Returns the length of this ByteString in bytes.
+    /// </summary>
+    public int Length {
+      get { return bytes.Length; }
+    }
+
+    public bool IsEmpty {
+      get { return Length == 0; }
+    }
+
+    public byte[] ToByteArray() {
+      return (byte[])bytes.Clone();
+    }
+
+    /// <summary>
+    /// Constructs a ByteString from the given array. The contents
+    /// are copied, so further modifications to the array will not
+    /// be reflected in the returned ByteString.
+    /// </summary>
+    public static ByteString CopyFrom(byte[] bytes) {
+      return new ByteString((byte[]) bytes.Clone());
+    }
+
+    /// <summary>
+    /// Constructs a ByteString from a portion of a byte array.
+    /// </summary>
+    public static ByteString CopyFrom(byte[] bytes, int offset, int count) {
+      byte[] portion = new byte[count];
+      Array.Copy(bytes, offset, portion, 0, count);
+      return new ByteString(portion);
+    }
+
+    /// <summary>
+    /// Creates a new ByteString by encoding the specified text with
+    /// the given encoding.
+    /// </summary>
+    public static ByteString CopyFrom(string text, Encoding encoding) {
+      return new ByteString(encoding.GetBytes(text));
+    }
+
+    /// <summary>
+    /// Creates a new ByteString by encoding the specified text in UTF-8.
+    /// </summary>
+    public static ByteString CopyFromUtf8(string text) {
+      return CopyFrom(text, Encoding.UTF8);
+    }
+    
+    /// <summary>
+    /// Retuns the byte at the given index.
+    /// </summary>
+    public byte this[int index] {
+      get { return bytes[index]; }
+    }
+
+    public string ToString(Encoding encoding) {
+      return encoding.GetString(bytes);
+    }
+
+    public string ToStringUtf8() {
+      return ToString(Encoding.UTF8);
+    }
+
+    // TODO(jonskeet): CopyTo, Equals, GetHashCode if they turn out to be required
+    // TODO(jonskeet): Input/Output stuff
+  }
+}

csharp/ProtocolBuffers/CodedInputStream.cs

+
+namespace Google.ProtocolBuffers {
+  public sealed class CodedInputStream {
+
+    /// <summary>
+    /// Decode a 32-bit value with ZigZag encoding.
+    /// </summary>
+    /// <remarks>
+    /// ZigZag encodes signed integers into values that can be efficiently
+    /// encoded with varint.  (Otherwise, negative values must be 
+    /// sign-extended to 64 bits to be varint encoded, thus always taking
+    /// 10 bytes on the wire.)
+    /// </remarks>
+    public static int DecodeZigZag32(uint n) {
+      return (int)(n >> 1) ^ -(int)(n & 1);
+    }
+
+    /// <summary>
+    /// Decode a 32-bit value with ZigZag encoding.
+    /// </summary>
+    /// <remarks>
+    /// ZigZag encodes signed integers into values that can be efficiently
+    /// encoded with varint.  (Otherwise, negative values must be 
+    /// sign-extended to 64 bits to be varint encoded, thus always taking
+    /// 10 bytes on the wire.)
+    /// </remarks>
+    public static long DecodeZigZag64(ulong n) {
+      return (long)(n >> 1) ^ -(long)(n & 1);
+    }
+  }
+}

csharp/ProtocolBuffers/Descriptors.cs

+
+using System;
+
+namespace Google.ProtocolBuffers {
+  public class Descriptors {
+    public class Descriptor {
+    }
+    public class FieldDescriptor {
+      public enum Type {
+        Double,
+        Float,
+        Int64,
+        UInt64,
+        Int32,
+        Fixed64,
+        Fixed32,
+        Bool,
+        String,
+        Group,
+        Message,
+        Bytes,
+        UInt32,
+        SFixed32,
+        SFixed64,
+        SInt32,
+        SInt64,
+        Enum
+      }
+    }
+
+    public class EnumValueDescriptor
+    {
+      public int Number
+      {
+        get { throw new NotImplementedException(); }
+      }
+    }
+  }
+}

csharp/ProtocolBuffers/ExtensionRegistry.cs

+
+namespace Google.ProtocolBuffers {
+  public class ExtensionRegistry {
+  }
+}

csharp/ProtocolBuffers/IBuilder.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+
+  /// <summary>
+  /// Interface implemented by Protocol Message builders.
+  /// TODO(jonskeet): Consider "SetXXX" methods returning the builder, as well as the properties.
+  /// </summary>
+  /// <typeparam name="T">Type of message</typeparam>
+  public interface IBuilder<T> where T : IMessage<T> {
+    /// <summary>
+    /// Resets all fields to their default values.
+    /// </summary>
+    IBuilder<T> Clear();
+
+    /// <summary>
+    /// Merge the specified other message into the message being
+    /// built. Merging occurs as follows. For each field:
+    /// For singular primitive fields, if the field is set in <paramref name="other"/>,
+    /// then <paramref name="other"/>'s value overwrites the value in this message.
+    /// For singular message fields, if the field is set in <paramref name="other"/>,
+    /// it is merged into the corresponding sub-message of this message using the same
+    /// merging rules.
+    /// For repeated fields, the elements in <paramref name="other"/> are concatenated
+    /// with the elements in this message.
+    /// </summary>
+    /// <param name="other"></param>
+    /// <returns></returns>
+    IBuilder<T> MergeFrom(IMessage<T> other);
+
+    /// <summary>
+    /// Constructs the final message. Once this is called, this Builder instance
+    /// is no longer valid, and calling any other method may throw a
+    /// NullReferenceException. If you need to continue working with the builder
+    /// after calling Build, call Clone first.
+    /// </summary>
+    /// <exception cref="UninitializedMessageException">the message
+    /// is missing one or more required fields; use BuildPartial to bypass
+    /// this check</exception>
+    IMessage<T> Build();
+
+    /// <summary>
+    /// Like Build(), but does not throw an exception if the message is missing
+    /// required fields. Instead, a partial message is returned.
+    /// </summary>
+    /// <returns></returns>
+    IMessage<T> BuildPartial();
+
+    /// <summary>
+    /// Clones this builder.
+    /// TODO(jonskeet): Explain depth of clone.
+    /// </summary>
+    IBuilder<T> Clone();
+
+    /// <summary>
+    /// Returns true iff all required fields in the message and all
+    /// embedded messages are set.
+    /// </summary>
+    bool Initialized { get; }
+
+    /// <summary>
+    /// Parses a message of this type from the input and merges it with this
+    /// message, as if using MergeFrom(IMessage&lt;T&gt;).
+    /// </summary>
+    /// <remarks>
+    /// Warning: This does not verify that all required fields are present
+    /// in the input message. If you call Build() without setting all
+    /// required fields, it will throw an UninitializedMessageException.
+    /// There are a few good ways to deal with this:
+    /// <list>
+    /// <item>Call Initialized to verify to verify that all required fields are
+    /// set before building.</item>
+    /// <item>Parse  the message separately using one of the static ParseFrom
+    /// methods, then use MergeFrom(IMessage&lt;T&gt;) to merge it with
+    /// this one. ParseFrom will throw an InvalidProtocolBufferException
+    /// (an IOException) if some required fields are missing.
+    /// Use BuildPartial to build, which ignores missing required fields.
+    /// </list>
+    /// </remarks>
+    IBuilder<T> MergeFrom(CodedInputStream input);
+
+    /// <summary>
+    /// Like MergeFrom(CodedInputStream), but also parses extensions.
+    /// The extensions that you want to be able to parse must be registered
+    /// in <paramref name="extensionRegistry"/>. Extensions not in the registry
+    /// will be treated as unknown fields.
+    /// </summary>
+    IBuilder<T> MergeFrom(CodedInputStream input, ExtensionRegistry extensionRegistry);
+
+    /// <summary>
+    /// Get the message's type's descriptor.
+    /// <see cref="IMessage{T}.DescriptorForType"/>
+    /// </summary>
+    Descriptors.Descriptor DescriptorForType { get; }
+
+    /// <summary>
+    /// Get's the message's type's default instance.
+    /// <see cref="IMessage{T}.DefaultInstanceForType" />
+    /// </summary>
+    IMessage<T> DefaultInstanceForType { get; }
+
+    /// <summary>
+    /// Behaves like the equivalent property in IMessage&lt;T&gt;.
+    /// The returned map may or may not reflect future changes to the builder.
+    /// Either way, the returned map is unmodifiable.
+    /// </summary>
+    IDictionary<ProtocolBuffers.Descriptors.FieldDescriptor, object> AllFields { get; }
+
+    /// <summary>
+    /// Create a builder for messages of the appropriate type for the given field.
+    /// Messages built with this can then be passed to the various mutation properties
+    /// and methods.
+    /// </summary>
+    /// <typeparam name="TField"></typeparam>
+    /// <param name="field"></param>
+    /// <returns></returns>
+    IBuilder<TField> NewBuilderForField<TField>(Descriptors.FieldDescriptor field)
+        where TField : IMessage<TField>;
+
+    /// <summary>
+    /// <see cref="IMessage{T}.HasField"/>
+    /// </summary>
+    bool HasField(Descriptors.FieldDescriptor field);
+
+    /// <summary>
+    /// Allows getting and setting of a field.
+    /// <see cref="IMessage{T}.Item(Descriptors.FieldDescriptor)"/>
+    /// </summary>
+    /// <param name="field"></param>
+    /// <returns></returns>
+    object this[Descriptors.FieldDescriptor field] { get; set; }
+
+    /// <summary>
+    /// Clears the field. This is exactly equivalent to calling the generated
+    /// Clear method corresponding to the field.
+    /// </summary>
+    /// <param name="field"></param>
+    /// <returns></returns>
+    IBuilder<T> ClearField(Descriptors.FieldDescriptor field);
+
+    /// <summary>
+    /// <see cref="IMessage{T}.GetRepeatedFieldCount"/>
+    /// </summary>
+    /// <param name="field"></param>
+    /// <returns></returns>
+    int GetRepeatedFieldCount(Descriptors.FieldDescriptor field);
+
+
+    /// <summary>
+    /// Allows getting and setting of a repeated field value.
+    /// <see cref="IMessage{T}.Item(Descriptors.FieldDescriptor, int)"/>
+    /// </summary>
+    object this[Descriptors.FieldDescriptor field, int index] { get; set; }
+
+    /// <summary>
+    /// Appends the given value as a new element for the specified repeated field.
+    /// </summary>
+    /// <exception cref="ArgumentException">the field is not a repeated field,
+    /// the field does not belong to this builder's type, or the value is
+    /// of the incorrect type
+    /// </exception>
+    IBuilder<T> AddRepeatedField(Descriptors.FieldDescriptor field, object value);
+
+    /// <summary>
+    /// <see cref="IMessage{T}.UnknownFields"/>
+    /// </summary>
+    UnknownFieldSet UnknownFields { get; set; }
+
+    /// <summary>
+    /// Merge some unknown fields into the set for this message.
+    /// </summary>
+    IBuilder<T> MergeUnknownFields(UnknownFieldSet unknownFields);
+
+    #region Convenience methods
+    // TODO(jonskeet): Implement these as extension methods?
+
+    /// <summary>
+    /// Parse <paramref name="data"/> as a message of this type and merge
+    /// it with the message being built. This is just a small wrapper around
+    /// MergeFrom(CodedInputStream).
+    /// </summary>
+    IBuilder<T> MergeFrom(ByteString data);
+
+    /// <summary>
+    /// Parse <paramref name="data"/> as a message of this type and merge
+    /// it with the message being built. This is just a small wrapper around
+    /// MergeFrom(CodedInputStream, ExtensionRegistry).
+    /// </summary>
+    IBuilder<T> MergeFrom(ByteString data, ExtensionRegistry extensionRegistry);
+
+    /// <summary>
+    /// Parse <paramref name="data"/> as a message of this type and merge
+    /// it with the message being built. This is just a small wrapper around
+    /// MergeFrom(CodedInputStream).
+    /// </summary>
+    IBuilder<T> MergeFrom(byte[] data);
+
+    /// <summary>
+    /// Parse <paramref name="data"/> as a message of this type and merge
+    /// it with the message being built. This is just a small wrapper around
+    /// MergeFrom(CodedInputStream, ExtensionRegistry).
+    /// </summary>
+    IBuilder<T> MergeFrom(byte[] data, ExtensionRegistry extensionRegistry);
+
+    /// <summary>
+    /// Parse <paramref name="data"/> as a message of this type and merge
+    /// it with the message being built. This is just a small wrapper around
+    /// MergeFrom(CodedInputStream). Note that this method always reads
+    /// the entire input (unless it throws an exception). If you want it to
+    /// stop earlier, you will need to wrap the input in a wrapper
+    /// stream which limits reading. Despite usually reading the entire
+    /// stream, this method never closes the stream.
+    /// </summary>
+    IBuilder<T> MergeFrom(Stream input);
+
+    /// <summary>
+    /// Parse <paramref name="data"/> as a message of this type and merge
+    /// it with the message being built. This is just a small wrapper around
+    /// MergeFrom(CodedInputStream, ExtensionRegistry).
+    /// </summary>
+    IBuilder<T> MergeFrom(Stream input, ExtensionRegistry extensionRegistry);
+    #endregion
+  }
+}

csharp/ProtocolBuffers/IMessage.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+
+  /// <summary>
+  /// Non-generic interface.
+  /// TODO(jonskeet): Do we want or need this?
+  /// </summary>
+  public interface IMessage {
+    void WriteTo(CodedOutputStream output);
+    int SerializedSize { get; }
+  }
+
+  /// <summary>
+  /// Interface implemented by all Protocol Buffers messages.
+  /// </summary>
+  public interface IMessage<T> where T : IMessage<T> {
+    /// <summary>
+    /// Returns the message's type's descriptor. This differs from the
+    /// Descriptor property of each generated message class in that this
+    /// method is an abstract method of IMessage whereas Descriptor is
+    /// a static property of a specific class. They return the same thing.
+    /// </summary>
+    Descriptors.Descriptor DescriptorForType { get; }
+
+    /// <summary>
+    /// Returns an instance of this message type with all fields set to
+    /// their default values. This may or may not be a singleton. This differs
+    /// from the DefaultInstance property of each generated message class in that this
+    /// method is an abstract method of IMessage whereas DefaultInstance is
+    /// a static property of a specific class. They return the same thing.
+    /// </summary>
+    IMessage<T> DefaultInstanceForType { get; }
+
+    /// <summary>
+    /// Returns a collection of all the fields in this message which are set
+    /// and their corresponding values.  A singular ("required" or "optional")
+    /// field is set iff HasField() returns true for that field.  A "repeated"
+    /// field is set iff GetRepeatedFieldSize() is greater than zero.  The
+    /// values are exactly what would be returned by calling
+    /// GetField(Descriptors.FieldDescriptor) for each field.  The map
+    /// is guaranteed to be a sorted map, so iterating over it will return fields
+    /// in order by field number. 
+    /// </summary>
+    IDictionary<Descriptors.FieldDescriptor, object> AllFields { get; }
+
+    /// <summary>
+    /// Returns true if the given field is set. This is exactly equivalent
+    /// to calling the generated "Has" property corresponding to the field.
+    /// </summary>
+    /// <exception cref="ArgumentException">the field is a repeated field,
+    /// or it's not a field of this type</exception>
+    bool HasField(Descriptors.FieldDescriptor field);
+
+    /// <summary>
+    /// Obtains the value of the given field, or the default value if
+    /// it isn't set. For value type fields including enums, the boxed
+    /// value is returned. For embedded message fields, the sub-message
+    /// is returned. For repeated fields, an IList&lt;T&gt; is returned.
+    /// </summary>
+    object this[Descriptors.FieldDescriptor field] { get; }
+
+    /// <summary>
+    /// Returns the number of elements of a repeated field. This is
+    /// exactly equivalent to calling the generated "Count" property
+    /// corresponding to the field.
+    /// </summary>
+    /// <exception cref="ArgumentException">the field is not a repeated field,
+    /// or it's not a field of this type</exception>
+    int GetRepeatedFieldCount(Descriptors.FieldDescriptor field);
+
+    /// <summary>
+    /// Gets an element of a repeated field. For value type fields 
+    /// including enums, the boxed value is returned. For embedded
+    /// message fields, the sub-message is returned.
+    /// </summary>
+    /// <exception cref="ArgumentException">the field is not a repeated field,
+    /// or it's not a field of this type</exception>
+    /// <exception cref="ArgumentOutOfRangeException">the index is out of
+    /// range for the repeated field's value</exception>
+    object this[Descriptors.FieldDescriptor field, int index] { get; }
+
+    /// <summary>
+    /// Returns the unknown fields for this message.
+    /// </summary>
+    UnknownFieldSet UnknownFields { get; }
+
+    /// <summary>
+    /// Returns true iff all required fields in the message and all embedded
+    /// messages are set.
+    /// </summary>
+    bool Initialized { get; }
+
+    /// <summary>
+    /// Serializes the message and writes it to the given output stream.
+    /// This does not flush or close the stream.
+    /// </summary>
+    /// <param name="output"></param>
+    void WriteTo(CodedOutputStream output);
+
+    /// <summary>
+    /// Returns the number of bytes required to encode this message.
+    /// The result is only computed on the first call and memoized after that.
+    /// </summary>
+    int SerializedSize { get; }
+
+    #region Comparison and hashing
+    /// <summary>
+    /// Compares the specified object with this message for equality.
+    /// Returns true iff the given object is a message of the same type
+    /// (as defined by DescriptorForType) and has identical values
+    /// for all its fields.
+    /// </summary>
+    bool Equals(object other);
+
+    /// <summary>
+    /// Returns the hash code value for this message.
+    /// TODO(jonskeet): Specify the hash algorithm, but better than the Java one!
+    /// </summary>
+    /// <returns></returns>
+    int GetHashCode();
+    #endregion
+
+    #region Convenience methods
+    /// <summary>
+    /// Converts the message to a string in protocol buffer text format.
+    /// This is just a trivial wrapper around TextFormat.PrintToString.
+    /// </summary>
+    string ToString();
+
+    /// <summary>
+    /// Serializes the message to a ByteString. This is a trivial wrapper
+    /// around WriteTo(CodedOutputStream).
+    /// </summary>
+    ByteString ToByteString();
+
+    /// <summary>
+    /// Serializes the message to a byte array. This is a trivial wrapper
+    /// around WriteTo(CodedOutputStream).
+    /// </summary>
+    byte[] ToByteArray();
+
+    /// <summary>
+    /// Serializes the message and writes it to the given stream.
+    /// This is just a wrapper around WriteTo(CodedOutputStream). This
+    /// does not flush or close the stream.
+    /// </summary>
+    /// <param name="output"></param>
+    void WriteTo(Stream output);
+    #endregion
+
+    #region Builders
+    /// <summary>
+    /// Constructs a new builder for a message of the same type as this message.
+    /// </summary>
+    IBuilder<T> NewBuilderForType();
+    #endregion
+
+  }
+}

csharp/ProtocolBuffers/InvalidProtocolBufferException.cs

+using System;
+using System.IO;
+
+namespace Google.ProtocolBuffers {
+  public class InvalidProtocolBufferException : IOException {
+  }
+}

csharp/ProtocolBuffers/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ProtocolBuffers")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ProtocolBuffers")]
+[assembly: AssemblyCopyright("Copyright ©  2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("279b643d-70e8-47ae-9eb1-500d1c48bab6")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

csharp/ProtocolBuffers/ProtocolBuffers.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{6908BDCE-D925-43F3-94AC-A531E6DF2591}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Google.ProtocolBuffers</RootNamespace>
+    <AssemblyName>Google.ProtocolBuffers</AssemblyName>
+    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ByteString.cs" />
+    <Compile Include="CodedInputStream.cs" />
+    <Compile Include="CodedOutputStream.cs" />
+    <Compile Include="Descriptors.cs" />
+    <Compile Include="ExtensionRegistry.cs" />
+    <Compile Include="IBuilder.cs" />
+    <Compile Include="IMessage.cs" />
+    <Compile Include="InvalidProtocolBufferException.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="UninitializedMessageException.cs" />
+    <Compile Include="UnknownFieldSet.cs" />
+    <Compile Include="WireFormat.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

csharp/ProtocolBuffers/UninitializedMessageException.cs

+using System;
+
+namespace Google.ProtocolBuffers {
+  public class UninitializedMessageException : Exception {
+  }
+}

csharp/ProtocolBuffers/UnknownFieldSet.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+  public class UnknownFieldSet {
+    public void WriteTo(CodedOutputStream output) {
+      throw new NotImplementedException();
+    }
+
+    public int SerializedSize { get { return 0; } }
+  }
+}

csharp/ProtocolBuffers/WireFormat.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Google.ProtocolBuffers {
+  public class WireFormat {
+    public enum WireType {
+      Varint = 0,
+      Fixed64 = 1,
+      LengthDelimited = 2,
+      StartGroup = 3,
+      EndGroup = 4,
+      Fixed32 = 5
+    }
+
+    internal class MessageSetField {
+      internal const int Item = 1;
+      internal const int TypeID = 2;
+      internal const int Message = 3;
+    }
+
+    public static uint MakeTag(int fieldNumber, WireType type) {
+
+      // FIXME
+      return 0;
+    }
+  }
+}