增加ProtobufGenerator,用于custom tools, VS可以直接把proto文件转换成cs文件

CSharp/App/Modules/Robot/Packages.config

@@ -4,4 +4,5 @@
   <package id="CommonServiceLocator" version="1.0" targetFramework="net45" />
   <package id="Prism" version="4.1.0.0" targetFramework="net45" />
   <package id="Prism.MEFExtensions" version="4.1.0.0" targetFramework="net45" />
+  <package id="protobuf-net" version="2.0.0.480" targetFramework="net45" />
 </packages>

CSharp/App/Modules/Robot/Person.proto

@@ -0,0 +1,4 @@
+message Person
+{
+	required int32 guid = 1;
+}

CSharp/App/Modules/Robot/Robot.csproj

@@ -43,6 +43,9 @@
     </Reference>
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
+    <Reference Include="protobuf-net">
+      <HintPath>..\..\..\packages\protobuf-net.2.0.0.480\lib\net40\protobuf-net.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Core" />
@@ -83,6 +86,9 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="Packages.config" />
+    <None Include="Person.proto">
+      <Generator>ProtobufTool</Generator>
+    </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\nuget.targets" />

CSharp/CSharp.sln

@@ -39,6 +39,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Log", "Platform\Log\Log.csp
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tools", "Tools", "{FD5F443E-CBEE-443E-821D-C47C86E09534}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ProtobufTool", "Tools\ProtobufTool\ProtobufTool.csproj", "{87537C92-B2C7-4E46-A6FB-02B73215C100}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -163,6 +165,18 @@ Global
 		{72E16572-FC1F-4A9E-BC96-035417239298}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{72E16572-FC1F-4A9E-BC96-035417239298}.Release|Win32.ActiveCfg = Release|Any CPU
 		{72E16572-FC1F-4A9E-BC96-035417239298}.Release|x86.ActiveCfg = Release|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Debug|Win32.ActiveCfg = Debug|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Release|Any CPU.Build.0 = Release|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Release|Win32.ActiveCfg = Release|Any CPU
+		{87537C92-B2C7-4E46-A6FB-02B73215C100}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -178,5 +192,6 @@ Global
 		{5AA48F9A-455D-4CD8-A605-A3AC38283E60} = {C4C64188-4FAE-4CC3-A9E6-D9D4AF7429B6}
 		{C9992B7C-313E-4C9F-A954-640D01EDFB58} = {9173C593-D63F-49F6-AFA7-028425D13E4B}
 		{D0B4CFAC-A368-4742-9863-68776CFA9938} = {9173C593-D63F-49F6-AFA7-028425D13E4B}
+		{87537C92-B2C7-4E46-A6FB-02B73215C100} = {FD5F443E-CBEE-443E-821D-C47C86E09534}
 	EndGlobalSection
 EndGlobal

CSharp/Tools/CmdTool.exe.config

@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-	<configSections>
-		<section name="CmdTool" type="CSharpTest.Net.CustomTool.Config, CmdTool"/>
-	</configSections>
-	<CmdTool xsi:noNamespaceSchemaLocation="CmdTool.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-		<match filespec="*.proto">
-			<generator debug="true">
-				<execute exe="ProtoGen.exe" />
-				<!-- protoc.exe arguments -->
-				<arg value="--proto_path=$(InputDir)\"/>
-				<arg value="--include_imports"/>
-				<arg value="$(InputPath)"/>
-				<!-- protogen.exe arguments -->
-				<arg value="-file_extension=.pb.cs"/>
-				<arg value="-output_directory=$(InputDir)\"/>
-				<output extension=".pb.cs"/>
-			</generator>
-		</match>
-	</CmdTool>
-</configuration>

CSharp/Tools/CmdTool.xsd

@@ -1,81 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<xs:schema elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
-  <xs:element name="CmdTool" nillable="true" type="CmdToolConfig" />
-  <xs:complexType name="CmdToolConfig">
-    <xs:sequence>
-      <xs:element minOccurs="0" maxOccurs="unbounded" name="match" type="FileMatch" />
-    </xs:sequence>
-  </xs:complexType>
-  <xs:complexType name="FileMatch">
-    <xs:sequence>
-      <xs:element minOccurs="0" maxOccurs="unbounded" name="applies-to" type="MatchAppliesTo" />
-      <xs:element minOccurs="1" maxOccurs="unbounded" name="generator" type="GeneratorConfig" />
-    </xs:sequence>
-    <xs:attribute name="filespec" type="FileMatchPattern" use="required" />
-  </xs:complexType>
-  <xs:complexType name="MatchAppliesTo">
-    <xs:attribute name="folder" type="FilePathPattern" use="required"/>
-  </xs:complexType>
-  <xs:complexType name="GeneratorConfig">
-    <xs:sequence>
-      <xs:choice minOccurs="1" maxOccurs="1">
-        <xs:element minOccurs="1" maxOccurs="1" name="script" type="GeneratorScript" />
-        <xs:element minOccurs="1" maxOccurs="1" name="execute" type="GeneratorExec" />
-      </xs:choice>
-      <xs:element minOccurs="0" maxOccurs="unbounded" name="arg" type="GeneratorArgument" />
-      <xs:element minOccurs="0" maxOccurs="1" name="std-input" type="GeneratorInput" />
-      <xs:element minOccurs="0" maxOccurs="1" name="std-output" type="GeneratorOutput" />
-      <xs:element minOccurs="0" maxOccurs="unbounded" name="output" type="GeneratorOutput" />
-    </xs:sequence>
-    <xs:attribute name="debug" type="xs:boolean" default="false" use="optional" />
-  </xs:complexType>
-  <xs:complexType name="GeneratorScript">
-    <xs:simpleContent>
-      <xs:extension base="xs:string">
-        <xs:attribute name="type" type="GeneratorScriptType" use="required"/>
-        <xs:attribute name="src" type="FilePathPattern" use="optional"/>
-      </xs:extension>
-    </xs:simpleContent>
-  </xs:complexType>
-  <xs:complexType name="GeneratorExec">
-    <xs:simpleContent>
-      <xs:extension base="xs:string">
-        <xs:attribute name="exe" type="FilePathPattern" use="required"/>
-      </xs:extension>
-    </xs:simpleContent>
-  </xs:complexType>
-  <xs:complexType name="GeneratorArgument">
-    <xs:attribute name="value" type="xs:string" use="required" />
-  </xs:complexType>
-  <xs:complexType name="GeneratorInput">
-    <xs:attribute name="redirect" type="xs:boolean" use="required" />
-  </xs:complexType>
-  <xs:complexType name="GeneratorOutput">
-    <xs:attribute name="extension" type="xs:string" use="required" />
-  </xs:complexType>
-  <xs:simpleType name="FilePathPattern">
-    <xs:restriction base="xs:string">
-      <xs:pattern value="^[^*?&quot;|&lt;&gt;]+$" />
-    </xs:restriction>
-  </xs:simpleType>
-  <xs:simpleType name="FileMatchPattern">
-    <xs:restriction base="xs:string">
-      <xs:pattern value="^[^\\/:&quot;|&lt;&gt;]+$" />
-    </xs:restriction>
-  </xs:simpleType>
-  <xs:simpleType name="FileExtensionPattern">
-    <xs:restriction base="xs:string">
-      <xs:pattern value="^.[^\\/:*?&quot;|&lt;&gt;]*$" />
-    </xs:restriction>
-  </xs:simpleType>
-  <xs:simpleType name="GeneratorScriptType">
-    <xs:restriction base="xs:string">
-      <xs:enumeration value="JScript"/>
-      <xs:enumeration value="VBScript"/>
-      <xs:enumeration value="Cmd"/>
-      <xs:enumeration value="PowerShell"/>
-      <xs:enumeration value="CSharp"/>
-      <xs:enumeration value="VBNet"/>
-    </xs:restriction>
-  </xs:simpleType>
-</xs:schema>

CSharp/Tools/ProtoGen/Licence.txt

@@ -0,0 +1,20 @@
+The core Protocol Buffers technology is provided courtesy of Google.
+At the time of writing, this is released under the BSD license.
+Full details can be found here:
+
+http://code.google.com/p/protobuf/
+
+
+This .NET implementation is Copyright 2008 Marc Gravell
+
+   Licensed 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.

CSharp/Tools/ProtoGen/common.xslt

@@ -0,0 +1,109 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="msxsl"
+>
+  <!--
+  <xsl:template name="capitalizeFirst">
+    <xsl:param name="value"/>
+    <xsl:value-of select="translate(substring($value,1,1),$alpha,$ALPHA)"/>
+    <xsl:value-of select="substring($value,2)"/>
+  </xsl:template>
+  -->
+  <xsl:template match="*">
+    <xsl:message terminate="yes">
+      Node not handled: <xsl:for-each select="ancestor-or-self::*">/<xsl:value-of select="name()"/></xsl:for-each>
+      <xsl:for-each select="*">
+        ; <xsl:value-of select="concat(name(),'=',.)"/>
+      </xsl:for-each>
+    </xsl:message>
+  </xsl:template>
+  <xsl:param name="fixCase"/>
+  <xsl:variable name="optionFixCase" select="$fixCase='true'"/>
+  
+  <xsl:template name="escapeKeyword">
+    <xsl:param name="value"/>
+    <xsl:value-of select="$value"/>
+  </xsl:template>
+  
+  <xsl:template name="toCamelCase">
+    <xsl:param name="value"/>
+    <xsl:param name="delimiter" select="'_'"/>
+    <xsl:param name="keepDelimiter" select="false()"/>
+    <xsl:variable name="segment" select="substring-before($value, $delimiter)"/>
+    <xsl:choose>
+      <xsl:when test="$segment != ''">
+        <xsl:value-of select="$segment"/><xsl:if test="$keepDelimiter"><xsl:value-of select="$delimiter"/></xsl:if>
+        <xsl:call-template name="toPascalCase">
+          <xsl:with-param name="value" select="substring-after($value, $delimiter)"/>
+          <xsl:with-param name="delimiter" select="$delimiter"/>
+          <xsl:with-param name="keepDelimiter" select="$keepDelimiter"/>
+        </xsl:call-template>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="$value"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:variable name="alpha" select="'abcdefghijklmnopqrstuvwxyz'"/>
+  <xsl:variable name="ALPHA" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>
+
+  <xsl:template name="toPascalCase">
+    <xsl:param name="value"/>
+    <xsl:param name="delimiter" select="'_'"/>
+    <xsl:param name="keepDelimiter" select="false()"/>
+    <xsl:if test="$value != ''">
+      <xsl:variable name="segment" select="substring-before($value, $delimiter)"/>
+      <xsl:choose>
+        <xsl:when test="$segment != ''">
+          <xsl:value-of select="translate(substring($segment,1,1),$alpha,$ALPHA)"/><xsl:value-of select="substring($segment,2)"/><xsl:if test="$keepDelimiter"><xsl:value-of select="$delimiter"/></xsl:if>
+          <xsl:call-template name="toPascalCase">
+            <xsl:with-param name="value" select="substring-after($value, $delimiter)"/>
+            <xsl:with-param name="delimiter" select="$delimiter"/>
+            <xsl:with-param name="keepDelimiter" select="$keepDelimiter"/>
+          </xsl:call-template>    
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="translate(substring($value,1,1),$alpha,$ALPHA)"/><xsl:value-of select="substring($value,2)"/>
+        </xsl:otherwise>
+      </xsl:choose>      
+    </xsl:if>
+  </xsl:template>
+    <xsl:template name="pascal">
+    <xsl:param name="value" select="name"/>
+    <xsl:param name="delimiter" select="'_'"/>
+    <xsl:call-template name="escapeKeyword">
+      <xsl:with-param name="value"><xsl:choose>
+      <xsl:when test="$optionFixCase"><xsl:variable name="dotted"><xsl:call-template name="toPascalCase">
+          <xsl:with-param name="value" select="$value"/>
+          <xsl:with-param name="delimiter" select="'.'"/>
+          <xsl:with-param name="keepDelimiter" select="true()"/>
+        </xsl:call-template></xsl:variable><xsl:call-template name="toPascalCase">
+          <xsl:with-param name="value" select="$dotted"/>
+          <xsl:with-param name="delimiter" select="$delimiter"/>
+        </xsl:call-template></xsl:when>
+      <xsl:otherwise><xsl:value-of select="$value"/></xsl:otherwise>
+    </xsl:choose></xsl:with-param></xsl:call-template>
+  </xsl:template>
+  
+  <xsl:template name="PickNamespace"><xsl:param name="defaultNamespace"/><xsl:choose>
+    <xsl:when test="package"><xsl:call-template name="pascal">
+      <xsl:with-param name="value" select="package"/>
+    </xsl:call-template></xsl:when>
+    <xsl:when test="$defaultNamespace"><xsl:value-of select="$defaultNamespace"/></xsl:when>
+    <xsl:otherwise><xsl:variable name="trimmedName"><xsl:choose>
+      <xsl:when test="substring(name,string-length(name)-5,6)='.proto'"><xsl:value-of select="substring(name,1,string-length(name)-6)"/></xsl:when>
+      <xsl:otherwise><xsl:value-of select="name"/></xsl:otherwise>  
+    </xsl:choose></xsl:variable><xsl:call-template name="pascal">
+      <xsl:with-param name="value" select="$trimmedName"/>
+    </xsl:call-template></xsl:otherwise>    
+  </xsl:choose></xsl:template>
+
+  <xsl:template match="FieldDescriptorProto/options"/>
+  <xsl:template match="FileDescriptorProto/options"/>
+  <xsl:template match="DescriptorProto/options"/>
+  <xsl:template match="EnumValueDescriptorProto/options"/>
+  <xsl:template match="EnumDescriptorProto/options"/>
+  <xsl:template match="ServiceDescriptorProto/options"/>
+  <xsl:template match="MethodDescriptorProto/options"/>
+</xsl:stylesheet>

CSharp/Tools/ProtoGen/csharp.xslt

@@ -0,0 +1,629 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsl:stylesheet version="1.0"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="xsl msxsl"
+>
+  <xsl:import href="common.xslt"/>
+  <xsl:param name="help"/>
+  <xsl:param name="xml"/>
+  <xsl:param name="datacontract"/>
+  <xsl:param name="binary"/>
+  <xsl:param name="protoRpc"/>
+  <xsl:param name="observable"/>
+  <xsl:param name="preObservable"/>
+  <xsl:param name="partialMethods"/>
+  <xsl:param name="detectMissing"/>
+  <xsl:param name="lightFramework"/>
+  <xsl:param name="asynchronous"/>
+  <xsl:param name="clientProxy"/>
+  <xsl:param name="defaultNamespace"/>
+  <xsl:param name="import"/>
+  
+  <xsl:key name="fieldNames" match="//FieldDescriptorProto" use="name"/>
+  <xsl:output method="text" indent="no" omit-xml-declaration="yes"/>
+
+  <xsl:variable name="optionXml" select="$xml='true'"/>
+  <xsl:variable name="optionDataContract" select="$datacontract='true'"/>
+  <xsl:variable name="optionBinary" select="$binary='true'"/>
+  <xsl:variable name="optionProtoRpc" select="$protoRpc='true'"/>
+  <xsl:variable name="optionObservable" select="$observable='true'"/>
+  <xsl:variable name="optionPreObservable" select="$preObservable='true'"/>
+  <xsl:variable name="optionPartialMethods" select="$partialMethods='true'"/>
+  <xsl:variable name="optionDetectMissing" select="$detectMissing='true'"/>
+  <xsl:variable name="optionFullFramework" select="not($lightFramework='true')"/>
+  <xsl:variable name="optionAsynchronous" select="$asynchronous='true'"/>
+  <xsl:variable name="optionClientProxy" select="$clientProxy='true'"/>
+
+  <xsl:template match="/">
+    <xsl:text disable-output-escaping="yes">//------------------------------------------------------------------------------
+// &lt;auto-generated&gt;
+//     This code was generated by a tool.
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// &lt;/auto-generated&gt;
+//------------------------------------------------------------------------------
+</xsl:text><!--
+    --><xsl:apply-templates select="*"/><!--
+  --></xsl:template>
+
+  <xsl:template name="WriteUsings">
+    <xsl:param name="ns"/>
+    <xsl:if test="$ns != ''"><xsl:choose>
+   <xsl:when test="contains($ns,';')">
+using <xsl:value-of select="substring-before($ns,';')"/>;<!--
+ --><xsl:call-template name="WriteUsings">
+       <xsl:with-param name="ns" select="substring-after($ns,';')"/>
+  </xsl:call-template>
+  </xsl:when>
+   <xsl:otherwise>
+using <xsl:value-of select="$ns"/>;
+   </xsl:otherwise>
+ </xsl:choose></xsl:if></xsl:template>
+  
+  <xsl:template match="FileDescriptorSet">
+    <xsl:if test="$help='true'">
+      <xsl:message terminate="yes">
+        CSharp template for protobuf-net.
+        Options:
+        General:
+          "help" - this page
+        Additional serializer support:
+          "xml" - enable explicit xml support (XmlSerializer)
+          "datacontract" - enable data-contract support (DataContractSerializer; requires .NET 3.0)
+          "binary" - enable binary support (BinaryFormatter; not supported on Silverlight)
+        Other:
+          "protoRpc" - enable proto-rpc client
+          "observable" - change notification (observer pattern) support
+          "preObservable" - pre-change notification (observer pattern) support (requires .NET 3.5)
+          "partialMethods" - provide partial methods for changes (requires C# 3.0)
+          "detectMissing" - provide *Specified properties to indicate whether fields are present
+          "lightFramework" - omit additional attributes not included in CF/Silverlight
+          "asynchronous" - emit asynchronous methods for use with WCF
+          "clientProxy" - emit asynchronous client proxy class
+          "import" - additional namespaces to import (semicolon delimited)
+          "fixCase" - change type/member names (types/properties become PascalCase; fields become camelCase)
+      </xsl:message>
+    </xsl:if>
+
+    <xsl:if test="$optionXml and $optionDataContract">
+      <xsl:message terminate="yes">
+        Invalid options: xml and data-contract serialization are mutually exclusive.
+      </xsl:message>
+    </xsl:if>
+    <xsl:if test="$optionXml">
+// Option: xml serialization ([XmlType]/[XmlElement]) enabled
+    </xsl:if><xsl:if test="$optionDataContract">
+// Option: data-contract serialization ([DataContract]/[DataMember]) enabled
+    </xsl:if><xsl:if test="$optionBinary">
+// Option: binary serialization (ISerializable) enabled
+    </xsl:if><xsl:if test="$optionObservable">
+// Option: observable (OnPropertyChanged) enabled
+    </xsl:if><xsl:if test="$optionPreObservable">
+// Option: pre-observable (OnPropertyChanging) enabled
+    </xsl:if><xsl:if test="$partialMethods">
+// Option: partial methods (On*Changing/On*Changed) enabled
+    </xsl:if><xsl:if test="$detectMissing">
+// Option: missing-value detection (*Specified/ShouldSerialize*/Reset*) enabled
+    </xsl:if><xsl:if test="not($optionFullFramework)">
+// Option: light framework (CF/Silverlight) enabled
+    </xsl:if><xsl:if test="$optionProtoRpc">
+// Option: proto-rpc enabled
+  </xsl:if>
+    <xsl:call-template name="WriteUsings">
+      <xsl:with-param name="ns" select="$import"/>
+    </xsl:call-template>
+    <xsl:apply-templates select="file/FileDescriptorProto"/>
+  </xsl:template>
+
+  
+  <xsl:template match="FileDescriptorProto">
+// Generated from: <xsl:value-of select="name"/>
+    
+    <xsl:apply-templates select="dependency/string[.!='']"/>
+    <xsl:variable name="namespace"><xsl:call-template name="PickNamespace">
+      <xsl:with-param name="defaultNamespace" select="$defaultNamespace"/>
+        </xsl:call-template>
+      </xsl:variable>
+    <xsl:if test="string($namespace) != ''">
+namespace <xsl:value-of select="translate($namespace,':-/\','__..')"/>
+{</xsl:if>
+    <xsl:apply-templates select="message_type | enum_type | service"/>
+    <xsl:if test="string($namespace) != ''">
+}</xsl:if></xsl:template>
+  
+  <xsl:template match="FileDescriptorProto/dependency/string">
+// Note: requires additional types generated from: <xsl:value-of select="."/></xsl:template>
+
+
+  <xsl:template name="camel">
+    <xsl:param name="value" select="name"/>
+    <xsl:param name="delimiter" select="'_'"/>
+    <xsl:choose>
+      <xsl:when test="$optionFixCase"><xsl:call-template name="toCamelCase">
+          <xsl:with-param name="value" select="$value"/>
+          <xsl:with-param name="delimiter" select="$delimiter"/>
+        </xsl:call-template></xsl:when>
+      <xsl:otherwise><xsl:value-of select="$value"/></xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  
+  <xsl:template match="DescriptorProto">
+  [<xsl:if test="$optionFullFramework">global::System.Serializable, </xsl:if>global::ProtoBuf.ProtoContract(Name=@"<xsl:value-of select="name"/>")]
+  <xsl:if test="$optionDataContract">[global::System.Runtime.Serialization.DataContract(Name=@"<xsl:value-of select="name"/>")]
+  </xsl:if><xsl:if test="$optionXml">[global::System.Xml.Serialization.XmlType(TypeName=@"<xsl:value-of select="name"/>")]
+  </xsl:if><!--
+  -->public partial class <xsl:call-template name="pascal"/> : global::ProtoBuf.IExtensible<!--
+  --><xsl:if test="$optionBinary">, global::System.Runtime.Serialization.ISerializable</xsl:if><!--
+  --><xsl:if test="$optionObservable">, global::System.ComponentModel.INotifyPropertyChanged</xsl:if><!--
+  --><xsl:if test="$optionPreObservable">, global::System.ComponentModel.INotifyPropertyChanging</xsl:if>
+  {
+    public <xsl:call-template name="pascal"/>() {}
+    <xsl:apply-templates select="*"/><xsl:if test="$optionBinary">
+    protected <xsl:call-template name="pascal"/>(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context)
+      : this() { global::ProtoBuf.Serializer.Merge(info, this); }
+    void global::System.Runtime.Serialization.ISerializable.GetObjectData(global::System.Runtime.Serialization.SerializationInfo info, global::System.Runtime.Serialization.StreamingContext context)
+      { global::ProtoBuf.Serializer.Serialize(info, this); }
+    </xsl:if><xsl:if test="$optionObservable">
+    public event global::System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
+    protected virtual void OnPropertyChanged(string propertyName)
+      { if(PropertyChanged != null) PropertyChanged(this, new global::System.ComponentModel.PropertyChangedEventArgs(propertyName)); }
+    </xsl:if><xsl:if test="$optionPreObservable">
+    public event global::System.ComponentModel.PropertyChangingEventHandler PropertyChanging;
+    protected virtual void OnPropertyChanging(string propertyName)
+    { if(PropertyChanging != null) PropertyChanging(this, new global::System.ComponentModel.PropertyChangingEventArgs(propertyName)); }
+    </xsl:if>
+    private global::ProtoBuf.IExtension extensionObject;
+    global::ProtoBuf.IExtension global::ProtoBuf.IExtensible.GetExtensionObject(bool createIfMissing)
+      { return global::ProtoBuf.Extensible.GetExtensionObject(ref extensionObject, createIfMissing); }
+  }
+  </xsl:template>
+
+  <xsl:template match="DescriptorProto/name | DescriptorProto/extension_range | DescriptorProto/extension"/>
+  
+  <xsl:template match="
+                FileDescriptorProto/message_type | FileDescriptorProto/enum_type | FileDescriptorProto/service
+                | DescriptorProto/enum_type | DescriptorProto/message_type
+                | DescriptorProto/nested_type | EnumDescriptorProto/value | ServiceDescriptorProto/method">
+    <xsl:apply-templates select="*"/>
+  </xsl:template>
+
+  <xsl:template match="DescriptorProto/field">
+    <xsl:apply-templates select="*"/>
+    <xsl:variable name="extName" select="concat('.',(ancestor::FileDescriptorProto/package)[1],'.',../name)"/>
+    <xsl:apply-templates select="//FieldDescriptorProto[extendee=$extName]"/>
+  </xsl:template>
+
+  <xsl:template match="EnumDescriptorProto">
+    [global::ProtoBuf.ProtoContract(Name=@"<xsl:value-of select="name"/>")]
+    <xsl:if test="$optionDataContract">[global::System.Runtime.Serialization.DataContract(Name=@"<xsl:value-of select="name"/>")]
+    </xsl:if>
+    <xsl:if test="$optionXml">[global::System.Xml.Serialization.XmlType(TypeName=@"<xsl:value-of select="name"/>")]
+    </xsl:if><!--
+    -->public enum <xsl:call-template name="pascal"/>
+    {
+      <xsl:apply-templates select="value"/>
+    }
+  </xsl:template>
+
+  <xsl:template match="EnumValueDescriptorProto">
+      <xsl:variable name="value"><xsl:choose>
+        <xsl:when test="number"><xsl:value-of select="number"/></xsl:when>
+        <xsl:otherwise>0</xsl:otherwise>
+      </xsl:choose></xsl:variable>      
+      [global::ProtoBuf.ProtoEnum(Name=@"<xsl:value-of select="name"/>", Value=<xsl:value-of select="$value"/>)]<!--
+      --><xsl:if test="$optionDataContract">
+      [global::System.Runtime.Serialization.EnumMember(Value=@"<xsl:value-of select="name"/>")]</xsl:if><!--
+      --><xsl:if test="$optionXml">
+      [global::System.Xml.Serialization.XmlEnum(@"<xsl:value-of select="name"/>")]</xsl:if><!--
+      --><xsl:text disable-output-escaping="yes">
+      </xsl:text><xsl:call-template name="pascal"/><xsl:text xml:space="preserve"> = </xsl:text><xsl:value-of select="$value"/><xsl:if test="position()!=last()">,
+      </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="FieldDescriptorProto" mode="field">
+    <xsl:variable name="field"><xsl:choose>
+      <xsl:when test="$optionFixCase"><xsl:call-template name="toCamelCase">
+          <xsl:with-param name="value" select="name"/>
+        </xsl:call-template></xsl:when>
+      <xsl:otherwise><xsl:value-of select="name"/></xsl:otherwise>
+    </xsl:choose></xsl:variable>
+    <xsl:call-template name="escapeKeyword">
+      <xsl:with-param name="value"><xsl:choose>
+      <xsl:when test="not(key('fieldNames',concat('_',$field)))"><xsl:value-of select="concat('_',$field)"/></xsl:when>
+      <xsl:when test="not(key('fieldNames',concat($field,'Field')))"><xsl:value-of select="concat($field,'Field')"/></xsl:when>
+      <xsl:otherwise><xsl:value-of select="concat('_',generate-id())"/></xsl:otherwise>
+    </xsl:choose></xsl:with-param>
+    </xsl:call-template>
+  </xsl:template>
+
+  <xsl:template name="escapeKeyword">
+    <xsl:param name="value"/>
+    <xsl:if test="contains($keywords,concat('|',$value,'|'))">@</xsl:if><xsl:value-of select="$value"/>
+  </xsl:template>
+  <xsl:variable name="keywords">|abstract|as|base|bool|break|byte|case|catch|char|checked|class|const|continue|decimal|default|delegate|do|double|else|enum|event|explicit|extern|false|finally|fixed|float|for|foreach|goto|if|implicit|in|int|interface|internal|is|lock|long|namespace|new|null|object|operator|out|override|params|private|protected|public|readonly|ref|return|sbyte|sealed|short|sizeof|stackalloc|static|string|struct|switch|this|throw|true|try|typeof|uint|ulong|unchecked|unsafe|ushort|using|virtual|void|volatile|while|</xsl:variable>
+
+  <xsl:template match="FieldDescriptorProto" mode="format">
+    <xsl:choose>
+      <xsl:when test="type='TYPE_DOUBLE' or type='TYPE_FLOAT'
+                or type='TYPE_FIXED32' or type='TYPE_FIXED64'
+                or type='TYPE_SFIXED32' or type='TYPE_SFIXED64'">FixedSize</xsl:when>
+      <xsl:when test="type='TYPE_GROUP'">Group</xsl:when>
+      <xsl:when test="not(type) or type='TYPE_INT32' or type='TYPE_INT64'
+                or type='TYPE_UINT32' or type='TYPE_UINT64'
+                or type='TYPE_ENUM'">TwosComplement</xsl:when>
+      <xsl:when test="type='TYPE_SINT32' or type='TYPE_SINT64'">ZigZag</xsl:when>
+      <xsl:otherwise>Default</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  <xsl:template match="FieldDescriptorProto" mode="primitiveType">
+    <xsl:choose>
+      <xsl:when test="not(type)">struct</xsl:when>
+      <xsl:when test="type='TYPE_DOUBLE'">struct</xsl:when>
+      <xsl:when test="type='TYPE_FLOAT'">struct</xsl:when>
+      <xsl:when test="type='TYPE_INT64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_UINT64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_INT32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_FIXED64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_FIXED32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_BOOL'">struct</xsl:when>
+      <xsl:when test="type='TYPE_STRING'">class</xsl:when>
+      <xsl:when test="type='TYPE_BYTES'">class</xsl:when>
+      <xsl:when test="type='TYPE_UINT32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SINT32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SINT64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_ENUM'">struct</xsl:when>
+      <xsl:when test="type='TYPE_GROUP' or type='TYPE_MESSAGE'">none</xsl:when>
+      <xsl:otherwise>
+        <xsl:message terminate="yes">
+          Field type not implemented: <xsl:value-of select="type"/> (<xsl:value-of select="../../name"/>.<xsl:value-of select="name"/>)
+        </xsl:message>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  <xsl:template match="FieldDescriptorProto" mode="type">
+    <xsl:choose>
+      <xsl:when test="not(type)">double</xsl:when>
+      <xsl:when test="type='TYPE_DOUBLE'">double</xsl:when>
+      <xsl:when test="type='TYPE_FLOAT'">float</xsl:when>
+      <xsl:when test="type='TYPE_INT64'">long</xsl:when>
+      <xsl:when test="type='TYPE_UINT64'">ulong</xsl:when>
+      <xsl:when test="type='TYPE_INT32'">int</xsl:when>
+      <xsl:when test="type='TYPE_FIXED64'">ulong</xsl:when>
+      <xsl:when test="type='TYPE_FIXED32'">uint</xsl:when>
+      <xsl:when test="type='TYPE_BOOL'">bool</xsl:when>
+      <xsl:when test="type='TYPE_STRING'">string</xsl:when>
+      <xsl:when test="type='TYPE_BYTES'">byte[]</xsl:when>
+      <xsl:when test="type='TYPE_UINT32'">uint</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED32'">int</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED64'">long</xsl:when>
+      <xsl:when test="type='TYPE_SINT32'">int</xsl:when>
+      <xsl:when test="type='TYPE_SINT64'">long</xsl:when>
+      <xsl:when test="type='TYPE_GROUP' or type='TYPE_MESSAGE' or type='TYPE_ENUM'"><xsl:call-template name="pascal">
+        <xsl:with-param name="value" select="substring-after(type_name,'.')"/>
+      </xsl:call-template></xsl:when>
+      <xsl:otherwise>
+        <xsl:message terminate="yes">
+          Field type not implemented: <xsl:value-of select="type"/> (<xsl:value-of select="../../name"/>.<xsl:value-of select="name"/>)
+        </xsl:message>
+      </xsl:otherwise>
+    </xsl:choose>
+    
+  </xsl:template>
+
+  <xsl:template match="FieldDescriptorProto[default_value]" mode="defaultValue">
+    <xsl:choose>
+      <xsl:when test="type='TYPE_STRING'">@"<xsl:value-of select="default_value"/>"</xsl:when>
+      <xsl:when test="type='TYPE_ENUM'"><xsl:apply-templates select="." mode="type"/>.<xsl:call-template name="pascal">
+        <xsl:with-param name="value" select="default_value"/>
+      </xsl:call-template></xsl:when>
+      <xsl:when test="type='TYPE_BYTES'"> /* 
+        <xsl:value-of select="default_value"/>
+        */ null </xsl:when>
+      <xsl:otherwise>(<xsl:apply-templates select="." mode="type"/>)<xsl:value-of select="default_value"/></xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!--
+    We need to find the first enum value given .foo.bar.SomeEnum - but the enum itself
+    only knows about SomeEnum; we need to look at all parent DescriptorProto nodes, and
+    the FileDescriptorProto for the namespace.
+    
+    This does an annoying up/down recursion... a bit expensive, but *generally* OK.
+    Could perhaps index the last part of the enum name to reduce overhead?
+  -->
+  <xsl:template name="GetFirstEnumValue">
+    <xsl:variable name="hunt" select="type_name"/>
+    <xsl:for-each select="//EnumDescriptorProto">
+      <xsl:variable name="fullName">
+        <xsl:for-each select="ancestor::FileDescriptorProto">.<xsl:value-of select="package"/></xsl:for-each>
+        <xsl:for-each select="ancestor::DescriptorProto">.<xsl:value-of select="name"/></xsl:for-each>
+        <xsl:value-of select="'.'"/>
+        <xsl:call-template name="pascal"/>
+      </xsl:variable>
+      <xsl:if test="$fullName=$hunt"><xsl:value-of select="(value/EnumValueDescriptorProto)[1]/name"/></xsl:if>
+    </xsl:for-each>
+  </xsl:template>
+  
+  <xsl:template match="FieldDescriptorProto[not(default_value)]" mode="defaultValue">
+    <xsl:choose>
+      <xsl:when test="type='TYPE_STRING'">""</xsl:when>
+      <xsl:when test="type='TYPE_MESSAGE'">null</xsl:when>
+      <xsl:when test="type='TYPE_BYTES'">null</xsl:when>
+      <xsl:when test="type='TYPE_ENUM'"><xsl:apply-templates select="." mode="type"/>.<xsl:call-template name="GetFirstEnumValue"/></xsl:when>
+      <xsl:otherwise>default(<xsl:apply-templates select="." mode="type"/>)</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="FieldDescriptorProto" mode="checkDeprecated"><!--
+    --><xsl:if test="options/deprecated='true'">global::System.Obsolete, </xsl:if><!--
+  --></xsl:template>
+  <xsl:template match="FieldDescriptorProto[label='LABEL_OPTIONAL' or not(label)]">
+    <xsl:variable name="propType"><xsl:apply-templates select="." mode="type"/></xsl:variable>
+    <xsl:variable name="format"><xsl:apply-templates select="." mode="format"/></xsl:variable>
+    <xsl:variable name="primitiveType"><xsl:apply-templates select="." mode="primitiveType"/></xsl:variable>
+    <xsl:variable name="defaultValue"><xsl:apply-templates select="." mode="defaultValue"/></xsl:variable>
+    <xsl:variable name="field"><xsl:apply-templates select="." mode="field"/></xsl:variable>
+    <xsl:variable name="specified" select="$optionDetectMissing and ($primitiveType='struct' or $primitiveType='class')"/>
+    <xsl:variable name="fieldType"><xsl:value-of select="$propType"/><xsl:if test="$specified and $primitiveType='struct'">?</xsl:if></xsl:variable>
+
+    private <xsl:value-of select="concat($fieldType,' ',$field)"/><xsl:if test="not($specified)"> = <xsl:value-of select="$defaultValue"/></xsl:if>;
+    [<xsl:apply-templates select="." mode="checkDeprecated"/>global::ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired = false, Name=@"<xsl:value-of select="name"/>", DataFormat = global::ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)]<!--
+    --><xsl:if test="not($specified)">
+    [global::System.ComponentModel.DefaultValue(<xsl:value-of select="$defaultValue"/>)]</xsl:if><!--
+    --><xsl:if test="$optionXml">
+    [global::System.Xml.Serialization.XmlElement(@"<xsl:value-of select="name"/>", Order = <xsl:value-of select="number"/>)]
+    </xsl:if><xsl:if test="$optionDataContract">
+    [global::System.Runtime.Serialization.DataMember(Name=@"<xsl:value-of select="name"/>", Order = <xsl:value-of select="number"/>, IsRequired = false)]
+    </xsl:if><xsl:call-template name="WriteGetSet">
+      <xsl:with-param name="fieldType" select="$fieldType"/>
+      <xsl:with-param name="propType" select="$propType"/>
+      <xsl:with-param name="name"><xsl:call-template name="pascal"/></xsl:with-param>
+      <xsl:with-param name="field" select="$field"/>
+      <xsl:with-param name="defaultValue" select="$defaultValue"/>
+      <xsl:with-param name="specified" select="$specified"/>
+    </xsl:call-template>
+  </xsl:template>
+  
+  <xsl:template match="FieldDescriptorProto[label='LABEL_REQUIRED']">
+    <xsl:variable name="type"><xsl:apply-templates select="." mode="type"/></xsl:variable>
+    <xsl:variable name="format"><xsl:apply-templates select="." mode="format"/></xsl:variable>
+    <xsl:variable name="field"><xsl:apply-templates select="." mode="field"/></xsl:variable>
+    private <xsl:value-of select="concat($type, ' ', $field)"/>;
+    [<xsl:apply-templates select="." mode="checkDeprecated"/>global::ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired = true, Name=@"<xsl:value-of select="name"/>", DataFormat = global::ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)]<!--
+    --><xsl:if test="$optionXml">
+    [global::System.Xml.Serialization.XmlElement(@"<xsl:value-of select="name"/>", Order = <xsl:value-of select="number"/>)]
+    </xsl:if><xsl:if test="$optionDataContract">
+    [global::System.Runtime.Serialization.DataMember(Name=@"<xsl:value-of select="name"/>", Order = <xsl:value-of select="number"/>, IsRequired = true)]
+    </xsl:if><xsl:call-template name="WriteGetSet">
+      <xsl:with-param name="fieldType" select="$type"/>
+      <xsl:with-param name="propType" select="$type"/>
+      <xsl:with-param name="name"><xsl:call-template name="pascal"/></xsl:with-param>
+      <xsl:with-param name="field" select="$field"/>
+    </xsl:call-template>    
+  </xsl:template>
+
+  <xsl:template name="stripKeyword">
+    <xsl:param name="value"/>
+    <xsl:choose>
+      <xsl:when test="starts-with($value,'@')"><xsl:value-of select="substring-after($value,'@')"/></xsl:when>
+      <xsl:otherwise><xsl:value-of select="$value"/></xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  
+  <xsl:template name="WriteGetSet">
+    <xsl:param name="fieldType"/>
+    <xsl:param name="propType"/>
+    <xsl:param name="name"/>
+    <xsl:param name="field"/>
+    <xsl:param name="specified" select="false()"/>
+    <xsl:param name="defaultValue"/>
+    <xsl:variable name="nameNoKeyword">
+      <xsl:call-template name="stripKeyword">
+        <xsl:with-param name="value" select="$name"/>
+      </xsl:call-template></xsl:variable>
+    public <xsl:value-of select="concat($propType,' ',$name)"/>
+    {
+      get { return <xsl:value-of select="$field"/> <xsl:if test="$specified">?? <xsl:value-of select="$defaultValue"/></xsl:if>; }
+      set { <xsl:if test="$optionPartialMethods">On<xsl:value-of select="$nameNoKeyword"/>Changing(value); </xsl:if><xsl:if test="$optionPreObservable">OnPropertyChanging(@"<xsl:value-of select="$nameNoKeyword"/>"); </xsl:if><xsl:value-of select="$field"/> = value; <xsl:if test="$optionObservable">OnPropertyChanged(@"<xsl:value-of select="$nameNoKeyword"/>"); </xsl:if><xsl:if test="$optionPartialMethods">On<xsl:value-of select="$nameNoKeyword"/>Changed();</xsl:if>}
+    }<xsl:if test="$optionPartialMethods">
+    partial void On<xsl:value-of select="$nameNoKeyword"/>Changing(<xsl:value-of select="$propType"/> value);
+    partial void On<xsl:value-of select="$nameNoKeyword"/>Changed();</xsl:if><xsl:if test="$specified">
+    [global::System.Xml.Serialization.XmlIgnore]
+    <xsl:if test="$optionFullFramework">[global::System.ComponentModel.Browsable(false)]</xsl:if>
+    public bool <xsl:value-of select="$nameNoKeyword"/>Specified
+    {
+      get { return <xsl:value-of select="$field"/> != null; }
+      set { if (value == (<xsl:value-of select="$field"/>== null)) <xsl:value-of select="$field"/> = value ? <xsl:value-of select="$name"/> : (<xsl:value-of select="$fieldType"/>)null; }
+    }
+    private bool ShouldSerialize<xsl:value-of select="$nameNoKeyword"/>() { return <xsl:value-of select="$nameNoKeyword"/>Specified; }
+    private void Reset<xsl:value-of select="$nameNoKeyword"/>() { <xsl:value-of select="$nameNoKeyword"/>Specified = false; }
+    </xsl:if>
+  </xsl:template>
+  <xsl:template match="FieldDescriptorProto[label='LABEL_REPEATED']">
+    <xsl:variable name="type"><xsl:apply-templates select="." mode="type"/></xsl:variable>
+    <xsl:variable name="format"><xsl:apply-templates select="." mode="format"/></xsl:variable>
+    <xsl:variable name="field"><xsl:apply-templates select="." mode="field"/></xsl:variable>
+    private <xsl:if test="not($optionXml)">readonly</xsl:if> global::System.Collections.Generic.List&lt;<xsl:value-of select="$type" />&gt; <xsl:value-of select="$field"/> = new global::System.Collections.Generic.List&lt;<xsl:value-of select="$type"/>&gt;();
+    [<xsl:apply-templates select="." mode="checkDeprecated"/>global::ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, Name=@"<xsl:value-of select="name"/>", DataFormat = global::ProtoBuf.DataFormat.<xsl:value-of select="$format"/><xsl:if test="options/packed='true'">, Options = global::ProtoBuf.MemberSerializationOptions.Packed</xsl:if>)]<!--
+    --><xsl:if test="$optionDataContract">
+    [global::System.Runtime.Serialization.DataMember(Name=@"<xsl:value-of select="name"/>", Order = <xsl:value-of select="number"/>, IsRequired = false)]
+    </xsl:if><xsl:if test="$optionXml">
+    [global::System.Xml.Serialization.XmlElement(@"<xsl:value-of select="name"/>", Order = <xsl:value-of select="number"/>)]
+    </xsl:if>
+    public global::System.Collections.Generic.List&lt;<xsl:value-of select="$type" />&gt; <xsl:call-template name="pascal"/>
+    {
+      get { return <xsl:value-of select="$field"/>; }<!--
+      --><xsl:if test="$optionXml">
+      set { <xsl:value-of select="$field"/> = value; }</xsl:if>
+    }
+  </xsl:template>
+
+  <xsl:template match="ServiceDescriptorProto">
+    <xsl:if test="($optionClientProxy or $optionDataContract)">
+    [global::System.ServiceModel.ServiceContract(Name = @"<xsl:value-of select="name"/>")]</xsl:if>
+    public interface I<xsl:value-of select="name"/>
+    {
+      <xsl:apply-templates select="method"/>
+    }
+    
+    <xsl:if test="$optionProtoRpc">
+    public class <xsl:value-of select="name"/>Client : global::ProtoBuf.ServiceModel.RpcClient
+    {
+      public <xsl:value-of select="name"/>Client() : base(typeof(I<xsl:value-of select="name"/>)) { }
+      <xsl:apply-templates select="method/MethodDescriptorProto" mode="protoRpc"/>
+    }
+    </xsl:if>
+    <xsl:apply-templates select="." mode="clientProxy"/>
+    
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto">
+    <xsl:if test="($optionClientProxy or $optionDataContract)">
+        [global::System.ServiceModel.OperationContract(Name = @"<xsl:value-of select="name"/>")]
+        <xsl:if test="$optionFullFramework">[global::ProtoBuf.ServiceModel.ProtoBehavior]</xsl:if>
+    </xsl:if>
+        <xsl:apply-templates select="output_type"/><xsl:text xml:space="preserve"> </xsl:text><xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request);
+    <xsl:if test="$optionAsynchronous and ($optionClientProxy or $optionDataContract)">
+        [global::System.ServiceModel.OperationContract(AsyncPattern = true, Name = @"<xsl:value-of select="name"/>")]
+        global::System.IAsyncResult Begin<xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request, global::System.AsyncCallback callback, object state);
+    <xsl:apply-templates select="output_type"/> End<xsl:value-of select="name"/>(global::System.IAsyncResult ar);
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto" mode="protoRpc">
+        <xsl:apply-templates select="output_type"/><xsl:text xml:space="preserve"> </xsl:text><xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request)
+        {
+            return (<xsl:apply-templates select="output_type"/>) Send(@"<xsl:value-of select="name"/>", request);
+        }
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto/input_type | MethodDescriptorProto/output_type">
+    <xsl:value-of select="substring-after(.,'.')"/>
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto" mode="CompleteEvent">
+  <xsl:if test="$optionAsynchronous and $optionDataContract">
+    public partial class <xsl:value-of select="name"/>CompletedEventArgs : global::System.ComponentModel.AsyncCompletedEventArgs
+    {
+        private object[] results;
+
+        public <xsl:value-of select="name"/>CompletedEventArgs(object[] results, global::System.Exception exception, bool cancelled, object userState)
+            : base(exception, cancelled, userState) 
+        {
+            this.results = results;
+        }
+        
+        public <xsl:apply-templates select="output_type"/> Result
+        {
+            get { 
+                base.RaiseExceptionIfNecessary();
+                return (<xsl:apply-templates select="output_type"/>)(this.results[0]); 
+            }
+        }
+    }
+  </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="ServiceDescriptorProto" mode="clientProxy">
+  <xsl:if test="$optionAsynchronous and $optionDataContract and $optionClientProxy">
+    <xsl:apply-templates select="method/MethodDescriptorProto" mode="CompleteEvent"/>
+    
+    [global::System.Diagnostics.DebuggerStepThroughAttribute()]
+    public partial class <xsl:value-of select="name"/>Client : global::System.ServiceModel.ClientBase&lt;I<xsl:value-of select="name"/>&gt;, I<xsl:value-of select="name"/>
+    {
+
+        public <xsl:value-of select="name"/>Client()
+        {}
+        public <xsl:value-of select="name"/>Client(string endpointConfigurationName) 
+            : base(endpointConfigurationName) 
+        {}
+        public <xsl:value-of select="name"/>Client(string endpointConfigurationName, string remoteAddress) 
+            : base(endpointConfigurationName, remoteAddress)
+        {}
+        public <xsl:value-of select="name"/>Client(string endpointConfigurationName, global::System.ServiceModel.EndpointAddress remoteAddress)
+            : base(endpointConfigurationName, remoteAddress)
+        {}
+        public <xsl:value-of select="name"/>Client(global::System.ServiceModel.Channels.Binding binding, global::System.ServiceModel.EndpointAddress remoteAddress)
+            : base(binding, remoteAddress)
+        {}
+
+        <xsl:apply-templates select="method/MethodDescriptorProto" mode="clientProxy"/>
+    }  
+  </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto" mode="clientProxy">
+  <xsl:if test="$optionAsynchronous and $optionDataContract and $optionClientProxy">
+        private BeginOperationDelegate onBegin<xsl:value-of select="name"/>Delegate;
+        private EndOperationDelegate onEnd<xsl:value-of select="name"/>Delegate;
+        private global::System.Threading.SendOrPostCallback on<xsl:value-of select="name"/>CompletedDelegate;
+
+        public event global::System.EventHandler&lt;<xsl:value-of select="name"/>CompletedEventArgs&gt; <xsl:value-of select="name"/>Completed;
+
+        public <xsl:apply-templates select="output_type"/><xsl:text xml:space="preserve"> </xsl:text><xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request)
+        {
+            return base.Channel.<xsl:value-of select="name"/>(request);
+        }
+
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public global::System.IAsyncResult Begin<xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request, global::System.AsyncCallback callback, object asyncState)
+        {
+            return base.Channel.Begin<xsl:value-of select="name"/>(request, callback, asyncState);
+        }
+
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        public <xsl:apply-templates select="output_type"/> End<xsl:value-of select="name"/>(global::System.IAsyncResult result)
+        {
+            return base.Channel.End<xsl:value-of select="name"/>(result);
+        }
+
+        private global::System.IAsyncResult OnBegin<xsl:value-of select="name"/>(object[] inValues, global::System.AsyncCallback callback, object asyncState)
+        {
+            <xsl:apply-templates select="input_type"/> request = ((<xsl:apply-templates select="input_type"/>)(inValues[0]));
+            return this.Begin<xsl:value-of select="name"/>(request, callback, asyncState);
+        }
+
+        private object[] OnEnd<xsl:value-of select="name"/>(global::System.IAsyncResult result)
+        {
+            <xsl:apply-templates select="output_type"/> retVal = this.End<xsl:value-of select="name"/>(result);
+            return new object[] {
+                retVal};
+        }
+
+        private void On<xsl:value-of select="name"/>Completed(object state)
+        {
+            if ((this.<xsl:value-of select="name"/>Completed != null))
+            {
+                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
+                this.<xsl:value-of select="name"/>Completed(this, new <xsl:value-of select="name"/>CompletedEventArgs(e.Results, e.Error, e.Cancelled, e.UserState));
+            }
+        }
+
+        public void <xsl:value-of select="name"/>Async(<xsl:apply-templates select="input_type"/> request)
+        {
+            this.<xsl:value-of select="name"/>Async(request, null);
+        }
+
+        public void <xsl:value-of select="name"/>Async(<xsl:apply-templates select="input_type"/> request, object userState)
+        {
+            if ((this.onBegin<xsl:value-of select="name"/>Delegate == null))
+            {
+                this.onBegin<xsl:value-of select="name"/>Delegate = new BeginOperationDelegate(this.OnBegin<xsl:value-of select="name"/>);
+            }
+            if ((this.onEnd<xsl:value-of select="name"/>Delegate == null))
+            {
+                this.onEnd<xsl:value-of select="name"/>Delegate = new EndOperationDelegate(this.OnEnd<xsl:value-of select="name"/>);
+            }
+            if ((this.on<xsl:value-of select="name"/>CompletedDelegate == null))
+            {
+                this.on<xsl:value-of select="name"/>CompletedDelegate = new global::System.Threading.SendOrPostCallback(this.On<xsl:value-of select="name"/>Completed);
+            }
+            base.InvokeAsync(this.onBegin<xsl:value-of select="name"/>Delegate, new object[] {
+                    request}, this.onEnd<xsl:value-of select="name"/>Delegate, this.on<xsl:value-of select="name"/>CompletedDelegate, userState);
+        }
+    </xsl:if>
+    </xsl:template>
+</xsl:stylesheet>

CSharp/Tools/ProtoGen/descriptor.proto

@@ -0,0 +1,533 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+
+
+package google.protobuf;
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DescriptorProtos";
+
+// descriptor.proto must be optimized for speed because reflection-based
+// algorithms don't work during bootstrapping.
+option optimize_for = SPEED;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+  repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+  optional string name = 1;       // file name, relative to root of source tree
+  optional string package = 2;    // e.g. "foo", "foo.bar", etc.
+
+  // Names of files imported by this file.
+  repeated string dependency = 3;
+
+  // All top-level definitions in this file.
+  repeated DescriptorProto message_type = 4;
+  repeated EnumDescriptorProto enum_type = 5;
+  repeated ServiceDescriptorProto service = 6;
+  repeated FieldDescriptorProto extension = 7;
+
+  optional FileOptions options = 8;
+
+  // This field contains optional information about the original source code.
+  // You may safely remove this entire field whithout harming runtime
+  // functionality of the descriptors -- the information is needed only by
+  // development tools.
+  optional SourceCodeInfo source_code_info = 9;
+}
+
+// Describes a message type.
+message DescriptorProto {
+  optional string name = 1;
+
+  repeated FieldDescriptorProto field = 2;
+  repeated FieldDescriptorProto extension = 6;
+
+  repeated DescriptorProto nested_type = 3;
+  repeated EnumDescriptorProto enum_type = 4;
+
+  message ExtensionRange {
+    optional int32 start = 1;
+    optional int32 end = 2;
+  }
+  repeated ExtensionRange extension_range = 5;
+
+  optional MessageOptions options = 7;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+  enum Type {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    TYPE_DOUBLE         = 1;
+    TYPE_FLOAT          = 2;
+    TYPE_INT64          = 3;   // Not ZigZag encoded.  Negative numbers
+                               // take 10 bytes.  Use TYPE_SINT64 if negative
+                               // values are likely.
+    TYPE_UINT64         = 4;
+    TYPE_INT32          = 5;   // Not ZigZag encoded.  Negative numbers
+                               // take 10 bytes.  Use TYPE_SINT32 if negative
+                               // values are likely.
+    TYPE_FIXED64        = 6;
+    TYPE_FIXED32        = 7;
+    TYPE_BOOL           = 8;
+    TYPE_STRING         = 9;
+    TYPE_GROUP          = 10;  // Tag-delimited aggregate.
+    TYPE_MESSAGE        = 11;  // Length-delimited aggregate.
+
+    // New in version 2.
+    TYPE_BYTES          = 12;
+    TYPE_UINT32         = 13;
+    TYPE_ENUM           = 14;
+    TYPE_SFIXED32       = 15;
+    TYPE_SFIXED64       = 16;
+    TYPE_SINT32         = 17;  // Uses ZigZag encoding.
+    TYPE_SINT64         = 18;  // Uses ZigZag encoding.
+  };
+
+  enum Label {
+    // 0 is reserved for errors
+    LABEL_OPTIONAL      = 1;
+    LABEL_REQUIRED      = 2;
+    LABEL_REPEATED      = 3;
+    // TODO(sanjay): Should we add LABEL_MAP?
+  };
+
+  optional string name = 1;
+  optional int32 number = 3;
+  optional Label label = 4;
+
+  // If type_name is set, this need not be set.  If both this and type_name
+  // are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
+  optional Type type = 5;
+
+  // For message and enum types, this is the name of the type.  If the name
+  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+  // rules are used to find the type (i.e. first the nested types within this
+  // message are searched, then within the parent, on up to the root
+  // namespace).
+  optional string type_name = 6;
+
+  // For extensions, this is the name of the type being extended.  It is
+  // resolved in the same manner as type_name.
+  optional string extendee = 2;
+
+  // For numeric types, contains the original text representation of the value.
+  // For booleans, "true" or "false".
+  // For strings, contains the default text contents (not escaped in any way).
+  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+  // TODO(kenton):  Base-64 encode?
+  optional string default_value = 7;
+
+  optional FieldOptions options = 8;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+  optional string name = 1;
+
+  repeated EnumValueDescriptorProto value = 2;
+
+  optional EnumOptions options = 3;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+  optional string name = 1;
+  optional int32 number = 2;
+
+  optional EnumValueOptions options = 3;
+}
+
+// Describes a service.
+message ServiceDescriptorProto {
+  optional string name = 1;
+  repeated MethodDescriptorProto method = 2;
+
+  optional ServiceOptions options = 3;
+}
+
+// Describes a method of a service.
+message MethodDescriptorProto {
+  optional string name = 1;
+
+  // Input and output type names.  These are resolved in the same way as
+  // FieldDescriptorProto.type_name, but must refer to a message type.
+  optional string input_type = 2;
+  optional string output_type = 3;
+
+  optional MethodOptions options = 4;
+}
+
+// ===================================================================
+// Options
+
+// Each of the definitions above may have "options" attached.  These are
+// just annotations which may cause code to be generated slightly differently
+// or may contain hints for code that manipulates protocol messages.
+//
+// Clients may define custom options as extensions of the *Options messages.
+// These extensions may not yet be known at parsing time, so the parser cannot
+// store the values in them.  Instead it stores them in a field in the *Options
+// message called uninterpreted_option. This field must have the same name
+// across all *Options messages. We then use this field to populate the
+// extensions when we build a descriptor, at which point all protos have been
+// parsed and so all extensions are known.
+//
+// Extension numbers for custom options may be chosen as follows:
+// * For options which will only be used within a single application or
+//   organization, or for experimental options, use field numbers 50000
+//   through 99999.  It is up to you to ensure that you do not use the
+//   same number for multiple options.
+// * For options which will be published and used publicly by multiple
+//   independent entities, e-mail kenton@google.com to reserve extension
+//   numbers.  Simply tell me how many you need and I'll send you back a
+//   set of numbers to use -- there's no need to explain how you intend to
+//   use them.  If this turns out to be popular, a web service will be set up
+//   to automatically assign option numbers.
+
+
+message FileOptions {
+
+  // Sets the Java package where classes generated from this .proto will be
+  // placed.  By default, the proto package is used, but this is often
+  // inappropriate because proto packages do not normally start with backwards
+  // domain names.
+  optional string java_package = 1;
+
+
+  // If set, all the classes from the .proto file are wrapped in a single
+  // outer class with the given name.  This applies to both Proto1
+  // (equivalent to the old "--one_java_file" option) and Proto2 (where
+  // a .proto always translates to a single class, but you may want to
+  // explicitly choose the class name).
+  optional string java_outer_classname = 8;
+
+  // If set true, then the Java code generator will generate a separate .java
+  // file for each top-level message, enum, and service defined in the .proto
+  // file.  Thus, these types will *not* be nested inside the outer class
+  // named by java_outer_classname.  However, the outer class will still be
+  // generated to contain the file's getDescriptor() method as well as any
+  // top-level extensions defined in the file.
+  optional bool java_multiple_files = 10 [default=false];
+
+  // If set true, then the Java code generator will generate equals() and
+  // hashCode() methods for all messages defined in the .proto file. This is
+  // purely a speed optimization, as the AbstractMessage base class includes
+  // reflection-based implementations of these methods.
+  optional bool java_generate_equals_and_hash = 20 [default=false];
+
+  // Generated classes can be optimized for speed or code size.
+  enum OptimizeMode {
+    SPEED = 1;        // Generate complete code for parsing, serialization,
+                      // etc.
+    CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
+    LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
+  }
+  optional OptimizeMode optimize_for = 9 [default=SPEED];
+
+
+
+
+  // Should generic services be generated in each language?  "Generic" services
+  // are not specific to any particular RPC system.  They are generated by the
+  // main code generators in each language (without additional plugins).
+  // Generic services were the only kind of service generation supported by
+  // early versions of proto2.
+  //
+  // Generic services are now considered deprecated in favor of using plugins
+  // that generate code specific to your particular RPC system.  Therefore,
+  // these default to false.  Old code which depends on generic services should
+  // explicitly set them to true.
+  optional bool cc_generic_services = 16 [default=false];
+  optional bool java_generic_services = 17 [default=false];
+  optional bool py_generic_services = 18 [default=false];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message MessageOptions {
+  // Set true to use the old proto1 MessageSet wire format for extensions.
+  // This is provided for backwards-compatibility with the MessageSet wire
+  // format.  You should not use this for any other reason:  It's less
+  // efficient, has fewer features, and is more complicated.
+  //
+  // The message must be defined exactly as follows:
+  //   message Foo {
+  //     option message_set_wire_format = true;
+  //     extensions 4 to max;
+  //   }
+  // Note that the message cannot have any defined fields; MessageSets only
+  // have extensions.
+  //
+  // All extensions of your type must be singular messages; e.g. they cannot
+  // be int32s, enums, or repeated messages.
+  //
+  // Because this is an option, the above two restrictions are not enforced by
+  // the protocol compiler.
+  optional bool message_set_wire_format = 1 [default=false];
+
+  // Disables the generation of the standard "descriptor()" accessor, which can
+  // conflict with a field of the same name.  This is meant to make migration
+  // from proto1 easier; new code should avoid fields named "descriptor".
+  optional bool no_standard_descriptor_accessor = 2 [default=false];
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message FieldOptions {
+  // The ctype option instructs the C++ code generator to use a different
+  // representation of the field than it normally would.  See the specific
+  // options below.  This option is not yet implemented in the open source
+  // release -- sorry, we'll try to include it in a future version!
+  optional CType ctype = 1 [default = STRING];
+  enum CType {
+    // Default mode.
+    STRING = 0;
+
+    CORD = 1;
+
+    STRING_PIECE = 2;
+  }
+  // The packed option can be enabled for repeated primitive fields to enable
+  // a more efficient representation on the wire. Rather than repeatedly
+  // writing the tag and type for each element, the entire array is encoded as
+  // a single length-delimited blob.
+  optional bool packed = 2;
+
+
+  // Is this field deprecated?
+  // Depending on the target platform, this can emit Deprecated annotations
+  // for accessors, or it will be completely ignored; in the very least, this
+  // is a formalization for deprecating fields.
+  optional bool deprecated = 3 [default=false];
+
+  // EXPERIMENTAL.  DO NOT USE.
+  // For "map" fields, the name of the field in the enclosed type that
+  // is the key for this map.  For example, suppose we have:
+  //   message Item {
+  //     required string name = 1;
+  //     required string value = 2;
+  //   }
+  //   message Config {
+  //     repeated Item items = 1 [experimental_map_key="name"];
+  //   }
+  // In this situation, the map key for Item will be set to "name".
+  // TODO: Fully-implement this, then remove the "experimental_" prefix.
+  optional string experimental_map_key = 9;
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message EnumOptions {
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message EnumValueOptions {
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message ServiceOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+message MethodOptions {
+
+  // Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
+  //   framework.  We apologize for hoarding these numbers to ourselves, but
+  //   we were already using them long before we decided to release Protocol
+  //   Buffers.
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+message UninterpretedOption {
+  // The name of the uninterpreted option.  Each string represents a segment in
+  // a dot-separated name.  is_extension is true iff a segment represents an
+  // extension (denoted with parentheses in options specs in .proto files).
+  // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+  // "foo.(bar.baz).qux".
+  message NamePart {
+    required string name_part = 1;
+    required bool is_extension = 2;
+  }
+  repeated NamePart name = 2;
+
+  // The value of the uninterpreted option, in whatever type the tokenizer
+  // identified it as during parsing. Exactly one of these should be set.
+  optional string identifier_value = 3;
+  optional uint64 positive_int_value = 4;
+  optional int64 negative_int_value = 5;
+  optional double double_value = 6;
+  optional bytes string_value = 7;
+  optional string aggregate_value = 8;
+}
+
+// ===================================================================
+// Optional source code info
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+message SourceCodeInfo {
+  // A Location identifies a piece of source code in a .proto file which
+  // corresponds to a particular definition.  This information is intended
+  // to be useful to IDEs, code indexers, documentation generators, and similar
+  // tools.
+  //
+  // For example, say we have a file like:
+  //   message Foo {
+  //     optional string foo = 1;
+  //   }
+  // Let's look at just the field definition:
+  //   optional string foo = 1;
+  //   ^       ^^     ^^  ^  ^^^
+  //   a       bc     de  f  ghi
+  // We have the following locations:
+  //   span   path               represents
+  //   [a,i)  [ 4, 0, 2, 0 ]     The whole field definition.
+  //   [a,b)  [ 4, 0, 2, 0, 4 ]  The label (optional).
+  //   [c,d)  [ 4, 0, 2, 0, 5 ]  The type (string).
+  //   [e,f)  [ 4, 0, 2, 0, 1 ]  The name (foo).
+  //   [g,h)  [ 4, 0, 2, 0, 3 ]  The number (1).
+  //
+  // Notes:
+  // - A location may refer to a repeated field itself (i.e. not to any
+  //   particular index within it).  This is used whenever a set of elements are
+  //   logically enclosed in a single code segment.  For example, an entire
+  //   extend block (possibly containing multiple extension definitions) will
+  //   have an outer location whose path refers to the "extensions" repeated
+  //   field without an index.
+  // - Multiple locations may have the same path.  This happens when a single
+  //   logical declaration is spread out across multiple places.  The most
+  //   obvious example is the "extend" block again -- there may be multiple
+  //   extend blocks in the same scope, each of which will have the same path.
+  // - A location's span is not always a subset of its parent's span.  For
+  //   example, the "extendee" of an extension declaration appears at the
+  //   beginning of the "extend" block and is shared by all extensions within
+  //   the block.
+  // - Just because a location's span is a subset of some other location's span
+  //   does not mean that it is a descendent.  For example, a "group" defines
+  //   both a type and a field in a single declaration.  Thus, the locations
+  //   corresponding to the type and field and their components will overlap.
+  // - Code which tries to interpret locations should probably be designed to
+  //   ignore those that it doesn't understand, as more types of locations could
+  //   be recorded in the future.
+  repeated Location location = 1;
+  message Location {
+    // Identifies which part of the FileDescriptorProto was defined at this
+    // location.
+    //
+    // Each element is a field number or an index.  They form a path from
+    // the root FileDescriptorProto to the place where the definition.  For
+    // example, this path:
+    //   [ 4, 3, 2, 7, 1 ]
+    // refers to:
+    //   file.message_type(3)  // 4, 3
+    //       .field(7)         // 2, 7
+    //       .name()           // 1
+    // This is because FileDescriptorProto.message_type has field number 4:
+    //   repeated DescriptorProto message_type = 4;
+    // and DescriptorProto.field has field number 2:
+    //   repeated FieldDescriptorProto field = 2;
+    // and FieldDescriptorProto.name has field number 1:
+    //   optional string name = 1;
+    //
+    // Thus, the above path gives the location of a field name.  If we removed
+    // the last element:
+    //   [ 4, 3, 2, 7 ]
+    // this path refers to the whole field declaration (from the beginning
+    // of the label to the terminating semicolon).
+    repeated int32 path = 1 [packed=true];
+
+    // Always has exactly three or four elements: start line, start column,
+    // end line (optional, otherwise assumed same as start line), end column.
+    // These are packed into a single field for efficiency.  Note that line
+    // and column numbers are zero-based -- typically you will want to add
+    // 1 to each before displaying to a user.
+    repeated int32 span = 2 [packed=true];
+
+    // TODO(kenton):  Record comments appearing before and after the
+    // declaration.
+  }
+}

CSharp/Tools/ProtoGen/protobuf-net.xml

@@ -0,0 +1,2825 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>protobuf-net</name>
+    </assembly>
+    <members>
+        <member name="T:ProtoBuf.BclHelpers">
+            <summary>
+            Provides support for common .NET types that do not have a direct representation
+            in protobuf, using the definitions from bcl.proto
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.GetUninitializedObject(System.Type)">
+            <summary>
+            Creates a new instance of the specified type, bypassing the constructor.
+            </summary>
+            <param name="type">The type to create</param>
+            <returns>The new instance</returns>
+            <exception cref="T:System.NotSupportedException">If the platform does not support constructor-skipping</exception>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.WriteTimeSpan(System.TimeSpan,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a TimeSpan to a protobuf stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.ReadTimeSpan(ProtoBuf.ProtoReader)">
+            <summary>
+            Parses a TimeSpan from a protobuf stream
+            </summary>        
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.ReadDateTime(ProtoBuf.ProtoReader)">
+            <summary>
+            Parses a DateTime from a protobuf stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.WriteDateTime(System.DateTime,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a DateTime to a protobuf stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.ReadDecimal(ProtoBuf.ProtoReader)">
+            <summary>
+            Parses a decimal from a protobuf stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.WriteDecimal(System.Decimal,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a decimal to a protobuf stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.WriteGuid(System.Guid,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a Guid to a protobuf stream
+            </summary>        
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.ReadGuid(ProtoBuf.ProtoReader)">
+            <summary>
+            Parses a Guid from a protobuf stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.ReadNetObject(System.Object,ProtoBuf.ProtoReader,System.Int32,System.Type,ProtoBuf.BclHelpers.NetObjectOptions)">
+            <summary>
+            Reads an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.BclHelpers.WriteNetObject(System.Object,ProtoBuf.ProtoWriter,System.Int32,ProtoBuf.BclHelpers.NetObjectOptions)">
+            <summary>
+            Writes an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.BclHelpers.NetObjectOptions">
+            <summary>
+            Optional behaviours that introduce .NET-specific functionality
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.None">
+            <summary>
+            No special behaviour
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.AsReference">
+            <summary>
+            Enables full object-tracking/full-graph support.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.DynamicType">
+            <summary>
+            Embeds the type information into the stream, allowing usage with types not known in advance.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.UseConstructor">
+            <summary>
+            If false, the constructor for the type is bypassed during deserialization, meaning any field initializers
+            or other initialization code is skipped.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.BufferExtension">
+            <summary>
+            Provides a simple buffer-based implementation of an <see cref="T:ProtoBuf.IExtension">extension</see> object.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.IExtension">
+            <summary>
+            Provides addition capability for supporting unexpected fields during
+            protocol-buffer serialization/deserialization. This allows for loss-less
+            round-trip/merge, even when the data is not fully understood.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.IExtension.BeginAppend">
+            <summary>
+            Requests a stream into which any unexpected fields can be persisted.
+            </summary>
+            <returns>A new stream suitable for storing data.</returns>
+        </member>
+        <member name="M:ProtoBuf.IExtension.EndAppend(System.IO.Stream,System.Boolean)">
+            <summary>
+            Indicates that all unexpected fields have now been stored. The
+            implementing class is responsible for closing the stream. If
+            "commit" is not true the data may be discarded.
+            </summary>
+            <param name="stream">The stream originally obtained by BeginAppend.</param>
+            <param name="commit">True if the append operation completed successfully.</param>
+        </member>
+        <member name="M:ProtoBuf.IExtension.BeginQuery">
+            <summary>
+            Requests a stream of the unexpected fields previously stored.
+            </summary>
+            <returns>A prepared stream of the unexpected fields.</returns>
+        </member>
+        <member name="M:ProtoBuf.IExtension.EndQuery(System.IO.Stream)">
+            <summary>
+            Indicates that all unexpected fields have now been read. The
+            implementing class is responsible for closing the stream.
+            </summary>
+            <param name="stream">The stream originally obtained by BeginQuery.</param>
+        </member>
+        <member name="M:ProtoBuf.IExtension.GetLength">
+            <summary>
+            Requests the length of the raw binary stream; this is used
+            when serializing sub-entities to indicate the expected size.
+            </summary>
+            <returns>The length of the binary stream representing unexpected data.</returns>
+        </member>
+        <member name="T:ProtoBuf.ProtoBeforeSerializationAttribute">
+            <summary>Specifies a method on the root-contract in an hierarchy to be invoked before serialization.</summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoAfterSerializationAttribute">
+            <summary>Specifies a method on the root-contract in an hierarchy to be invoked after serialization.</summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoBeforeDeserializationAttribute">
+            <summary>Specifies a method on the root-contract in an hierarchy to be invoked before deserialization.</summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoAfterDeserializationAttribute">
+            <summary>Specifies a method on the root-contract in an hierarchy to be invoked after deserialization.</summary>
+        </member>
+        <member name="M:ProtoBuf.Compiler.CompilerContext.LoadNullRef">
+            <summary>
+            Pushes a null reference onto the stack. Note that this should only
+            be used to return a null (or set a variable to null); for null-tests
+            use BranchIfTrue / BranchIfFalse.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Compiler.CompilerContext.UsingBlock.#ctor(ProtoBuf.Compiler.CompilerContext,ProtoBuf.Compiler.Local)">
+            <summary>
+            Creates a new "using" block (equivalent) around a variable;
+            the variable must exist, and note that (unlike in C#) it is
+            the variables *final* value that gets disposed. If you need
+            *original* disposal, copy your variable first.
+            
+            It is the callers responsibility to ensure that the variable's
+            scope fully-encapsulates the "using"; if not, the variable
+            may be re-used (and thus re-assigned) unexpectedly.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.DataFormat">
+            <summary>
+            Sub-format to use when serializing/deserializing data
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.DataFormat.Default">
+            <summary>
+            Uses the default encoding for the data-type.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.DataFormat.ZigZag">
+            <summary>
+            When applied to signed integer-based data (including Decimal), this
+            indicates that zigzag variant encoding will be used. This means that values
+            with small magnitude (regardless of sign) take a small amount
+            of space to encode.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.DataFormat.TwosComplement">
+            <summary>
+            When applied to signed integer-based data (including Decimal), this
+            indicates that two's-complement variant encoding will be used.
+            This means that any -ve number will take 10 bytes (even for 32-bit),
+            so should only be used for compatibility.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.DataFormat.FixedSize">
+            <summary>
+            When applied to signed integer-based data (including Decimal), this
+            indicates that a fixed amount of space will be used.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.DataFormat.Group">
+            <summary>
+            When applied to a sub-message, indicates that the value should be treated
+            as group-delimited.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Extensible">
+            <summary>
+            Simple base class for supporting unexpected fields allowing
+            for loss-less round-tips/merge, even if the data is not understod.
+            The additional fields are (by default) stored in-memory in a buffer.
+            </summary>
+            <remarks>As an example of an alternative implementation, you might
+            choose to use the file system (temporary files) as the back-end, tracking
+            only the paths [such an object would ideally be IDisposable and use
+            a finalizer to ensure that the files are removed].</remarks>
+            <seealso cref="T:ProtoBuf.IExtensible"/>
+        </member>
+        <member name="T:ProtoBuf.IExtensible">
+            <summary>
+            Indicates that the implementing type has support for protocol-buffer
+            <see cref="T:ProtoBuf.IExtension">extensions</see>.
+            </summary>
+            <remarks>Can be implemented by deriving from Extensible.</remarks>
+        </member>
+        <member name="M:ProtoBuf.IExtensible.GetExtensionObject(System.Boolean)">
+            <summary>
+            Retrieves the <see cref="T:ProtoBuf.IExtension">extension</see> object for the current
+            instance, optionally creating it if it does not already exist.
+            </summary>
+            <param name="createIfMissing">Should a new extension object be
+            created if it does not already exist?</param>
+            <returns>The extension object if it exists (or was created), or null
+            if the extension object does not exist or is not available.</returns>
+            <remarks>The <c>createIfMissing</c> argument is false during serialization,
+            and true during deserialization upon encountering unexpected fields.</remarks>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetExtensionObject(System.Boolean)">
+            <summary>
+            Retrieves the <see cref="T:ProtoBuf.IExtension">extension</see> object for the current
+            instance, optionally creating it if it does not already exist.
+            </summary>
+            <param name="createIfMissing">Should a new extension object be
+            created if it does not already exist?</param>
+            <returns>The extension object if it exists (or was created), or null
+            if the extension object does not exist or is not available.</returns>
+            <remarks>The <c>createIfMissing</c> argument is false during serialization,
+            and true during deserialization upon encountering unexpected fields.</remarks>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetExtensionObject(ProtoBuf.IExtension@,System.Boolean)">
+            <summary>
+            Provides a simple, default implementation for <see cref="T:ProtoBuf.IExtension">extension</see> support,
+            optionally creating it if it does not already exist. Designed to be called by
+            classes implementing <see cref="T:ProtoBuf.IExtensible"/>.
+            </summary>
+            <param name="createIfMissing">Should a new extension object be
+            created if it does not already exist?</param>
+            <param name="extensionObject">The extension field to check (and possibly update).</param>
+            <returns>The extension object if it exists (or was created), or null
+            if the extension object does not exist or is not available.</returns>
+            <remarks>The <c>createIfMissing</c> argument is false during serialization,
+            and true during deserialization upon encountering unexpected fields.</remarks>
+        </member>
+        <member name="M:ProtoBuf.Extensible.AppendValue``1(ProtoBuf.IExtensible,System.Int32,``0)">
+            <summary>
+            Appends the value as an additional (unexpected) data-field for the instance.
+            Note that for non-repeated sub-objects, this equates to a merge operation;
+            for repeated sub-objects this adds a new instance to the set; for simple
+            values the new value supercedes the old value.
+            </summary>
+            <remarks>Note that appending a value does not remove the old value from
+            the stream; avoid repeatedly appending values for the same field.</remarks>
+            <typeparam name="TValue">The type of the value to append.</typeparam>
+            <param name="instance">The extensible object to append the value to.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="value">The value to append.</param>
+        </member>
+        <member name="M:ProtoBuf.Extensible.AppendValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,``0)">
+            <summary>
+            Appends the value as an additional (unexpected) data-field for the instance.
+            Note that for non-repeated sub-objects, this equates to a merge operation;
+            for repeated sub-objects this adds a new instance to the set; for simple
+            values the new value supercedes the old value.
+            </summary>
+            <remarks>Note that appending a value does not remove the old value from
+            the stream; avoid repeatedly appending values for the same field.</remarks>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="format">The data-format to use when encoding the value.</param>
+            <param name="instance">The extensible object to append the value to.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="value">The value to append.</param>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetValue``1(ProtoBuf.IExtensible,System.Int32)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            The value returned is the composed value after merging any duplicated content; if the
+            value is "repeated" (a list), then use GetValues instead.
+            </summary>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <returns>The effective value of the field, or the default value if not found.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            The value returned is the composed value after merging any duplicated content; if the
+            value is "repeated" (a list), then use GetValues instead.
+            </summary>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="format">The data-format to use when decoding the value.</param>
+            <returns>The effective value of the field, or the default value if not found.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.TryGetValue``1(ProtoBuf.IExtensible,System.Int32,``0@)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            The value returned (in "value") is the composed value after merging any duplicated content;
+            if the value is "repeated" (a list), then use GetValues instead.
+            </summary>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="value">The effective value of the field, or the default value if not found.</param>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <returns>True if data for the field was present, false otherwise.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.TryGetValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,``0@)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            The value returned (in "value") is the composed value after merging any duplicated content;
+            if the value is "repeated" (a list), then use GetValues instead.
+            </summary>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="value">The effective value of the field, or the default value if not found.</param>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="format">The data-format to use when decoding the value.</param>
+            <returns>True if data for the field was present, false otherwise.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.TryGetValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,``0@)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            The value returned (in "value") is the composed value after merging any duplicated content;
+            if the value is "repeated" (a list), then use GetValues instead.
+            </summary>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="value">The effective value of the field, or the default value if not found.</param>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="format">The data-format to use when decoding the value.</param>
+            <param name="allowDefinedTag">Allow tags that are present as part of the definition; for example, to query unknown enum values.</param>
+            <returns>True if data for the field was present, false otherwise.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetValues``1(ProtoBuf.IExtensible,System.Int32)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
+            (list) fields.
+            </summary>
+            <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <returns>An enumerator that yields each occurrence of the field.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetValues``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
+            (list) fields.
+            </summary>
+            <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
+            <typeparam name="TValue">The data-type of the field.</typeparam>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="format">The data-format to use when decoding the value.</param>
+            <returns>An enumerator that yields each occurrence of the field.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.TryGetValue(ProtoBuf.Meta.TypeModel,System.Type,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,System.Object@)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            The value returned (in "value") is the composed value after merging any duplicated content;
+            if the value is "repeated" (a list), then use GetValues instead.
+            </summary>
+            <param name="type">The data-type of the field.</param>
+            <param name="model">The model to use for configuration.</param>
+            <param name="value">The effective value of the field, or the default value if not found.</param>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="format">The data-format to use when decoding the value.</param>
+            <param name="allowDefinedTag">Allow tags that are present as part of the definition; for example, to query unknown enum values.</param>
+            <returns>True if data for the field was present, false otherwise.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.GetValues(ProtoBuf.Meta.TypeModel,System.Type,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat)">
+            <summary>
+            Queries an extensible object for an additional (unexpected) data-field for the instance.
+            Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
+            (list) fields.
+            </summary>
+            <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
+            <param name="model">The model to use for configuration.</param>
+            <param name="type">The data-type of the field.</param>
+            <param name="instance">The extensible object to obtain the value from.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="format">The data-format to use when decoding the value.</param>
+            <returns>An enumerator that yields each occurrence of the field.</returns>
+        </member>
+        <member name="M:ProtoBuf.Extensible.AppendValue(ProtoBuf.Meta.TypeModel,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Object)">
+            <summary>
+            Appends the value as an additional (unexpected) data-field for the instance.
+            Note that for non-repeated sub-objects, this equates to a merge operation;
+            for repeated sub-objects this adds a new instance to the set; for simple
+            values the new value supercedes the old value.
+            </summary>
+            <remarks>Note that appending a value does not remove the old value from
+            the stream; avoid repeatedly appending values for the same field.</remarks>
+            <param name="model">The model to use for configuration.</param>
+            <param name="format">The data-format to use when encoding the value.</param>
+            <param name="instance">The extensible object to append the value to.</param>
+            <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
+            <param name="value">The value to append.</param>
+        </member>
+        <member name="T:ProtoBuf.ExtensibleUtil">
+            <summary>
+            This class acts as an internal wrapper allowing us to do a dynamic
+            methodinfo invoke; an't put into Serializer as don't want on public
+            API; can't put into Serializer&lt;T&gt; since we need to invoke
+            accross classes, which isn't allowed in Silverlight)
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ExtensibleUtil.GetExtendedValues``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,System.Boolean)">
+            <summary>
+            All this does is call GetExtendedValuesTyped with the correct type for "instance";
+            this ensures that we don't get issues with subclasses declaring conflicting types -
+            the caller must respect the fields defined for the type they pass in.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ExtensibleUtil.GetExtendedValues(ProtoBuf.Meta.TypeModel,System.Type,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,System.Boolean)">
+            <summary>
+            All this does is call GetExtendedValuesTyped with the correct type for "instance";
+            this ensures that we don't get issues with subclasses declaring conflicting types -
+            the caller must respect the fields defined for the type they pass in.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ExtensibleUtil.AppendExtendValueTyped``2(ProtoBuf.Meta.TypeModel,``0,System.Int32,ProtoBuf.DataFormat,``1)">
+            <summary>
+            Stores the given value into the instance's stream; the serializer
+            is inferred from TValue and format.
+            </summary>
+            <remarks>Needs to be public to be callable thru reflection in Silverlight</remarks>
+        </member>
+        <member name="T:ProtoBuf.Helpers">
+            <summary>
+            Not all frameworks are created equal (fx1.1 vs fx2.0,
+            micro-framework, compact-framework,
+            silverlight, etc). This class simply wraps up a few things that would
+            otherwise make the real code unnecessarily messy, providing fallback
+            implementations if necessary.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoTypeCode">
+            <summary>
+            Intended to be a direct map to regular TypeCode, but:
+            - with missing types
+            - existing on WinRT
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ImplicitFields">
+            <summary>
+            Specifies the method used to infer field tags for members of the type
+            under consideration. Tags are deduced using the invariant alphabetic
+            sequence of the members' names; this makes implicit field tags very brittle,
+            and susceptible to changes such as field names (normally an isolated
+            change).
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.ImplicitFields.None">
+            <summary>
+            No members are serialized implicitly; all members require a suitable
+            attribute such as [ProtoMember]. This is the recmomended mode for
+            most scenarios.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.ImplicitFields.AllPublic">
+            <summary>
+            Public properties and fields are eligible for implicit serialization;
+            this treats the public API as a contract. Ordering beings from ImplicitFirstTag.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.ImplicitFields.AllFields">
+            <summary>
+            Public and non-public fields are eligible for implicit serialization;
+            this acts as a state/implementation serializer. Ordering beings from ImplicitFirstTag.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.CallbackSet">
+            <summary>
+            Represents the set of serialization callbacks to be used when serializing/deserializing a type.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.CallbackSet.BeforeSerialize">
+            <summary>Called before serializing an instance</summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.CallbackSet.BeforeDeserialize">
+            <summary>Called before deserializing an instance</summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.CallbackSet.AfterSerialize">
+            <summary>Called after serializing an instance</summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.CallbackSet.AfterDeserialize">
+            <summary>Called after deserializing an instance</summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.CallbackSet.NonTrivial">
+            <summary>
+            True if any callback is set, else False
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.MetaType">
+            <summary>
+            Represents a type at runtime for use with protobuf, allowing the field mappings (etc) to be defined
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.ToString">
+            <summary>
+            Get the name of the type being represented
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.AddSubType(System.Int32,System.Type)">
+            <summary>
+            Adds a known sub-type to the inheritance model
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.AddSubType(System.Int32,System.Type,ProtoBuf.DataFormat)">
+            <summary>
+            Adds a known sub-type to the inheritance model
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.SetCallbacks(System.Reflection.MethodInfo,System.Reflection.MethodInfo,System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
+            <summary>
+            Assigns the callbacks to use during serialiation/deserialization.
+            </summary>
+            <param name="beforeSerialize">The method (or null) called before serialization begins.</param>
+            <param name="afterSerialize">The method (or null) called when serialization is complete.</param>
+            <param name="beforeDeserialize">The method (or null) called before deserialization begins (or when a new instance is created during deserialization).</param>
+            <param name="afterDeserialize">The method (or null) called when deserialization is complete.</param>
+            <returns>The set of callbacks.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.SetCallbacks(System.String,System.String,System.String,System.String)">
+            <summary>
+            Assigns the callbacks to use during serialiation/deserialization.
+            </summary>
+            <param name="beforeSerialize">The name of the method (or null) called before serialization begins.</param>
+            <param name="afterSerialize">The name of the method (or null) called when serialization is complete.</param>
+            <param name="beforeDeserialize">The name of the method (or null) called before deserialization begins (or when a new instance is created during deserialization).</param>
+            <param name="afterDeserialize">The name of the method (or null) called when deserialization is complete.</param>
+            <returns>The set of callbacks.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.SetFactory(System.Reflection.MethodInfo)">
+            <summary>
+            Designate a factory-method to use to create instances of this type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.SetFactory(System.String)">
+            <summary>
+            Designate a factory-method to use to create instances of this type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.ThrowIfFrozen">
+            <summary>
+            Throws an exception if the type has been made immutable
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.Add(System.Int32,System.String)">
+            <summary>
+            Adds a member (by name) to the MetaType
+            </summary>        
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.AddField(System.Int32,System.String)">
+            <summary>
+            Adds a member (by name) to the MetaType, returning the ValueMember rather than the fluent API.
+            This is otherwise identical to Add.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.Add(System.String)">
+            <summary>
+            Adds a member (by name) to the MetaType
+            </summary>     
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.SetSurrogate(System.Type)">
+            <summary>
+            Performs serialization of this type via a surrogate; all
+            other serialization options are ignored and handled
+            by the surrogate's configuration.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.Add(System.String[])">
+            <summary>
+            Adds a set of members (by name) to the MetaType
+            </summary>     
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.Add(System.Int32,System.String,System.Object)">
+            <summary>
+            Adds a member (by name) to the MetaType
+            </summary>        
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.Add(System.Int32,System.String,System.Type,System.Type)">
+            <summary>
+            Adds a member (by name) to the MetaType, including an itemType and defaultType for representing lists
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.AddField(System.Int32,System.String,System.Type,System.Type)">
+            <summary>
+            Adds a member (by name) to the MetaType, including an itemType and defaultType for representing lists, returning the ValueMember rather than the fluent API.
+            This is otherwise identical to Add.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.GetFields">
+            <summary>
+            Returns the ValueMember instances associated with this type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.GetSubtypes">
+            <summary>
+            Returns the SubType instances associated with this type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.MetaType.CompileInPlace">
+            <summary>
+            Compiles the serializer for this type; this is *not* a full
+            standalone compile, but can significantly boost performance
+            while allowing additional types to be added.
+            </summary>
+            <remarks>An in-place compile can access non-public types / members</remarks>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.BaseType">
+            <summary>
+            Gets the base-type for this type
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.IncludeSerializerMethod">
+            <summary>
+            When used to compile a model, should public serialization/deserialzation methods
+            be included for this type?
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.AsReferenceDefault">
+            <summary>
+            Should this type be treated as a reference by default?
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.HasCallbacks">
+            <summary>
+            Indicates whether the current type has defined callbacks 
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.HasSubtypes">
+            <summary>
+            Indicates whether the current type has defined subtypes
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.Callbacks">
+            <summary>
+            Returns the set of callbacks defined for this type
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.Name">
+            <summary>
+            Gets or sets the name of this contract.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.Type">
+            <summary>
+            The runtime type that the meta-type represents
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.UseConstructor">
+            <summary>
+            Gets or sets whether the type should use a parameterless constructor (the default),
+            or whether the type should skip the constructor completely. This option is not supported
+            on compact-framework.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.ConstructType">
+            <summary>
+            The concrete type to create when a new instance of this type is needed; this may be useful when dealing
+            with dynamic proxies, or with interface-based APIs
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.Item(System.Int32)">
+            <summary>
+            Returns the ValueMember that matchs a given field number, or null if not found
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.Item(System.Reflection.MemberInfo)">
+            <summary>
+            Returns the ValueMember that matchs a given member (property/field), or null if not found
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.EnumPassthru">
+            <summary>
+            Gets or sets a value indicating that an enum should be treated directly as an int/short/etc, rather
+            than enforcing .proto enum rules. This is useful *in particul* for [Flags] enums.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.MetaType.IgnoreListHandling">
+            <summary>
+            Gets or sets a value indicating that this type should NOT be treated as a list, even if it has
+            familiar list-like characteristics (enumerable, add, etc)
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.RuntimeTypeModel">
+            <summary>
+            Provides protobuf serialization support for a number of types that can be defined at runtime
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.TypeModel">
+            <summary>
+            Provides protobuf serialization support for a number of types
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.MapType(System.Type)">
+            <summary>
+            Resolve a System.Type to the compiler-specific type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.MapType(System.Type,System.Boolean)">
+            <summary>
+            Resolve a System.Type to the compiler-specific type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.TrySerializeAuxiliaryType(ProtoBuf.ProtoWriter,System.Type,ProtoBuf.DataFormat,System.Int32,System.Object,System.Boolean)">
+            <summary>
+            This is the more "complete" version of Serialize, which handles single instances of mapped types.
+            The value is written as a complete field, including field-header and (for sub-objects) a
+            length-prefix
+            In addition to that, this provides support for:
+             - basic values; individual int / string / Guid / etc
+             - IEnumerable sequences of any type handled by TrySerializeAuxiliaryType
+             
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Serialize(System.IO.Stream,System.Object)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream.
+            </summary>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="dest">The destination stream to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Serialize(System.IO.Stream,System.Object,ProtoBuf.SerializationContext)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream.
+            </summary>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="dest">The destination stream to write to.</param>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Serialize(ProtoBuf.ProtoWriter,System.Object)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied writer.
+            </summary>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="dest">The destination writer to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
+            data - useful with network IO.
+            </summary>
+            <param name="type">The type being merged.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
+            data - useful with network IO.
+            </summary>
+            <param name="type">The type being merged.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="expectedField">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+            <param name="resolver">Used to resolve types on a per-field basis.</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver,System.Int32@)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
+            data - useful with network IO.
+            </summary>
+            <param name="type">The type being merged.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="expectedField">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+            <param name="resolver">Used to resolve types on a per-field basis.</param>
+            <param name="bytesRead">Returns the number of bytes consumed by this operation (includes length-prefix overheads and any skipped data).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems(System.IO.Stream,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver)">
+            <summary>
+            Reads a sequence of consecutive length-prefixed items from a stream, using
+            either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
+            are directly comparable to serializing multiple items in succession
+            (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
+            when serializing a list/array). When a tag is
+            specified, any records with different tags are silently omitted. The
+            tag is ignored. The tag is ignores for fixed-length prefixes.
+            </summary>
+            <param name="source">The binary stream containing the serialized records.</param>
+            <param name="style">The prefix style used in the data.</param>
+            <param name="expectedField">The tag of records to return (if non-positive, then no tag is
+            expected and all records are returned).</param>
+            <param name="resolver">On a field-by-field basis, the type of object to deserialize (can be null if "type" is specified). </param>
+            <param name="type">The type of object to deserialize (can be null if "resolver" is specified).</param>
+            <returns>The sequence of deserialized objects.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems(System.IO.Stream,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver,ProtoBuf.SerializationContext)">
+            <summary>
+            Reads a sequence of consecutive length-prefixed items from a stream, using
+            either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
+            are directly comparable to serializing multiple items in succession
+            (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
+            when serializing a list/array). When a tag is
+            specified, any records with different tags are silently omitted. The
+            tag is ignored. The tag is ignores for fixed-length prefixes.
+            </summary>
+            <param name="source">The binary stream containing the serialized records.</param>
+            <param name="style">The prefix style used in the data.</param>
+            <param name="expectedField">The tag of records to return (if non-positive, then no tag is
+            expected and all records are returned).</param>
+            <param name="resolver">On a field-by-field basis, the type of object to deserialize (can be null if "type" is specified). </param>
+            <param name="type">The type of object to deserialize (can be null if "resolver" is specified).</param>
+            <returns>The sequence of deserialized objects.</returns>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Reads a sequence of consecutive length-prefixed items from a stream, using
+            either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
+            are directly comparable to serializing multiple items in succession
+            (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
+            when serializing a list/array). When a tag is
+            specified, any records with different tags are silently omitted. The
+            tag is ignored. The tag is ignores for fixed-length prefixes.
+            </summary>
+            <typeparam name="T">The type of object to deserialize.</typeparam>
+            <param name="source">The binary stream containing the serialized records.</param>
+            <param name="style">The prefix style used in the data.</param>
+            <param name="expectedField">The tag of records to return (if non-positive, then no tag is
+            expected and all records are returned).</param>
+            <returns>The sequence of deserialized objects.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.SerializationContext)">
+            <summary>
+            Reads a sequence of consecutive length-prefixed items from a stream, using
+            either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
+            are directly comparable to serializing multiple items in succession
+            (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
+            when serializing a list/array). When a tag is
+            specified, any records with different tags are silently omitted. The
+            tag is ignored. The tag is ignores for fixed-length prefixes.
+            </summary>
+            <typeparam name="T">The type of object to deserialize.</typeparam>
+            <param name="source">The binary stream containing the serialized records.</param>
+            <param name="style">The prefix style used in the data.</param>
+            <param name="expectedField">The tag of records to return (if non-positive, then no tag is
+            expected and all records are returned).</param>
+            <returns>The sequence of deserialized objects.</returns>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.SerializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream,
+            with a length-prefix. This is useful for socket programming,
+            as DeserializeWithLengthPrefix can be used to read the single object back
+            from an ongoing stream.
+            </summary>
+            <param name="type">The type being serialized.</param>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="dest">The destination stream to write to.</param>
+            <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.SerializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.SerializationContext)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream,
+            with a length-prefix. This is useful for socket programming,
+            as DeserializeWithLengthPrefix can be used to read the single object back
+            from an ongoing stream.
+            </summary>
+            <param name="type">The type being serialized.</param>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="dest">The destination stream to write to.</param>
+            <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (which may be null).
+            </summary>
+            <param name="type">The type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type,ProtoBuf.SerializationContext)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (which may be null).
+            </summary>
+            <param name="type">The type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type,System.Int32)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (which may be null).
+            </summary>
+            <param name="type">The type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="length">The number of bytes to consume.</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type,System.Int32,ProtoBuf.SerializationContext)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (which may be null).
+            </summary>
+            <param name="type">The type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="length">The number of bytes to consume (or -1 to read to the end of the stream).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(ProtoBuf.ProtoReader,System.Object,System.Type)">
+            <summary>
+            Applies a protocol-buffer reader to an existing instance (which may be null).
+            </summary>
+            <param name="type">The type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The reader to apply to the instance (cannot be null).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.TryDeserializeAuxiliaryType(ProtoBuf.ProtoReader,ProtoBuf.DataFormat,System.Int32,System.Type,System.Object@,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
+            <summary>
+            This is the more "complete" version of Deserialize, which handles single instances of mapped types.
+            The value is read as a complete field, including field-header and (for sub-objects) a
+            length-prefix..kmc  
+            
+            In addition to that, this provides support for:
+             - basic values; individual int / string / Guid / etc
+             - IList sets of any type handled by TryDeserializeAuxiliaryType
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Create">
+            <summary>
+            Creates a new runtime model, to which the caller
+            can add support for a range of types. A model
+            can be used "as is", or can be compiled for
+            optimal performance.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.ResolveProxies(System.Type)">
+            <summary>
+            Applies common proxy scenarios, resolving the actual type to consider
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.IsDefined(System.Type)">
+            <summary>
+            Indicates whether the supplied type is explicitly modelled by the model
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.GetKey(System.Type@)">
+            <summary>
+            Provides the key that represents a given type in the current model.
+            The type is also normalized for proxies at the same time.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.GetKeyImpl(System.Type)">
+            <summary>
+            Provides the key that represents a given type in the current model.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Serialize(System.Int32,System.Object,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream.
+            </summary>
+            <param name="key">Represents the type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="dest">The destination stream to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.Int32,System.Object,ProtoBuf.ProtoReader)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (which may be null).
+            </summary>
+            <param name="key">Represents the type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.DeepClone(System.Object)">
+            <summary>
+            Create a deep clone of the supplied instance; any sub-items are also cloned.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.ThrowUnexpectedSubtype(System.Type,System.Type)">
+            <summary>
+            Indicates that while an inheritance tree exists, the exact type encountered was not
+            specified in that hierarchy and cannot be processed.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.ThrowUnexpectedType(System.Type)">
+            <summary>
+            Indicates that the given type was not expected, and cannot be processed.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.ThrowCannotCreateInstance(System.Type)">
+            <summary>
+            Indicates that the given type cannot be constructed; it may still be possible to 
+            deserialize into existing instances.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.CanSerializeContractType(System.Type)">
+            <summary>
+            Returns true if the type supplied is either a recognised contract type,
+            or a *list* of a recognised contract type. 
+            </summary>
+            <remarks>Note that primitives always return false, even though the engine
+            will, if forced, try to serialize such</remarks>
+            <returns>True if this type is recognised as a serializable entity, else false</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.CanSerialize(System.Type)">
+            <summary>
+            Returns true if the type supplied is a basic type with inbuilt handling,
+            a recognised contract type, or a *list* of a basic / contract type. 
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.CanSerializeBasicType(System.Type)">
+            <summary>
+            Returns true if the type supplied is a basic type with inbuilt handling,
+            or a *list* of a basic type with inbuilt handling
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.GetSchema(System.Type)">
+            <summary>
+            Suggest a .proto definition for the given type
+            </summary>
+            <param name="type">The type to generate a .proto definition for, or <c>null</c> to generate a .proto that represents the entire model</param>
+            <returns>The .proto definition as a string</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.TypeModel.CreateFormatter(System.Type)">
+            <summary>
+            Creates a new IFormatter that uses protocol-buffer [de]serialization.
+            </summary>
+            <returns>A new IFormatter to be used during [de]serialization.</returns>
+            <param name="type">The type of object to be [de]deserialized by the formatter.</param>
+        </member>
+        <member name="E:ProtoBuf.Meta.TypeModel.DynamicTypeFormatting">
+            <summary>
+            Used to provide custom services for writing and parsing type names when using dynamic types. Both parsing and formatting
+            are provided on a single API as it is essential that both are mapped identically at all times.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.TypeModel.CallbackType">
+            <summary>
+            Indicates the type of callback to be used
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.BeforeSerialize">
+            <summary>
+            Invoked before an object is serialized
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.AfterSerialize">
+            <summary>
+            Invoked after an object is serialized
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.BeforeDeserialize">
+            <summary>
+            Invoked before an object is deserialized (or when a new instance is created)
+            </summary>            
+        </member>
+        <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.AfterDeserialize">
+            <summary>
+            Invoked after an object is deserialized
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.GetTypes">
+            <summary>
+            Returns a sequence of the Type instances that can be
+            processed by this model.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.GetSchema(System.Type)">
+            <summary>
+            Suggest a .proto definition for the given type
+            </summary>
+            <param name="type">The type to generate a .proto definition for, or <c>null</c> to generate a .proto that represents the entire model</param>
+            <returns>The .proto definition as a string</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Add(System.Type,System.Boolean)">
+            <summary>
+            Adds support for an additional type in this model, optionally
+            appplying inbuilt patterns. If the type is already known to the
+            model, the existing type is returned **without** applying
+            any additional behaviour.
+            </summary>
+            <remarks>Inbuilt patterns include:
+            [ProtoContract]/[ProtoMember(n)]
+            [DataContract]/[DataMember(Order=n)]
+            [XmlType]/[XmlElement(Order=n)]
+            [On{Des|S}erializ{ing|ed}]
+            ShouldSerialize*/*Specified
+            </remarks>
+            <param name="type">The type to be supported</param>
+            <param name="applyDefaultBehaviour">Whether to apply the inbuilt configuration patterns (via attributes etc), or
+            just add the type with no additional configuration (the type must then be manually configured).</param>
+            <returns>The MetaType representing this type, allowing
+            further configuration.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.ThrowIfFrozen">
+            <summary>
+            Verifies that the model is still open to changes; if not, an exception is thrown
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Freeze">
+            <summary>
+            Prevents further changes to this model
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.GetKeyImpl(System.Type)">
+            <summary>
+            Provides the key that represents a given type in the current model.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Serialize(System.Int32,System.Object,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream.
+            </summary>
+            <param name="key">Represents the type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be serialized (cannot be null).</param>
+            <param name="dest">The destination stream to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Deserialize(System.Int32,System.Object,ProtoBuf.ProtoReader)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (which may be null).
+            </summary>
+            <param name="key">Represents the type (including inheritance) to consider.</param>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.CompileInPlace">
+            <summary>
+            Compiles the serializers individually; this is *not* a full
+            standalone compile, but can significantly boost performance
+            while allowing additional types to be added.
+            </summary>
+            <remarks>An in-place compile can access non-public types / members</remarks>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Compile">
+            <summary>
+            Fully compiles the current model into a static-compiled model instance
+            </summary>
+            <remarks>A full compilation is restricted to accessing public types / members</remarks>
+            <returns>An instance of the newly created compiled type-model</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Compile(System.String,System.String)">
+            <summary>
+            Fully compiles the current model into a static-compiled serialization dll
+            (the serialization dll still requires protobuf-net for support services).
+            </summary>
+            <remarks>A full compilation is restricted to accessing public types / members</remarks>
+            <param name="name">The name of the TypeModel class to create</param>
+            <param name="path">The path for the new dll</param>
+            <returns>An instance of the newly created compiled type-model</returns>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Compile(ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions)">
+            <summary>
+            Fully compiles the current model into a static-compiled serialization dll
+            (the serialization dll still requires protobuf-net for support services).
+            </summary>
+            <remarks>A full compilation is restricted to accessing public types / members</remarks>
+            <returns>An instance of the newly created compiled type-model</returns>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.InferTagFromNameDefault">
+            <summary>
+            Global default that
+            enables/disables automatic tag generation based on the existing name / order
+            of the defined members. See <seealso cref="P:ProtoBuf.ProtoContractAttribute.InferTagFromName"/>
+            for usage and <b>important warning</b> / explanation.
+            You must set the global default before attempting to serialize/deserialize any
+            impacted type.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AutoAddProtoContractTypesOnly">
+            <summary>
+            Global default that determines whether types are considered serializable
+            if they have [DataContract] / [XmlType]. With this enabled, <b>ONLY</b>
+            types marked as [ProtoContract] are added automatically.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.UseImplicitZeroDefaults">
+            <summary>
+            Global switch that enables or disables the implicit
+            handling of "zero defaults"; meanning: if no other default is specified,
+            it assumes bools always default to false, integers to zero, etc.
+            
+            If this is disabled, no such assumptions are made and only *explicit*
+            default values are processed. This is enabled by default to 
+            preserve similar logic to v1.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AllowParseableTypes">
+            <summary>
+            Global switch that determines whether types with a <c>.ToString()</c> and a <c>Parse(string)</c>
+            should be serialized as strings.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.Default">
+            <summary>
+            The default model, used to support ProtoBuf.Serializer
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.Item(System.Type)">
+            <summary>
+            Obtains the MetaType associated with a given Type for the current model,
+            allowing additional configuration.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AutoCompile">
+            <summary>
+            Should serializers be compiled on demand? It may be useful
+            to disable this for debugging purposes.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AutoAddMissingTypes">
+            <summary>
+            Should support for unexpected types be added automatically?
+            If false, an exception is thrown when unexpected types
+            are encountered.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.MetadataTimeoutMilliseconds">
+            <summary>
+            The amount of time to wait if there are concurrent metadata access operations
+            </summary>
+        </member>
+        <member name="E:ProtoBuf.Meta.RuntimeTypeModel.LockContended">
+            <summary>
+            If a lock-contention is detected, this event signals the *owner* of the lock responsible for the blockage, indicating
+            what caused the problem; this is only raised if the lock-owning code successfully completes.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions">
+            <summary>
+            Represents configuration options for compiling a model to 
+            a standalone assembly.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.SetFrameworkOptions(ProtoBuf.Meta.MetaType)">
+            <summary>
+            Import framework options from an existing type
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.TargetFrameworkName">
+            <summary>
+            The TargetFrameworkAttribute FrameworkName value to burn into the generated assembly
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.TargetFrameworkDisplayName">
+            <summary>
+            The TargetFrameworkAttribute FrameworkDisplayName value to burn into the generated assembly
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.TypeName">
+            <summary>
+            The name of the TypeModel class to create
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.OutputPath">
+            <summary>
+            The path for the new dll
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.ImageRuntimeVersion">
+            <summary>
+            The runtime version for the generated assembly
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.MetaDataVersion">
+            <summary>
+            The runtime version for the generated assembly
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.LockContentedEventArgs">
+            <summary>
+            Contains the stack-trace of the owning code when a lock-contention scenario is detected
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.LockContentedEventArgs.OwnerStackTrace">
+            <summary>
+            The stack-trace of the code that owned the lock when a lock-contention scenario occurred
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.LockContentedEventHandler">
+            <summary>
+            Event-type that is raised when a lock-contention scenario is detected
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.SubType">
+            <summary>
+            Represents an inherited type in a type hierarchy.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.SubType.#ctor(System.Int32,ProtoBuf.Meta.MetaType,ProtoBuf.DataFormat)">
+            <summary>
+            Creates a new SubType instance.
+            </summary>
+            <param name="fieldNumber">The field-number that is used to encapsulate the data (as a nested
+            message) for the derived dype.</param>
+            <param name="derivedType">The sub-type to be considered.</param>
+            <param name="format">Specific encoding style to use; in particular, Grouped can be used to avoid buffering, but is not the default.</param>
+        </member>
+        <member name="P:ProtoBuf.Meta.SubType.FieldNumber">
+            <summary>
+            The field-number that is used to encapsulate the data (as a nested
+            message) for the derived dype.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.SubType.DerivedType">
+            <summary>
+            The sub-type to be considered.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.TypeFormatEventArgs">
+            <summary>
+            Event arguments needed to perform type-formatting functions; this could be resolving a Type to a string suitable for serialization, or could
+            be requesting a Type from a string. If no changes are made, a default implementation will be used (from the assembly-qualified names).
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.TypeFormatEventArgs.Type">
+            <summary>
+            The type involved in this map; if this is initially null, a Type is expected to be provided for the string in FormattedName.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.TypeFormatEventArgs.FormattedName">
+            <summary>
+            The formatted-name involved in this map; if this is initially null, a formatted-name is expected from the type in Type.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.TypeFormatEventHandler">
+            <summary>
+            Delegate type used to perform type-formatting functions; the sender originates as the type-model.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Meta.ValueMember">
+            <summary>
+            Represents a member (property/field) that is mapped to a protobuf field
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.ValueMember.#ctor(ProtoBuf.Meta.RuntimeTypeModel,System.Type,System.Int32,System.Reflection.MemberInfo,System.Type,System.Type,System.Type,ProtoBuf.DataFormat,System.Object)">
+            <summary>
+            Creates a new ValueMember instance
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.ValueMember.#ctor(ProtoBuf.Meta.RuntimeTypeModel,System.Int32,System.Type,System.Type,System.Type,ProtoBuf.DataFormat)">
+            <summary>
+            Creates a new ValueMember instance
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Meta.ValueMember.SetSpecified(System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
+            <summary>
+            Specifies methods for working with optional data members.
+            </summary>
+            <param name="getSpecified">Provides a method (null for none) to query whether this member should
+            be serialized; it must be of the form "bool {Method}()". The member is only serialized if the
+            method returns true.</param>
+            <param name="setSpecified">Provides a method (null for none) to indicate that a member was
+            deserialized; it must be of the form "void {Method}(bool)", and will be called with "true"
+            when data is found.</param>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.FieldNumber">
+            <summary>
+            The number that identifies this member in a protobuf stream
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.Member">
+            <summary>
+            Gets the member (field/property) which this member relates to.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.ItemType">
+            <summary>
+            Within a list / array / etc, the type of object for each item in the list (especially useful with ArrayList)
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.MemberType">
+            <summary>
+            The underlying type of the member
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.DefaultType">
+            <summary>
+            For abstract types (IList etc), the type of concrete object to create (if required)
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.ParentType">
+            <summary>
+            The type the defines the member
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.DefaultValue">
+            <summary>
+            The default value of the item (members with this value will not be serialized)
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.DataFormat">
+            <summary>
+            Specifies the rules used to process the field; this is used to determine the most appropriate
+            wite-type, but also to describe subtypes <i>within</i> that wire-type (such as SignedVariant)
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.IsStrict">
+            <summary>
+            Indicates whether this field should follow strict encoding rules; this means (for example) that if a "fixed32"
+            is encountered when "variant" is defined, then it will fail (throw an exception) when parsing. Note that
+            when serializing the defined type is always used.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.IsPacked">
+            <summary>
+            Indicates whether this field should use packed encoding (which can save lots of space for repeated primitive values).
+            This option only applies to list/array data of primitive types (int, double, etc).
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.OverwriteList">
+            <summary>
+            Indicates whether this field should *repace* existing values (the default is false, meaning *append*).
+            This option only applies to list/array data.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.IsRequired">
+            <summary>
+            Indicates whether this field is mandatory.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.AsReference">
+            <summary>
+            Enables full object-tracking/full-graph support.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.DynamicType">
+            <summary>
+            Embeds the type information into the stream, allowing usage with types not known in advance.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.Name">
+            <summary>
+            Gets the logical name for this member in the schema (this is not critical for binary serialization, but may be used
+            when inferring a schema).
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Meta.ValueMember.SupportNull">
+            <summary>
+            Should lists have extended support for null values? Note this makes the serialization less efficient.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.PrefixStyle">
+            <summary>
+            Specifies the type of prefix that should be applied to messages.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.PrefixStyle.None">
+            <summary>
+            No length prefix is applied to the data; the data is terminated only be the end of the stream.
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.PrefixStyle.Base128">
+            <summary>
+            A base-128 length prefix is applied to the data (efficient for short messages).
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.PrefixStyle.Fixed32">
+            <summary>
+            A fixed-length (little-endian) length prefix is applied to the data (useful for compatibility).
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.PrefixStyle.Fixed32BigEndian">
+            <summary>
+            A fixed-length (big-endian) length prefix is applied to the data (useful for compatibility).
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoContractAttribute">
+            <summary>
+            Indicates that a type is defined for protocol-buffer serialization.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.Name">
+            <summary>
+            Gets or sets the defined name of the type.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.ImplicitFirstTag">
+            <summary>
+            Gets or sets the fist offset to use with implicit field tags;
+            only uesd if ImplicitFields is set.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.UseProtoMembersOnly">
+            <summary>
+            If specified, alternative contract markers (such as markers for XmlSerailizer or DataContractSerializer) are ignored.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.IgnoreListHandling">
+            <summary>
+            If specified, do NOT treat this type as a list, even if it looks like one.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.ImplicitFields">
+            <summary>
+            Gets or sets the mechanism used to automatically infer field tags
+            for members. This option should be used in advanced scenarios only.
+            Please review the important notes against the ImplicitFields enumeration.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.InferTagFromName">
+            <summary>
+            Enables/disables automatic tag generation based on the existing name / order
+            of the defined members. This option is not used for members marked
+            with ProtoMemberAttribute, as intended to provide compatibility with
+            WCF serialization. WARNING: when adding new fields you must take
+            care to increase the Order for new elements, otherwise data corruption
+            may occur.
+            </summary>
+            <remarks>If not explicitly specified, the default is assumed from Serializer.GlobalOptions.InferTagFromName.</remarks>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.InferTagFromNameHasValue">
+            <summary>
+            Has a InferTagFromName value been explicitly set? if not, the default from the type-model is assumed.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.DataMemberOffset">
+            <summary>
+            Specifies an offset to apply to [DataMember(Order=...)] markers;
+            this is useful when working with mex-generated classes that have
+            a different origin (usually 1 vs 0) than the original data-contract.
+            
+            This value is added to the Order of each member.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoContractAttribute.SkipConstructor">
+            <summary>
+            If true, the constructor for the type is bypassed during deserialization, meaning any field initializers
+            or other initialization code is skipped.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoEnumAttribute">
+            <summary>
+            Used to define protocol-buffer specific behavior for
+            enumerated values.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoEnumAttribute.HasValue">
+            <summary>
+            Indicates whether this instance has a customised value mapping
+            </summary>
+            <returns>true if a specific value is set</returns>
+        </member>
+        <member name="P:ProtoBuf.ProtoEnumAttribute.Value">
+            <summary>
+            Gets or sets the specific value to use for this enum during serialization.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoEnumAttribute.Name">
+            <summary>
+            Gets or sets the defined name of the enum, as used in .proto
+            (this name is not used during serialization).
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoException">
+            <summary>
+            Indicates an error during serialization/deserialization of a proto stream.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoException.#ctor">
+            <summary>Creates a new ProtoException instance.</summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoException.#ctor(System.String)">
+            <summary>Creates a new ProtoException instance.</summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoException.#ctor(System.String,System.Exception)">
+            <summary>Creates a new ProtoException instance.</summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoIgnoreAttribute">
+            <summary>
+            Indicates that a member should be excluded from serialization; this
+            is only normally used when using implict fields.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoPartialIgnoreAttribute">
+            <summary>
+            Indicates that a member should be excluded from serialization; this
+            is only normally used when using implict fields. This allows
+            ProtoIgnoreAttribute usage
+            even for partial classes where the individual members are not
+            under direct control.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoPartialIgnoreAttribute.#ctor(System.String)">
+            <summary>
+            Creates a new ProtoPartialIgnoreAttribute instance.
+            </summary>
+            <param name="memberName">Specifies the member to be ignored.</param>
+        </member>
+        <member name="P:ProtoBuf.ProtoPartialIgnoreAttribute.MemberName">
+            <summary>
+            The name of the member to be ignored.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoIncludeAttribute">
+            <summary>
+            Indicates the known-types to support for an individual
+            message. This serializes each level in the hierarchy as
+            a nested message to retain wire-compatibility with
+            other protocol-buffer implementations.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoIncludeAttribute.#ctor(System.Int32,System.Type)">
+            <summary>
+             Creates a new instance of the ProtoIncludeAttribute.
+             </summary>
+             <param name="tag">The unique index (within the type) that will identify this data.</param>
+             <param name="knownType">The additional type to serialize/deserialize.</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoIncludeAttribute.#ctor(System.Int32,System.String)">
+            <summary>
+            Creates a new instance of the ProtoIncludeAttribute.
+            </summary>
+            <param name="tag">The unique index (within the type) that will identify this data.</param>
+            <param name="knownTypeName">The additional type to serialize/deserialize.</param>
+        </member>
+        <member name="P:ProtoBuf.ProtoIncludeAttribute.Tag">
+            <summary>
+            Gets the unique index (within the type) that will identify this data.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoIncludeAttribute.KnownTypeName">
+            <summary>
+            Gets the additional type to serialize/deserialize.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoIncludeAttribute.KnownType">
+            <summary>
+            Gets the additional type to serialize/deserialize.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoIncludeAttribute.DataFormat">
+            <summary>
+            Specifies whether the inherited sype's sub-message should be
+            written with a length-prefix (default), or with group markers.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoMemberAttribute">
+            <summary>
+            Declares a member to be used in protocol-buffer serialization, using
+            the given Tag. A DataFormat may be used to optimise the serialization
+            format (for instance, using zigzag encoding for negative numbers, or 
+            fixed-length encoding for large values.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoMemberAttribute.CompareTo(System.Object)">
+            <summary>
+            Compare with another ProtoMemberAttribute for sorting purposes
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoMemberAttribute.CompareTo(ProtoBuf.ProtoMemberAttribute)">
+            <summary>
+            Compare with another ProtoMemberAttribute for sorting purposes
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoMemberAttribute.#ctor(System.Int32)">
+            <summary>
+            Creates a new ProtoMemberAttribute instance.
+            </summary>
+            <param name="tag">Specifies the unique tag used to identify this member within the type.</param>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.Name">
+            <summary>
+            Gets or sets the original name defined in the .proto; not used
+            during serialization.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.DataFormat">
+            <summary>
+            Gets or sets the data-format to be used when encoding this value.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.Tag">
+            <summary>
+            Gets the unique tag used to identify this member within the type.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.IsRequired">
+            <summary>
+            Gets or sets a value indicating whether this member is mandatory.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.IsPacked">
+            <summary>
+            Gets a value indicating whether this member is packed.
+            This option only applies to list/array data of primitive types (int, double, etc).
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.OverwriteList">
+            <summary>
+            Indicates whether this field should *repace* existing values (the default is false, meaning *append*).
+            This option only applies to list/array data.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.AsReference">
+            <summary>
+            Enables full object-tracking/full-graph support.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.DynamicType">
+            <summary>
+            Embeds the type information into the stream, allowing usage with types not known in advance.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoMemberAttribute.Options">
+            <summary>
+            Gets or sets a value indicating whether this member is packed (lists/arrays).
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.MemberSerializationOptions">
+            <summary>
+            Additional (optional) settings that control serialization of members
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.MemberSerializationOptions.None">
+            <summary>
+            Default; no additional options
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.MemberSerializationOptions.Packed">
+            <summary>
+            Indicates that repeated elements should use packed (length-prefixed) encoding
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.MemberSerializationOptions.Required">
+            <summary>
+            Indicates that the given item is required
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.MemberSerializationOptions.AsReference">
+            <summary>
+            Enables full object-tracking/full-graph support
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.MemberSerializationOptions.DynamicType">
+            <summary>
+            Embeds the type information into the stream, allowing usage with types not known in advance
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.MemberSerializationOptions.OverwriteList">
+            <summary>
+            Indicates whether this field should *repace* existing values (the default is false, meaning *append*).
+            This option only applies to list/array data.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoPartialMemberAttribute">
+            <summary>
+            Declares a member to be used in protocol-buffer serialization, using
+            the given Tag and MemberName. This allows ProtoMemberAttribute usage
+            even for partial classes where the individual members are not
+            under direct control.
+            A DataFormat may be used to optimise the serialization
+            format (for instance, using zigzag encoding for negative numbers, or 
+            fixed-length encoding for large values.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoPartialMemberAttribute.#ctor(System.Int32,System.String)">
+            <summary>
+            Creates a new ProtoMemberAttribute instance.
+            </summary>
+            <param name="tag">Specifies the unique tag used to identify this member within the type.</param>
+            <param name="memberName">Specifies the member to be serialized.</param>
+        </member>
+        <member name="P:ProtoBuf.ProtoPartialMemberAttribute.MemberName">
+            <summary>
+            The name of the member to be serialized.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoReader">
+            <summary>
+            A stateful reader, used to read a protobuf stream. Typical usage would be (sequentially) to call
+            ReadFieldHeader and (after matching the field) an appropriate Read* method.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.#ctor(System.IO.Stream,ProtoBuf.Meta.TypeModel,ProtoBuf.SerializationContext)">
+            <summary>
+            Creates a new reader against a stream
+            </summary>
+            <param name="source">The source stream</param>
+            <param name="model">The model to use for serialization; this can be null, but this will impair the ability to deserialize sub-objects</param>
+            <param name="context">Additional context about this serialization operation</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.#ctor(System.IO.Stream,ProtoBuf.Meta.TypeModel,ProtoBuf.SerializationContext,System.Int32)">
+            <summary>
+            Creates a new reader against a stream
+            </summary>
+            <param name="source">The source stream</param>
+            <param name="model">The model to use for serialization; this can be null, but this will impair the ability to deserialize sub-objects</param>
+            <param name="context">Additional context about this serialization operation</param>
+            <param name="length">The number of bytes to read, or -1 to read until the end of the stream</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.Dispose">
+            <summary>
+            Releases resources used by the reader, but importantly <b>does not</b> Dispose the 
+            underlying stream; in many typical use-cases the stream is used for different
+            processes, so it is assumed that the consumer will Dispose their stream separately.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadUInt32">
+            <summary>
+            Reads an unsigned 32-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadInt16">
+            <summary>
+            Reads a signed 16-bit integer from the stream: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadUInt16">
+            <summary>
+            Reads an unsigned 16-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadByte">
+            <summary>
+            Reads an unsigned 8-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadSByte">
+            <summary>
+            Reads a signed 8-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadInt32">
+            <summary>
+            Reads a signed 32-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadInt64">
+            <summary>
+            Reads a signed 64-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadString">
+            <summary>
+            Reads a string from the stream (using UTF8); supported wire-types: String
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ThrowEnumException(System.Type,System.Int32)">
+            <summary>
+            Throws an exception indication that the given value cannot be mapped to an enum.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadDouble">
+            <summary>
+            Reads a double-precision number from the stream; supported wire-types: Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadObject(System.Object,System.Int32,ProtoBuf.ProtoReader)">
+            <summary>
+            Reads (merges) a sub-message from the stream, internally calling StartSubItem and EndSubItem, and (in between)
+            parsing the message in accordance with the model associated with the reader
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.EndSubItem(ProtoBuf.SubItemToken,ProtoBuf.ProtoReader)">
+            <summary>
+            Makes the end of consuming a nested message in the stream; the stream must be either at the correct EndGroup
+            marker, or all fields of the sub-message must have been consumed (in either case, this means ReadFieldHeader
+            should return zero)
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.StartSubItem(ProtoBuf.ProtoReader)">
+            <summary>
+            Begins consuming a nested message in the stream; supported wire-types: StartGroup, String
+            </summary>
+            <remarks>The token returned must be help and used when callining EndSubItem</remarks>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadFieldHeader">
+            <summary>
+            Reads a field header from the stream, setting the wire-type and retuning the field number. If no
+            more fields are available, then 0 is returned. This methods respects sub-messages.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.TryReadFieldHeader(System.Int32)">
+            <summary>
+            Looks ahead to see whether the next field in the stream is what we expect
+            (typically; what we've just finished reading - for example ot read successive list items)
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.Hint(ProtoBuf.WireType)">
+            <summary>
+            Compares the streams current wire-type to the hinted wire-type, updating the reader if necessary; for example,
+            a Variant may be updated to SignedVariant. If the hinted wire-type is unrelated then no change is made.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.Assert(ProtoBuf.WireType)">
+            <summary>
+            Verifies that the stream's current wire-type is as expected, or a specialized sub-type (for example,
+            SignedVariant) - in which case the current wire-type is updated. Otherwise an exception is thrown.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.SkipField">
+            <summary>
+            Discards the data for the current field.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadUInt64">
+            <summary>
+            Reads an unsigned 64-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadSingle">
+            <summary>
+            Reads a single-precision number from the stream; supported wire-types: Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadBoolean">
+            <summary>
+            Reads a boolean value from the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.AppendBytes(System.Byte[],ProtoBuf.ProtoReader)">
+            <summary>
+            Reads a byte-sequence from the stream, appending them to an existing byte-sequence (which can be null); supported wire-types: String
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadLengthPrefix(System.IO.Stream,System.Boolean,ProtoBuf.PrefixStyle,System.Int32@)">
+            <summary>
+            Reads the length-prefix of a message from a stream without buffering additional data, allowing a fixed-length
+            reader to be created.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.DirectReadLittleEndianInt32(System.IO.Stream)">
+            <summary>
+            Reads a little-endian encoded integer. An exception is thrown if the data is not all available.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.DirectReadBigEndianInt32(System.IO.Stream)">
+            <summary>
+            Reads a big-endian encoded integer. An exception is thrown if the data is not all available.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.DirectReadVarintInt32(System.IO.Stream)">
+            <summary>
+            Reads a varint encoded integer. An exception is thrown if the data is not all available.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.DirectReadBytes(System.IO.Stream,System.Byte[],System.Int32,System.Int32)">
+            <summary>
+            Reads a string (of a given lenth, in bytes) directly from the source into a pre-existing buffer. An exception is thrown if the data is not all available.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.DirectReadBytes(System.IO.Stream,System.Int32)">
+            <summary>
+            Reads a given number of bytes directly from the source. An exception is thrown if the data is not all available.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.DirectReadString(System.IO.Stream,System.Int32)">
+            <summary>
+            Reads a string (of a given lenth, in bytes) directly from the source. An exception is thrown if the data is not all available.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadLengthPrefix(System.IO.Stream,System.Boolean,ProtoBuf.PrefixStyle,System.Int32@,System.Int32@)">
+            <summary>
+            Reads the length-prefix of a message from a stream without buffering additional data, allowing a fixed-length
+            reader to be created.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.TryReadUInt32Variant(System.IO.Stream,System.UInt32@)">
+            <returns>The number of bytes consumed; 0 if no data available</returns>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.AppendExtensionData(ProtoBuf.IExtensible)">
+            <summary>
+            Copies the current field into the instance as extension data
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.HasSubValue(ProtoBuf.WireType,ProtoBuf.ProtoReader)">
+            <summary>
+            Indicates whether the reader still has data remaining in the current sub-item,
+            additionally setting the wire-type for the next field if there is more data.
+            This is used when decoding packed data.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.NoteObject(System.Object,ProtoBuf.ProtoReader)">
+            <summary>
+            Utility method, not intended for public use; this helps maintain the root object is complex scenarios
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoReader.ReadType">
+            <summary>
+            Reads a Type from the stream, using the model's DynamicTypeFormatting if appropriate; supported wire-types: String
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoReader.FieldNumber">
+            <summary>
+            Gets the number of the field being processed.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoReader.WireType">
+            <summary>
+            Indicates the underlying proto serialization format on the wire.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoReader.InternStrings">
+            <summary>
+            Gets / sets a flag indicating whether strings should be checked for repetition; if
+            true, any repeated UTF-8 byte sequence will result in the same String instance, rather
+            than a second instance of the same string. Enabled by default. Note that this uses
+            a <i>custom</i> interner - the system-wide string interner is not used.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoReader.Context">
+            <summary>
+            Addition information about this deserialization operation.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoReader.Position">
+            <summary>
+            Returns the position of the current reader (note that this is not necessarily the same as the position
+            in the underlying stream, if multiple readers are used on the same stream)
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoReader.Model">
+            <summary>
+            Get the TypeModel associated with this reader
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ProtoWriter">
+            <summary>
+            Represents an output stream for writing protobuf data.
+            
+            Why is the API backwards (static methods with writer arguments)?
+            See: http://marcgravell.blogspot.com/2010/03/last-will-be-first-and-first-will-be.html
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteObject(System.Object,System.Int32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Write an encapsulated sub-object, using the supplied unique key (reprasenting a type).
+            </summary>
+            <param name="value">The object to write.</param>
+            <param name="key">The key that uniquely identifies the type within the model.</param>
+            <param name="writer">The destination.</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteRecursionSafeObject(System.Object,System.Int32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Write an encapsulated sub-object, using the supplied unique key (reprasenting a type) - but the
+            caller is asserting that this relationship is non-recursive; no recursion check will be
+            performed.
+            </summary>
+            <param name="value">The object to write.</param>
+            <param name="key">The key that uniquely identifies the type within the model.</param>
+            <param name="writer">The destination.</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteFieldHeader(System.Int32,ProtoBuf.WireType,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a field-header, indicating the format of the next data we plan to write.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteBytes(System.Byte[],ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a byte-array to the stream; supported wire-types: String
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteBytes(System.Byte[],System.Int32,System.Int32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a byte-array to the stream; supported wire-types: String
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.StartSubItem(System.Object,ProtoBuf.ProtoWriter)">
+            <summary>
+            Indicates the start of a nested record.
+            </summary>
+            <param name="instance">The instance to write.</param>
+            <param name="writer">The destination.</param>
+            <returns>A token representing the state of the stream; this token is given to EndSubItem.</returns>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.EndSubItem(ProtoBuf.SubItemToken,ProtoBuf.ProtoWriter)">
+            <summary>
+            Indicates the end of a nested record.
+            </summary>
+            <param name="token">The token obtained from StartubItem.</param>
+            <param name="writer">The destination.</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.#ctor(System.IO.Stream,ProtoBuf.Meta.TypeModel,ProtoBuf.SerializationContext)">
+            <summary>
+            Creates a new writer against a stream
+            </summary>
+            <param name="dest">The destination stream</param>
+            <param name="model">The model to use for serialization; this can be null, but this will impair the ability to serialize sub-objects</param>
+            <param name="context">Additional context about this serialization operation</param>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.Close">
+            <summary>
+            Flushes data to the underlying stream, and releases any resources. The underlying stream is *not* disposed
+            by this operation.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.Flush(ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes any buffered data (if possible) to the underlying stream.
+            </summary>
+            <param name="writer">The writer to flush</param>
+            <remarks>It is not always possible to fully flush, since some sequences
+            may require values to be back-filled into the byte-stream.</remarks>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteUInt32Variant(System.UInt32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes an unsigned 32-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteString(System.String,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a string to the stream; supported wire-types: String
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteUInt64(System.UInt64,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes an unsigned 64-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteInt64(System.Int64,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a signed 64-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteUInt32(System.UInt32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes an unsigned 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteInt16(System.Int16,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a signed 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteUInt16(System.UInt16,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes an unsigned 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteByte(System.Byte,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes an unsigned 8-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteSByte(System.SByte,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a signed 8-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteInt32(System.Int32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a signed 32-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteDouble(System.Double,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a double-precision number to the stream; supported wire-types: Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteSingle(System.Single,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a single-precision number to the stream; supported wire-types: Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.ThrowEnumException(ProtoBuf.ProtoWriter,System.Object)">
+            <summary>
+            Throws an exception indicating that the given enum cannot be mapped to a serialized value.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteBoolean(System.Boolean,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a boolean to the stream; supported wire-types: Variant, Fixed32, Fixed64
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.AppendExtensionData(ProtoBuf.IExtensible,ProtoBuf.ProtoWriter)">
+            <summary>
+            Copies any extension data stored for the instance to the underlying stream
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.SetPackedField(System.Int32,ProtoBuf.ProtoWriter)">
+            <summary>
+            Used for packed encoding; indicates that the next field should be skipped rather than
+            a field header written. Note that the field number must match, else an exception is thrown
+            when the attempt is made to write the (incorrect) field. The wire-type is taken from the
+            subsequent call to WriteFieldHeader. Only primitive types can be packed.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.SetRootObject(System.Object)">
+            <summary>
+            Specifies a known root object to use during reference-tracked serialization
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ProtoWriter.WriteType(System.Type,ProtoBuf.ProtoWriter)">
+            <summary>
+            Writes a Type to the stream, using the model's DynamicTypeFormatting if appropriate; supported wire-types: String
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoWriter.Context">
+            <summary>
+            Addition information about this serialization operation.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ProtoWriter.Model">
+            <summary>
+            Get the TypeModel associated with this writer
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.SerializationContext">
+            <summary>
+            Additional information about a serialization operation
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.SerializationContext.op_Implicit(ProtoBuf.SerializationContext)~System.Runtime.Serialization.StreamingContext">
+            <summary>
+            Convert a SerializationContext to a StreamingContext
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.SerializationContext.op_Implicit(System.Runtime.Serialization.StreamingContext)~ProtoBuf.SerializationContext">
+            <summary>
+            Convert a StreamingContext to a SerializationContext
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.SerializationContext.Context">
+            <summary>
+            Gets or sets a user-defined object containing additional information about this serialization/deserialization operation.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.SerializationContext.Default">
+            <summary>
+            A default SerializationContext, with minimal information.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.SerializationContext.State">
+            <summary>
+            Gets or sets the source or destination of the transmitted data.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Serializer">
+            <summary>
+            Provides protocol-buffer serialization capability for concrete, attributed types. This
+            is a *default* model, but custom serializer models are also supported.
+            </summary>
+            <remarks>
+            Protocol-buffer serialization is a compact binary format, designed to take
+            advantage of sparse data and knowledge of specific data types; it is also
+            extensible, allowing a type to be deserialized / merged even if some data is
+            not recognised.
+            </remarks>
+        </member>
+        <member name="F:ProtoBuf.Serializer.ListItemTag">
+            <summary>
+            The field number that is used as a default when serializing/deserializing a list of objects.
+            The data is treated as repeated message with field number 1.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Serializer.GetProto``1">
+            <summary>
+            Suggest a .proto definition for the given type
+            </summary>
+            <typeparam name="T">The type to generate a .proto definition for</typeparam>
+            <returns>The .proto definition as a string</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.DeepClone``1(``0)">
+            <summary>
+            Create a deep clone of the supplied instance; any sub-items are also cloned.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Merge``1(System.IO.Stream,``0)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance.
+            </summary>
+            <typeparam name="T">The type being merged.</typeparam>
+            <param name="instance">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Deserialize``1(System.IO.Stream)">
+            <summary>
+            Creates a new instance from a protocol-buffer stream
+            </summary>
+            <typeparam name="T">The type to be created.</typeparam>
+            <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
+            <returns>A new, initialized instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Serialize``1(System.IO.Stream,``0)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream.
+            </summary>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="destination">The destination stream to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.ChangeType``2(``0)">
+            <summary>
+            Serializes a given instance and deserializes it as a different type;
+            this can be used to translate between wire-compatible objects (where
+            two .NET types represent the same data), or to promote/demote a type
+            through an inheritance hierarchy.
+            </summary>
+            <remarks>No assumption of compatibility is made between the types.</remarks>
+            <typeparam name="TFrom">The type of the object being copied.</typeparam>
+            <typeparam name="TTo">The type of the new object to be created.</typeparam>
+            <param name="instance">The existing instance to use as a template.</param>
+            <returns>A new instane of type TNewType, with the data from TOldType.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Serialize``1(System.Runtime.Serialization.SerializationInfo,``0)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo.
+            </summary>
+            <typeparam name="T">The type being serialized.</typeparam>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="info">The destination SerializationInfo to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Serialize``1(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,``0)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo.
+            </summary>
+            <typeparam name="T">The type being serialized.</typeparam>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="info">The destination SerializationInfo to write to.</param>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Serialize``1(System.Xml.XmlWriter,``0)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied XmlWriter.
+            </summary>
+            <typeparam name="T">The type being serialized.</typeparam>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="writer">The destination XmlWriter to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Merge``1(System.Xml.XmlReader,``0)">
+            <summary>
+            Applies a protocol-buffer from an XmlReader to an existing instance.
+            </summary>
+            <typeparam name="T">The type being merged.</typeparam>
+            <param name="instance">The existing instance to be modified (cannot be null).</param>
+            <param name="reader">The XmlReader containing the data to apply to the instance (cannot be null).</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Merge``1(System.Runtime.Serialization.SerializationInfo,``0)">
+            <summary>
+            Applies a protocol-buffer from a SerializationInfo to an existing instance.
+            </summary>
+            <typeparam name="T">The type being merged.</typeparam>
+            <param name="instance">The existing instance to be modified (cannot be null).</param>
+            <param name="info">The SerializationInfo containing the data to apply to the instance (cannot be null).</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.Merge``1(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,``0)">
+            <summary>
+            Applies a protocol-buffer from a SerializationInfo to an existing instance.
+            </summary>
+            <typeparam name="T">The type being merged.</typeparam>
+            <param name="instance">The existing instance to be modified (cannot be null).</param>
+            <param name="info">The SerializationInfo containing the data to apply to the instance (cannot be null).</param>
+            <param name="context">Additional information about this serialization operation.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.PrepareSerializer``1">
+            <summary>
+            Precompiles the serializer for a given type.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Serializer.CreateFormatter``1">
+            <summary>
+            Creates a new IFormatter that uses protocol-buffer [de]serialization.
+            </summary>
+            <typeparam name="T">The type of object to be [de]deserialized by the formatter.</typeparam>
+            <returns>A new IFormatter to be used during [de]serialization.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.DeserializeItems``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Reads a sequence of consecutive length-prefixed items from a stream, using
+            either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
+            are directly comparable to serializing multiple items in succession
+            (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
+            when serializing a list/array). When a tag is
+            specified, any records with different tags are silently omitted. The
+            tag is ignored. The tag is ignores for fixed-length prefixes.
+            </summary>
+            <typeparam name="T">The type of object to deserialize.</typeparam>
+            <param name="source">The binary stream containing the serialized records.</param>
+            <param name="style">The prefix style used in the data.</param>
+            <param name="fieldNumber">The tag of records to return (if non-positive, then no tag is
+            expected and all records are returned).</param>
+            <returns>The sequence of deserialized objects.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.DeserializeWithLengthPrefix``1(System.IO.Stream,ProtoBuf.PrefixStyle)">
+            <summary>
+            Creates a new instance from a protocol-buffer stream that has a length-prefix
+            on data (to assist with network IO).
+            </summary>
+            <typeparam name="T">The type to be created.</typeparam>
+            <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <returns>A new, initialized instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.DeserializeWithLengthPrefix``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Creates a new instance from a protocol-buffer stream that has a length-prefix
+            on data (to assist with network IO).
+            </summary>
+            <typeparam name="T">The type to be created.</typeparam>
+            <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="fieldNumber">The expected tag of the item (only used with base-128 prefix style).</param>
+            <returns>A new, initialized instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.MergeWithLengthPrefix``1(System.IO.Stream,``0,ProtoBuf.PrefixStyle)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance, using length-prefixed
+            data - useful with network IO.
+            </summary>
+            <typeparam name="T">The type being merged.</typeparam>
+            <param name="instance">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.SerializeWithLengthPrefix``1(System.IO.Stream,``0,ProtoBuf.PrefixStyle)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream,
+            with a length-prefix. This is useful for socket programming,
+            as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
+            from an ongoing stream.
+            </summary>
+            <typeparam name="T">The type being serialized.</typeparam>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="destination">The destination stream to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.SerializeWithLengthPrefix``1(System.IO.Stream,``0,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream,
+            with a length-prefix. This is useful for socket programming,
+            as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
+            from an ongoing stream.
+            </summary>
+            <typeparam name="T">The type being serialized.</typeparam>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="destination">The destination stream to write to.</param>
+            <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.TryReadLengthPrefix(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32@)">
+            <summary>Indicates the number of bytes expected for the next message.</summary>
+            <param name="source">The stream containing the data to investigate for a length.</param>
+            <param name="style">The algorithm used to encode the length.</param>
+            <param name="length">The length of the message, if it could be identified.</param>
+            <returns>True if a length could be obtained, false otherwise.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.TryReadLengthPrefix(System.Byte[],System.Int32,System.Int32,ProtoBuf.PrefixStyle,System.Int32@)">
+            <summary>Indicates the number of bytes expected for the next message.</summary>
+            <param name="buffer">The buffer containing the data to investigate for a length.</param>
+            <param name="index">The offset of the first byte to read from the buffer.</param>
+            <param name="count">The number of bytes to read from the buffer.</param>
+            <param name="style">The algorithm used to encode the length.</param>
+            <param name="length">The length of the message, if it could be identified.</param>
+            <returns>True if a length could be obtained, false otherwise.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.FlushPool">
+            <summary>
+            Releases any internal buffers that have been reserved for efficiency; this does not affect any serialization
+            operations; simply: it can be used (optionally) to release the buffers for garbage collection (at the expense
+            of having to re-allocate a new buffer for the next operation, rather than re-use prior buffers).
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Serializer.NonGeneric">
+            <summary>
+            Provides non-generic access to the default serializer.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.DeepClone(System.Object)">
+            <summary>
+            Create a deep clone of the supplied instance; any sub-items are also cloned.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.Serialize(System.IO.Stream,System.Object)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream.
+            </summary>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="dest">The destination stream to write to.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.Deserialize(System.Type,System.IO.Stream)">
+            <summary>
+            Creates a new instance from a protocol-buffer stream
+            </summary>
+            <param name="type">The type to be created.</param>
+            <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
+            <returns>A new, initialized instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.Merge(System.IO.Stream,System.Object)">
+            <summary>Applies a protocol-buffer stream to an existing instance.</summary>
+            <param name="instance">The existing instance to be modified (cannot be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <returns>The updated instance</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.SerializeWithLengthPrefix(System.IO.Stream,System.Object,ProtoBuf.PrefixStyle,System.Int32)">
+            <summary>
+            Writes a protocol-buffer representation of the given instance to the supplied stream,
+            with a length-prefix. This is useful for socket programming,
+            as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
+            from an ongoing stream.
+            </summary>
+            <param name="instance">The existing instance to be serialized (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="destination">The destination stream to write to.</param>
+            <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.TryDeserializeWithLengthPrefix(System.IO.Stream,ProtoBuf.PrefixStyle,ProtoBuf.Serializer.TypeResolver,System.Object@)">
+            <summary>
+            Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
+            data - useful with network IO.
+            </summary>
+            <param name="value">The existing instance to be modified (can be null).</param>
+            <param name="source">The binary stream to apply to the instance (cannot be null).</param>
+            <param name="style">How to encode the length prefix.</param>
+            <param name="resolver">Used to resolve types on a per-field basis.</param>
+            <returns>The updated instance; this may be different to the instance argument if
+            either the original instance was null, or the stream defines a known sub-type of the
+            original instance.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializer.NonGeneric.CanSerialize(System.Type)">
+            <summary>
+            Indicates whether the supplied type is explicitly modelled by the model
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Serializer.GlobalOptions">
+            <summary>
+            Global switches that change the behavior of protobuf-net
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Serializer.GlobalOptions.InferTagFromName">
+            <summary>
+            <see cref="P:ProtoBuf.Meta.RuntimeTypeModel.InferTagFromNameDefault"/>
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.Serializer.TypeResolver">
+            <summary>
+            Maps a field-number to a type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.Serializers.IProtoSerializer.Write(System.Object,ProtoBuf.ProtoWriter)">
+            <summary>
+            Perform the steps necessary to serialize this data.
+            </summary>
+            <param name="value">The value to be serialized.</param>
+            <param name="dest">The writer entity that is accumulating the output data.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializers.IProtoSerializer.Read(System.Object,ProtoBuf.ProtoReader)">
+            <summary>
+            Perform the steps necessary to deserialize this data.
+            </summary>
+            <param name="value">The current value, if appropriate.</param>
+            <param name="source">The reader providing the input data.</param>
+            <returns>The updated / replacement value.</returns>
+        </member>
+        <member name="M:ProtoBuf.Serializers.IProtoSerializer.EmitWrite(ProtoBuf.Compiler.CompilerContext,ProtoBuf.Compiler.Local)">
+            <summary>Emit the IL necessary to perform the given actions
+            to serialize this data.
+            </summary>
+            <param name="ctx">Details and utilities for the method being generated.</param>
+            <param name="valueFrom">The source of the data to work against;
+            If the value is only needed once, then LoadValue is sufficient. If
+            the value is needed multiple times, then note that a "null"
+            means "the top of the stack", in which case you should create your
+            own copy - GetLocalWithValue.</param>
+        </member>
+        <member name="M:ProtoBuf.Serializers.IProtoSerializer.EmitRead(ProtoBuf.Compiler.CompilerContext,ProtoBuf.Compiler.Local)">
+            <summary>
+            Emit the IL necessary to perform the given actions to deserialize this data.
+            </summary>
+            <param name="ctx">Details and utilities for the method being generated.</param>
+            <param name="entity">For nested values, the instance holding the values; note
+            that this is not always provided - a null means not supplied. Since this is always
+            a variable or argument, it is not necessary to consume this value.</param>
+        </member>
+        <member name="P:ProtoBuf.Serializers.IProtoSerializer.ExpectedType">
+            <summary>
+            The type that this serializer is intended to work for.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Serializers.IProtoSerializer.RequiresOldValue">
+            <summary>
+            Indicates whether a Read operation <em>replaces</em> the existing value, or
+            <em>extends</em> the value. If false, the "value" parameter to Read is
+            discarded, and should be passed in as null.
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.Serializers.IProtoSerializer.ReturnsValue">
+            <summary>
+            Now all Read operations return a value (although most do); if false no
+            value should be expected.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ServiceModel.ProtoBehaviorAttribute">
+            <summary>
+            Uses protocol buffer serialization on the specified operation; note that this
+            must be enabled on both the client and server.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ServiceModel.ProtoBehaviorExtension">
+            <summary>
+            Configuration element to swap out DatatContractSerilaizer with the XmlProtoSerializer for a given endpoint.
+            </summary>
+            <seealso cref="T:ProtoBuf.ServiceModel.ProtoEndpointBehavior"/>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.ProtoBehaviorExtension.#ctor">
+            <summary>
+            Creates a new ProtoBehaviorExtension instance.
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.ProtoBehaviorExtension.CreateBehavior">
+            <summary>
+            Creates a behavior extension based on the current configuration settings.
+            </summary>
+            <returns>The behavior extension.</returns>
+        </member>
+        <member name="P:ProtoBuf.ServiceModel.ProtoBehaviorExtension.BehaviorType">
+            <summary>
+            Gets the type of behavior.
+            </summary>     
+        </member>
+        <member name="T:ProtoBuf.ServiceModel.ProtoEndpointBehavior">
+            <summary>
+            Behavior to swap out DatatContractSerilaizer with the XmlProtoSerializer for a given endpoint.
+             <example>
+            Add the following to the server and client app.config in the system.serviceModel section:
+             <behaviors>
+               <endpointBehaviors>
+                 <behavior name="ProtoBufBehaviorConfig">
+                   <ProtoBufSerialization/>
+                 </behavior>
+               </endpointBehaviors>
+             </behaviors>
+             <extensions>
+               <behaviorExtensions>
+                 <add name="ProtoBufSerialization" type="ProtoBuf.ServiceModel.ProtoBehaviorExtension, protobuf-net, Version=1.0.0.255, Culture=neutral, PublicKeyToken=257b51d87d2e4d67"/>
+               </behaviorExtensions>
+             </extensions>
+            
+            Configure your endpoints to have a behaviorConfiguration as follows:
+            
+             <service name="TK.Framework.Samples.ServiceModel.Contract.SampleService">
+               <endpoint address="http://myhost:9003/SampleService" binding="basicHttpBinding" behaviorConfiguration="ProtoBufBehaviorConfig"
+                bindingConfiguration="basicHttpBindingConfig" name="basicHttpProtoBuf" contract="ISampleServiceContract" />
+             </service>
+             <client>
+                 <endpoint address="http://myhost:9003/SampleService" binding="basicHttpBinding"
+                     bindingConfiguration="basicHttpBindingConfig" contract="ISampleServiceContract"
+                     name="BasicHttpProtoBufEndpoint" behaviorConfiguration="ProtoBufBehaviorConfig"/>
+              </client>
+            </example>
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ServiceModel.ProtoOperationBehavior">
+            <summary>
+            Describes a WCF operation behaviour that can perform protobuf serialization
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.ProtoOperationBehavior.#ctor(System.ServiceModel.Description.OperationDescription)">
+            <summary>
+            Create a new ProtoOperationBehavior instance
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.ProtoOperationBehavior.CreateSerializer(System.Type,System.Xml.XmlDictionaryString,System.Xml.XmlDictionaryString,System.Collections.Generic.IList{System.Type})">
+            <summary>
+            Creates a protobuf serializer if possible (falling back to the default WCF serializer)
+            </summary>
+        </member>
+        <member name="P:ProtoBuf.ServiceModel.ProtoOperationBehavior.Model">
+            <summary>
+            The type-model that should be used with this behaviour
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.ServiceModel.XmlProtoSerializer">
+            <summary>
+            An xml object serializer that can embed protobuf data in a base-64 hunk (looking like a byte[])
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.TryCreate(ProtoBuf.Meta.TypeModel,System.Type)">
+            <summary>
+            Attempt to create a new serializer for the given model and type
+            </summary>
+            <returns>A new serializer instance if the type is recognised by the model; null otherwise</returns>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.#ctor(ProtoBuf.Meta.TypeModel,System.Type)">
+            <summary>
+            Creates a new serializer for the given model and type
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.WriteEndObject(System.Xml.XmlDictionaryWriter)">
+            <summary>
+            Ends an object in the output
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.WriteStartObject(System.Xml.XmlDictionaryWriter,System.Object)">
+            <summary>
+            Begins an object in the output
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.WriteObjectContent(System.Xml.XmlDictionaryWriter,System.Object)">
+            <summary>
+            Writes the body of an object in the output
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.IsStartObject(System.Xml.XmlDictionaryReader)">
+            <summary>
+            Indicates whether this is the start of an object we are prepared to handle
+            </summary>
+        </member>
+        <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.ReadObject(System.Xml.XmlDictionaryReader,System.Boolean)">
+            <summary>
+            Reads the body of an object
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.SubItemToken">
+            <summary>
+            Used to hold particulars relating to nested objects. This is opaque to the caller - simply
+            give back the token you are given at the end of an object.
+            </summary>
+        </member>
+        <member name="T:ProtoBuf.WireType">
+            <summary>
+            Indicates the encoding used to represent an individual value in a protobuf stream
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.None">
+            <summary>
+            Represents an error condition
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.Variant">
+            <summary>
+            Base-128 variant-length encoding
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.Fixed64">
+            <summary>
+            Fixed-length 8-byte encoding
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.String">
+            <summary>
+            Length-variant-prefixed encoding
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.StartGroup">
+            <summary>
+            Indicates the start of a group
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.EndGroup">
+            <summary>
+            Indicates the end of a group
+            </summary>
+        </member>
+        <member name="F:ProtoBuf.WireType.Fixed32">
+            <summary>
+            Fixed-length 4-byte encoding
+            </summary>10
+        </member>
+        <member name="F:ProtoBuf.WireType.SignedVariant">
+            <summary>
+            This is not a formal wire-type in the "protocol buffers" spec, but
+            denotes a variant integer that should be interpreted using
+            zig-zag semantics (so -ve numbers aren't a significant overhead)
+            </summary>
+        </member>
+    </members>
+</doc>

CSharp/Tools/ProtoGen/protoc-license.txt

@@ -0,0 +1,15 @@
+Protocol Buffers - Google's data interchange format
+Copyright 2008 Google Inc.
+http://code.google.com/p/protobuf/
+
+This package contains a precompiled Win32 binary version of the protocol buffer
+compiler (protoc).  This binary is intended for Windows users who want to
+use Protocol Buffers in Java or Python but do not want to compile protoc
+themselves.  To install, simply place this binary somewhere in your PATH.
+
+This binary was built using MinGW, but the output is the same regardless of
+the C++ compiler used.
+
+You will still need to download the source code package in order to obtain the
+Java or Python runtime libraries.  Get it from:
+  http://code.google.com/p/protobuf/downloads/

CSharp/Tools/ProtoGen/protogen.exe.config

@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<configuration>
+<startup><supportedRuntime version="v2.0.50727"/></startup></configuration>

CSharp/Tools/ProtoGen/vb.xslt

@@ -0,0 +1,745 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsl:stylesheet version="1.0"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="xsl msxsl"
+>
+  <xsl:import href="common.xslt"/>
+  <xsl:param name="help"/>
+  <xsl:param name="xml"/>
+  <xsl:param name="datacontract"/>
+  <xsl:param name="binary"/>
+  <xsl:param name="protoRpc"/>
+  <xsl:param name="observable"/>
+  <xsl:param name="preObservable"/>
+  <xsl:param name="partialMethods"/>
+  <xsl:param name="detectMissing"/>
+  <xsl:param name="lightFramework"/>
+  <xsl:param name="asynchronous"/>
+  <xsl:param name="clientProxy"/>
+  <xsl:param name="defaultNamespace"/>
+  
+  
+  <xsl:key name="fieldNames" match="//FieldDescriptorProto" use="name"/>
+  
+  <xsl:output method="text" indent="no" omit-xml-declaration="yes"/>
+  <xsl:variable name="types" select="//EnumDescriptorProto | //DescriptorProto"/>
+  <xsl:variable name="optionXml" select="$xml='true'"/>
+  <xsl:variable name="optionDataContract" select="$datacontract='true'"/>
+  <xsl:variable name="optionBinary" select="$binary='true'"/>
+  <xsl:variable name="optionProtoRpc" select="$protoRpc='true'"/>
+  <xsl:variable name="optionObservable" select="$observable='true'"/>
+  <xsl:variable name="optionPreObservable" select="$preObservable='true'"/>
+  <xsl:variable name="optionPartialMethods" select="$partialMethods='true'"/>
+  <xsl:variable name="optionDetectMissing" select="$detectMissing='true'"/>
+  <xsl:variable name="optionFullFramework" select="not($lightFramework='true')"/>
+  <xsl:variable name="optionAsynchronous" select="$asynchronous='true'"/>
+  <xsl:variable name="optionClientProxy" select="$clientProxy='true'"/>
+  <xsl:variable name="optionFixCase" select="$fixCase='true'"/>  
+  
+  <xsl:template match="FileDescriptorSet">
+    <xsl:if test="$help='true'">
+      <xsl:message terminate="yes">
+        VisualBasic template for protobuf-net.
+        Options:
+        General:
+          "help" - this page
+        Additional serializer support:
+          "xml" - enable explicit xml support (XmlSerializer)
+          "datacontract" - enable data-contract support (DataContractSerializer; requires .NET 3.0)
+          "binary" - enable binary support (BinaryFormatter; not supported on Silverlight)
+        Other:
+          "protoRpc" - enable proto-rpc client
+          "observable" - change notification (observer pattern) support
+          "preObservable" - pre-change notification (observer pattern) support (requires .NET 3.5)
+          "partialMethods" - provide partial methods for changes (requires C# 3.0)
+          "detectMissing" - provide *Specified properties to indicate whether fields are present
+          "lightFramework" - omit additional attributes not included in CF/Silverlight
+          "asynchronous" - emit asynchronous methods for use with WCF
+          "clientProxy" - emit asynchronous client proxy class
+      </xsl:message>
+    </xsl:if>
+
+    <xsl:if test="$optionXml and $optionDataContract">
+      <xsl:message terminate="yes">
+        Invalid options: xml and data-contract serialization are mutually exclusive.
+      </xsl:message>
+    </xsl:if>
+      ' Generated from <xsl:value-of select="name"/>
+    <xsl:if test="$optionXml">
+      ' Option: xml serialization ([XmlType]/[XmlElement]) enabled
+    </xsl:if><xsl:if test="$optionDataContract">
+      ' Option: data-contract serialization ([DataContract]/[DataMember]) enabled
+    </xsl:if><xsl:if test="$optionBinary">
+      ' Option: binary serialization (ISerializable) enabled
+    </xsl:if><xsl:if test="$optionObservable">
+      ' Option: observable (OnPropertyChanged) enabled
+    </xsl:if><xsl:if test="$optionPreObservable">
+      ' Option: pre-observable (OnPropertyChanging) enabled
+    </xsl:if><xsl:if test="$partialMethods">
+      ' Option: partial methods (On*Changing/On*Changed) enabled
+    </xsl:if><xsl:if test="$detectMissing">
+      ' Option: missing-value detection (*Specified/ShouldSerialize*/Reset*) enabled
+    </xsl:if><xsl:if test="not($optionFullFramework)">
+      ' Option: light framework (CF/Silverlight) enabled
+    </xsl:if><xsl:if test="$optionProtoRpc">
+      ' Option: proto-rpc enabled
+  </xsl:if>
+    <xsl:apply-templates select="file/FileDescriptorProto"/>
+  </xsl:template>
+
+  <xsl:template match="FileDescriptorProto">
+' Generated from: <xsl:value-of select="name"/>
+    <xsl:apply-templates select="dependency/string[.!='']"/>
+    <xsl:variable name="namespace"><xsl:call-template name="PickNamespace">
+      <xsl:with-param name="defaultNamespace" select="$defaultNamespace"/>
+        </xsl:call-template>
+      </xsl:variable>
+    <xsl:if test="string($namespace) != ''">
+Namespace <xsl:value-of select="translate($namespace,':-/\','__..')"/>
+</xsl:if>
+    <xsl:apply-templates select="message_type | enum_type | service"/>
+    <xsl:if test="string($namespace) != ''">
+End Namespace</xsl:if></xsl:template>
+  
+<xsl:template match="FileDescriptorProto/dependency/string">
+' Note: requires additional types generated from: <xsl:value-of select="."/></xsl:template>
+
+<xsl:template match="DescriptorProto">
+<xsl:choose>
+<xsl:when test="$optionDataContract">
+&lt;Global.System.Serializable, Global.ProtoBuf.ProtoContract(Name:="<xsl:value-of select="name"/>")&gt; _
+&lt;Global.System.Runtime.Serialization.DataContract(Name:="<xsl:value-of select="name"/>")&gt; _
+</xsl:when>
+<xsl:when test="$optionXml">
+&lt;Global.System.Serializable, Global.ProtoBuf.ProtoContract(Name:="<xsl:value-of select="name"/>")&gt; _
+&lt;Global.System.Xml.Serialization.XmlType(TypeName:="<xsl:value-of select="name"/>")&gt; _
+</xsl:when>
+<xsl:otherwise>
+&lt;Global.System.Serializable, Global.ProtoBuf.ProtoContract(Name:="<xsl:value-of select="name"/>")&gt; _
+</xsl:otherwise>
+</xsl:choose><!--
+-->Public Partial Class <xsl:call-template name="pascal"/>
+    implements Global.ProtoBuf.IExtensible<!--
+    --><xsl:if test="$optionBinary">, Global.System.Runtime.Serialization.ISerializable</xsl:if><!--
+    --><xsl:if test="$optionObservable">, Global.System.ComponentModel.INotifyPropertyChanged</xsl:if><!--
+    --><xsl:if test="$optionPreObservable">, Global.System.ComponentModel.INotifyPropertyChanging</xsl:if>
+	
+	Public Sub New
+	End Sub
+    <xsl:apply-templates select="*"/><xsl:if test="$optionBinary">
+    Protected Sub New(ByVal info As Global.System.Runtime.Serialization.SerializationInfo, ByVal context As Global.System.Runtime.Serialization.StreamingContext)
+          MyBase.New()
+          Global.ProtoBuf.Serializer.Merge(info, Me)
+    End Sub
+	  
+	Sub GetObjectData(ByVal info As Global.System.Runtime.Serialization.SerializationInfo, ByVal context As Global.System.Runtime.Serialization.StreamingContext) implements Global.System.Runtime.Serialization.ISerializable.GetObjectData
+		Global.ProtoBuf.Serializer.Serialize(info, Me)
+	End Sub
+	
+      </xsl:if><xsl:if test="$optionObservable">
+    Public Event PropertyChanged As Global.System.ComponentModel.PropertyChangedEventHandler Implements Global.System.ComponentModel.INotifyPropertyChanged.PropertyChanged
+    Protected Overridable Sub OnPropertyChanged(ByVal propertyName As String)
+        RaiseEvent PropertyChanged(Me, New Global.System.ComponentModel.PropertyChangedEventArgs(propertyName))
+    End Sub
+    </xsl:if><xsl:if test="$optionPreObservable">
+	Public Event PropertyChanging As Global.System.ComponentModel.PropertyChangingEventHandler Implements Global.System.ComponentModel.INotifyPropertyChanging.PropertyChanging
+	Protected Overridable Sub OnPropertyChanging(ByVal propertyName As String)
+		RaiseEvent PropertyChanging(Me, New Global.System.ComponentModel.PropertyChangingEventArgs(propertyName))
+	End Sub
+	</xsl:if>
+    Private extensionObject As Global.ProtoBuf.IExtension
+		Function GetExtensionObject(createIfMissing As Boolean) As Global.ProtoBuf.IExtension Implements Global.ProtoBuf.IExtensible.GetExtensionObject
+			Return Global.ProtoBuf.Extensible.GetExtensionObject(extensionObject, createIfMissing)
+		End Function
+End Class
+  </xsl:template>
+
+  
+  
+  <xsl:template match="DescriptorProto/name | DescriptorProto/extension_range | DescriptorProto/extension"/>
+  
+  <xsl:template match="
+                FileDescriptorProto/message_type | FileDescriptorProto/enum_type | FileDescriptorProto/service
+                | DescriptorProto/field | DescriptorProto/enum_type | DescriptorProto/message_type
+                | DescriptorProto/nested_type | EnumDescriptorProto/value | ServiceDescriptorProto/method">
+    <xsl:apply-templates select="*"/>
+  </xsl:template>
+
+  <xsl:template match="EnumDescriptorProto">
+    Public Enum <xsl:call-template name="pascal"/>
+      <xsl:apply-templates select="value"/>
+    End Enum
+  </xsl:template>
+
+  <xsl:template match="EnumValueDescriptorProto">
+	  	<xsl:text> 
+		</xsl:text>
+		<xsl:value-of select="name"/>
+		<xsl:text xml:space="preserve"> = </xsl:text><xsl:choose>
+	      <xsl:when test="number"><xsl:value-of select="number"/></xsl:when>
+	      <xsl:otherwise>0</xsl:otherwise>
+	    </xsl:choose><xsl:if test="position()!=last()">
+	    </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="FieldDescriptorProto" mode="field">
+    <xsl:choose>
+      <xsl:when test="not(key('fieldNames',concat('_',name)))"><xsl:value-of select="concat('_',name)"/></xsl:when>
+      <xsl:when test="not(key('fieldNames',concat(name,'Field')))"><xsl:value-of select="concat(name,'Field')"/></xsl:when>
+      <xsl:otherwise><xsl:value-of select="concat('_',generate-id())"/></xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  
+  <xsl:template match="FieldDescriptorProto" mode="format">
+    <xsl:choose>
+      <xsl:when test="type='TYPE_DOUBLE' or type='TYPE_FLOAT'
+                or type='TYPE_FIXED32' or type='TYPE_FIXED64'
+                or type='TYPE_SFIXED32' or type='TYPE_SFIXED64'">FixedSize</xsl:when>
+      <xsl:when test="type='TYPE_GROUP'">Group</xsl:when>
+      <xsl:when test="not(type) or type='TYPE_INT32' or type='TYPE_INT64'
+                or type='TYPE_UINT32' or type='TYPE_UINT64'
+                or type='TYPE_ENUM'">TwosComplement</xsl:when>
+      <xsl:when test="type='TYPE_SINT32' or type='TYPE_SINT64'">ZigZag</xsl:when>
+      <xsl:otherwise>Default</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  <xsl:template match="FieldDescriptorProto" mode="primitiveType">
+    <xsl:choose>
+      <xsl:when test="not(type)">struct</xsl:when>
+      <xsl:when test="type='TYPE_DOUBLE'">struct</xsl:when>
+      <xsl:when test="type='TYPE_FLOAT'">struct</xsl:when>
+      <xsl:when test="type='TYPE_INT64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_UINT64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_INT32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_FIXED64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_FIXED32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_BOOL'">struct</xsl:when>
+      <xsl:when test="type='TYPE_STRING'">class</xsl:when>
+      <xsl:when test="type='TYPE_BYTES'">class</xsl:when>
+      <xsl:when test="type='TYPE_UINT32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SINT32'">struct</xsl:when>
+      <xsl:when test="type='TYPE_SINT64'">struct</xsl:when>
+      <xsl:when test="type='TYPE_ENUM'">struct</xsl:when>
+      <xsl:when test="type='TYPE_GROUP' or type='TYPE_MESSAGE'">none</xsl:when>
+      <xsl:otherwise>
+        <xsl:message terminate="yes">
+          Field type not implemented: <xsl:value-of select="type"/> (<xsl:value-of select="../../name"/>.<xsl:value-of select="name"/>)
+        </xsl:message>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+  <xsl:template match="FieldDescriptorProto" mode="type">
+    <xsl:choose>
+      <xsl:when test="not(type)">double</xsl:when>
+      <xsl:when test="type='TYPE_DOUBLE'">Double</xsl:when>
+      <xsl:when test="type='TYPE_FLOAT'">Single</xsl:when>
+      <xsl:when test="type='TYPE_INT64'">Long</xsl:when>
+      <xsl:when test="type='TYPE_UINT64'">ULong</xsl:when>
+      <xsl:when test="type='TYPE_INT32'">Integer</xsl:when>
+      <xsl:when test="type='TYPE_FIXED64'">ULong</xsl:when>
+      <xsl:when test="type='TYPE_FIXED32'">UInteger</xsl:when>
+      <xsl:when test="type='TYPE_BOOL'">Boolean</xsl:when>
+      <xsl:when test="type='TYPE_STRING'">String</xsl:when>
+      <xsl:when test="type='TYPE_BYTES'">Byte()</xsl:when>
+      <xsl:when test="type='TYPE_UINT32'">UInteger</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED32'">Integer</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED64'">Long</xsl:when>
+      <xsl:when test="type='TYPE_SINT32'">Integer</xsl:when>
+      <xsl:when test="type='TYPE_SINT64'">Long</xsl:when>
+      <xsl:when test="type='TYPE_GROUP' or type='TYPE_MESSAGE' or type='TYPE_ENUM'"><xsl:call-template name="pascal">
+          <xsl:with-param name="value" select="substring-after(type_name,'.')"/>
+        </xsl:call-template></xsl:when>
+      <xsl:otherwise>
+        <xsl:message terminate="yes">
+          Field type not implemented: <xsl:value-of select="type"/> (<xsl:value-of select="../../name"/>.<xsl:value-of select="name"/>)
+        </xsl:message>
+      </xsl:otherwise>
+    </xsl:choose>
+    
+  </xsl:template>
+
+  <xsl:template match="FieldDescriptorProto[default_value]" mode="defaultValue">
+    <xsl:choose>
+      <xsl:when test="type='TYPE_STRING'">"<xsl:value-of select="default_value"/>"</xsl:when>
+      <xsl:when test="type='TYPE_ENUM'"><xsl:apply-templates select="." mode="type"/>.<xsl:value-of select="default_value"/></xsl:when>
+      <xsl:when test="type='TYPE_BYTES'"> ' <xsl:value-of select="default_value"/></xsl:when>
+      <xsl:otherwise>CType(<xsl:value-of select="default_value"/>, <xsl:apply-templates select="." mode="type"/>)</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!--
+    We need to find the first enum value given .foo.bar.SomeEnum - but the enum itself
+    only knows about SomeEnum; we need to look at all parent DescriptorProto nodes, and
+    the FileDescriptorProto for the namespace.
+    
+    This does an annoying up/down recursion... a bit expensive, but *generally* OK.
+    Could perhaps index the last part of the enum name to reduce overhead?
+  -->
+  <xsl:template name="GetFirstEnumValue">
+    <xsl:variable name="hunt" select="type_name"/>
+    <xsl:for-each select="//EnumDescriptorProto">
+      <xsl:variable name="fullName">
+        <xsl:for-each select="ancestor::FileDescriptorProto">.<xsl:value-of select="package"/></xsl:for-each>
+        <xsl:for-each select="ancestor::DescriptorProto">.<xsl:value-of select="name"/></xsl:for-each>
+        <xsl:value-of select="concat('.',name)"/>
+      </xsl:variable>
+      <xsl:if test="$fullName=$hunt"><xsl:value-of select="(value/EnumValueDescriptorProto)[1]/name"/></xsl:if>
+    </xsl:for-each>
+  </xsl:template>
+  
+  <xsl:template match="FieldDescriptorProto[not(default_value)]" mode="defaultValue">
+    <xsl:choose>
+      <xsl:when test="type='TYPE_DOUBLE'">0.0</xsl:when>
+      <xsl:when test="type='TYPE_FLOAT'">0.0F</xsl:when>
+      <xsl:when test="type='TYPE_INT64'">0L</xsl:when>
+      <xsl:when test="type='TYPE_UINT64'">0L</xsl:when>
+      <xsl:when test="type='TYPE_INT32'">0</xsl:when>
+      <xsl:when test="type='TYPE_FIXED64'">0L</xsl:when>
+      <xsl:when test="type='TYPE_FIXED32'">0</xsl:when>
+      <xsl:when test="type='TYPE_BOOL'">False</xsl:when>
+      <xsl:when test="type='TYPE_STRING'">""</xsl:when>
+      <xsl:when test="type='TYPE_BYTES'">Nothing</xsl:when>
+      <xsl:when test="type='TYPE_UINT32'">0</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED32'">0</xsl:when>
+      <xsl:when test="type='TYPE_SFIXED64'">0L</xsl:when>
+      <xsl:when test="type='TYPE_SINT32'">0</xsl:when>
+      <xsl:when test="type='TYPE_SINT64'">0L</xsl:when>
+      <xsl:when test="type='TYPE_MESSAGE'">Nothing</xsl:when>
+      <xsl:when test="type='TYPE_ENUM'"><xsl:apply-templates select="." mode="type"/>.<xsl:call-template name="GetFirstEnumValue"/></xsl:when>
+      <xsl:otherwise>Nothing</xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template match="FieldDescriptorProto[label='LABEL_OPTIONAL' or not(label)]">
+    <xsl:variable name="propType"><xsl:apply-templates select="." mode="type"/></xsl:variable>
+    <xsl:variable name="format"><xsl:apply-templates select="." mode="format"/></xsl:variable>
+    <xsl:variable name="primitiveType"><xsl:apply-templates select="." mode="primitiveType"/></xsl:variable>
+    <xsl:variable name="defaultValue"><xsl:apply-templates select="." mode="defaultValue"/></xsl:variable>
+    <xsl:variable name="field"><xsl:apply-templates select="." mode="field"/></xsl:variable>
+	<xsl:variable name="specified" select="$optionDetectMissing and ($primitiveType='struct' or $primitiveType='class')"/>
+    <xsl:variable name="fieldType"><xsl:if test="$specified and $primitiveType='struct'">Nullable(Of </xsl:if><xsl:value-of select="$propType"/><xsl:if test="$specified and $primitiveType='struct'">)</xsl:if></xsl:variable>
+
+    <xsl:choose>
+	  <xsl:when test="substring-after($fieldType, 'google.protobuf.')">
+    Private <xsl:value-of select="concat($field,' As ',substring-after($fieldType, 'google.protobuf.'))"/><xsl:if test="not($specified)"> =<xsl:value-of select="$defaultValue"/></xsl:if>
+	  </xsl:when>
+	  <xsl:otherwise>
+    Private <xsl:value-of select="concat($field,' As ',$fieldType)"/><xsl:if test="not($specified)"> =<xsl:value-of select="$defaultValue"/></xsl:if>
+	  </xsl:otherwise>
+	</xsl:choose>
+	<xsl:choose>
+		<xsl:when test="not($specified) and $optionXml">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=False, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+	<xsl:choose>
+		<xsl:when test="substring-after($fieldType, 'google.protobuf.')">
+    &lt;Global.System.ComponentModel.DefaultValue(CType(<xsl:value-of select="$defaultValue"/>, <xsl:value-of select="substring-after($fieldType, 'google.protobuf.')"/>))&gt; _
+		</xsl:when>
+		<xsl:otherwise>
+    &lt;Global.System.ComponentModel.DefaultValue(CType(<xsl:value-of select="$defaultValue"/>, <xsl:value-of select="$fieldType"/>))&gt; _
+		</xsl:otherwise>
+	</xsl:choose>
+    &lt;Global.System.Xml.Serialization.XmlElement("<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>)&gt; _ <!--
+		--></xsl:when>
+		<xsl:when test="not($specified) and $optionDataContract">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=False, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+    <xsl:choose>
+		<xsl:when test="substring-after($fieldType, 'google.protobuf.')">
+    &lt;Global.System.ComponentModel.DefaultValue(CType(<xsl:value-of select="$defaultValue"/>, <xsl:value-of select="substring-after($fieldType, 'google.protobuf.')"/>))&gt; _
+		</xsl:when>
+		<xsl:otherwise>
+    &lt;Global.System.ComponentModel.DefaultValue(CType(<xsl:value-of select="$defaultValue"/>, <xsl:value-of select="$fieldType"/>))&gt; _
+		</xsl:otherwise>
+	</xsl:choose>
+    &lt;Global.System.Runtime.Serialization.DataMember(Name:="<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>, IsRequired:=False)&gt; _ <!--
+		--></xsl:when>
+		<xsl:when test="not($specified)">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=False, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _ <!--
+    --><xsl:choose>
+		<xsl:when test="substring-after($fieldType, 'google.protobuf.')">
+    &lt;Global.System.ComponentModel.DefaultValue(CType(<xsl:value-of select="$defaultValue"/>, <xsl:value-of select="substring-after($fieldType, 'google.protobuf.')"/>))&gt; _ <!--
+		--></xsl:when>
+		<xsl:otherwise>
+    &lt;Global.System.ComponentModel.DefaultValue(CType(<xsl:value-of select="$defaultValue"/>, <xsl:value-of select="$fieldType"/>))&gt; _ <!--
+		--></xsl:otherwise>
+	</xsl:choose><!--
+		--></xsl:when>
+		<xsl:when test="$optionDataContract">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=False, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+    &lt;Global.System.Runtime.Serialization.DataMember(Name:="<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>, IsRequired:=False)&gt; _ <!--
+		--></xsl:when>
+		<xsl:when test="$optionXml">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=False, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+    &lt;Global.System.Xml.Serialization.XmlElement("<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>)&gt; _ <!--
+		--></xsl:when>
+		<xsl:otherwise>
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=False, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _ <!--
+		--></xsl:otherwise>
+	</xsl:choose><!--
+	--><xsl:call-template name="WriteGetSet">
+      <xsl:with-param name="fieldType" select="$fieldType"/>
+      <xsl:with-param name="propType" select="$propType"/>
+      <xsl:with-param name="name"><xsl:call-template name="pascalPropName"/></xsl:with-param>
+      <xsl:with-param name="field" select="$field"/>
+      <xsl:with-param name="defaultValue" select="$defaultValue"/>
+      <xsl:with-param name="specified" select="$specified"/>
+    </xsl:call-template>
+  </xsl:template>
+
+  <xsl:template name="pascalPropName">
+    <xsl:param name="value" select="name"/>
+    <xsl:param name="delimiter" select="'_'"/>
+    <xsl:variable name="valueUC" select="translate($value,$alpha,$ALPHA)"/>
+    <xsl:variable name="finalName">
+      <xsl:choose>
+        <xsl:when test="$types[translate(name,$alpha,$ALPHA)=$valueUC]"><xsl:value-of select="concat($value,$delimiter,'Property')"/></xsl:when>
+        <xsl:otherwise><xsl:value-of select="$value"/></xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:call-template name="pascal">
+      <xsl:with-param name="value" select="$finalName"/>
+      <xsl:with-param name="delimiter" select="$delimiter"/>
+    </xsl:call-template>
+  </xsl:template>
+  
+  <xsl:template match="FieldDescriptorProto[label='LABEL_REQUIRED']">
+    <xsl:variable name="type"><xsl:apply-templates select="." mode="type"/></xsl:variable>
+    <xsl:variable name="format"><xsl:apply-templates select="." mode="format"/></xsl:variable>
+    <xsl:variable name="field"><xsl:apply-templates select="." mode="field"/></xsl:variable>
+    Private <xsl:value-of select="concat($field, ' As ', $type)"/>
+	<xsl:choose>
+		<xsl:when test="$optionDataContract">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=True, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+    &lt;Global.System.Runtime.Serialization.DataMember(Name:="<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>, IsRequired:=True)&gt; _ <!--
+		--></xsl:when>
+		<xsl:when test="$optionXml">
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=True, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+    &lt;Global.System.Xml.Serialization.XmlElement("<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>)&gt; _ <!--
+		--></xsl:when>
+		<xsl:otherwise>
+    &lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, IsRequired:=True, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _ <!--
+		--></xsl:otherwise>
+	</xsl:choose><!--
+    --><xsl:call-template name="WriteGetSet">
+      <xsl:with-param name="fieldType" select="$type"/>
+      <xsl:with-param name="propType" select="$type"/>
+      <xsl:with-param name="name" select="name"/>
+      <xsl:with-param name="field" select="$field"/>
+    </xsl:call-template>    
+  </xsl:template>
+
+  <xsl:template name="WriteGetSet">
+    <xsl:param name="fieldType"/>
+    <xsl:param name="propType"/>
+    <xsl:param name="name"/>
+    <xsl:param name="field"/>
+    <xsl:param name="specified" select="false()"/>
+    <xsl:param name="defaultValue"/>
+	<xsl:variable name="primitiveType"><xsl:apply-templates select="." mode="primitiveType"/></xsl:variable>
+	<xsl:choose>
+		<xsl:when test="substring-after($fieldType, 'google.protobuf.')">
+    Public Property <xsl:value-of select="concat($name,' As ',substring-after($fieldType, 'google.protobuf.'))"/>
+		</xsl:when>
+		<xsl:otherwise>
+    Public Property <xsl:value-of select="concat($name,' As ',$fieldType)"/>
+		</xsl:otherwise>
+	</xsl:choose>
+		Get 
+			<xsl:choose>
+				<xsl:when test="$specified and $primitiveType='struct'"><!--
+					-->Return <xsl:value-of select="$field"/><!--
+					--></xsl:when>
+				<xsl:when test="$specified">
+			If Not <xsl:value-of select="$field"/> Is Nothing Then
+				Return <xsl:value-of select="$field"/>
+			Else
+				Return <xsl:value-of select="$defaultValue"/>
+			End If<!--
+				--></xsl:when>
+				<xsl:otherwise><!--
+			-->Return <xsl:value-of select="$field"/><!--
+				--></xsl:otherwise>
+			</xsl:choose>
+		End Get
+	<xsl:choose>
+		<xsl:when test="substring-after($fieldType, 'google.protobuf.')">
+		Set(<xsl:value-of select="concat('value As ',substring-after($fieldType, 'google.protobuf.'))"/>)
+		</xsl:when>
+		<xsl:otherwise>
+		Set(<xsl:value-of select="concat('value As ',$fieldType)"/>)
+		</xsl:otherwise>
+	</xsl:choose>
+			<xsl:if test="$optionPartialMethods">On<xsl:value-of select="$name"/>Changing(value)
+			</xsl:if><xsl:if test="$optionPreObservable">OnPropertyChanging("<xsl:value-of select="$name"/>") 
+			</xsl:if><xsl:value-of select="$field"/> = value 
+			<xsl:if test="$optionObservable">OnPropertyChanged("<xsl:value-of select="$name"/>") </xsl:if><xsl:if test="$optionPartialMethods">On<xsl:value-of select="$name"/>Changed()</xsl:if>
+		End Set
+	End Property
+    <xsl:if test="$optionPartialMethods">
+    partial void On<xsl:value-of select="$name"/>Changing(<xsl:value-of select="$propType"/> value);
+    partial void On<xsl:value-of select="$name"/>Changed();</xsl:if><xsl:if test="$specified">
+    &lt;Global.System.Xml.Serialization.XmlIgnore&gt; _
+    <xsl:if test="$optionFullFramework">&lt;Global.System.ComponentModel.Browsable(false)&gt; _ </xsl:if>
+	<xsl:choose>
+		<xsl:when test="$specified and $primitiveType='struct'">
+	Public Property <xsl:value-of select="$name"/>Specified As Boolean
+        Get 
+            Return <xsl:value-of select="$field"/>.HasValue
+        End Get
+        Set (ByVal value As Boolean) 
+            If Not <xsl:value-of select="$field"/>.HasValue Then
+				If value = True then <xsl:value-of select="$field"/> = <xsl:value-of select="$name"/>
+			Else
+				If value = False then <xsl:value-of select="$field"/> = Nothing
+			End If
+        End Set
+    End Property
+		</xsl:when>
+		<xsl:otherwise>
+	Public Property <xsl:value-of select="$name"/>Specified As Boolean
+        Get 
+            Return <xsl:value-of select="$field"/> IsNot Nothing
+        End Get
+        Set (ByVal value As Boolean) 
+            If <xsl:value-of select="$field"/> Is Nothing Then
+				If value = True then <xsl:value-of select="$field"/> = <xsl:value-of select="$name"/>
+			Else
+				If value = False then <xsl:value-of select="$field"/> = Nothing
+			End If
+        End Set
+    End Property
+		</xsl:otherwise>
+	</xsl:choose>
+	Private Function ShouldSerialize<xsl:value-of select="$name"/>() As Boolean
+		Return <xsl:value-of select="$name"/>Specified 
+	End Function
+    Private Sub Reset<xsl:value-of select="$name"/>()
+		<xsl:value-of select="$name"/>Specified = false
+	End Sub
+    </xsl:if>
+  </xsl:template>
+  <xsl:template match="FieldDescriptorProto[label='LABEL_REPEATED']">
+    <xsl:variable name="type"><xsl:apply-templates select="." mode="type"/></xsl:variable>
+    <xsl:variable name="format"><xsl:apply-templates select="." mode="format"/></xsl:variable>
+    <xsl:variable name="field"><xsl:apply-templates select="." mode="field"/></xsl:variable>
+	<xsl:choose>
+		<xsl:when test="substring-after($type, 'google.protobuf.')">
+    Private <xsl:if test="not($optionXml)">ReadOnly </xsl:if> <xsl:value-of select="$field"/> as Global.System.Collections.Generic.List(Of <xsl:value-of select="substring-after($type, 'google.protobuf.')" />) = New Global.System.Collections.Generic.List(Of <xsl:value-of select="substring-after($type, 'google.protobuf.')"/>)()
+		</xsl:when>
+		<xsl:otherwise>
+    Private <xsl:if test="not($optionXml)">ReadOnly </xsl:if> <xsl:value-of select="$field"/> as Global.System.Collections.Generic.List(Of <xsl:value-of select="$type" />) = New Global.System.Collections.Generic.List(Of <xsl:value-of select="$type"/>)()
+		</xsl:otherwise>
+	</xsl:choose>
+	<xsl:choose>
+		<xsl:when test="$optionDataContract">
+	&lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+	&lt;Global.System.Runtime.Serialization.DataMember(Name:="<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>, IsRequired:=False)&gt; _ 
+		</xsl:when>
+		<xsl:when test="$optionXml">
+	&lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+	&lt;Global.System.Xml.Serialization.XmlElement("<xsl:value-of select="name"/>", Order:=<xsl:value-of select="number"/>)&gt; _
+		</xsl:when>
+		<xsl:otherwise>
+	&lt;Global.ProtoBuf.ProtoMember(<xsl:value-of select="number"/>, Name:="<xsl:value-of select="name"/>", DataFormat:=Global.ProtoBuf.DataFormat.<xsl:value-of select="$format"/>)&gt; _
+		</xsl:otherwise>
+	</xsl:choose><!--
+	--><xsl:choose>
+		<xsl:when test="substring-after($type, 'google.protobuf.')"><!--
+    -->Public <xsl:if test="not($optionXml)">ReadOnly </xsl:if>Property <xsl:value-of select="name"/> As Global.System.Collections.Generic.List(Of <xsl:value-of select="substring-after($type, 'google.protobuf.')" />)
+		</xsl:when>
+		<xsl:otherwise><!--
+    -->Public <xsl:if test="not($optionXml)">ReadOnly </xsl:if>Property <xsl:value-of select="name"/> As Global.System.Collections.Generic.List(Of <xsl:value-of select="$type" />)
+		</xsl:otherwise>
+	</xsl:choose>
+		Get
+			Return <xsl:value-of select="$field"/>
+		End Get
+		<!----><xsl:if test="$optionXml">
+		<xsl:choose>
+			<xsl:when test="substring-after($type, 'google.protobuf.')">
+		Set (value As Global.System.Collections.Generic.List(Of <xsl:value-of select="substring-after($type, 'google.protobuf.')" />))
+			</xsl:when>
+			<xsl:otherwise>
+		Set (value As Global.System.Collections.Generic.List(Of <xsl:value-of select="$type" />))
+			</xsl:otherwise>
+		</xsl:choose>
+			<xsl:value-of select="$field"/> = value 
+		End Set
+		</xsl:if>
+	End Property
+  </xsl:template>
+
+  <xsl:template match="ServiceDescriptorProto">
+    <xsl:if test="($optionClientProxy or $optionDataContract)">
+    &lt;Global.System.ServiceModel.ServiceContract(Name:="<xsl:value-of select="name"/>")&gt; _
+    </xsl:if>
+    Public Interface I<xsl:value-of select="name"/>
+      <xsl:apply-templates select="method"/>
+    End Interface
+    
+    <xsl:if test="$optionProtoRpc">
+    Public Class <xsl:value-of select="name"/>Client : Global.ProtoBuf.ServiceModel.RpcClient
+      public <xsl:value-of select="name"/>Client() : base(typeof(I<xsl:value-of select="name"/>)) { }
+
+      <xsl:apply-templates select="method/MethodDescriptorProto" mode="protoRpc"/>
+    End Class
+    </xsl:if>
+    <xsl:apply-templates select="." mode="clientProxy"/>
+    
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto">
+    <xsl:if test="$optionDataContract">
+    &lt;Global.System.ServiceModel.OperationContract(Name:="<xsl:value-of select="name"/>")&gt; _
+    &lt;Global.ProtoBuf.ServiceModel.ProtoBehavior()&gt; _
+    </xsl:if>
+    <xsl:apply-templates select="output_type"/><xsl:text xml:space="preserve"> </xsl:text><xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request);
+    <xsl:if test="$optionAsynchronous and $optionDataContract">
+    &lt;Global.System.ServiceModel.OperationContract(AsyncPattern:=True, Name:="<xsl:value-of select="name"/>")&gt; _
+    Global.System.IAsyncResult Begin<xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request, Global.System.AsyncCallback callback, object state);
+    <xsl:apply-templates select="output_type"/> End<xsl:value-of select="name"/>(Global.System.IAsyncResult ar);
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto" mode="protoRpc">
+      <xsl:apply-templates select="output_type"/><xsl:text xml:space="preserve"> </xsl:text><xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request)
+      {
+        return (<xsl:apply-templates select="output_type"/>) Send("<xsl:value-of select="name"/>", request);
+      }
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto/input_type | MethodDescriptorProto/output_type">
+    <xsl:value-of select="substring-after(.,'.')"/>
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto" mode="CompleteEvent">
+  <xsl:if test="$optionAsynchronous and $optionDataContract">
+    Public Class <xsl:value-of select="name"/>CompletedEventArgs : Global.System.ComponentModel.AsyncCompletedEventArgs
+        private object[] results;
+
+        public <xsl:value-of select="name"/>CompletedEventArgs(object[] results, Global.System.Exception exception, bool cancelled, object userState)
+            : base(exception, cancelled, userState) 
+        {
+            this.results = results;
+        }
+        
+        public <xsl:apply-templates select="output_type"/> Result
+        {
+            get { 
+                base.RaiseExceptionIfNecessary();
+                return (<xsl:apply-templates select="output_type"/>)(this.results[0]); 
+            }
+        }
+    End Class
+  </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="ServiceDescriptorProto" mode="clientProxy">
+  <xsl:if test="$optionAsynchronous and $optionDataContract and $optionClientProxy">
+    <xsl:apply-templates select="method/MethodDescriptorProto" mode="CompleteEvent"/>
+    
+    &lt;Global.System.Diagnostics.DebuggerStepThroughAttribute()&gt; _
+    public partial class <xsl:value-of select="name"/>Client : Global.System.ServiceModel.ClientBase&lt;I<xsl:value-of select="name"/>&gt;, I<xsl:value-of select="name"/>
+    {
+
+        public <xsl:value-of select="name"/>Client()
+        {}
+        public <xsl:value-of select="name"/>Client(string endpointConfigurationName) 
+            : base(endpointConfigurationName) 
+        {}
+        public <xsl:value-of select="name"/>Client(string endpointConfigurationName, string remoteAddress) 
+            : base(endpointConfigurationName, remoteAddress)
+        {}
+        public <xsl:value-of select="name"/>Client(string endpointConfigurationName, Global.System.ServiceModel.EndpointAddress remoteAddress)
+            : base(endpointConfigurationName, remoteAddress)
+        {}
+        public <xsl:value-of select="name"/>Client(Global.System.ServiceModel.Channels.Binding binding, Global.System.ServiceModel.EndpointAddress remoteAddress)
+            : base(binding, remoteAddress)
+        {}
+
+        <xsl:apply-templates select="method/MethodDescriptorProto" mode="clientProxy"/>
+    }  
+  </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="MethodDescriptorProto" mode="clientProxy">
+  <xsl:if test="$optionAsynchronous and $optionDataContract and $optionClientProxy">
+        private BeginOperationDelegate onBegin<xsl:value-of select="name"/>Delegate;
+        private EndOperationDelegate onEnd<xsl:value-of select="name"/>Delegate;
+        private Global.System.Threading.SendOrPostCallback on<xsl:value-of select="name"/>CompletedDelegate;
+
+        public event Global.System.EventHandler&lt;<xsl:value-of select="name"/>CompletedEventArgs&gt; <xsl:value-of select="name"/>Completed;
+
+        public <xsl:apply-templates select="output_type"/><xsl:text xml:space="preserve"> </xsl:text><xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request)
+        {
+            return base.Channel.<xsl:value-of select="name"/>(request);
+        }
+
+        &lt;Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)&gt; _
+        public Global.System.IAsyncResult Begin<xsl:value-of select="name"/>(<xsl:apply-templates select="input_type"/> request, Global.System.AsyncCallback callback, object asyncState)
+        {
+            return base.Channel.Begin<xsl:value-of select="name"/>(request, callback, asyncState);
+        }
+
+        &lt;Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Advanced)&gt; _
+        public <xsl:apply-templates select="output_type"/> End<xsl:value-of select="name"/>(Global.System.IAsyncResult result)
+        {
+            return base.Channel.End<xsl:value-of select="name"/>(result);
+        }
+
+        private Global.System.IAsyncResult OnBegin<xsl:value-of select="name"/>(object[] inValues, Global.System.AsyncCallback callback, object asyncState)
+        {
+            <xsl:apply-templates select="input_type"/> request = ((<xsl:apply-templates select="input_type"/>)(inValues[0]));
+            return this.Begin<xsl:value-of select="name"/>(request, callback, asyncState);
+        }
+
+        private object[] OnEnd<xsl:value-of select="name"/>(Global.System.IAsyncResult result)
+        {
+            <xsl:apply-templates select="output_type"/> retVal = this.End<xsl:value-of select="name"/>(result);
+            return new object[] {
+                retVal};
+        }
+
+        private void On<xsl:value-of select="name"/>Completed(object state)
+        {
+            if ((this.<xsl:value-of select="name"/>Completed != null))
+            {
+                InvokeAsyncCompletedEventArgs e = ((InvokeAsyncCompletedEventArgs)(state));
+                this.<xsl:value-of select="name"/>Completed(this, new <xsl:value-of select="name"/>CompletedEventArgs(e.Results, e.Error, e.Cancelled, e.UserState));
+            }
+        }
+
+        public void <xsl:value-of select="name"/>Async(<xsl:apply-templates select="input_type"/> request)
+        {
+            this.<xsl:value-of select="name"/>Async(request, null);
+        }
+
+        public void <xsl:value-of select="name"/>Async(<xsl:apply-templates select="input_type"/> request, object userState)
+        {
+            if ((this.onBegin<xsl:value-of select="name"/>Delegate == null))
+            {
+                this.onBegin<xsl:value-of select="name"/>Delegate = new BeginOperationDelegate(this.OnBegin<xsl:value-of select="name"/>);
+            }
+            if ((this.onEnd<xsl:value-of select="name"/>Delegate == null))
+            {
+                this.onEnd<xsl:value-of select="name"/>Delegate = new EndOperationDelegate(this.OnEnd<xsl:value-of select="name"/>);
+            }
+            if ((this.on<xsl:value-of select="name"/>CompletedDelegate == null))
+            {
+                this.on<xsl:value-of select="name"/>CompletedDelegate = new Global.System.Threading.SendOrPostCallback(this.On<xsl:value-of select="name"/>Completed);
+            }
+            base.InvokeAsync(this.onBegin<xsl:value-of select="name"/>Delegate, new object[] {
+                    request}, this.onEnd<xsl:value-of select="name"/>Delegate, this.on<xsl:value-of select="name"/>CompletedDelegate, userState);
+        }
+    </xsl:if>
+    </xsl:template>
+  
+  <xsl:template name="escapeKeyword"><xsl:param name="value"/><xsl:choose>
+      <xsl:when test="contains($keywordsUpper,concat('|',translate($value, $alpha, $ALPHA),'|'))">[<xsl:value-of select="$value"/>]</xsl:when>
+      <xsl:otherwise><xsl:value-of select="$value"/></xsl:otherwise>
+    </xsl:choose></xsl:template>
+  <xsl:variable name="keywords">|AddHandler|AddressOf|Alias|And|AndAlso|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|CBool|CByte|CChar|CDate|CDec|CDbl|Char|CInt|Class|CLng|CObj|Const|Continue|CSByte|CShort|CSng|CStr|CType|CUInt|CULng|CUShort|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else|ElseIf|End|EndIf|Enum|Erase|Error|Event|Exit|False|Finally|For|Friend|Function|Get|GetType|GetXMLNamespace|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|MustInherit|MustOverride|MyBase|MyClass|Namespace|Narrowing|New|Next|Not|Nothing|NotInheritable|NotOverridable|Object|Of|On|Operator|Option|Optional|Or|OrElse|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|REM|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|Short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|True|Try|TryCast|TypeOf|Variant|Wend|UInteger|ULong|UShort|Using|When|While|Widening|With|WithEvents|WriteOnly|Xor|</xsl:variable>
+  <xsl:variable name="keywordsUpper" select="translate($keywords, $alpha, $ALPHA)"/>
+
+</xsl:stylesheet>

CSharp/Tools/ProtoGen/xml.xslt

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+    xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes="xsl msxsl"
+>
+  <xsl:param name="help"/>
+  <xsl:output method="xml" indent="yes"/>
+
+
+  <xsl:template match="/*">
+    <xsl:if test="$help='true'">
+      <xsl:message terminate="yes">
+        Xml template for protobuf-net.
+        
+        This template writes the proto descriptor as xml.
+        No options available.
+      </xsl:message>
+    </xsl:if>
+    <xsl:call-template name="main"/>
+  </xsl:template>
+  
+    <xsl:template match="@* | node()" name="main">
+        <xsl:copy>
+            <xsl:apply-templates select="@* | node()"/>
+        </xsl:copy>
+    </xsl:template>
+</xsl:stylesheet>

CSharp/Tools/ProtobufTool/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的常规信息通过以下
+// 特性集控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("ProtobufTool")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("ProtobufTool")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2012")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 使此程序集中的类型
+// 对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型，
+// 则将该类型上的 ComVisible 特性设置为 true。
+[assembly: ComVisible(true)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("9cf79956-6dfb-4d5b-8d29-7b43f7306acf")]
+
+// 程序集的版本信息由下面四个值组成:
+//
+//      主版本
+//      次版本 
+//      生成号
+//      修订号
+//
+// 可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值，
+// 方法是按如下所示使用“*”:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

CSharp/Tools/ProtobufTool/ProtobufGenerator.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using Microsoft.VisualStudio.TextTemplating.VSHost;
+
+namespace ProtobufTool
+{
+	[ComVisible(true)]
+	[Guid("9cf79956-6dfb-4d5b-8d29-7b43f7306acf")]
+	public class ProtobufGenerator : BaseCodeGeneratorWithSite
+    {
+		public override string GetDefaultExtension()
+		{
+			return ".pb.cs";
+		}
+
+		protected override byte[] GenerateCode(string inputFileName, string inputFileContent)
+		{
+			var processStartInfo = new ProcessStartInfo("protogen.exe")
+			{
+				CreateNoWindow = true,
+				WindowStyle = ProcessWindowStyle.Hidden,
+				WorkingDirectory = Environment.CurrentDirectory,
+				RedirectStandardError = true,
+				RedirectStandardOutput = true
+			};
+			processStartInfo.CreateNoWindow = true;
+			processStartInfo.WindowStyle = ProcessWindowStyle.Hidden;
+
+			var tempFile = Path.GetTempFileName();
+			string inputDir = Path.GetFullPath(inputFileName);
+			processStartInfo.Arguments = string.Format(
+				" -q -writeErrors -t: csharp -i:{0} -w:{1} -o:{2} ",
+				inputFileName, inputDir, tempFile);			
+			using(var process = Process.Start(processStartInfo))
+			{
+				process.WaitForExit();
+			}
+			byte[] bytes = File.ReadAllBytes(tempFile);
+			File.Delete(tempFile);
+			return bytes;
+		}
+    }
+}

CSharp/Tools/ProtobufTool/ProtobufGenerator.reg

@@ -0,0 +1,7 @@
+Windows Registry Editor Version 5.00
+
+[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\Generators\{FAE04EC1-301F-11D3-BF4B-00C04F79EFBC}\ProtobufTool]
+@="ProtobufTool"
+"CLSID"="{9cf79956-6dfb-4d5b-8d29-7b43f7306acf}"
+"GeneratesDesignTimeSource"=dword:00000001
+"GeneratesSharedDesignTimeSource"=dword:00000001

CSharp/Tools/ProtobufTool/ProtobufTool.csproj

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{87537C92-B2C7-4E46-A6FB-02B73215C100}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ProtobufTool</RootNamespace>
+    <AssemblyName>ProtobufTool</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\Bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <RegisterForComInterop>false</RegisterForComInterop>
+  </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>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>..\..\Egametang.pfx</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.OLE.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+    <Reference Include="Microsoft.VisualStudio.Shell.11.0, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
+    <Reference Include="Microsoft.VisualStudio.Shell.Interop.11.0, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <EmbedInteropTypes>True</EmbedInteropTypes>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.TextTemplating.VSHost.11.0, Version=11.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ProtobufGenerator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\Egametang.pfx">
+      <Link>Egametang.pfx</Link>
+    </None>
+    <None Include="ProtobufGenerator.reg" />
+    <None Include="register.bat" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PostBuildEvent>$(ProjectDir)\register.bat $(TargetPath) $(TargetDir)</PostBuildEvent>
+  </PropertyGroup>
+  <!-- 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>

CSharp/Tools/ProtobufTool/register.bat

@@ -0,0 +1,15 @@
+@echo off
+rem "%windir%\Microsoft.NET\Framework\v4.0.30319\regasm.exe" /nologo /unregister "%1"
+
+rem "%ProgramFiles%\Microsoft SDKs\Windows\v7.0A\Bin\gacutil.exe" /nologo /f /i "%1"
+rem "%windir%\Microsoft.NET\Framework\v4.0.30319\regasm.exe" /nologo /CodeBase "%1"
+
+goto BuildEventOK
+
+:BuildEventFailed
+echo POSTBUILDSTEP FAILED
+exit 1
+
+:BuildEventOK
+echo POSTBUILDSTEP COMPLETED OK
+exit 0