Removed the contorted concept of 'curation' and added proper serialization and deserialization using protobufs. Now design shines through by showing nearly 50% reduction of object that needs to be parsed in memory (depending on rules for the game) :). .NET's BinarySerializer was dropping 88 MB file and never completed deserialization during my test runs. Protobuf takes < 1 sec to load seriazilzed file into a usable object. (6236c42)

Removed the contorted concept of 'curation' and added proper serialization and deserialization using protobufs. Now design shines through by showing nearly 50% reduction of object that needs to be parsed in memory (depending on rules for the game) :). .NET's BinarySerializer was dropping 88 MB file and never completed deserialization during my test runs. Protobuf takes < 1 sec to load seriazilzed file into a usable object.

Parent 248fba3

Dev Ghai commited on 2013-12-25 10:46:49
Showing 12 changed files, with 3011 additions and 123 deletions.

.gitignore 9a892f9..f6522a1
Boggle.cs 397a184..68212c6
Boggle.csproj 66ade7b..1efca36
Boggle.sln baa1419..1b94800
BoggleList.cs 2af0736..06e901a
Constants.cs 47c9cf2..f7253ad
ListWord.cs 137c82d..f9ab145
SupportedLists.cs 0000000..c150e13
WordComparer.cs df32d4c..e6ed870
dependencies/protobuf-net.dll 0000000..de4701c
dependencies/protobuf-net.pdb 0000000..44c73eb
dependencies/protobuf-net.xml 0000000..4e047de

.gitignore

View file @ 6236c42

@@ -1,5 +1,9 @@
 git-export-daemon-ok
 bin
+obj
 *.swp
 *.csproj.user
 *.userprefs
+*.suo
+.directory
+*.psess

Boggle.cs

View file @ 6236c42

@@ -1,4 +1,4 @@
-//#define DEVELOPING
+#define DEVELOPING
 
 using System;
 using System.Collections.Generic;
@@ -32,7 +32,7 @@ namespace Boggle
             int minWordLength = 4;
 
             char wordListInput = 'Z';
-            BoggleLists listToUseForLookup;
+            SupportedLists listToUseForLookup;
             
 #if !DEVELOPING
             do
@@ -56,11 +56,11 @@ namespace Boggle
             switch (wordListInput)
             {
                 case 'T':
-                    listToUseForLookup = BoggleLists.TWS;
+                    listToUseForLookup = SupportedLists.TWS;
                     break;
 
                 case 'Z':
-                    listToUseForLookup = BoggleLists.ZINGARELLI;
+                    listToUseForLookup = SupportedLists.ZINGARELLI;
                     break;
                 default:
                     throw new Exception("Unexpected!!");

Boggle.csproj

View file @ 6236c42

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+﻿<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -32,6 +32,9 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="protobuf-net">
+      <HintPath>dependencies\protobuf-net.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -44,6 +47,7 @@
     <Compile Include="Boggle.cs" />
     <Compile Include="BoggleBoard.cs" />
     <Compile Include="BoggleList.cs" />
+    <Compile Include="SupportedLists.cs" />
     <Compile Include="BoggleSolver.cs" />
     <Compile Include="Constants.cs" />
     <Compile Include="ListWord.cs" />

Boggle.sln

View file @ 6236c42

@@ -1,8 +1,9 @@
-
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Boggle", "Boggle.csproj", "{AB752D5B-37CC-4029-8621-FA970CDD5E2A}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5DA3320C-AD61-449F-B900-9F8B763B9E27}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x86 = Debug|x86
@@ -14,6 +15,12 @@ Global
 		{AB752D5B-37CC-4029-8621-FA970CDD5E2A}.Release|x86.ActiveCfg = Release|x86
 		{AB752D5B-37CC-4029-8621-FA970CDD5E2A}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 	GlobalSection(MonoDevelopProperties) = preSolution
 		StartupItem = Boggle.csproj
 	EndGlobalSection

BoggleList.cs

View file @ 6236c42

@@ -1,30 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using ProtoBuf.Serializers;
 
 namespace Boggle
 {
-    /// <summary>
-    /// Supported lists.
-    /// </summary>
-    public enum BoggleLists
-    {
-        /// <summary>
-        /// Scrabble dictionary for USA, Canada and Thailand
-        /// </summary>
-        TWS,
-
-        /// <summary>
-        /// Scrabble dictionary used world wide except in USA, Canada and Thailand.
-        /// </summary>
-        //SOWPODS,
-
-        /// <summary>
-        /// A huge dictionary found on official Internet Scrabble Club's website (http://www.isc.ro/en/commands/lists.html)
-        /// </summary>
-        ZINGARELLI
-    }
-
     public class BoggleList
     {
         /// <summary>
@@ -42,65 +22,12 @@ namespace Boggle
         /// <summary>
         /// Contains a list of dictionaries that have been loaded, indexed by enum that contains dictionaries we support.
         /// </summary>
-        private Dictionary<BoggleLists, Dictionary<string, ListWord>> _LoadedDictionaries;
-
-        /// <summary>
-        /// Determines if we have an absolute path
-        /// </summary>
-        /// <param name="filePath">File that contains the list SORTED list of words. Path can be relative or absolute.</param>
-        /// <returns>The absolute file path that we can use to access it.</returns>
-        private string GetAbsoluteFilePath(string filePath)
-        {
-            //check if the absolute file path exists.            
-            if (!File.Exists(filePath))
-            {
-                //try checking if this is a relative file path and prepend current directory's path.
-                filePath = string.Format("{0}\\{1}", Directory.GetCurrentDirectory(), filePath);
-                if (!File.Exists(filePath))
-                {
-                    filePath = string.Empty;
-                }
-            }
-
-            return filePath;
-        }
-
-        /// <summary>
-        /// Curates the list for use by this solver. Basically culls out words that do not meet the criteria.
-        /// Criteria: Min_word_length < word_length < Max_word_length. Max_word_length = sideLength^2 + 1.
-        /// </summary>
-        /// <param name="filePath"> Path to file that contains the SORTED list of words. 
-        ///                         It can be relative to current execution directory or absolute.</param>
-        /// <param name="boardSideLength">Length of the side of board in number of tiles.</param>
-        /// <param name="minWordLength">Number of alphabets that can be there in the shortest word on the board.</param>
-        private void CurateList(string filePath, int boardSideLength, int minWordLength)
-        {
-            //filePath = GetAbsoluteFilePath(filePath);
-            //true tells stream reader to auto detect encoding of the file.
-            StreamReader rawList = new StreamReader(filePath, true);
-            //Create a new file. Do not append anything.
-            string curatedFilePath = string.Format("{0}.{1}.{2}", filePath, Constants.CURATED_FILE_SUFFIX, minWordLength.ToString());
-            StreamWriter curatedList = new StreamWriter(curatedFilePath, false);
-
-            string word;
-            //write out the words whose number of characters are between the shortest and largest provided length.
-            while ((word = rawList.ReadLine()) != null)
-            {
-                if (word.Length >= minWordLength && word.Length <= boardSideLength * boardSideLength + 1)
-                {
-                    curatedList.WriteLine(word);
-                }
-            }
-
-            curatedList.Flush();
-            curatedList.Close();
-            rawList.Close();
-        }
+        private Dictionary<string, Dictionary<string, ListWord>> _LoadedDictionaries;
         
         public BoggleList()
         {
             //Initialize the dictionary containing the lists.
-            _LoadedDictionaries = new Dictionary<BoggleLists, Dictionary<string, ListWord>>(Enum.GetNames(typeof(BoggleLists)).Length);
+            _LoadedDictionaries = new Dictionary<string, Dictionary<string, ListWord>>(Enum.GetNames(typeof(SupportedLists)).Length);
         }
 
         /// <summary>
@@ -110,26 +37,38 @@ namespace Boggle
         /// <param name="boardSideLength"></param>
         /// <param name="minWordLength"></param>
         /// <returns>A hybird tree containing the words with each level containing one alphabet (or QU)</returns>
-        public Dictionary<string, ListWord> LoadList(BoggleLists dict, int boardSideLength, int minWordLength, string listRootPath)
+        public void LoadList(SupportedLists dict, int boardSideLength, int minWordLength, string currentWorkingDirectory)
         {
-            if (_LoadedDictionaries.ContainsKey(dict))
-                return _LoadedDictionaries[dict];
+            int maxWordLength = boardSideLength * boardSideLength + 1;
+            string dictPath = this.GetSerializedDictPath(dict, minWordLength, maxWordLength, currentWorkingDirectory);
 
-            string filePath = string.Empty;
+            if (_LoadedDictionaries.ContainsKey(dictPath))
+            {
+                _WordList = _LoadedDictionaries[dictPath];
+                return;
+            }
 
-            if (NeedsCuration(dict, minWordLength, listRootPath, ref filePath))
-                CurateList(filePath, boardSideLength, minWordLength);
+            //Load the seriazlized dictionary if it exists on the disk.
+            if (SerializedDictExists(dictPath))
+            {
+                _LoadedDictionaries.Add(dictPath, DeserializeDict(dictPath));
+                _WordList = _LoadedDictionaries[dictPath];
+                return;
+            }
 
             _WordList = new Dictionary<string, ListWord>(27);
-
+            string rawListPath = GetWordlistPath(dict);
             //true tells stream reader to auto detect encoding of the file.
-            StreamReader rawList = new StreamReader(filePath, true);
+            StreamReader rawList = new StreamReader(rawListPath, true);
             string word, substring;
             ListWord prevListWord;
             int startIndex;
 
             while ((word = rawList.ReadLine()) != null)
             {
+                //no need to process the word if it cannot logically lie on the board.
+                if (word.Length < minWordLength || word.Length > maxWordLength)
+                    continue;
                 //First deal with the head node and then deal with following letters.
                 startIndex = 0;
                 word = word.ToUpper();
@@ -183,44 +122,63 @@ namespace Boggle
             }
 
             //Store it in the collection 
-            _LoadedDictionaries.Add(dict, _WordList);
-            return _WordList;
+            _LoadedDictionaries.Add(dictPath, _WordList);
+
+            //Writes the dictionary just constructed to disk
+            SerializeDict(_WordList, dictPath);
         }
 
-        /// <summary>
-        /// Checks to see if the proper file exists that contains the appropriate words.
-        /// </summary>
-        /// <param name="list">Type of list to check for.</param>
-        /// <param name="minWordLength">Minimum number of LETTERS the word should contain. </param>
-        /// <param name="filePath">Reference to path of file. If the list will need curation, it will store path to source list. 
-        /// If list is there, it will store the path to the curated list.</param>
-        /// <returns>Whether there is a need to run the curation procedure or not.</returns>
-        private bool NeedsCuration(BoggleLists list, int minWordLength, string wordlistContainer, ref string filePath)
-        {
-            bool needsCuration = false;
-            switch (list)
+        private string GetSerializedDictPath(SupportedLists list, int minWordLength, int maxWordLength, string currentWorkingDirectory)
         {
-                case BoggleLists.TWS:
-                    filePath = GetAbsoluteFilePath(string.Format("{0}/{1}.{2}.{3}", filePath, Constants.TWS_FILE_PATH, Constants.CURATED_FILE_SUFFIX, minWordLength.ToString()));
-                    if (filePath == string.Empty)
+            string serializationFolder = string.Format("{0}/{1}", currentWorkingDirectory, Constants.SERIALIZATION_FOLDER);
+            if (!Directory.Exists(serializationFolder))
             {
-                        filePath = string.Format("{0}/{1}", wordlistContainer, Constants.TWS_FILE_PATH);
-                        needsCuration = true;
+                Directory.CreateDirectory(serializationFolder);
+            }
+            string filename = string.Format("{0}/{1}.{2}.{3}.{4}", serializationFolder,
+                                                                   list,
+                                                                   minWordLength,
+                                                                   maxWordLength,
+                                                                   Constants.SERIALIZED_FILE_SUFFIX
+                                            );
+            //File creation is done by serialization function. No need to do it here. In case there is an error and we cannot
+            //load the raw dictionary into our hybrid tree, we would be left with an empty and a useless file.
+            return filename;
         }
-                    break;
-                case BoggleLists.ZINGARELLI:
-                    filePath = GetAbsoluteFilePath(string.Format("{0}/{1}.{2}.{3}", filePath, Constants.ZINGARELLI_FILE_PATH, Constants.CURATED_FILE_SUFFIX, minWordLength.ToString()));
-                    if (filePath == string.Empty)
+
+        private bool SerializedDictExists(string serializedObjPath)
         {
-                        filePath = string.Format("{0}/{1}", wordlistContainer, Constants.ZINGARELLI_FILE_PATH);
-                        needsCuration = true;
+            return File.Exists(serializedObjPath);
         }
-                    break;
-                default:
-                    throw new ArgumentException(string.Format("Support for {0} wordlist has not been coded yet :(", list));
+
+        private void SerializeDict(Dictionary<string, ListWord> funkyDict, string serializationPath)
+        {
+            Stream serializationFile = File.Open(serializationPath, FileMode.CreateNew, FileAccess.Write);
+            ProtoBuf.Serializer.Serialize <Dictionary<string, ListWord>>(serializationFile, funkyDict);
+            serializationFile.Flush();
+            serializationFile.Close();
+        }
+
+        private Dictionary<string, ListWord> DeserializeDict(string serializedObjPath)
+        {
+            Stream serializationFile = File.Open(serializedObjPath, FileMode.Open, FileAccess.Read);
+            Dictionary<string, ListWord> funkyDict = ProtoBuf.Serializer.Deserialize<Dictionary<string, ListWord>>(serializationFile);
+            serializationFile.Flush();
+            serializationFile.Close();
+            return funkyDict;
         }
 
-            return needsCuration;
+        private string GetWordlistPath(SupportedLists list)
+        {
+            switch (list)
+            {
+                case SupportedLists.TWS:
+                    return Constants.TWS_FILE_PATH;
+                case SupportedLists.ZINGARELLI:
+                    return Constants.ZINGARELLI_FILE_PATH;
+                default:
+                    throw new ArgumentException(string.Format("Support for {0} wordlist has not been coded yet :(", list));;
+            }
         }
     }
 }

Constants.cs

View file @ 6236c42

@@ -2,7 +2,8 @@ namespace Boggle
 {
     static class Constants
     {
-        public const string CURATED_FILE_SUFFIX = "curated";
+        public const string SERIALIZED_FILE_SUFFIX = "bin";
+        public const string SERIALIZATION_FOLDER = "serializedDictionaries";
         public const int MIN_SIDE_LENGTH = 3;
         public const int MIN_WORD_LENGTH = 3;
         public const int MIN_SCORE = 1;

ListWord.cs

View file @ 6236c42

@@ -1,10 +1,15 @@
 using System.Collections.Generic;
+using ProtoBuf;
 
 namespace Boggle
 {
+    [ProtoContract]
     public class ListWord
     {
+        [ProtoMember(1)]
         public bool IsWord;
+
+        [ProtoMember(2)]
         public Dictionary<string, ListWord> Next;
 
         public ListWord()

SupportedLists.cs

View file @ 6236c42

...	...	@@ -0,0 +1,28 @@
	1	+using System;
	2	+using System.Collections.Generic;
	3	+using System.Linq;
	4	+using System.Text;
	5	+
	6	+namespace Boggle
	7	+{
	8	+ /// <summary>
	9	+ /// Supported lists.
	10	+ /// </summary>
	11	+ public enum SupportedLists
	12	+ {
	13	+ /// <summary>
	14	+ /// Scrabble dictionary for USA, Canada and Thailand
	15	+ /// </summary>
	16	+ TWS,
	17	+
	18	+ /// <summary>
	19	+ /// Scrabble dictionary used world wide except in USA, Canada and Thailand.
	20	+ /// </summary>
	21	+ //SOWPODS,
	22	+
	23	+ /// <summary>
	24	+ /// A huge dictionary found on official Internet Scrabble Club's website (http://www.isc.ro/en/commands/lists.html)
	25	+ /// </summary>
	26	+ ZINGARELLI
	27	+ }
	28	+}

WordComparer.cs

View file @ 6236c42

@@ -3,7 +3,9 @@ using System.Collections.Generic;
 namespace Boggle
 {
     /// <summary>
-    /// Equality comparer used for HashSet. No longer used as I switched to Dictionaries.
+    /// Equality comparer used for HashSet. Used to compare two words in the hash set and detect collisions.
+    /// This is needed because we are making HashSet with a custom type and .NET will use expensive
+    /// procedure to determine a unique hash (by treating it as an Object instance) if this is not provided.
     /// </summary>
     public class WordComparer : EqualityComparer<WordOnBoard>
     {

dependencies/protobuf-net.dll

View file @ 6236c42

dependencies/protobuf-net.pdb

View file @ 6236c42

dependencies/protobuf-net.xml

View file @ 6236c42

...	...	@@ -0,0 +1,2879 @@
	1	+<?xml version="1.0"?>
	2	+<doc>
	3	+ <assembly>
	4	+ <name>protobuf-net</name>
	5	+ </assembly>
	6	+ <members>
	7	+ <member name="T:ProtoBuf.BclHelpers">
	8	+ <summary>
	9	+ Provides support for common .NET types that do not have a direct representation
	10	+ in protobuf, using the definitions from bcl.proto
	11	+ </summary>
	12	+ </member>
	13	+ <member name="M:ProtoBuf.BclHelpers.GetUninitializedObject(System.Type)">
	14	+ <summary>
	15	+ Creates a new instance of the specified type, bypassing the constructor.
	16	+ </summary>
	17	+ <param name="type">The type to create</param>
	18	+ <returns>The new instance</returns>
	19	+ <exception cref="T:System.NotSupportedException">If the platform does not support constructor-skipping</exception>
	20	+ </member>
	21	+ <member name="M:ProtoBuf.BclHelpers.WriteTimeSpan(System.TimeSpan,ProtoBuf.ProtoWriter)">
	22	+ <summary>
	23	+ Writes a TimeSpan to a protobuf stream
	24	+ </summary>
	25	+ </member>
	26	+ <member name="M:ProtoBuf.BclHelpers.ReadTimeSpan(ProtoBuf.ProtoReader)">
	27	+ <summary>
	28	+ Parses a TimeSpan from a protobuf stream
	29	+ </summary>
	30	+ </member>
	31	+ <member name="M:ProtoBuf.BclHelpers.ReadDateTime(ProtoBuf.ProtoReader)">
	32	+ <summary>
	33	+ Parses a DateTime from a protobuf stream
	34	+ </summary>
	35	+ </member>
	36	+ <member name="M:ProtoBuf.BclHelpers.WriteDateTime(System.DateTime,ProtoBuf.ProtoWriter)">
	37	+ <summary>
	38	+ Writes a DateTime to a protobuf stream
	39	+ </summary>
	40	+ </member>
	41	+ <member name="M:ProtoBuf.BclHelpers.ReadDecimal(ProtoBuf.ProtoReader)">
	42	+ <summary>
	43	+ Parses a decimal from a protobuf stream
	44	+ </summary>
	45	+ </member>
	46	+ <member name="M:ProtoBuf.BclHelpers.WriteDecimal(System.Decimal,ProtoBuf.ProtoWriter)">
	47	+ <summary>
	48	+ Writes a decimal to a protobuf stream
	49	+ </summary>
	50	+ </member>
	51	+ <member name="M:ProtoBuf.BclHelpers.WriteGuid(System.Guid,ProtoBuf.ProtoWriter)">
	52	+ <summary>
	53	+ Writes a Guid to a protobuf stream
	54	+ </summary>
	55	+ </member>
	56	+ <member name="M:ProtoBuf.BclHelpers.ReadGuid(ProtoBuf.ProtoReader)">
	57	+ <summary>
	58	+ Parses a Guid from a protobuf stream
	59	+ </summary>
	60	+ </member>
	61	+ <member name="M:ProtoBuf.BclHelpers.ReadNetObject(System.Object,ProtoBuf.ProtoReader,System.Int32,System.Type,ProtoBuf.BclHelpers.NetObjectOptions)">
	62	+ <summary>
	63	+ Reads an implementation specific bundled .NET object, including (as options) type-metadata, identity/re-use, etc.
	64	+ </summary>
	65	+ </member>
	66	+ <member name="M:ProtoBuf.BclHelpers.WriteNetObject(System.Object,ProtoBuf.ProtoWriter,System.Int32,ProtoBuf.BclHelpers.NetObjectOptions)">
	67	+ <summary>
	68	+ Writes an implementation specific bundled .NET object, including (as options) type-metadata, identity/re-use, etc.
	69	+ </summary>
	70	+ </member>
	71	+ <member name="T:ProtoBuf.BclHelpers.NetObjectOptions">
	72	+ <summary>
	73	+ Optional behaviours that introduce .NET-specific functionality
	74	+ </summary>
	75	+ </member>
	76	+ <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.None">
	77	+ <summary>
	78	+ No special behaviour
	79	+ </summary>
	80	+ </member>
	81	+ <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.AsReference">
	82	+ <summary>
	83	+ Enables full object-tracking/full-graph support.
	84	+ </summary>
	85	+ </member>
	86	+ <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.DynamicType">
	87	+ <summary>
	88	+ Embeds the type information into the stream, allowing usage with types not known in advance.
	89	+ </summary>
	90	+ </member>
	91	+ <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.UseConstructor">
	92	+ <summary>
	93	+ If false, the constructor for the type is bypassed during deserialization, meaning any field initializers
	94	+ or other initialization code is skipped.
	95	+ </summary>
	96	+ </member>
	97	+ <member name="F:ProtoBuf.BclHelpers.NetObjectOptions.LateSet">
	98	+ <summary>
	99	+ Should the object index be reserved, rather than creating an object promptly
	100	+ </summary>
	101	+ </member>
	102	+ <member name="T:ProtoBuf.BufferExtension">
	103	+ <summary>
	104	+ Provides a simple buffer-based implementation of an <see cref="T:ProtoBuf.IExtension">extension</see> object.
	105	+ </summary>
	106	+ </member>
	107	+ <member name="T:ProtoBuf.IExtension">
	108	+ <summary>
	109	+ Provides addition capability for supporting unexpected fields during
	110	+ protocol-buffer serialization/deserialization. This allows for loss-less
	111	+ round-trip/merge, even when the data is not fully understood.
	112	+ </summary>
	113	+ </member>
	114	+ <member name="M:ProtoBuf.IExtension.BeginAppend">
	115	+ <summary>
	116	+ Requests a stream into which any unexpected fields can be persisted.
	117	+ </summary>
	118	+ <returns>A new stream suitable for storing data.</returns>
	119	+ </member>
	120	+ <member name="M:ProtoBuf.IExtension.EndAppend(System.IO.Stream,System.Boolean)">
	121	+ <summary>
	122	+ Indicates that all unexpected fields have now been stored. The
	123	+ implementing class is responsible for closing the stream. If
	124	+ "commit" is not true the data may be discarded.
	125	+ </summary>
	126	+ <param name="stream">The stream originally obtained by BeginAppend.</param>
	127	+ <param name="commit">True if the append operation completed successfully.</param>
	128	+ </member>
	129	+ <member name="M:ProtoBuf.IExtension.BeginQuery">
	130	+ <summary>
	131	+ Requests a stream of the unexpected fields previously stored.
	132	+ </summary>
	133	+ <returns>A prepared stream of the unexpected fields.</returns>
	134	+ </member>
	135	+ <member name="M:ProtoBuf.IExtension.EndQuery(System.IO.Stream)">
	136	+ <summary>
	137	+ Indicates that all unexpected fields have now been read. The
	138	+ implementing class is responsible for closing the stream.
	139	+ </summary>
	140	+ <param name="stream">The stream originally obtained by BeginQuery.</param>
	141	+ </member>
	142	+ <member name="M:ProtoBuf.IExtension.GetLength">
	143	+ <summary>
	144	+ Requests the length of the raw binary stream; this is used
	145	+ when serializing sub-entities to indicate the expected size.
	146	+ </summary>
	147	+ <returns>The length of the binary stream representing unexpected data.</returns>
	148	+ </member>
	149	+ <member name="T:ProtoBuf.ProtoBeforeSerializationAttribute">
	150	+ <summary>Specifies a method on the root-contract in an hierarchy to be invoked before serialization.</summary>
	151	+ </member>
	152	+ <member name="T:ProtoBuf.ProtoAfterSerializationAttribute">
	153	+ <summary>Specifies a method on the root-contract in an hierarchy to be invoked after serialization.</summary>
	154	+ </member>
	155	+ <member name="T:ProtoBuf.ProtoBeforeDeserializationAttribute">
	156	+ <summary>Specifies a method on the root-contract in an hierarchy to be invoked before deserialization.</summary>
	157	+ </member>
	158	+ <member name="T:ProtoBuf.ProtoAfterDeserializationAttribute">
	159	+ <summary>Specifies a method on the root-contract in an hierarchy to be invoked after deserialization.</summary>
	160	+ </member>
	161	+ <member name="M:ProtoBuf.Compiler.CompilerContext.LoadNullRef">
	162	+ <summary>
	163	+ Pushes a null reference onto the stack. Note that this should only
	164	+ be used to return a null (or set a variable to null); for null-tests
	165	+ use BranchIfTrue / BranchIfFalse.
	166	+ </summary>
	167	+ </member>
	168	+ <member name="M:ProtoBuf.Compiler.CompilerContext.UsingBlock.#ctor(ProtoBuf.Compiler.CompilerContext,ProtoBuf.Compiler.Local)">
	169	+ <summary>
	170	+ Creates a new "using" block (equivalent) around a variable;
	171	+ the variable must exist, and note that (unlike in C#) it is
	172	+ the variables final value that gets disposed. If you need
	173	+ original disposal, copy your variable first.
	174	+
	175	+ It is the callers responsibility to ensure that the variable's
	176	+ scope fully-encapsulates the "using"; if not, the variable
	177	+ may be re-used (and thus re-assigned) unexpectedly.
	178	+ </summary>
	179	+ </member>
	180	+ <member name="T:ProtoBuf.DataFormat">
	181	+ <summary>
	182	+ Sub-format to use when serializing/deserializing data
	183	+ </summary>
	184	+ </member>
	185	+ <member name="F:ProtoBuf.DataFormat.Default">
	186	+ <summary>
	187	+ Uses the default encoding for the data-type.
	188	+ </summary>
	189	+ </member>
	190	+ <member name="F:ProtoBuf.DataFormat.ZigZag">
	191	+ <summary>
	192	+ When applied to signed integer-based data (including Decimal), this
	193	+ indicates that zigzag variant encoding will be used. This means that values
	194	+ with small magnitude (regardless of sign) take a small amount
	195	+ of space to encode.
	196	+ </summary>
	197	+ </member>
	198	+ <member name="F:ProtoBuf.DataFormat.TwosComplement">
	199	+ <summary>
	200	+ When applied to signed integer-based data (including Decimal), this
	201	+ indicates that two's-complement variant encoding will be used.
	202	+ This means that any -ve number will take 10 bytes (even for 32-bit),
	203	+ so should only be used for compatibility.
	204	+ </summary>
	205	+ </member>
	206	+ <member name="F:ProtoBuf.DataFormat.FixedSize">
	207	+ <summary>
	208	+ When applied to signed integer-based data (including Decimal), this
	209	+ indicates that a fixed amount of space will be used.
	210	+ </summary>
	211	+ </member>
	212	+ <member name="F:ProtoBuf.DataFormat.Group">
	213	+ <summary>
	214	+ When applied to a sub-message, indicates that the value should be treated
	215	+ as group-delimited.
	216	+ </summary>
	217	+ </member>
	218	+ <member name="T:ProtoBuf.Extensible">
	219	+ <summary>
	220	+ Simple base class for supporting unexpected fields allowing
	221	+ for loss-less round-tips/merge, even if the data is not understod.
	222	+ The additional fields are (by default) stored in-memory in a buffer.
	223	+ </summary>
	224	+ <remarks>As an example of an alternative implementation, you might
	225	+ choose to use the file system (temporary files) as the back-end, tracking
	226	+ only the paths [such an object would ideally be IDisposable and use
	227	+ a finalizer to ensure that the files are removed].</remarks>
	228	+ <seealso cref="T:ProtoBuf.IExtensible"/>
	229	+ </member>
	230	+ <member name="T:ProtoBuf.IExtensible">
	231	+ <summary>
	232	+ Indicates that the implementing type has support for protocol-buffer
	233	+ <see cref="T:ProtoBuf.IExtension">extensions</see>.
	234	+ </summary>
	235	+ <remarks>Can be implemented by deriving from Extensible.</remarks>
	236	+ </member>
	237	+ <member name="M:ProtoBuf.IExtensible.GetExtensionObject(System.Boolean)">
	238	+ <summary>
	239	+ Retrieves the <see cref="T:ProtoBuf.IExtension">extension</see> object for the current
	240	+ instance, optionally creating it if it does not already exist.
	241	+ </summary>
	242	+ <param name="createIfMissing">Should a new extension object be
	243	+ created if it does not already exist?</param>
	244	+ <returns>The extension object if it exists (or was created), or null
	245	+ if the extension object does not exist or is not available.</returns>
	246	+ <remarks>The <c>createIfMissing</c> argument is false during serialization,
	247	+ and true during deserialization upon encountering unexpected fields.</remarks>
	248	+ </member>
	249	+ <member name="M:ProtoBuf.Extensible.GetExtensionObject(System.Boolean)">
	250	+ <summary>
	251	+ Retrieves the <see cref="T:ProtoBuf.IExtension">extension</see> object for the current
	252	+ instance, optionally creating it if it does not already exist.
	253	+ </summary>
	254	+ <param name="createIfMissing">Should a new extension object be
	255	+ created if it does not already exist?</param>
	256	+ <returns>The extension object if it exists (or was created), or null
	257	+ if the extension object does not exist or is not available.</returns>
	258	+ <remarks>The <c>createIfMissing</c> argument is false during serialization,
	259	+ and true during deserialization upon encountering unexpected fields.</remarks>
	260	+ </member>
	261	+ <member name="M:ProtoBuf.Extensible.GetExtensionObject(ProtoBuf.IExtension@,System.Boolean)">
	262	+ <summary>
	263	+ Provides a simple, default implementation for <see cref="T:ProtoBuf.IExtension">extension</see> support,
	264	+ optionally creating it if it does not already exist. Designed to be called by
	265	+ classes implementing <see cref="T:ProtoBuf.IExtensible"/>.
	266	+ </summary>
	267	+ <param name="createIfMissing">Should a new extension object be
	268	+ created if it does not already exist?</param>
	269	+ <param name="extensionObject">The extension field to check (and possibly update).</param>
	270	+ <returns>The extension object if it exists (or was created), or null
	271	+ if the extension object does not exist or is not available.</returns>
	272	+ <remarks>The <c>createIfMissing</c> argument is false during serialization,
	273	+ and true during deserialization upon encountering unexpected fields.</remarks>
	274	+ </member>
	275	+ <member name="M:ProtoBuf.Extensible.AppendValue``1(ProtoBuf.IExtensible,System.Int32,``0)">
	276	+ <summary>
	277	+ Appends the value as an additional (unexpected) data-field for the instance.
	278	+ Note that for non-repeated sub-objects, this equates to a merge operation;
	279	+ for repeated sub-objects this adds a new instance to the set; for simple
	280	+ values the new value supercedes the old value.
	281	+ </summary>
	282	+ <remarks>Note that appending a value does not remove the old value from
	283	+ the stream; avoid repeatedly appending values for the same field.</remarks>
	284	+ <typeparam name="TValue">The type of the value to append.</typeparam>
	285	+ <param name="instance">The extensible object to append the value to.</param>
	286	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	287	+ <param name="value">The value to append.</param>
	288	+ </member>
	289	+ <member name="M:ProtoBuf.Extensible.AppendValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,``0)">
	290	+ <summary>
	291	+ Appends the value as an additional (unexpected) data-field for the instance.
	292	+ Note that for non-repeated sub-objects, this equates to a merge operation;
	293	+ for repeated sub-objects this adds a new instance to the set; for simple
	294	+ values the new value supercedes the old value.
	295	+ </summary>
	296	+ <remarks>Note that appending a value does not remove the old value from
	297	+ the stream; avoid repeatedly appending values for the same field.</remarks>
	298	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	299	+ <param name="format">The data-format to use when encoding the value.</param>
	300	+ <param name="instance">The extensible object to append the value to.</param>
	301	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	302	+ <param name="value">The value to append.</param>
	303	+ </member>
	304	+ <member name="M:ProtoBuf.Extensible.GetValue``1(ProtoBuf.IExtensible,System.Int32)">
	305	+ <summary>
	306	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	307	+ The value returned is the composed value after merging any duplicated content; if the
	308	+ value is "repeated" (a list), then use GetValues instead.
	309	+ </summary>
	310	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	311	+ <param name="instance">The extensible object to obtain the value from.</param>
	312	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	313	+ <returns>The effective value of the field, or the default value if not found.</returns>
	314	+ </member>
	315	+ <member name="M:ProtoBuf.Extensible.GetValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat)">
	316	+ <summary>
	317	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	318	+ The value returned is the composed value after merging any duplicated content; if the
	319	+ value is "repeated" (a list), then use GetValues instead.
	320	+ </summary>
	321	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	322	+ <param name="instance">The extensible object to obtain the value from.</param>
	323	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	324	+ <param name="format">The data-format to use when decoding the value.</param>
	325	+ <returns>The effective value of the field, or the default value if not found.</returns>
	326	+ </member>
	327	+ <member name="M:ProtoBuf.Extensible.TryGetValue``1(ProtoBuf.IExtensible,System.Int32,``0@)">
	328	+ <summary>
	329	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	330	+ The value returned (in "value") is the composed value after merging any duplicated content;
	331	+ if the value is "repeated" (a list), then use GetValues instead.
	332	+ </summary>
	333	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	334	+ <param name="value">The effective value of the field, or the default value if not found.</param>
	335	+ <param name="instance">The extensible object to obtain the value from.</param>
	336	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	337	+ <returns>True if data for the field was present, false otherwise.</returns>
	338	+ </member>
	339	+ <member name="M:ProtoBuf.Extensible.TryGetValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,``0@)">
	340	+ <summary>
	341	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	342	+ The value returned (in "value") is the composed value after merging any duplicated content;
	343	+ if the value is "repeated" (a list), then use GetValues instead.
	344	+ </summary>
	345	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	346	+ <param name="value">The effective value of the field, or the default value if not found.</param>
	347	+ <param name="instance">The extensible object to obtain the value from.</param>
	348	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	349	+ <param name="format">The data-format to use when decoding the value.</param>
	350	+ <returns>True if data for the field was present, false otherwise.</returns>
	351	+ </member>
	352	+ <member name="M:ProtoBuf.Extensible.TryGetValue``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,``0@)">
	353	+ <summary>
	354	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	355	+ The value returned (in "value") is the composed value after merging any duplicated content;
	356	+ if the value is "repeated" (a list), then use GetValues instead.
	357	+ </summary>
	358	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	359	+ <param name="value">The effective value of the field, or the default value if not found.</param>
	360	+ <param name="instance">The extensible object to obtain the value from.</param>
	361	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	362	+ <param name="format">The data-format to use when decoding the value.</param>
	363	+ <param name="allowDefinedTag">Allow tags that are present as part of the definition; for example, to query unknown enum values.</param>
	364	+ <returns>True if data for the field was present, false otherwise.</returns>
	365	+ </member>
	366	+ <member name="M:ProtoBuf.Extensible.GetValues``1(ProtoBuf.IExtensible,System.Int32)">
	367	+ <summary>
	368	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	369	+ Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
	370	+ (list) fields.
	371	+ </summary>
	372	+ <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
	373	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	374	+ <param name="instance">The extensible object to obtain the value from.</param>
	375	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	376	+ <returns>An enumerator that yields each occurrence of the field.</returns>
	377	+ </member>
	378	+ <member name="M:ProtoBuf.Extensible.GetValues``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat)">
	379	+ <summary>
	380	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	381	+ Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
	382	+ (list) fields.
	383	+ </summary>
	384	+ <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
	385	+ <typeparam name="TValue">The data-type of the field.</typeparam>
	386	+ <param name="instance">The extensible object to obtain the value from.</param>
	387	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	388	+ <param name="format">The data-format to use when decoding the value.</param>
	389	+ <returns>An enumerator that yields each occurrence of the field.</returns>
	390	+ </member>
	391	+ <member name="M:ProtoBuf.Extensible.TryGetValue(ProtoBuf.Meta.TypeModel,System.Type,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,System.Object@)">
	392	+ <summary>
	393	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	394	+ The value returned (in "value") is the composed value after merging any duplicated content;
	395	+ if the value is "repeated" (a list), then use GetValues instead.
	396	+ </summary>
	397	+ <param name="type">The data-type of the field.</param>
	398	+ <param name="model">The model to use for configuration.</param>
	399	+ <param name="value">The effective value of the field, or the default value if not found.</param>
	400	+ <param name="instance">The extensible object to obtain the value from.</param>
	401	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	402	+ <param name="format">The data-format to use when decoding the value.</param>
	403	+ <param name="allowDefinedTag">Allow tags that are present as part of the definition; for example, to query unknown enum values.</param>
	404	+ <returns>True if data for the field was present, false otherwise.</returns>
	405	+ </member>
	406	+ <member name="M:ProtoBuf.Extensible.GetValues(ProtoBuf.Meta.TypeModel,System.Type,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat)">
	407	+ <summary>
	408	+ Queries an extensible object for an additional (unexpected) data-field for the instance.
	409	+ Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
	410	+ (list) fields.
	411	+ </summary>
	412	+ <remarks>The extended data is processed lazily as the enumerator is iterated.</remarks>
	413	+ <param name="model">The model to use for configuration.</param>
	414	+ <param name="type">The data-type of the field.</param>
	415	+ <param name="instance">The extensible object to obtain the value from.</param>
	416	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	417	+ <param name="format">The data-format to use when decoding the value.</param>
	418	+ <returns>An enumerator that yields each occurrence of the field.</returns>
	419	+ </member>
	420	+ <member name="M:ProtoBuf.Extensible.AppendValue(ProtoBuf.Meta.TypeModel,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Object)">
	421	+ <summary>
	422	+ Appends the value as an additional (unexpected) data-field for the instance.
	423	+ Note that for non-repeated sub-objects, this equates to a merge operation;
	424	+ for repeated sub-objects this adds a new instance to the set; for simple
	425	+ values the new value supercedes the old value.
	426	+ </summary>
	427	+ <remarks>Note that appending a value does not remove the old value from
	428	+ the stream; avoid repeatedly appending values for the same field.</remarks>
	429	+ <param name="model">The model to use for configuration.</param>
	430	+ <param name="format">The data-format to use when encoding the value.</param>
	431	+ <param name="instance">The extensible object to append the value to.</param>
	432	+ <param name="tag">The field identifier; the tag should not be defined as a known data-field for the instance.</param>
	433	+ <param name="value">The value to append.</param>
	434	+ </member>
	435	+ <member name="T:ProtoBuf.ExtensibleUtil">
	436	+ <summary>
	437	+ This class acts as an internal wrapper allowing us to do a dynamic
	438	+ methodinfo invoke; an't put into Serializer as don't want on public
	439	+ API; can't put into Serializer<T> since we need to invoke
	440	+ accross classes, which isn't allowed in Silverlight)
	441	+ </summary>
	442	+ </member>
	443	+ <member name="M:ProtoBuf.ExtensibleUtil.GetExtendedValues``1(ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,System.Boolean)">
	444	+ <summary>
	445	+ All this does is call GetExtendedValuesTyped with the correct type for "instance";
	446	+ this ensures that we don't get issues with subclasses declaring conflicting types -
	447	+ the caller must respect the fields defined for the type they pass in.
	448	+ </summary>
	449	+ </member>
	450	+ <member name="M:ProtoBuf.ExtensibleUtil.GetExtendedValues(ProtoBuf.Meta.TypeModel,System.Type,ProtoBuf.IExtensible,System.Int32,ProtoBuf.DataFormat,System.Boolean,System.Boolean)">
	451	+ <summary>
	452	+ All this does is call GetExtendedValuesTyped with the correct type for "instance";
	453	+ this ensures that we don't get issues with subclasses declaring conflicting types -
	454	+ the caller must respect the fields defined for the type they pass in.
	455	+ </summary>
	456	+ </member>
	457	+ <member name="T:ProtoBuf.Helpers">
	458	+ <summary>
	459	+ Not all frameworks are created equal (fx1.1 vs fx2.0,
	460	+ micro-framework, compact-framework,
	461	+ silverlight, etc). This class simply wraps up a few things that would
	462	+ otherwise make the real code unnecessarily messy, providing fallback
	463	+ implementations if necessary.
	464	+ </summary>
	465	+ </member>
	466	+ <member name="T:ProtoBuf.ProtoTypeCode">
	467	+ <summary>
	468	+ Intended to be a direct map to regular TypeCode, but:
	469	+ - with missing types
	470	+ - existing on WinRT
	471	+ </summary>
	472	+ </member>
	473	+ <member name="T:ProtoBuf.ImplicitFields">
	474	+ <summary>
	475	+ Specifies the method used to infer field tags for members of the type
	476	+ under consideration. Tags are deduced using the invariant alphabetic
	477	+ sequence of the members' names; this makes implicit field tags very brittle,
	478	+ and susceptible to changes such as field names (normally an isolated
	479	+ change).
	480	+ </summary>
	481	+ </member>
	482	+ <member name="F:ProtoBuf.ImplicitFields.None">
	483	+ <summary>
	484	+ No members are serialized implicitly; all members require a suitable
	485	+ attribute such as [ProtoMember]. This is the recmomended mode for
	486	+ most scenarios.
	487	+ </summary>
	488	+ </member>
	489	+ <member name="F:ProtoBuf.ImplicitFields.AllPublic">
	490	+ <summary>
	491	+ Public properties and fields are eligible for implicit serialization;
	492	+ this treats the public API as a contract. Ordering beings from ImplicitFirstTag.
	493	+ </summary>
	494	+ </member>
	495	+ <member name="F:ProtoBuf.ImplicitFields.AllFields">
	496	+ <summary>
	497	+ Public and non-public fields are eligible for implicit serialization;
	498	+ this acts as a state/implementation serializer. Ordering beings from ImplicitFirstTag.
	499	+ </summary>
	500	+ </member>
	501	+ <member name="T:ProtoBuf.Meta.CallbackSet">
	502	+ <summary>
	503	+ Represents the set of serialization callbacks to be used when serializing/deserializing a type.
	504	+ </summary>
	505	+ </member>
	506	+ <member name="P:ProtoBuf.Meta.CallbackSet.BeforeSerialize">
	507	+ <summary>Called before serializing an instance</summary>
	508	+ </member>
	509	+ <member name="P:ProtoBuf.Meta.CallbackSet.BeforeDeserialize">
	510	+ <summary>Called before deserializing an instance</summary>
	511	+ </member>
	512	+ <member name="P:ProtoBuf.Meta.CallbackSet.AfterSerialize">
	513	+ <summary>Called after serializing an instance</summary>
	514	+ </member>
	515	+ <member name="P:ProtoBuf.Meta.CallbackSet.AfterDeserialize">
	516	+ <summary>Called after deserializing an instance</summary>
	517	+ </member>
	518	+ <member name="P:ProtoBuf.Meta.CallbackSet.NonTrivial">
	519	+ <summary>
	520	+ True if any callback is set, else False
	521	+ </summary>
	522	+ </member>
	523	+ <member name="T:ProtoBuf.Meta.MetaType">
	524	+ <summary>
	525	+ Represents a type at runtime for use with protobuf, allowing the field mappings (etc) to be defined
	526	+ </summary>
	527	+ </member>
	528	+ <member name="M:ProtoBuf.Meta.MetaType.ToString">
	529	+ <summary>
	530	+ Get the name of the type being represented
	531	+ </summary>
	532	+ </member>
	533	+ <member name="M:ProtoBuf.Meta.MetaType.AddSubType(System.Int32,System.Type)">
	534	+ <summary>
	535	+ Adds a known sub-type to the inheritance model
	536	+ </summary>
	537	+ </member>
	538	+ <member name="M:ProtoBuf.Meta.MetaType.AddSubType(System.Int32,System.Type,ProtoBuf.DataFormat)">
	539	+ <summary>
	540	+ Adds a known sub-type to the inheritance model
	541	+ </summary>
	542	+ </member>
	543	+ <member name="M:ProtoBuf.Meta.MetaType.SetCallbacks(System.Reflection.MethodInfo,System.Reflection.MethodInfo,System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
	544	+ <summary>
	545	+ Assigns the callbacks to use during serialiation/deserialization.
	546	+ </summary>
	547	+ <param name="beforeSerialize">The method (or null) called before serialization begins.</param>
	548	+ <param name="afterSerialize">The method (or null) called when serialization is complete.</param>
	549	+ <param name="beforeDeserialize">The method (or null) called before deserialization begins (or when a new instance is created during deserialization).</param>
	550	+ <param name="afterDeserialize">The method (or null) called when deserialization is complete.</param>
	551	+ <returns>The set of callbacks.</returns>
	552	+ </member>
	553	+ <member name="M:ProtoBuf.Meta.MetaType.SetCallbacks(System.String,System.String,System.String,System.String)">
	554	+ <summary>
	555	+ Assigns the callbacks to use during serialiation/deserialization.
	556	+ </summary>
	557	+ <param name="beforeSerialize">The name of the method (or null) called before serialization begins.</param>
	558	+ <param name="afterSerialize">The name of the method (or null) called when serialization is complete.</param>
	559	+ <param name="beforeDeserialize">The name of the method (or null) called before deserialization begins (or when a new instance is created during deserialization).</param>
	560	+ <param name="afterDeserialize">The name of the method (or null) called when deserialization is complete.</param>
	561	+ <returns>The set of callbacks.</returns>
	562	+ </member>
	563	+ <member name="M:ProtoBuf.Meta.MetaType.SetFactory(System.Reflection.MethodInfo)">
	564	+ <summary>
	565	+ Designate a factory-method to use to create instances of this type
	566	+ </summary>
	567	+ </member>
	568	+ <member name="M:ProtoBuf.Meta.MetaType.SetFactory(System.String)">
	569	+ <summary>
	570	+ Designate a factory-method to use to create instances of this type
	571	+ </summary>
	572	+ </member>
	573	+ <member name="M:ProtoBuf.Meta.MetaType.ThrowIfFrozen">
	574	+ <summary>
	575	+ Throws an exception if the type has been made immutable
	576	+ </summary>
	577	+ </member>
	578	+ <member name="M:ProtoBuf.Meta.MetaType.Add(System.Int32,System.String)">
	579	+ <summary>
	580	+ Adds a member (by name) to the MetaType
	581	+ </summary>
	582	+ </member>
	583	+ <member name="M:ProtoBuf.Meta.MetaType.AddField(System.Int32,System.String)">
	584	+ <summary>
	585	+ Adds a member (by name) to the MetaType, returning the ValueMember rather than the fluent API.
	586	+ This is otherwise identical to Add.
	587	+ </summary>
	588	+ </member>
	589	+ <member name="M:ProtoBuf.Meta.MetaType.Add(System.String)">
	590	+ <summary>
	591	+ Adds a member (by name) to the MetaType
	592	+ </summary>
	593	+ </member>
	594	+ <member name="M:ProtoBuf.Meta.MetaType.SetSurrogate(System.Type)">
	595	+ <summary>
	596	+ Performs serialization of this type via a surrogate; all
	597	+ other serialization options are ignored and handled
	598	+ by the surrogate's configuration.
	599	+ </summary>
	600	+ </member>
	601	+ <member name="M:ProtoBuf.Meta.MetaType.Add(System.String[])">
	602	+ <summary>
	603	+ Adds a set of members (by name) to the MetaType
	604	+ </summary>
	605	+ </member>
	606	+ <member name="M:ProtoBuf.Meta.MetaType.Add(System.Int32,System.String,System.Object)">
	607	+ <summary>
	608	+ Adds a member (by name) to the MetaType
	609	+ </summary>
	610	+ </member>
	611	+ <member name="M:ProtoBuf.Meta.MetaType.Add(System.Int32,System.String,System.Type,System.Type)">
	612	+ <summary>
	613	+ Adds a member (by name) to the MetaType, including an itemType and defaultType for representing lists
	614	+ </summary>
	615	+ </member>
	616	+ <member name="M:ProtoBuf.Meta.MetaType.AddField(System.Int32,System.String,System.Type,System.Type)">
	617	+ <summary>
	618	+ Adds a member (by name) to the MetaType, including an itemType and defaultType for representing lists, returning the ValueMember rather than the fluent API.
	619	+ This is otherwise identical to Add.
	620	+ </summary>
	621	+ </member>
	622	+ <member name="M:ProtoBuf.Meta.MetaType.GetFields">
	623	+ <summary>
	624	+ Returns the ValueMember instances associated with this type
	625	+ </summary>
	626	+ </member>
	627	+ <member name="M:ProtoBuf.Meta.MetaType.GetSubtypes">
	628	+ <summary>
	629	+ Returns the SubType instances associated with this type
	630	+ </summary>
	631	+ </member>
	632	+ <member name="M:ProtoBuf.Meta.MetaType.CompileInPlace">
	633	+ <summary>
	634	+ Compiles the serializer for this type; this is not a full
	635	+ standalone compile, but can significantly boost performance
	636	+ while allowing additional types to be added.
	637	+ </summary>
	638	+ <remarks>An in-place compile can access non-public types / members</remarks>
	639	+ </member>
	640	+ <member name="P:ProtoBuf.Meta.MetaType.BaseType">
	641	+ <summary>
	642	+ Gets the base-type for this type
	643	+ </summary>
	644	+ </member>
	645	+ <member name="P:ProtoBuf.Meta.MetaType.IncludeSerializerMethod">
	646	+ <summary>
	647	+ When used to compile a model, should public serialization/deserialzation methods
	648	+ be included for this type?
	649	+ </summary>
	650	+ </member>
	651	+ <member name="P:ProtoBuf.Meta.MetaType.AsReferenceDefault">
	652	+ <summary>
	653	+ Should this type be treated as a reference by default?
	654	+ </summary>
	655	+ </member>
	656	+ <member name="P:ProtoBuf.Meta.MetaType.HasCallbacks">
	657	+ <summary>
	658	+ Indicates whether the current type has defined callbacks
	659	+ </summary>
	660	+ </member>
	661	+ <member name="P:ProtoBuf.Meta.MetaType.HasSubtypes">
	662	+ <summary>
	663	+ Indicates whether the current type has defined subtypes
	664	+ </summary>
	665	+ </member>
	666	+ <member name="P:ProtoBuf.Meta.MetaType.Callbacks">
	667	+ <summary>
	668	+ Returns the set of callbacks defined for this type
	669	+ </summary>
	670	+ </member>
	671	+ <member name="P:ProtoBuf.Meta.MetaType.Name">
	672	+ <summary>
	673	+ Gets or sets the name of this contract.
	674	+ </summary>
	675	+ </member>
	676	+ <member name="P:ProtoBuf.Meta.MetaType.Type">
	677	+ <summary>
	678	+ The runtime type that the meta-type represents
	679	+ </summary>
	680	+ </member>
	681	+ <member name="P:ProtoBuf.Meta.MetaType.UseConstructor">
	682	+ <summary>
	683	+ Gets or sets whether the type should use a parameterless constructor (the default),
	684	+ or whether the type should skip the constructor completely. This option is not supported
	685	+ on compact-framework.
	686	+ </summary>
	687	+ </member>
	688	+ <member name="P:ProtoBuf.Meta.MetaType.ConstructType">
	689	+ <summary>
	690	+ The concrete type to create when a new instance of this type is needed; this may be useful when dealing
	691	+ with dynamic proxies, or with interface-based APIs
	692	+ </summary>
	693	+ </member>
	694	+ <member name="P:ProtoBuf.Meta.MetaType.Item(System.Int32)">
	695	+ <summary>
	696	+ Returns the ValueMember that matchs a given field number, or null if not found
	697	+ </summary>
	698	+ </member>
	699	+ <member name="P:ProtoBuf.Meta.MetaType.Item(System.Reflection.MemberInfo)">
	700	+ <summary>
	701	+ Returns the ValueMember that matchs a given member (property/field), or null if not found
	702	+ </summary>
	703	+ </member>
	704	+ <member name="P:ProtoBuf.Meta.MetaType.EnumPassthru">
	705	+ <summary>
	706	+ Gets or sets a value indicating that an enum should be treated directly as an int/short/etc, rather
	707	+ than enforcing .proto enum rules. This is useful in particul for [Flags] enums.
	708	+ </summary>
	709	+ </member>
	710	+ <member name="P:ProtoBuf.Meta.MetaType.IgnoreListHandling">
	711	+ <summary>
	712	+ Gets or sets a value indicating that this type should NOT be treated as a list, even if it has
	713	+ familiar list-like characteristics (enumerable, add, etc)
	714	+ </summary>
	715	+ </member>
	716	+ <member name="T:ProtoBuf.Meta.RuntimeTypeModel">
	717	+ <summary>
	718	+ Provides protobuf serialization support for a number of types that can be defined at runtime
	719	+ </summary>
	720	+ </member>
	721	+ <member name="T:ProtoBuf.Meta.TypeModel">
	722	+ <summary>
	723	+ Provides protobuf serialization support for a number of types
	724	+ </summary>
	725	+ </member>
	726	+ <member name="M:ProtoBuf.Meta.TypeModel.MapType(System.Type)">
	727	+ <summary>
	728	+ Resolve a System.Type to the compiler-specific type
	729	+ </summary>
	730	+ </member>
	731	+ <member name="M:ProtoBuf.Meta.TypeModel.MapType(System.Type,System.Boolean)">
	732	+ <summary>
	733	+ Resolve a System.Type to the compiler-specific type
	734	+ </summary>
	735	+ </member>
	736	+ <member name="M:ProtoBuf.Meta.TypeModel.TrySerializeAuxiliaryType(ProtoBuf.ProtoWriter,System.Type,ProtoBuf.DataFormat,System.Int32,System.Object,System.Boolean)">
	737	+ <summary>
	738	+ This is the more "complete" version of Serialize, which handles single instances of mapped types.
	739	+ The value is written as a complete field, including field-header and (for sub-objects) a
	740	+ length-prefix
	741	+ In addition to that, this provides support for:
	742	+ - basic values; individual int / string / Guid / etc
	743	+ - IEnumerable sequences of any type handled by TrySerializeAuxiliaryType
	744	+
	745	+ </summary>
	746	+ </member>
	747	+ <member name="M:ProtoBuf.Meta.TypeModel.Serialize(System.IO.Stream,System.Object)">
	748	+ <summary>
	749	+ Writes a protocol-buffer representation of the given instance to the supplied stream.
	750	+ </summary>
	751	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	752	+ <param name="dest">The destination stream to write to.</param>
	753	+ </member>
	754	+ <member name="M:ProtoBuf.Meta.TypeModel.Serialize(System.IO.Stream,System.Object,ProtoBuf.SerializationContext)">
	755	+ <summary>
	756	+ Writes a protocol-buffer representation of the given instance to the supplied stream.
	757	+ </summary>
	758	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	759	+ <param name="dest">The destination stream to write to.</param>
	760	+ <param name="context">Additional information about this serialization operation.</param>
	761	+ </member>
	762	+ <member name="M:ProtoBuf.Meta.TypeModel.Serialize(ProtoBuf.ProtoWriter,System.Object)">
	763	+ <summary>
	764	+ Writes a protocol-buffer representation of the given instance to the supplied writer.
	765	+ </summary>
	766	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	767	+ <param name="dest">The destination writer to write to.</param>
	768	+ </member>
	769	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32)">
	770	+ <summary>
	771	+ Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
	772	+ data - useful with network IO.
	773	+ </summary>
	774	+ <param name="type">The type being merged.</param>
	775	+ <param name="value">The existing instance to be modified (can be null).</param>
	776	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	777	+ <param name="style">How to encode the length prefix.</param>
	778	+ <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	779	+ <returns>The updated instance; this may be different to the instance argument if
	780	+ either the original instance was null, or the stream defines a known sub-type of the
	781	+ original instance.</returns>
	782	+ </member>
	783	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver)">
	784	+ <summary>
	785	+ Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
	786	+ data - useful with network IO.
	787	+ </summary>
	788	+ <param name="type">The type being merged.</param>
	789	+ <param name="value">The existing instance to be modified (can be null).</param>
	790	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	791	+ <param name="style">How to encode the length prefix.</param>
	792	+ <param name="expectedField">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	793	+ <param name="resolver">Used to resolve types on a per-field basis.</param>
	794	+ <returns>The updated instance; this may be different to the instance argument if
	795	+ either the original instance was null, or the stream defines a known sub-type of the
	796	+ original instance.</returns>
	797	+ </member>
	798	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver,System.Int32@)">
	799	+ <summary>
	800	+ Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
	801	+ data - useful with network IO.
	802	+ </summary>
	803	+ <param name="type">The type being merged.</param>
	804	+ <param name="value">The existing instance to be modified (can be null).</param>
	805	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	806	+ <param name="style">How to encode the length prefix.</param>
	807	+ <param name="expectedField">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	808	+ <param name="resolver">Used to resolve types on a per-field basis.</param>
	809	+ <param name="bytesRead">Returns the number of bytes consumed by this operation (includes length-prefix overheads and any skipped data).</param>
	810	+ <returns>The updated instance; this may be different to the instance argument if
	811	+ either the original instance was null, or the stream defines a known sub-type of the
	812	+ original instance.</returns>
	813	+ </member>
	814	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems(System.IO.Stream,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver)">
	815	+ <summary>
	816	+ Reads a sequence of consecutive length-prefixed items from a stream, using
	817	+ either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
	818	+ are directly comparable to serializing multiple items in succession
	819	+ (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
	820	+ when serializing a list/array). When a tag is
	821	+ specified, any records with different tags are silently omitted. The
	822	+ tag is ignored. The tag is ignores for fixed-length prefixes.
	823	+ </summary>
	824	+ <param name="source">The binary stream containing the serialized records.</param>
	825	+ <param name="style">The prefix style used in the data.</param>
	826	+ <param name="expectedField">The tag of records to return (if non-positive, then no tag is
	827	+ expected and all records are returned).</param>
	828	+ <param name="resolver">On a field-by-field basis, the type of object to deserialize (can be null if "type" is specified). </param>
	829	+ <param name="type">The type of object to deserialize (can be null if "resolver" is specified).</param>
	830	+ <returns>The sequence of deserialized objects.</returns>
	831	+ </member>
	832	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems(System.IO.Stream,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.Serializer.TypeResolver,ProtoBuf.SerializationContext)">
	833	+ <summary>
	834	+ Reads a sequence of consecutive length-prefixed items from a stream, using
	835	+ either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
	836	+ are directly comparable to serializing multiple items in succession
	837	+ (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
	838	+ when serializing a list/array). When a tag is
	839	+ specified, any records with different tags are silently omitted. The
	840	+ tag is ignored. The tag is ignores for fixed-length prefixes.
	841	+ </summary>
	842	+ <param name="source">The binary stream containing the serialized records.</param>
	843	+ <param name="style">The prefix style used in the data.</param>
	844	+ <param name="expectedField">The tag of records to return (if non-positive, then no tag is
	845	+ expected and all records are returned).</param>
	846	+ <param name="resolver">On a field-by-field basis, the type of object to deserialize (can be null if "type" is specified). </param>
	847	+ <param name="type">The type of object to deserialize (can be null if "resolver" is specified).</param>
	848	+ <returns>The sequence of deserialized objects.</returns>
	849	+ <param name="context">Additional information about this serialization operation.</param>
	850	+ </member>
	851	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32)">
	852	+ <summary>
	853	+ Reads a sequence of consecutive length-prefixed items from a stream, using
	854	+ either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
	855	+ are directly comparable to serializing multiple items in succession
	856	+ (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
	857	+ when serializing a list/array). When a tag is
	858	+ specified, any records with different tags are silently omitted. The
	859	+ tag is ignored. The tag is ignores for fixed-length prefixes.
	860	+ </summary>
	861	+ <typeparam name="T">The type of object to deserialize.</typeparam>
	862	+ <param name="source">The binary stream containing the serialized records.</param>
	863	+ <param name="style">The prefix style used in the data.</param>
	864	+ <param name="expectedField">The tag of records to return (if non-positive, then no tag is
	865	+ expected and all records are returned).</param>
	866	+ <returns>The sequence of deserialized objects.</returns>
	867	+ </member>
	868	+ <member name="M:ProtoBuf.Meta.TypeModel.DeserializeItems``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.SerializationContext)">
	869	+ <summary>
	870	+ Reads a sequence of consecutive length-prefixed items from a stream, using
	871	+ either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
	872	+ are directly comparable to serializing multiple items in succession
	873	+ (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
	874	+ when serializing a list/array). When a tag is
	875	+ specified, any records with different tags are silently omitted. The
	876	+ tag is ignored. The tag is ignores for fixed-length prefixes.
	877	+ </summary>
	878	+ <typeparam name="T">The type of object to deserialize.</typeparam>
	879	+ <param name="source">The binary stream containing the serialized records.</param>
	880	+ <param name="style">The prefix style used in the data.</param>
	881	+ <param name="expectedField">The tag of records to return (if non-positive, then no tag is
	882	+ expected and all records are returned).</param>
	883	+ <returns>The sequence of deserialized objects.</returns>
	884	+ <param name="context">Additional information about this serialization operation.</param>
	885	+ </member>
	886	+ <member name="M:ProtoBuf.Meta.TypeModel.SerializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32)">
	887	+ <summary>
	888	+ Writes a protocol-buffer representation of the given instance to the supplied stream,
	889	+ with a length-prefix. This is useful for socket programming,
	890	+ as DeserializeWithLengthPrefix can be used to read the single object back
	891	+ from an ongoing stream.
	892	+ </summary>
	893	+ <param name="type">The type being serialized.</param>
	894	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	895	+ <param name="style">How to encode the length prefix.</param>
	896	+ <param name="dest">The destination stream to write to.</param>
	897	+ <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	898	+ </member>
	899	+ <member name="M:ProtoBuf.Meta.TypeModel.SerializeWithLengthPrefix(System.IO.Stream,System.Object,System.Type,ProtoBuf.PrefixStyle,System.Int32,ProtoBuf.SerializationContext)">
	900	+ <summary>
	901	+ Writes a protocol-buffer representation of the given instance to the supplied stream,
	902	+ with a length-prefix. This is useful for socket programming,
	903	+ as DeserializeWithLengthPrefix can be used to read the single object back
	904	+ from an ongoing stream.
	905	+ </summary>
	906	+ <param name="type">The type being serialized.</param>
	907	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	908	+ <param name="style">How to encode the length prefix.</param>
	909	+ <param name="dest">The destination stream to write to.</param>
	910	+ <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	911	+ <param name="context">Additional information about this serialization operation.</param>
	912	+ </member>
	913	+ <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type)">
	914	+ <summary>
	915	+ Applies a protocol-buffer stream to an existing instance (which may be null).
	916	+ </summary>
	917	+ <param name="type">The type (including inheritance) to consider.</param>
	918	+ <param name="value">The existing instance to be modified (can be null).</param>
	919	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	920	+ <returns>The updated instance; this may be different to the instance argument if
	921	+ either the original instance was null, or the stream defines a known sub-type of the
	922	+ original instance.</returns>
	923	+ </member>
	924	+ <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type,ProtoBuf.SerializationContext)">
	925	+ <summary>
	926	+ Applies a protocol-buffer stream to an existing instance (which may be null).
	927	+ </summary>
	928	+ <param name="type">The type (including inheritance) to consider.</param>
	929	+ <param name="value">The existing instance to be modified (can be null).</param>
	930	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	931	+ <returns>The updated instance; this may be different to the instance argument if
	932	+ either the original instance was null, or the stream defines a known sub-type of the
	933	+ original instance.</returns>
	934	+ <param name="context">Additional information about this serialization operation.</param>
	935	+ </member>
	936	+ <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type,System.Int32)">
	937	+ <summary>
	938	+ Applies a protocol-buffer stream to an existing instance (which may be null).
	939	+ </summary>
	940	+ <param name="type">The type (including inheritance) to consider.</param>
	941	+ <param name="value">The existing instance to be modified (can be null).</param>
	942	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	943	+ <param name="length">The number of bytes to consume.</param>
	944	+ <returns>The updated instance; this may be different to the instance argument if
	945	+ either the original instance was null, or the stream defines a known sub-type of the
	946	+ original instance.</returns>
	947	+ </member>
	948	+ <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.IO.Stream,System.Object,System.Type,System.Int32,ProtoBuf.SerializationContext)">
	949	+ <summary>
	950	+ Applies a protocol-buffer stream to an existing instance (which may be null).
	951	+ </summary>
	952	+ <param name="type">The type (including inheritance) to consider.</param>
	953	+ <param name="value">The existing instance to be modified (can be null).</param>
	954	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	955	+ <param name="length">The number of bytes to consume (or -1 to read to the end of the stream).</param>
	956	+ <returns>The updated instance; this may be different to the instance argument if
	957	+ either the original instance was null, or the stream defines a known sub-type of the
	958	+ original instance.</returns>
	959	+ <param name="context">Additional information about this serialization operation.</param>
	960	+ </member>
	961	+ <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(ProtoBuf.ProtoReader,System.Object,System.Type)">
	962	+ <summary>
	963	+ Applies a protocol-buffer reader to an existing instance (which may be null).
	964	+ </summary>
	965	+ <param name="type">The type (including inheritance) to consider.</param>
	966	+ <param name="value">The existing instance to be modified (can be null).</param>
	967	+ <param name="source">The reader to apply to the instance (cannot be null).</param>
	968	+ <returns>The updated instance; this may be different to the instance argument if
	969	+ either the original instance was null, or the stream defines a known sub-type of the
	970	+ original instance.</returns>
	971	+ </member>
	972	+ <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)">
	973	+ <summary>
	974	+ This is the more "complete" version of Deserialize, which handles single instances of mapped types.
	975	+ The value is read as a complete field, including field-header and (for sub-objects) a
	976	+ length-prefix..kmc
	977	+
	978	+ In addition to that, this provides support for:
	979	+ - basic values; individual int / string / Guid / etc
	980	+ - IList sets of any type handled by TryDeserializeAuxiliaryType
	981	+ </summary>
	982	+ </member>
	983	+ <member name="M:ProtoBuf.Meta.TypeModel.Create">
	984	+ <summary>
	985	+ Creates a new runtime model, to which the caller
	986	+ can add support for a range of types. A model
	987	+ can be used "as is", or can be compiled for
	988	+ optimal performance.
	989	+ </summary>
	990	+ </member>
	991	+ <member name="M:ProtoBuf.Meta.TypeModel.ResolveProxies(System.Type)">
	992	+ <summary>
	993	+ Applies common proxy scenarios, resolving the actual type to consider
	994	+ </summary>
	995	+ </member>
	996	+ <member name="M:ProtoBuf.Meta.TypeModel.IsDefined(System.Type)">
	997	+ <summary>
	998	+ Indicates whether the supplied type is explicitly modelled by the model
	999	+ </summary>
	1000	+ </member>
	1001	+ <member name="M:ProtoBuf.Meta.TypeModel.GetKey(System.Type@)">
	1002	+ <summary>
	1003	+ Provides the key that represents a given type in the current model.
	1004	+ The type is also normalized for proxies at the same time.
	1005	+ </summary>
	1006	+ </member>
	1007	+ <member name="M:ProtoBuf.Meta.TypeModel.GetKeyImpl(System.Type)">
	1008	+ <summary>
	1009	+ Provides the key that represents a given type in the current model.
	1010	+ </summary>
	1011	+ </member>
	1012	+ <member name="M:ProtoBuf.Meta.TypeModel.Serialize(System.Int32,System.Object,ProtoBuf.ProtoWriter)">
	1013	+ <summary>
	1014	+ Writes a protocol-buffer representation of the given instance to the supplied stream.
	1015	+ </summary>
	1016	+ <param name="key">Represents the type (including inheritance) to consider.</param>
	1017	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	1018	+ <param name="dest">The destination stream to write to.</param>
	1019	+ </member>
	1020	+ <member name="M:ProtoBuf.Meta.TypeModel.Deserialize(System.Int32,System.Object,ProtoBuf.ProtoReader)">
	1021	+ <summary>
	1022	+ Applies a protocol-buffer stream to an existing instance (which may be null).
	1023	+ </summary>
	1024	+ <param name="key">Represents the type (including inheritance) to consider.</param>
	1025	+ <param name="value">The existing instance to be modified (can be null).</param>
	1026	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	1027	+ <returns>The updated instance; this may be different to the instance argument if
	1028	+ either the original instance was null, or the stream defines a known sub-type of the
	1029	+ original instance.</returns>
	1030	+ </member>
	1031	+ <member name="M:ProtoBuf.Meta.TypeModel.DeepClone(System.Object)">
	1032	+ <summary>
	1033	+ Create a deep clone of the supplied instance; any sub-items are also cloned.
	1034	+ </summary>
	1035	+ </member>
	1036	+ <member name="M:ProtoBuf.Meta.TypeModel.ThrowUnexpectedSubtype(System.Type,System.Type)">
	1037	+ <summary>
	1038	+ Indicates that while an inheritance tree exists, the exact type encountered was not
	1039	+ specified in that hierarchy and cannot be processed.
	1040	+ </summary>
	1041	+ </member>
	1042	+ <member name="M:ProtoBuf.Meta.TypeModel.ThrowUnexpectedType(System.Type)">
	1043	+ <summary>
	1044	+ Indicates that the given type was not expected, and cannot be processed.
	1045	+ </summary>
	1046	+ </member>
	1047	+ <member name="M:ProtoBuf.Meta.TypeModel.ThrowCannotCreateInstance(System.Type)">
	1048	+ <summary>
	1049	+ Indicates that the given type cannot be constructed; it may still be possible to
	1050	+ deserialize into existing instances.
	1051	+ </summary>
	1052	+ </member>
	1053	+ <member name="M:ProtoBuf.Meta.TypeModel.CanSerializeContractType(System.Type)">
	1054	+ <summary>
	1055	+ Returns true if the type supplied is either a recognised contract type,
	1056	+ or a list of a recognised contract type.
	1057	+ </summary>
	1058	+ <remarks>Note that primitives always return false, even though the engine
	1059	+ will, if forced, try to serialize such</remarks>
	1060	+ <returns>True if this type is recognised as a serializable entity, else false</returns>
	1061	+ </member>
	1062	+ <member name="M:ProtoBuf.Meta.TypeModel.CanSerialize(System.Type)">
	1063	+ <summary>
	1064	+ Returns true if the type supplied is a basic type with inbuilt handling,
	1065	+ a recognised contract type, or a list of a basic / contract type.
	1066	+ </summary>
	1067	+ </member>
	1068	+ <member name="M:ProtoBuf.Meta.TypeModel.CanSerializeBasicType(System.Type)">
	1069	+ <summary>
	1070	+ Returns true if the type supplied is a basic type with inbuilt handling,
	1071	+ or a list of a basic type with inbuilt handling
	1072	+ </summary>
	1073	+ </member>
	1074	+ <member name="M:ProtoBuf.Meta.TypeModel.GetSchema(System.Type)">
	1075	+ <summary>
	1076	+ Suggest a .proto definition for the given type
	1077	+ </summary>
	1078	+ <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>
	1079	+ <returns>The .proto definition as a string</returns>
	1080	+ </member>
	1081	+ <member name="M:ProtoBuf.Meta.TypeModel.CreateFormatter(System.Type)">
	1082	+ <summary>
	1083	+ Creates a new IFormatter that uses protocol-buffer [de]serialization.
	1084	+ </summary>
	1085	+ <returns>A new IFormatter to be used during [de]serialization.</returns>
	1086	+ <param name="type">The type of object to be [de]deserialized by the formatter.</param>
	1087	+ </member>
	1088	+ <member name="E:ProtoBuf.Meta.TypeModel.DynamicTypeFormatting">
	1089	+ <summary>
	1090	+ Used to provide custom services for writing and parsing type names when using dynamic types. Both parsing and formatting
	1091	+ are provided on a single API as it is essential that both are mapped identically at all times.
	1092	+ </summary>
	1093	+ </member>
	1094	+ <member name="T:ProtoBuf.Meta.TypeModel.CallbackType">
	1095	+ <summary>
	1096	+ Indicates the type of callback to be used
	1097	+ </summary>
	1098	+ </member>
	1099	+ <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.BeforeSerialize">
	1100	+ <summary>
	1101	+ Invoked before an object is serialized
	1102	+ </summary>
	1103	+ </member>
	1104	+ <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.AfterSerialize">
	1105	+ <summary>
	1106	+ Invoked after an object is serialized
	1107	+ </summary>
	1108	+ </member>
	1109	+ <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.BeforeDeserialize">
	1110	+ <summary>
	1111	+ Invoked before an object is deserialized (or when a new instance is created)
	1112	+ </summary>
	1113	+ </member>
	1114	+ <member name="F:ProtoBuf.Meta.TypeModel.CallbackType.AfterDeserialize">
	1115	+ <summary>
	1116	+ Invoked after an object is deserialized
	1117	+ </summary>
	1118	+ </member>
	1119	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.GetTypes">
	1120	+ <summary>
	1121	+ Returns a sequence of the Type instances that can be
	1122	+ processed by this model.
	1123	+ </summary>
	1124	+ </member>
	1125	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.GetSchema(System.Type)">
	1126	+ <summary>
	1127	+ Suggest a .proto definition for the given type
	1128	+ </summary>
	1129	+ <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>
	1130	+ <returns>The .proto definition as a string</returns>
	1131	+ </member>
	1132	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Add(System.Type,System.Boolean)">
	1133	+ <summary>
	1134	+ Adds support for an additional type in this model, optionally
	1135	+ appplying inbuilt patterns. If the type is already known to the
	1136	+ model, the existing type is returned without applying
	1137	+ any additional behaviour.
	1138	+ </summary>
	1139	+ <remarks>Inbuilt patterns include:
	1140	+ [ProtoContract]/[ProtoMember(n)]
	1141	+ [DataContract]/[DataMember(Order=n)]
	1142	+ [XmlType]/[XmlElement(Order=n)]
	1143	+ [On{Des\|S}erializ{ing\|ed}]
	1144	+ ShouldSerialize/Specified
	1145	+ </remarks>
	1146	+ <param name="type">The type to be supported</param>
	1147	+ <param name="applyDefaultBehaviour">Whether to apply the inbuilt configuration patterns (via attributes etc), or
	1148	+ just add the type with no additional configuration (the type must then be manually configured).</param>
	1149	+ <returns>The MetaType representing this type, allowing
	1150	+ further configuration.</returns>
	1151	+ </member>
	1152	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.ThrowIfFrozen">
	1153	+ <summary>
	1154	+ Verifies that the model is still open to changes; if not, an exception is thrown
	1155	+ </summary>
	1156	+ </member>
	1157	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Freeze">
	1158	+ <summary>
	1159	+ Prevents further changes to this model
	1160	+ </summary>
	1161	+ </member>
	1162	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.GetKeyImpl(System.Type)">
	1163	+ <summary>
	1164	+ Provides the key that represents a given type in the current model.
	1165	+ </summary>
	1166	+ </member>
	1167	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Serialize(System.Int32,System.Object,ProtoBuf.ProtoWriter)">
	1168	+ <summary>
	1169	+ Writes a protocol-buffer representation of the given instance to the supplied stream.
	1170	+ </summary>
	1171	+ <param name="key">Represents the type (including inheritance) to consider.</param>
	1172	+ <param name="value">The existing instance to be serialized (cannot be null).</param>
	1173	+ <param name="dest">The destination stream to write to.</param>
	1174	+ </member>
	1175	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Deserialize(System.Int32,System.Object,ProtoBuf.ProtoReader)">
	1176	+ <summary>
	1177	+ Applies a protocol-buffer stream to an existing instance (which may be null).
	1178	+ </summary>
	1179	+ <param name="key">Represents the type (including inheritance) to consider.</param>
	1180	+ <param name="value">The existing instance to be modified (can be null).</param>
	1181	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	1182	+ <returns>The updated instance; this may be different to the instance argument if
	1183	+ either the original instance was null, or the stream defines a known sub-type of the
	1184	+ original instance.</returns>
	1185	+ </member>
	1186	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.CompileInPlace">
	1187	+ <summary>
	1188	+ Compiles the serializers individually; this is not a full
	1189	+ standalone compile, but can significantly boost performance
	1190	+ while allowing additional types to be added.
	1191	+ </summary>
	1192	+ <remarks>An in-place compile can access non-public types / members</remarks>
	1193	+ </member>
	1194	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Compile">
	1195	+ <summary>
	1196	+ Fully compiles the current model into a static-compiled model instance
	1197	+ </summary>
	1198	+ <remarks>A full compilation is restricted to accessing public types / members</remarks>
	1199	+ <returns>An instance of the newly created compiled type-model</returns>
	1200	+ </member>
	1201	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Compile(System.String,System.String)">
	1202	+ <summary>
	1203	+ Fully compiles the current model into a static-compiled serialization dll
	1204	+ (the serialization dll still requires protobuf-net for support services).
	1205	+ </summary>
	1206	+ <remarks>A full compilation is restricted to accessing public types / members</remarks>
	1207	+ <param name="name">The name of the TypeModel class to create</param>
	1208	+ <param name="path">The path for the new dll</param>
	1209	+ <returns>An instance of the newly created compiled type-model</returns>
	1210	+ </member>
	1211	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.Compile(ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions)">
	1212	+ <summary>
	1213	+ Fully compiles the current model into a static-compiled serialization dll
	1214	+ (the serialization dll still requires protobuf-net for support services).
	1215	+ </summary>
	1216	+ <remarks>A full compilation is restricted to accessing public types / members</remarks>
	1217	+ <returns>An instance of the newly created compiled type-model</returns>
	1218	+ </member>
	1219	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.SetDefaultFactory(System.Reflection.MethodInfo)">
	1220	+ <summary>
	1221	+ Designate a factory-method to use to create instances of any type; note that this only affect types seen by the serializer after setting the factory.
	1222	+ </summary>
	1223	+ </member>
	1224	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.InferTagFromNameDefault">
	1225	+ <summary>
	1226	+ Global default that
	1227	+ enables/disables automatic tag generation based on the existing name / order
	1228	+ of the defined members. See <seealso cref="P:ProtoBuf.ProtoContractAttribute.InferTagFromName"/>
	1229	+ for usage and <b>important warning</b> / explanation.
	1230	+ You must set the global default before attempting to serialize/deserialize any
	1231	+ impacted type.
	1232	+ </summary>
	1233	+ </member>
	1234	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AutoAddProtoContractTypesOnly">
	1235	+ <summary>
	1236	+ Global default that determines whether types are considered serializable
	1237	+ if they have [DataContract] / [XmlType]. With this enabled, <b>ONLY</b>
	1238	+ types marked as [ProtoContract] are added automatically.
	1239	+ </summary>
	1240	+ </member>
	1241	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.UseImplicitZeroDefaults">
	1242	+ <summary>
	1243	+ Global switch that enables or disables the implicit
	1244	+ handling of "zero defaults"; meanning: if no other default is specified,
	1245	+ it assumes bools always default to false, integers to zero, etc.
	1246	+
	1247	+ If this is disabled, no such assumptions are made and only explicit
	1248	+ default values are processed. This is enabled by default to
	1249	+ preserve similar logic to v1.
	1250	+ </summary>
	1251	+ </member>
	1252	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AllowParseableTypes">
	1253	+ <summary>
	1254	+ Global switch that determines whether types with a <c>.ToString()</c> and a <c>Parse(string)</c>
	1255	+ should be serialized as strings.
	1256	+ </summary>
	1257	+ </member>
	1258	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.Default">
	1259	+ <summary>
	1260	+ The default model, used to support ProtoBuf.Serializer
	1261	+ </summary>
	1262	+ </member>
	1263	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.Item(System.Type)">
	1264	+ <summary>
	1265	+ Obtains the MetaType associated with a given Type for the current model,
	1266	+ allowing additional configuration.
	1267	+ </summary>
	1268	+ </member>
	1269	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AutoCompile">
	1270	+ <summary>
	1271	+ Should serializers be compiled on demand? It may be useful
	1272	+ to disable this for debugging purposes.
	1273	+ </summary>
	1274	+ </member>
	1275	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.AutoAddMissingTypes">
	1276	+ <summary>
	1277	+ Should support for unexpected types be added automatically?
	1278	+ If false, an exception is thrown when unexpected types
	1279	+ are encountered.
	1280	+ </summary>
	1281	+ </member>
	1282	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.MetadataTimeoutMilliseconds">
	1283	+ <summary>
	1284	+ The amount of time to wait if there are concurrent metadata access operations
	1285	+ </summary>
	1286	+ </member>
	1287	+ <member name="E:ProtoBuf.Meta.RuntimeTypeModel.LockContended">
	1288	+ <summary>
	1289	+ If a lock-contention is detected, this event signals the owner of the lock responsible for the blockage, indicating
	1290	+ what caused the problem; this is only raised if the lock-owning code successfully completes.
	1291	+ </summary>
	1292	+ </member>
	1293	+ <member name="T:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions">
	1294	+ <summary>
	1295	+ Represents configuration options for compiling a model to
	1296	+ a standalone assembly.
	1297	+ </summary>
	1298	+ </member>
	1299	+ <member name="M:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.SetFrameworkOptions(ProtoBuf.Meta.MetaType)">
	1300	+ <summary>
	1301	+ Import framework options from an existing type
	1302	+ </summary>
	1303	+ </member>
	1304	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.TargetFrameworkName">
	1305	+ <summary>
	1306	+ The TargetFrameworkAttribute FrameworkName value to burn into the generated assembly
	1307	+ </summary>
	1308	+ </member>
	1309	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.TargetFrameworkDisplayName">
	1310	+ <summary>
	1311	+ The TargetFrameworkAttribute FrameworkDisplayName value to burn into the generated assembly
	1312	+ </summary>
	1313	+ </member>
	1314	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.TypeName">
	1315	+ <summary>
	1316	+ The name of the TypeModel class to create
	1317	+ </summary>
	1318	+ </member>
	1319	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.OutputPath">
	1320	+ <summary>
	1321	+ The path for the new dll
	1322	+ </summary>
	1323	+ </member>
	1324	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.ImageRuntimeVersion">
	1325	+ <summary>
	1326	+ The runtime version for the generated assembly
	1327	+ </summary>
	1328	+ </member>
	1329	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.MetaDataVersion">
	1330	+ <summary>
	1331	+ The runtime version for the generated assembly
	1332	+ </summary>
	1333	+ </member>
	1334	+ <member name="P:ProtoBuf.Meta.RuntimeTypeModel.CompilerOptions.Accessibility">
	1335	+ <summary>
	1336	+ The acecssibility of the generated serializer
	1337	+ </summary>
	1338	+ </member>
	1339	+ <member name="T:ProtoBuf.Meta.RuntimeTypeModel.Accessibility">
	1340	+ <summary>
	1341	+ Type accessibility
	1342	+ </summary>
	1343	+ </member>
	1344	+ <member name="F:ProtoBuf.Meta.RuntimeTypeModel.Accessibility.Public">
	1345	+ <summary>
	1346	+ Available to all callers
	1347	+ </summary>
	1348	+ </member>
	1349	+ <member name="F:ProtoBuf.Meta.RuntimeTypeModel.Accessibility.Internal">
	1350	+ <summary>
	1351	+ Available to all callers in the same assembly, or assemblies specified via [InternalsVisibleTo(...)]
	1352	+ </summary>
	1353	+ </member>
	1354	+ <member name="T:ProtoBuf.Meta.LockContentedEventArgs">
	1355	+ <summary>
	1356	+ Contains the stack-trace of the owning code when a lock-contention scenario is detected
	1357	+ </summary>
	1358	+ </member>
	1359	+ <member name="P:ProtoBuf.Meta.LockContentedEventArgs.OwnerStackTrace">
	1360	+ <summary>
	1361	+ The stack-trace of the code that owned the lock when a lock-contention scenario occurred
	1362	+ </summary>
	1363	+ </member>
	1364	+ <member name="T:ProtoBuf.Meta.LockContentedEventHandler">
	1365	+ <summary>
	1366	+ Event-type that is raised when a lock-contention scenario is detected
	1367	+ </summary>
	1368	+ </member>
	1369	+ <member name="T:ProtoBuf.Meta.SubType">
	1370	+ <summary>
	1371	+ Represents an inherited type in a type hierarchy.
	1372	+ </summary>
	1373	+ </member>
	1374	+ <member name="M:ProtoBuf.Meta.SubType.#ctor(System.Int32,ProtoBuf.Meta.MetaType,ProtoBuf.DataFormat)">
	1375	+ <summary>
	1376	+ Creates a new SubType instance.
	1377	+ </summary>
	1378	+ <param name="fieldNumber">The field-number that is used to encapsulate the data (as a nested
	1379	+ message) for the derived dype.</param>
	1380	+ <param name="derivedType">The sub-type to be considered.</param>
	1381	+ <param name="format">Specific encoding style to use; in particular, Grouped can be used to avoid buffering, but is not the default.</param>
	1382	+ </member>
	1383	+ <member name="P:ProtoBuf.Meta.SubType.FieldNumber">
	1384	+ <summary>
	1385	+ The field-number that is used to encapsulate the data (as a nested
	1386	+ message) for the derived dype.
	1387	+ </summary>
	1388	+ </member>
	1389	+ <member name="P:ProtoBuf.Meta.SubType.DerivedType">
	1390	+ <summary>
	1391	+ The sub-type to be considered.
	1392	+ </summary>
	1393	+ </member>
	1394	+ <member name="T:ProtoBuf.Meta.TypeFormatEventArgs">
	1395	+ <summary>
	1396	+ Event arguments needed to perform type-formatting functions; this could be resolving a Type to a string suitable for serialization, or could
	1397	+ be requesting a Type from a string. If no changes are made, a default implementation will be used (from the assembly-qualified names).
	1398	+ </summary>
	1399	+ </member>
	1400	+ <member name="P:ProtoBuf.Meta.TypeFormatEventArgs.Type">
	1401	+ <summary>
	1402	+ The type involved in this map; if this is initially null, a Type is expected to be provided for the string in FormattedName.
	1403	+ </summary>
	1404	+ </member>
	1405	+ <member name="P:ProtoBuf.Meta.TypeFormatEventArgs.FormattedName">
	1406	+ <summary>
	1407	+ The formatted-name involved in this map; if this is initially null, a formatted-name is expected from the type in Type.
	1408	+ </summary>
	1409	+ </member>
	1410	+ <member name="T:ProtoBuf.Meta.TypeFormatEventHandler">
	1411	+ <summary>
	1412	+ Delegate type used to perform type-formatting functions; the sender originates as the type-model.
	1413	+ </summary>
	1414	+ </member>
	1415	+ <member name="T:ProtoBuf.Meta.ValueMember">
	1416	+ <summary>
	1417	+ Represents a member (property/field) that is mapped to a protobuf field
	1418	+ </summary>
	1419	+ </member>
	1420	+ <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)">
	1421	+ <summary>
	1422	+ Creates a new ValueMember instance
	1423	+ </summary>
	1424	+ </member>
	1425	+ <member name="M:ProtoBuf.Meta.ValueMember.#ctor(ProtoBuf.Meta.RuntimeTypeModel,System.Int32,System.Type,System.Type,System.Type,ProtoBuf.DataFormat)">
	1426	+ <summary>
	1427	+ Creates a new ValueMember instance
	1428	+ </summary>
	1429	+ </member>
	1430	+ <member name="M:ProtoBuf.Meta.ValueMember.SetSpecified(System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
	1431	+ <summary>
	1432	+ Specifies methods for working with optional data members.
	1433	+ </summary>
	1434	+ <param name="getSpecified">Provides a method (null for none) to query whether this member should
	1435	+ be serialized; it must be of the form "bool {Method}()". The member is only serialized if the
	1436	+ method returns true.</param>
	1437	+ <param name="setSpecified">Provides a method (null for none) to indicate that a member was
	1438	+ deserialized; it must be of the form "void {Method}(bool)", and will be called with "true"
	1439	+ when data is found.</param>
	1440	+ </member>
	1441	+ <member name="P:ProtoBuf.Meta.ValueMember.FieldNumber">
	1442	+ <summary>
	1443	+ The number that identifies this member in a protobuf stream
	1444	+ </summary>
	1445	+ </member>
	1446	+ <member name="P:ProtoBuf.Meta.ValueMember.Member">
	1447	+ <summary>
	1448	+ Gets the member (field/property) which this member relates to.
	1449	+ </summary>
	1450	+ </member>
	1451	+ <member name="P:ProtoBuf.Meta.ValueMember.ItemType">
	1452	+ <summary>
	1453	+ Within a list / array / etc, the type of object for each item in the list (especially useful with ArrayList)
	1454	+ </summary>
	1455	+ </member>
	1456	+ <member name="P:ProtoBuf.Meta.ValueMember.MemberType">
	1457	+ <summary>
	1458	+ The underlying type of the member
	1459	+ </summary>
	1460	+ </member>
	1461	+ <member name="P:ProtoBuf.Meta.ValueMember.DefaultType">
	1462	+ <summary>
	1463	+ For abstract types (IList etc), the type of concrete object to create (if required)
	1464	+ </summary>
	1465	+ </member>
	1466	+ <member name="P:ProtoBuf.Meta.ValueMember.ParentType">
	1467	+ <summary>
	1468	+ The type the defines the member
	1469	+ </summary>
	1470	+ </member>
	1471	+ <member name="P:ProtoBuf.Meta.ValueMember.DefaultValue">
	1472	+ <summary>
	1473	+ The default value of the item (members with this value will not be serialized)
	1474	+ </summary>
	1475	+ </member>
	1476	+ <member name="P:ProtoBuf.Meta.ValueMember.DataFormat">
	1477	+ <summary>
	1478	+ Specifies the rules used to process the field; this is used to determine the most appropriate
	1479	+ wite-type, but also to describe subtypes <i>within</i> that wire-type (such as SignedVariant)
	1480	+ </summary>
	1481	+ </member>
	1482	+ <member name="P:ProtoBuf.Meta.ValueMember.IsStrict">
	1483	+ <summary>
	1484	+ Indicates whether this field should follow strict encoding rules; this means (for example) that if a "fixed32"
	1485	+ is encountered when "variant" is defined, then it will fail (throw an exception) when parsing. Note that
	1486	+ when serializing the defined type is always used.
	1487	+ </summary>
	1488	+ </member>
	1489	+ <member name="P:ProtoBuf.Meta.ValueMember.IsPacked">
	1490	+ <summary>
	1491	+ Indicates whether this field should use packed encoding (which can save lots of space for repeated primitive values).
	1492	+ This option only applies to list/array data of primitive types (int, double, etc).
	1493	+ </summary>
	1494	+ </member>
	1495	+ <member name="P:ProtoBuf.Meta.ValueMember.OverwriteList">
	1496	+ <summary>
	1497	+ Indicates whether this field should repace existing values (the default is false, meaning append).
	1498	+ This option only applies to list/array data.
	1499	+ </summary>
	1500	+ </member>
	1501	+ <member name="P:ProtoBuf.Meta.ValueMember.IsRequired">
	1502	+ <summary>
	1503	+ Indicates whether this field is mandatory.
	1504	+ </summary>
	1505	+ </member>
	1506	+ <member name="P:ProtoBuf.Meta.ValueMember.AsReference">
	1507	+ <summary>
	1508	+ Enables full object-tracking/full-graph support.
	1509	+ </summary>
	1510	+ </member>
	1511	+ <member name="P:ProtoBuf.Meta.ValueMember.DynamicType">
	1512	+ <summary>
	1513	+ Embeds the type information into the stream, allowing usage with types not known in advance.
	1514	+ </summary>
	1515	+ </member>
	1516	+ <member name="P:ProtoBuf.Meta.ValueMember.Name">
	1517	+ <summary>
	1518	+ Gets the logical name for this member in the schema (this is not critical for binary serialization, but may be used
	1519	+ when inferring a schema).
	1520	+ </summary>
	1521	+ </member>
	1522	+ <member name="P:ProtoBuf.Meta.ValueMember.SupportNull">
	1523	+ <summary>
	1524	+ Should lists have extended support for null values? Note this makes the serialization less efficient.
	1525	+ </summary>
	1526	+ </member>
	1527	+ <member name="T:ProtoBuf.PrefixStyle">
	1528	+ <summary>
	1529	+ Specifies the type of prefix that should be applied to messages.
	1530	+ </summary>
	1531	+ </member>
	1532	+ <member name="F:ProtoBuf.PrefixStyle.None">
	1533	+ <summary>
	1534	+ No length prefix is applied to the data; the data is terminated only be the end of the stream.
	1535	+ </summary>
	1536	+ </member>
	1537	+ <member name="F:ProtoBuf.PrefixStyle.Base128">
	1538	+ <summary>
	1539	+ A base-128 length prefix is applied to the data (efficient for short messages).
	1540	+ </summary>
	1541	+ </member>
	1542	+ <member name="F:ProtoBuf.PrefixStyle.Fixed32">
	1543	+ <summary>
	1544	+ A fixed-length (little-endian) length prefix is applied to the data (useful for compatibility).
	1545	+ </summary>
	1546	+ </member>
	1547	+ <member name="F:ProtoBuf.PrefixStyle.Fixed32BigEndian">
	1548	+ <summary>
	1549	+ A fixed-length (big-endian) length prefix is applied to the data (useful for compatibility).
	1550	+ </summary>
	1551	+ </member>
	1552	+ <member name="T:ProtoBuf.ProtoContractAttribute">
	1553	+ <summary>
	1554	+ Indicates that a type is defined for protocol-buffer serialization.
	1555	+ </summary>
	1556	+ </member>
	1557	+ <member name="P:ProtoBuf.ProtoContractAttribute.Name">
	1558	+ <summary>
	1559	+ Gets or sets the defined name of the type.
	1560	+ </summary>
	1561	+ </member>
	1562	+ <member name="P:ProtoBuf.ProtoContractAttribute.ImplicitFirstTag">
	1563	+ <summary>
	1564	+ Gets or sets the fist offset to use with implicit field tags;
	1565	+ only uesd if ImplicitFields is set.
	1566	+ </summary>
	1567	+ </member>
	1568	+ <member name="P:ProtoBuf.ProtoContractAttribute.UseProtoMembersOnly">
	1569	+ <summary>
	1570	+ If specified, alternative contract markers (such as markers for XmlSerailizer or DataContractSerializer) are ignored.
	1571	+ </summary>
	1572	+ </member>
	1573	+ <member name="P:ProtoBuf.ProtoContractAttribute.IgnoreListHandling">
	1574	+ <summary>
	1575	+ If specified, do NOT treat this type as a list, even if it looks like one.
	1576	+ </summary>
	1577	+ </member>
	1578	+ <member name="P:ProtoBuf.ProtoContractAttribute.ImplicitFields">
	1579	+ <summary>
	1580	+ Gets or sets the mechanism used to automatically infer field tags
	1581	+ for members. This option should be used in advanced scenarios only.
	1582	+ Please review the important notes against the ImplicitFields enumeration.
	1583	+ </summary>
	1584	+ </member>
	1585	+ <member name="P:ProtoBuf.ProtoContractAttribute.InferTagFromName">
	1586	+ <summary>
	1587	+ Enables/disables automatic tag generation based on the existing name / order
	1588	+ of the defined members. This option is not used for members marked
	1589	+ with ProtoMemberAttribute, as intended to provide compatibility with
	1590	+ WCF serialization. WARNING: when adding new fields you must take
	1591	+ care to increase the Order for new elements, otherwise data corruption
	1592	+ may occur.
	1593	+ </summary>
	1594	+ <remarks>If not explicitly specified, the default is assumed from Serializer.GlobalOptions.InferTagFromName.</remarks>
	1595	+ </member>
	1596	+ <member name="P:ProtoBuf.ProtoContractAttribute.InferTagFromNameHasValue">
	1597	+ <summary>
	1598	+ Has a InferTagFromName value been explicitly set? if not, the default from the type-model is assumed.
	1599	+ </summary>
	1600	+ </member>
	1601	+ <member name="P:ProtoBuf.ProtoContractAttribute.DataMemberOffset">
	1602	+ <summary>
	1603	+ Specifies an offset to apply to [DataMember(Order=...)] markers;
	1604	+ this is useful when working with mex-generated classes that have
	1605	+ a different origin (usually 1 vs 0) than the original data-contract.
	1606	+
	1607	+ This value is added to the Order of each member.
	1608	+ </summary>
	1609	+ </member>
	1610	+ <member name="P:ProtoBuf.ProtoContractAttribute.SkipConstructor">
	1611	+ <summary>
	1612	+ If true, the constructor for the type is bypassed during deserialization, meaning any field initializers
	1613	+ or other initialization code is skipped.
	1614	+ </summary>
	1615	+ </member>
	1616	+ <member name="P:ProtoBuf.ProtoContractAttribute.AsReferenceDefault">
	1617	+ <summary>
	1618	+ Should this type be treated as a reference by default? Please also see the implications of this,
	1619	+ as recorded on ProtoMemberAttribute.AsReference
	1620	+ </summary>
	1621	+ </member>
	1622	+ <member name="P:ProtoBuf.ProtoContractAttribute.EnumPassthru">
	1623	+ <summary>
	1624	+ Applies only to enums (not to DTO classes themselves); gets or sets a value indicating that an enum should be treated directly as an int/short/etc, rather
	1625	+ than enforcing .proto enum rules. This is useful in particul for [Flags] enums.
	1626	+ </summary>
	1627	+ </member>
	1628	+ <member name="P:ProtoBuf.ProtoContractAttribute.EnumPassthruHasValue">
	1629	+ <summary>
	1630	+ Has a EnumPassthru value been explicitly set?
	1631	+ </summary>
	1632	+ </member>
	1633	+ <member name="T:ProtoBuf.ProtoEnumAttribute">
	1634	+ <summary>
	1635	+ Used to define protocol-buffer specific behavior for
	1636	+ enumerated values.
	1637	+ </summary>
	1638	+ </member>
	1639	+ <member name="M:ProtoBuf.ProtoEnumAttribute.HasValue">
	1640	+ <summary>
	1641	+ Indicates whether this instance has a customised value mapping
	1642	+ </summary>
	1643	+ <returns>true if a specific value is set</returns>
	1644	+ </member>
	1645	+ <member name="P:ProtoBuf.ProtoEnumAttribute.Value">
	1646	+ <summary>
	1647	+ Gets or sets the specific value to use for this enum during serialization.
	1648	+ </summary>
	1649	+ </member>
	1650	+ <member name="P:ProtoBuf.ProtoEnumAttribute.Name">
	1651	+ <summary>
	1652	+ Gets or sets the defined name of the enum, as used in .proto
	1653	+ (this name is not used during serialization).
	1654	+ </summary>
	1655	+ </member>
	1656	+ <member name="T:ProtoBuf.ProtoException">
	1657	+ <summary>
	1658	+ Indicates an error during serialization/deserialization of a proto stream.
	1659	+ </summary>
	1660	+ </member>
	1661	+ <member name="M:ProtoBuf.ProtoException.#ctor">
	1662	+ <summary>Creates a new ProtoException instance.</summary>
	1663	+ </member>
	1664	+ <member name="M:ProtoBuf.ProtoException.#ctor(System.String)">
	1665	+ <summary>Creates a new ProtoException instance.</summary>
	1666	+ </member>
	1667	+ <member name="M:ProtoBuf.ProtoException.#ctor(System.String,System.Exception)">
	1668	+ <summary>Creates a new ProtoException instance.</summary>
	1669	+ </member>
	1670	+ <member name="M:ProtoBuf.ProtoException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
	1671	+ <summary>Creates a new ProtoException instance.</summary>
	1672	+ </member>
	1673	+ <member name="T:ProtoBuf.ProtoIgnoreAttribute">
	1674	+ <summary>
	1675	+ Indicates that a member should be excluded from serialization; this
	1676	+ is only normally used when using implict fields.
	1677	+ </summary>
	1678	+ </member>
	1679	+ <member name="T:ProtoBuf.ProtoPartialIgnoreAttribute">
	1680	+ <summary>
	1681	+ Indicates that a member should be excluded from serialization; this
	1682	+ is only normally used when using implict fields. This allows
	1683	+ ProtoIgnoreAttribute usage
	1684	+ even for partial classes where the individual members are not
	1685	+ under direct control.
	1686	+ </summary>
	1687	+ </member>
	1688	+ <member name="M:ProtoBuf.ProtoPartialIgnoreAttribute.#ctor(System.String)">
	1689	+ <summary>
	1690	+ Creates a new ProtoPartialIgnoreAttribute instance.
	1691	+ </summary>
	1692	+ <param name="memberName">Specifies the member to be ignored.</param>
	1693	+ </member>
	1694	+ <member name="P:ProtoBuf.ProtoPartialIgnoreAttribute.MemberName">
	1695	+ <summary>
	1696	+ The name of the member to be ignored.
	1697	+ </summary>
	1698	+ </member>
	1699	+ <member name="T:ProtoBuf.ProtoIncludeAttribute">
	1700	+ <summary>
	1701	+ Indicates the known-types to support for an individual
	1702	+ message. This serializes each level in the hierarchy as
	1703	+ a nested message to retain wire-compatibility with
	1704	+ other protocol-buffer implementations.
	1705	+ </summary>
	1706	+ </member>
	1707	+ <member name="M:ProtoBuf.ProtoIncludeAttribute.#ctor(System.Int32,System.Type)">
	1708	+ <summary>
	1709	+ Creates a new instance of the ProtoIncludeAttribute.
	1710	+ </summary>
	1711	+ <param name="tag">The unique index (within the type) that will identify this data.</param>
	1712	+ <param name="knownType">The additional type to serialize/deserialize.</param>
	1713	+ </member>
	1714	+ <member name="M:ProtoBuf.ProtoIncludeAttribute.#ctor(System.Int32,System.String)">
	1715	+ <summary>
	1716	+ Creates a new instance of the ProtoIncludeAttribute.
	1717	+ </summary>
	1718	+ <param name="tag">The unique index (within the type) that will identify this data.</param>
	1719	+ <param name="knownTypeName">The additional type to serialize/deserialize.</param>
	1720	+ </member>
	1721	+ <member name="P:ProtoBuf.ProtoIncludeAttribute.Tag">
	1722	+ <summary>
	1723	+ Gets the unique index (within the type) that will identify this data.
	1724	+ </summary>
	1725	+ </member>
	1726	+ <member name="P:ProtoBuf.ProtoIncludeAttribute.KnownTypeName">
	1727	+ <summary>
	1728	+ Gets the additional type to serialize/deserialize.
	1729	+ </summary>
	1730	+ </member>
	1731	+ <member name="P:ProtoBuf.ProtoIncludeAttribute.KnownType">
	1732	+ <summary>
	1733	+ Gets the additional type to serialize/deserialize.
	1734	+ </summary>
	1735	+ </member>
	1736	+ <member name="P:ProtoBuf.ProtoIncludeAttribute.DataFormat">
	1737	+ <summary>
	1738	+ Specifies whether the inherited sype's sub-message should be
	1739	+ written with a length-prefix (default), or with group markers.
	1740	+ </summary>
	1741	+ </member>
	1742	+ <member name="T:ProtoBuf.ProtoMemberAttribute">
	1743	+ <summary>
	1744	+ Declares a member to be used in protocol-buffer serialization, using
	1745	+ the given Tag. A DataFormat may be used to optimise the serialization
	1746	+ format (for instance, using zigzag encoding for negative numbers, or
	1747	+ fixed-length encoding for large values.
	1748	+ </summary>
	1749	+ </member>
	1750	+ <member name="M:ProtoBuf.ProtoMemberAttribute.CompareTo(System.Object)">
	1751	+ <summary>
	1752	+ Compare with another ProtoMemberAttribute for sorting purposes
	1753	+ </summary>
	1754	+ </member>
	1755	+ <member name="M:ProtoBuf.ProtoMemberAttribute.CompareTo(ProtoBuf.ProtoMemberAttribute)">
	1756	+ <summary>
	1757	+ Compare with another ProtoMemberAttribute for sorting purposes
	1758	+ </summary>
	1759	+ </member>
	1760	+ <member name="M:ProtoBuf.ProtoMemberAttribute.#ctor(System.Int32)">
	1761	+ <summary>
	1762	+ Creates a new ProtoMemberAttribute instance.
	1763	+ </summary>
	1764	+ <param name="tag">Specifies the unique tag used to identify this member within the type.</param>
	1765	+ </member>
	1766	+ <member name="P:ProtoBuf.ProtoMemberAttribute.Name">
	1767	+ <summary>
	1768	+ Gets or sets the original name defined in the .proto; not used
	1769	+ during serialization.
	1770	+ </summary>
	1771	+ </member>
	1772	+ <member name="P:ProtoBuf.ProtoMemberAttribute.DataFormat">
	1773	+ <summary>
	1774	+ Gets or sets the data-format to be used when encoding this value.
	1775	+ </summary>
	1776	+ </member>
	1777	+ <member name="P:ProtoBuf.ProtoMemberAttribute.Tag">
	1778	+ <summary>
	1779	+ Gets the unique tag used to identify this member within the type.
	1780	+ </summary>
	1781	+ </member>
	1782	+ <member name="P:ProtoBuf.ProtoMemberAttribute.IsRequired">
	1783	+ <summary>
	1784	+ Gets or sets a value indicating whether this member is mandatory.
	1785	+ </summary>
	1786	+ </member>
	1787	+ <member name="P:ProtoBuf.ProtoMemberAttribute.IsPacked">
	1788	+ <summary>
	1789	+ Gets a value indicating whether this member is packed.
	1790	+ This option only applies to list/array data of primitive types (int, double, etc).
	1791	+ </summary>
	1792	+ </member>
	1793	+ <member name="P:ProtoBuf.ProtoMemberAttribute.OverwriteList">
	1794	+ <summary>
	1795	+ Indicates whether this field should repace existing values (the default is false, meaning append).
	1796	+ This option only applies to list/array data.
	1797	+ </summary>
	1798	+ </member>
	1799	+ <member name="P:ProtoBuf.ProtoMemberAttribute.AsReference">
	1800	+ <summary>
	1801	+ Enables full object-tracking/full-graph support.
	1802	+ </summary>
	1803	+ </member>
	1804	+ <member name="P:ProtoBuf.ProtoMemberAttribute.DynamicType">
	1805	+ <summary>
	1806	+ Embeds the type information into the stream, allowing usage with types not known in advance.
	1807	+ </summary>
	1808	+ </member>
	1809	+ <member name="P:ProtoBuf.ProtoMemberAttribute.Options">
	1810	+ <summary>
	1811	+ Gets or sets a value indicating whether this member is packed (lists/arrays).
	1812	+ </summary>
	1813	+ </member>
	1814	+ <member name="T:ProtoBuf.MemberSerializationOptions">
	1815	+ <summary>
	1816	+ Additional (optional) settings that control serialization of members
	1817	+ </summary>
	1818	+ </member>
	1819	+ <member name="F:ProtoBuf.MemberSerializationOptions.None">
	1820	+ <summary>
	1821	+ Default; no additional options
	1822	+ </summary>
	1823	+ </member>
	1824	+ <member name="F:ProtoBuf.MemberSerializationOptions.Packed">
	1825	+ <summary>
	1826	+ Indicates that repeated elements should use packed (length-prefixed) encoding
	1827	+ </summary>
	1828	+ </member>
	1829	+ <member name="F:ProtoBuf.MemberSerializationOptions.Required">
	1830	+ <summary>
	1831	+ Indicates that the given item is required
	1832	+ </summary>
	1833	+ </member>
	1834	+ <member name="F:ProtoBuf.MemberSerializationOptions.AsReference">
	1835	+ <summary>
	1836	+ Enables full object-tracking/full-graph support
	1837	+ </summary>
	1838	+ </member>
	1839	+ <member name="F:ProtoBuf.MemberSerializationOptions.DynamicType">
	1840	+ <summary>
	1841	+ Embeds the type information into the stream, allowing usage with types not known in advance
	1842	+ </summary>
	1843	+ </member>
	1844	+ <member name="F:ProtoBuf.MemberSerializationOptions.OverwriteList">
	1845	+ <summary>
	1846	+ Indicates whether this field should repace existing values (the default is false, meaning append).
	1847	+ This option only applies to list/array data.
	1848	+ </summary>
	1849	+ </member>
	1850	+ <member name="F:ProtoBuf.MemberSerializationOptions.AsReferenceHasValue">
	1851	+ <summary>
	1852	+ Determines whether the types AsReferenceDefault value is used, or whether this member's AsReference should be used
	1853	+ </summary>
	1854	+ </member>
	1855	+ <member name="T:ProtoBuf.ProtoPartialMemberAttribute">
	1856	+ <summary>
	1857	+ Declares a member to be used in protocol-buffer serialization, using
	1858	+ the given Tag and MemberName. This allows ProtoMemberAttribute usage
	1859	+ even for partial classes where the individual members are not
	1860	+ under direct control.
	1861	+ A DataFormat may be used to optimise the serialization
	1862	+ format (for instance, using zigzag encoding for negative numbers, or
	1863	+ fixed-length encoding for large values.
	1864	+ </summary>
	1865	+ </member>
	1866	+ <member name="M:ProtoBuf.ProtoPartialMemberAttribute.#ctor(System.Int32,System.String)">
	1867	+ <summary>
	1868	+ Creates a new ProtoMemberAttribute instance.
	1869	+ </summary>
	1870	+ <param name="tag">Specifies the unique tag used to identify this member within the type.</param>
	1871	+ <param name="memberName">Specifies the member to be serialized.</param>
	1872	+ </member>
	1873	+ <member name="P:ProtoBuf.ProtoPartialMemberAttribute.MemberName">
	1874	+ <summary>
	1875	+ The name of the member to be serialized.
	1876	+ </summary>
	1877	+ </member>
	1878	+ <member name="T:ProtoBuf.ProtoReader">
	1879	+ <summary>
	1880	+ A stateful reader, used to read a protobuf stream. Typical usage would be (sequentially) to call
	1881	+ ReadFieldHeader and (after matching the field) an appropriate Read* method.
	1882	+ </summary>
	1883	+ </member>
	1884	+ <member name="M:ProtoBuf.ProtoReader.#ctor(System.IO.Stream,ProtoBuf.Meta.TypeModel,ProtoBuf.SerializationContext)">
	1885	+ <summary>
	1886	+ Creates a new reader against a stream
	1887	+ </summary>
	1888	+ <param name="source">The source stream</param>
	1889	+ <param name="model">The model to use for serialization; this can be null, but this will impair the ability to deserialize sub-objects</param>
	1890	+ <param name="context">Additional context about this serialization operation</param>
	1891	+ </member>
	1892	+ <member name="M:ProtoBuf.ProtoReader.#ctor(System.IO.Stream,ProtoBuf.Meta.TypeModel,ProtoBuf.SerializationContext,System.Int32)">
	1893	+ <summary>
	1894	+ Creates a new reader against a stream
	1895	+ </summary>
	1896	+ <param name="source">The source stream</param>
	1897	+ <param name="model">The model to use for serialization; this can be null, but this will impair the ability to deserialize sub-objects</param>
	1898	+ <param name="context">Additional context about this serialization operation</param>
	1899	+ <param name="length">The number of bytes to read, or -1 to read until the end of the stream</param>
	1900	+ </member>
	1901	+ <member name="M:ProtoBuf.ProtoReader.Dispose">
	1902	+ <summary>
	1903	+ Releases resources used by the reader, but importantly <b>does not</b> Dispose the
	1904	+ underlying stream; in many typical use-cases the stream is used for different
	1905	+ processes, so it is assumed that the consumer will Dispose their stream separately.
	1906	+ </summary>
	1907	+ </member>
	1908	+ <member name="M:ProtoBuf.ProtoReader.ReadUInt32">
	1909	+ <summary>
	1910	+ Reads an unsigned 32-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
	1911	+ </summary>
	1912	+ </member>
	1913	+ <member name="M:ProtoBuf.ProtoReader.ReadInt16">
	1914	+ <summary>
	1915	+ Reads a signed 16-bit integer from the stream: Variant, Fixed32, Fixed64, SignedVariant
	1916	+ </summary>
	1917	+ </member>
	1918	+ <member name="M:ProtoBuf.ProtoReader.ReadUInt16">
	1919	+ <summary>
	1920	+ Reads an unsigned 16-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
	1921	+ </summary>
	1922	+ </member>
	1923	+ <member name="M:ProtoBuf.ProtoReader.ReadByte">
	1924	+ <summary>
	1925	+ Reads an unsigned 8-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
	1926	+ </summary>
	1927	+ </member>
	1928	+ <member name="M:ProtoBuf.ProtoReader.ReadSByte">
	1929	+ <summary>
	1930	+ Reads a signed 8-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	1931	+ </summary>
	1932	+ </member>
	1933	+ <member name="M:ProtoBuf.ProtoReader.ReadInt32">
	1934	+ <summary>
	1935	+ Reads a signed 32-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	1936	+ </summary>
	1937	+ </member>
	1938	+ <member name="M:ProtoBuf.ProtoReader.ReadInt64">
	1939	+ <summary>
	1940	+ Reads a signed 64-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	1941	+ </summary>
	1942	+ </member>
	1943	+ <member name="M:ProtoBuf.ProtoReader.ReadString">
	1944	+ <summary>
	1945	+ Reads a string from the stream (using UTF8); supported wire-types: String
	1946	+ </summary>
	1947	+ </member>
	1948	+ <member name="M:ProtoBuf.ProtoReader.ThrowEnumException(System.Type,System.Int32)">
	1949	+ <summary>
	1950	+ Throws an exception indication that the given value cannot be mapped to an enum.
	1951	+ </summary>
	1952	+ </member>
	1953	+ <member name="M:ProtoBuf.ProtoReader.ReadDouble">
	1954	+ <summary>
	1955	+ Reads a double-precision number from the stream; supported wire-types: Fixed32, Fixed64
	1956	+ </summary>
	1957	+ </member>
	1958	+ <member name="M:ProtoBuf.ProtoReader.ReadObject(System.Object,System.Int32,ProtoBuf.ProtoReader)">
	1959	+ <summary>
	1960	+ Reads (merges) a sub-message from the stream, internally calling StartSubItem and EndSubItem, and (in between)
	1961	+ parsing the message in accordance with the model associated with the reader
	1962	+ </summary>
	1963	+ </member>
	1964	+ <member name="M:ProtoBuf.ProtoReader.EndSubItem(ProtoBuf.SubItemToken,ProtoBuf.ProtoReader)">
	1965	+ <summary>
	1966	+ Makes the end of consuming a nested message in the stream; the stream must be either at the correct EndGroup
	1967	+ marker, or all fields of the sub-message must have been consumed (in either case, this means ReadFieldHeader
	1968	+ should return zero)
	1969	+ </summary>
	1970	+ </member>
	1971	+ <member name="M:ProtoBuf.ProtoReader.StartSubItem(ProtoBuf.ProtoReader)">
	1972	+ <summary>
	1973	+ Begins consuming a nested message in the stream; supported wire-types: StartGroup, String
	1974	+ </summary>
	1975	+ <remarks>The token returned must be help and used when callining EndSubItem</remarks>
	1976	+ </member>
	1977	+ <member name="M:ProtoBuf.ProtoReader.ReadFieldHeader">
	1978	+ <summary>
	1979	+ Reads a field header from the stream, setting the wire-type and retuning the field number. If no
	1980	+ more fields are available, then 0 is returned. This methods respects sub-messages.
	1981	+ </summary>
	1982	+ </member>
	1983	+ <member name="M:ProtoBuf.ProtoReader.TryReadFieldHeader(System.Int32)">
	1984	+ <summary>
	1985	+ Looks ahead to see whether the next field in the stream is what we expect
	1986	+ (typically; what we've just finished reading - for example ot read successive list items)
	1987	+ </summary>
	1988	+ </member>
	1989	+ <member name="M:ProtoBuf.ProtoReader.Hint(ProtoBuf.WireType)">
	1990	+ <summary>
	1991	+ Compares the streams current wire-type to the hinted wire-type, updating the reader if necessary; for example,
	1992	+ a Variant may be updated to SignedVariant. If the hinted wire-type is unrelated then no change is made.
	1993	+ </summary>
	1994	+ </member>
	1995	+ <member name="M:ProtoBuf.ProtoReader.Assert(ProtoBuf.WireType)">
	1996	+ <summary>
	1997	+ Verifies that the stream's current wire-type is as expected, or a specialized sub-type (for example,
	1998	+ SignedVariant) - in which case the current wire-type is updated. Otherwise an exception is thrown.
	1999	+ </summary>
	2000	+ </member>
	2001	+ <member name="M:ProtoBuf.ProtoReader.SkipField">
	2002	+ <summary>
	2003	+ Discards the data for the current field.
	2004	+ </summary>
	2005	+ </member>
	2006	+ <member name="M:ProtoBuf.ProtoReader.ReadUInt64">
	2007	+ <summary>
	2008	+ Reads an unsigned 64-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64
	2009	+ </summary>
	2010	+ </member>
	2011	+ <member name="M:ProtoBuf.ProtoReader.ReadSingle">
	2012	+ <summary>
	2013	+ Reads a single-precision number from the stream; supported wire-types: Fixed32, Fixed64
	2014	+ </summary>
	2015	+ </member>
	2016	+ <member name="M:ProtoBuf.ProtoReader.ReadBoolean">
	2017	+ <summary>
	2018	+ Reads a boolean value from the stream; supported wire-types: Variant, Fixed32, Fixed64
	2019	+ </summary>
	2020	+ <returns></returns>
	2021	+ </member>
	2022	+ <member name="M:ProtoBuf.ProtoReader.AppendBytes(System.Byte[],ProtoBuf.ProtoReader)">
	2023	+ <summary>
	2024	+ Reads a byte-sequence from the stream, appending them to an existing byte-sequence (which can be null); supported wire-types: String
	2025	+ </summary>
	2026	+ </member>
	2027	+ <member name="M:ProtoBuf.ProtoReader.ReadLengthPrefix(System.IO.Stream,System.Boolean,ProtoBuf.PrefixStyle,System.Int32@)">
	2028	+ <summary>
	2029	+ Reads the length-prefix of a message from a stream without buffering additional data, allowing a fixed-length
	2030	+ reader to be created.
	2031	+ </summary>
	2032	+ </member>
	2033	+ <member name="M:ProtoBuf.ProtoReader.DirectReadLittleEndianInt32(System.IO.Stream)">
	2034	+ <summary>
	2035	+ Reads a little-endian encoded integer. An exception is thrown if the data is not all available.
	2036	+ </summary>
	2037	+ </member>
	2038	+ <member name="M:ProtoBuf.ProtoReader.DirectReadBigEndianInt32(System.IO.Stream)">
	2039	+ <summary>
	2040	+ Reads a big-endian encoded integer. An exception is thrown if the data is not all available.
	2041	+ </summary>
	2042	+ </member>
	2043	+ <member name="M:ProtoBuf.ProtoReader.DirectReadVarintInt32(System.IO.Stream)">
	2044	+ <summary>
	2045	+ Reads a varint encoded integer. An exception is thrown if the data is not all available.
	2046	+ </summary>
	2047	+ </member>
	2048	+ <member name="M:ProtoBuf.ProtoReader.DirectReadBytes(System.IO.Stream,System.Byte[],System.Int32,System.Int32)">
	2049	+ <summary>
	2050	+ 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.
	2051	+ </summary>
	2052	+ </member>
	2053	+ <member name="M:ProtoBuf.ProtoReader.DirectReadBytes(System.IO.Stream,System.Int32)">
	2054	+ <summary>
	2055	+ Reads a given number of bytes directly from the source. An exception is thrown if the data is not all available.
	2056	+ </summary>
	2057	+ </member>
	2058	+ <member name="M:ProtoBuf.ProtoReader.DirectReadString(System.IO.Stream,System.Int32)">
	2059	+ <summary>
	2060	+ Reads a string (of a given lenth, in bytes) directly from the source. An exception is thrown if the data is not all available.
	2061	+ </summary>
	2062	+ </member>
	2063	+ <member name="M:ProtoBuf.ProtoReader.ReadLengthPrefix(System.IO.Stream,System.Boolean,ProtoBuf.PrefixStyle,System.Int32@,System.Int32@)">
	2064	+ <summary>
	2065	+ Reads the length-prefix of a message from a stream without buffering additional data, allowing a fixed-length
	2066	+ reader to be created.
	2067	+ </summary>
	2068	+ </member>
	2069	+ <member name="M:ProtoBuf.ProtoReader.TryReadUInt32Variant(System.IO.Stream,System.UInt32@)">
	2070	+ <returns>The number of bytes consumed; 0 if no data available</returns>
	2071	+ </member>
	2072	+ <member name="M:ProtoBuf.ProtoReader.AppendExtensionData(ProtoBuf.IExtensible)">
	2073	+ <summary>
	2074	+ Copies the current field into the instance as extension data
	2075	+ </summary>
	2076	+ </member>
	2077	+ <member name="M:ProtoBuf.ProtoReader.HasSubValue(ProtoBuf.WireType,ProtoBuf.ProtoReader)">
	2078	+ <summary>
	2079	+ Indicates whether the reader still has data remaining in the current sub-item,
	2080	+ additionally setting the wire-type for the next field if there is more data.
	2081	+ This is used when decoding packed data.
	2082	+ </summary>
	2083	+ </member>
	2084	+ <member name="M:ProtoBuf.ProtoReader.NoteObject(System.Object,ProtoBuf.ProtoReader)">
	2085	+ <summary>
	2086	+ Utility method, not intended for public use; this helps maintain the root object is complex scenarios
	2087	+ </summary>
	2088	+ </member>
	2089	+ <member name="M:ProtoBuf.ProtoReader.ReadType">
	2090	+ <summary>
	2091	+ Reads a Type from the stream, using the model's DynamicTypeFormatting if appropriate; supported wire-types: String
	2092	+ </summary>
	2093	+ </member>
	2094	+ <member name="M:ProtoBuf.ProtoReader.Merge(ProtoBuf.ProtoReader,System.Object,System.Object)">
	2095	+ <summary>
	2096	+ Merge two objects using the details from the current reader; this is used to change the type
	2097	+ of objects when an inheritance relationship is discovered later than usual during deserilazation.
	2098	+ </summary>
	2099	+ </member>
	2100	+ <member name="P:ProtoBuf.ProtoReader.FieldNumber">
	2101	+ <summary>
	2102	+ Gets the number of the field being processed.
	2103	+ </summary>
	2104	+ </member>
	2105	+ <member name="P:ProtoBuf.ProtoReader.WireType">
	2106	+ <summary>
	2107	+ Indicates the underlying proto serialization format on the wire.
	2108	+ </summary>
	2109	+ </member>
	2110	+ <member name="P:ProtoBuf.ProtoReader.InternStrings">
	2111	+ <summary>
	2112	+ Gets / sets a flag indicating whether strings should be checked for repetition; if
	2113	+ true, any repeated UTF-8 byte sequence will result in the same String instance, rather
	2114	+ than a second instance of the same string. Enabled by default. Note that this uses
	2115	+ a <i>custom</i> interner - the system-wide string interner is not used.
	2116	+ </summary>
	2117	+ </member>
	2118	+ <member name="P:ProtoBuf.ProtoReader.Context">
	2119	+ <summary>
	2120	+ Addition information about this deserialization operation.
	2121	+ </summary>
	2122	+ </member>
	2123	+ <member name="P:ProtoBuf.ProtoReader.Position">
	2124	+ <summary>
	2125	+ Returns the position of the current reader (note that this is not necessarily the same as the position
	2126	+ in the underlying stream, if multiple readers are used on the same stream)
	2127	+ </summary>
	2128	+ </member>
	2129	+ <member name="P:ProtoBuf.ProtoReader.Model">
	2130	+ <summary>
	2131	+ Get the TypeModel associated with this reader
	2132	+ </summary>
	2133	+ </member>
	2134	+ <member name="T:ProtoBuf.ProtoWriter">
	2135	+ <summary>
	2136	+ Represents an output stream for writing protobuf data.
	2137	+
	2138	+ Why is the API backwards (static methods with writer arguments)?
	2139	+ See: http://marcgravell.blogspot.com/2010/03/last-will-be-first-and-first-will-be.html
	2140	+ </summary>
	2141	+ </member>
	2142	+ <member name="M:ProtoBuf.ProtoWriter.WriteObject(System.Object,System.Int32,ProtoBuf.ProtoWriter)">
	2143	+ <summary>
	2144	+ Write an encapsulated sub-object, using the supplied unique key (reprasenting a type).
	2145	+ </summary>
	2146	+ <param name="value">The object to write.</param>
	2147	+ <param name="key">The key that uniquely identifies the type within the model.</param>
	2148	+ <param name="writer">The destination.</param>
	2149	+ </member>
	2150	+ <member name="M:ProtoBuf.ProtoWriter.WriteRecursionSafeObject(System.Object,System.Int32,ProtoBuf.ProtoWriter)">
	2151	+ <summary>
	2152	+ Write an encapsulated sub-object, using the supplied unique key (reprasenting a type) - but the
	2153	+ caller is asserting that this relationship is non-recursive; no recursion check will be
	2154	+ performed.
	2155	+ </summary>
	2156	+ <param name="value">The object to write.</param>
	2157	+ <param name="key">The key that uniquely identifies the type within the model.</param>
	2158	+ <param name="writer">The destination.</param>
	2159	+ </member>
	2160	+ <member name="M:ProtoBuf.ProtoWriter.WriteFieldHeader(System.Int32,ProtoBuf.WireType,ProtoBuf.ProtoWriter)">
	2161	+ <summary>
	2162	+ Writes a field-header, indicating the format of the next data we plan to write.
	2163	+ </summary>
	2164	+ </member>
	2165	+ <member name="M:ProtoBuf.ProtoWriter.WriteBytes(System.Byte[],ProtoBuf.ProtoWriter)">
	2166	+ <summary>
	2167	+ Writes a byte-array to the stream; supported wire-types: String
	2168	+ </summary>
	2169	+ </member>
	2170	+ <member name="M:ProtoBuf.ProtoWriter.WriteBytes(System.Byte[],System.Int32,System.Int32,ProtoBuf.ProtoWriter)">
	2171	+ <summary>
	2172	+ Writes a byte-array to the stream; supported wire-types: String
	2173	+ </summary>
	2174	+ </member>
	2175	+ <member name="M:ProtoBuf.ProtoWriter.StartSubItem(System.Object,ProtoBuf.ProtoWriter)">
	2176	+ <summary>
	2177	+ Indicates the start of a nested record.
	2178	+ </summary>
	2179	+ <param name="instance">The instance to write.</param>
	2180	+ <param name="writer">The destination.</param>
	2181	+ <returns>A token representing the state of the stream; this token is given to EndSubItem.</returns>
	2182	+ </member>
	2183	+ <member name="M:ProtoBuf.ProtoWriter.EndSubItem(ProtoBuf.SubItemToken,ProtoBuf.ProtoWriter)">
	2184	+ <summary>
	2185	+ Indicates the end of a nested record.
	2186	+ </summary>
	2187	+ <param name="token">The token obtained from StartubItem.</param>
	2188	+ <param name="writer">The destination.</param>
	2189	+ </member>
	2190	+ <member name="M:ProtoBuf.ProtoWriter.#ctor(System.IO.Stream,ProtoBuf.Meta.TypeModel,ProtoBuf.SerializationContext)">
	2191	+ <summary>
	2192	+ Creates a new writer against a stream
	2193	+ </summary>
	2194	+ <param name="dest">The destination stream</param>
	2195	+ <param name="model">The model to use for serialization; this can be null, but this will impair the ability to serialize sub-objects</param>
	2196	+ <param name="context">Additional context about this serialization operation</param>
	2197	+ </member>
	2198	+ <member name="M:ProtoBuf.ProtoWriter.Close">
	2199	+ <summary>
	2200	+ Flushes data to the underlying stream, and releases any resources. The underlying stream is not disposed
	2201	+ by this operation.
	2202	+ </summary>
	2203	+ </member>
	2204	+ <member name="M:ProtoBuf.ProtoWriter.Flush(ProtoBuf.ProtoWriter)">
	2205	+ <summary>
	2206	+ Writes any buffered data (if possible) to the underlying stream.
	2207	+ </summary>
	2208	+ <param name="writer">The writer to flush</param>
	2209	+ <remarks>It is not always possible to fully flush, since some sequences
	2210	+ may require values to be back-filled into the byte-stream.</remarks>
	2211	+ </member>
	2212	+ <member name="M:ProtoBuf.ProtoWriter.WriteUInt32Variant(System.UInt32,ProtoBuf.ProtoWriter)">
	2213	+ <summary>
	2214	+ Writes an unsigned 32-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
	2215	+ </summary>
	2216	+ </member>
	2217	+ <member name="M:ProtoBuf.ProtoWriter.WriteString(System.String,ProtoBuf.ProtoWriter)">
	2218	+ <summary>
	2219	+ Writes a string to the stream; supported wire-types: String
	2220	+ </summary>
	2221	+ </member>
	2222	+ <member name="M:ProtoBuf.ProtoWriter.WriteUInt64(System.UInt64,ProtoBuf.ProtoWriter)">
	2223	+ <summary>
	2224	+ Writes an unsigned 64-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
	2225	+ </summary>
	2226	+ </member>
	2227	+ <member name="M:ProtoBuf.ProtoWriter.WriteInt64(System.Int64,ProtoBuf.ProtoWriter)">
	2228	+ <summary>
	2229	+ Writes a signed 64-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	2230	+ </summary>
	2231	+ </member>
	2232	+ <member name="M:ProtoBuf.ProtoWriter.WriteUInt32(System.UInt32,ProtoBuf.ProtoWriter)">
	2233	+ <summary>
	2234	+ Writes an unsigned 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
	2235	+ </summary>
	2236	+ </member>
	2237	+ <member name="M:ProtoBuf.ProtoWriter.WriteInt16(System.Int16,ProtoBuf.ProtoWriter)">
	2238	+ <summary>
	2239	+ Writes a signed 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	2240	+ </summary>
	2241	+ </member>
	2242	+ <member name="M:ProtoBuf.ProtoWriter.WriteUInt16(System.UInt16,ProtoBuf.ProtoWriter)">
	2243	+ <summary>
	2244	+ Writes an unsigned 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
	2245	+ </summary>
	2246	+ </member>
	2247	+ <member name="M:ProtoBuf.ProtoWriter.WriteByte(System.Byte,ProtoBuf.ProtoWriter)">
	2248	+ <summary>
	2249	+ Writes an unsigned 8-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64
	2250	+ </summary>
	2251	+ </member>
	2252	+ <member name="M:ProtoBuf.ProtoWriter.WriteSByte(System.SByte,ProtoBuf.ProtoWriter)">
	2253	+ <summary>
	2254	+ Writes a signed 8-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	2255	+ </summary>
	2256	+ </member>
	2257	+ <member name="M:ProtoBuf.ProtoWriter.WriteInt32(System.Int32,ProtoBuf.ProtoWriter)">
	2258	+ <summary>
	2259	+ Writes a signed 32-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant
	2260	+ </summary>
	2261	+ </member>
	2262	+ <member name="M:ProtoBuf.ProtoWriter.WriteDouble(System.Double,ProtoBuf.ProtoWriter)">
	2263	+ <summary>
	2264	+ Writes a double-precision number to the stream; supported wire-types: Fixed32, Fixed64
	2265	+ </summary>
	2266	+ </member>
	2267	+ <member name="M:ProtoBuf.ProtoWriter.WriteSingle(System.Single,ProtoBuf.ProtoWriter)">
	2268	+ <summary>
	2269	+ Writes a single-precision number to the stream; supported wire-types: Fixed32, Fixed64
	2270	+ </summary>
	2271	+ </member>
	2272	+ <member name="M:ProtoBuf.ProtoWriter.ThrowEnumException(ProtoBuf.ProtoWriter,System.Object)">
	2273	+ <summary>
	2274	+ Throws an exception indicating that the given enum cannot be mapped to a serialized value.
	2275	+ </summary>
	2276	+ </member>
	2277	+ <member name="M:ProtoBuf.ProtoWriter.WriteBoolean(System.Boolean,ProtoBuf.ProtoWriter)">
	2278	+ <summary>
	2279	+ Writes a boolean to the stream; supported wire-types: Variant, Fixed32, Fixed64
	2280	+ </summary>
	2281	+ </member>
	2282	+ <member name="M:ProtoBuf.ProtoWriter.AppendExtensionData(ProtoBuf.IExtensible,ProtoBuf.ProtoWriter)">
	2283	+ <summary>
	2284	+ Copies any extension data stored for the instance to the underlying stream
	2285	+ </summary>
	2286	+ </member>
	2287	+ <member name="M:ProtoBuf.ProtoWriter.SetPackedField(System.Int32,ProtoBuf.ProtoWriter)">
	2288	+ <summary>
	2289	+ Used for packed encoding; indicates that the next field should be skipped rather than
	2290	+ a field header written. Note that the field number must match, else an exception is thrown
	2291	+ when the attempt is made to write the (incorrect) field. The wire-type is taken from the
	2292	+ subsequent call to WriteFieldHeader. Only primitive types can be packed.
	2293	+ </summary>
	2294	+ </member>
	2295	+ <member name="M:ProtoBuf.ProtoWriter.SetRootObject(System.Object)">
	2296	+ <summary>
	2297	+ Specifies a known root object to use during reference-tracked serialization
	2298	+ </summary>
	2299	+ </member>
	2300	+ <member name="M:ProtoBuf.ProtoWriter.WriteType(System.Type,ProtoBuf.ProtoWriter)">
	2301	+ <summary>
	2302	+ Writes a Type to the stream, using the model's DynamicTypeFormatting if appropriate; supported wire-types: String
	2303	+ </summary>
	2304	+ </member>
	2305	+ <member name="P:ProtoBuf.ProtoWriter.Context">
	2306	+ <summary>
	2307	+ Addition information about this serialization operation.
	2308	+ </summary>
	2309	+ </member>
	2310	+ <member name="P:ProtoBuf.ProtoWriter.Model">
	2311	+ <summary>
	2312	+ Get the TypeModel associated with this writer
	2313	+ </summary>
	2314	+ </member>
	2315	+ <member name="T:ProtoBuf.SerializationContext">
	2316	+ <summary>
	2317	+ Additional information about a serialization operation
	2318	+ </summary>
	2319	+ </member>
	2320	+ <member name="M:ProtoBuf.SerializationContext.op_Implicit(ProtoBuf.SerializationContext)~System.Runtime.Serialization.StreamingContext">
	2321	+ <summary>
	2322	+ Convert a SerializationContext to a StreamingContext
	2323	+ </summary>
	2324	+ </member>
	2325	+ <member name="M:ProtoBuf.SerializationContext.op_Implicit(System.Runtime.Serialization.StreamingContext)~ProtoBuf.SerializationContext">
	2326	+ <summary>
	2327	+ Convert a StreamingContext to a SerializationContext
	2328	+ </summary>
	2329	+ </member>
	2330	+ <member name="P:ProtoBuf.SerializationContext.Context">
	2331	+ <summary>
	2332	+ Gets or sets a user-defined object containing additional information about this serialization/deserialization operation.
	2333	+ </summary>
	2334	+ </member>
	2335	+ <member name="P:ProtoBuf.SerializationContext.Default">
	2336	+ <summary>
	2337	+ A default SerializationContext, with minimal information.
	2338	+ </summary>
	2339	+ </member>
	2340	+ <member name="P:ProtoBuf.SerializationContext.State">
	2341	+ <summary>
	2342	+ Gets or sets the source or destination of the transmitted data.
	2343	+ </summary>
	2344	+ </member>
	2345	+ <member name="T:ProtoBuf.Serializer">
	2346	+ <summary>
	2347	+ Provides protocol-buffer serialization capability for concrete, attributed types. This
	2348	+ is a default model, but custom serializer models are also supported.
	2349	+ </summary>
	2350	+ <remarks>
	2351	+ Protocol-buffer serialization is a compact binary format, designed to take
	2352	+ advantage of sparse data and knowledge of specific data types; it is also
	2353	+ extensible, allowing a type to be deserialized / merged even if some data is
	2354	+ not recognised.
	2355	+ </remarks>
	2356	+ </member>
	2357	+ <member name="F:ProtoBuf.Serializer.ListItemTag">
	2358	+ <summary>
	2359	+ The field number that is used as a default when serializing/deserializing a list of objects.
	2360	+ The data is treated as repeated message with field number 1.
	2361	+ </summary>
	2362	+ </member>
	2363	+ <member name="M:ProtoBuf.Serializer.GetProto``1">
	2364	+ <summary>
	2365	+ Suggest a .proto definition for the given type
	2366	+ </summary>
	2367	+ <typeparam name="T">The type to generate a .proto definition for</typeparam>
	2368	+ <returns>The .proto definition as a string</returns>
	2369	+ </member>
	2370	+ <member name="M:ProtoBuf.Serializer.DeepClone``1(``0)">
	2371	+ <summary>
	2372	+ Create a deep clone of the supplied instance; any sub-items are also cloned.
	2373	+ </summary>
	2374	+ </member>
	2375	+ <member name="M:ProtoBuf.Serializer.Merge``1(System.IO.Stream,``0)">
	2376	+ <summary>
	2377	+ Applies a protocol-buffer stream to an existing instance.
	2378	+ </summary>
	2379	+ <typeparam name="T">The type being merged.</typeparam>
	2380	+ <param name="instance">The existing instance to be modified (can be null).</param>
	2381	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	2382	+ <returns>The updated instance; this may be different to the instance argument if
	2383	+ either the original instance was null, or the stream defines a known sub-type of the
	2384	+ original instance.</returns>
	2385	+ </member>
	2386	+ <member name="M:ProtoBuf.Serializer.Deserialize``1(System.IO.Stream)">
	2387	+ <summary>
	2388	+ Creates a new instance from a protocol-buffer stream
	2389	+ </summary>
	2390	+ <typeparam name="T">The type to be created.</typeparam>
	2391	+ <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
	2392	+ <returns>A new, initialized instance.</returns>
	2393	+ </member>
	2394	+ <member name="M:ProtoBuf.Serializer.Serialize``1(System.IO.Stream,``0)">
	2395	+ <summary>
	2396	+ Writes a protocol-buffer representation of the given instance to the supplied stream.
	2397	+ </summary>
	2398	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2399	+ <param name="destination">The destination stream to write to.</param>
	2400	+ </member>
	2401	+ <member name="M:ProtoBuf.Serializer.ChangeType``2(``0)">
	2402	+ <summary>
	2403	+ Serializes a given instance and deserializes it as a different type;
	2404	+ this can be used to translate between wire-compatible objects (where
	2405	+ two .NET types represent the same data), or to promote/demote a type
	2406	+ through an inheritance hierarchy.
	2407	+ </summary>
	2408	+ <remarks>No assumption of compatibility is made between the types.</remarks>
	2409	+ <typeparam name="TFrom">The type of the object being copied.</typeparam>
	2410	+ <typeparam name="TTo">The type of the new object to be created.</typeparam>
	2411	+ <param name="instance">The existing instance to use as a template.</param>
	2412	+ <returns>A new instane of type TNewType, with the data from TOldType.</returns>
	2413	+ </member>
	2414	+ <member name="M:ProtoBuf.Serializer.Serialize``1(System.Runtime.Serialization.SerializationInfo,``0)">
	2415	+ <summary>
	2416	+ Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo.
	2417	+ </summary>
	2418	+ <typeparam name="T">The type being serialized.</typeparam>
	2419	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2420	+ <param name="info">The destination SerializationInfo to write to.</param>
	2421	+ </member>
	2422	+ <member name="M:ProtoBuf.Serializer.Serialize``1(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,``0)">
	2423	+ <summary>
	2424	+ Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo.
	2425	+ </summary>
	2426	+ <typeparam name="T">The type being serialized.</typeparam>
	2427	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2428	+ <param name="info">The destination SerializationInfo to write to.</param>
	2429	+ <param name="context">Additional information about this serialization operation.</param>
	2430	+ </member>
	2431	+ <member name="M:ProtoBuf.Serializer.Serialize``1(System.Xml.XmlWriter,``0)">
	2432	+ <summary>
	2433	+ Writes a protocol-buffer representation of the given instance to the supplied XmlWriter.
	2434	+ </summary>
	2435	+ <typeparam name="T">The type being serialized.</typeparam>
	2436	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2437	+ <param name="writer">The destination XmlWriter to write to.</param>
	2438	+ </member>
	2439	+ <member name="M:ProtoBuf.Serializer.Merge``1(System.Xml.XmlReader,``0)">
	2440	+ <summary>
	2441	+ Applies a protocol-buffer from an XmlReader to an existing instance.
	2442	+ </summary>
	2443	+ <typeparam name="T">The type being merged.</typeparam>
	2444	+ <param name="instance">The existing instance to be modified (cannot be null).</param>
	2445	+ <param name="reader">The XmlReader containing the data to apply to the instance (cannot be null).</param>
	2446	+ </member>
	2447	+ <member name="M:ProtoBuf.Serializer.Merge``1(System.Runtime.Serialization.SerializationInfo,``0)">
	2448	+ <summary>
	2449	+ Applies a protocol-buffer from a SerializationInfo to an existing instance.
	2450	+ </summary>
	2451	+ <typeparam name="T">The type being merged.</typeparam>
	2452	+ <param name="instance">The existing instance to be modified (cannot be null).</param>
	2453	+ <param name="info">The SerializationInfo containing the data to apply to the instance (cannot be null).</param>
	2454	+ </member>
	2455	+ <member name="M:ProtoBuf.Serializer.Merge``1(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext,``0)">
	2456	+ <summary>
	2457	+ Applies a protocol-buffer from a SerializationInfo to an existing instance.
	2458	+ </summary>
	2459	+ <typeparam name="T">The type being merged.</typeparam>
	2460	+ <param name="instance">The existing instance to be modified (cannot be null).</param>
	2461	+ <param name="info">The SerializationInfo containing the data to apply to the instance (cannot be null).</param>
	2462	+ <param name="context">Additional information about this serialization operation.</param>
	2463	+ </member>
	2464	+ <member name="M:ProtoBuf.Serializer.PrepareSerializer``1">
	2465	+ <summary>
	2466	+ Precompiles the serializer for a given type.
	2467	+ </summary>
	2468	+ </member>
	2469	+ <member name="M:ProtoBuf.Serializer.CreateFormatter``1">
	2470	+ <summary>
	2471	+ Creates a new IFormatter that uses protocol-buffer [de]serialization.
	2472	+ </summary>
	2473	+ <typeparam name="T">The type of object to be [de]deserialized by the formatter.</typeparam>
	2474	+ <returns>A new IFormatter to be used during [de]serialization.</returns>
	2475	+ </member>
	2476	+ <member name="M:ProtoBuf.Serializer.DeserializeItems``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32)">
	2477	+ <summary>
	2478	+ Reads a sequence of consecutive length-prefixed items from a stream, using
	2479	+ either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
	2480	+ are directly comparable to serializing multiple items in succession
	2481	+ (use the <see cref="F:ProtoBuf.Serializer.ListItemTag"/> tag to emulate the implicit behavior
	2482	+ when serializing a list/array). When a tag is
	2483	+ specified, any records with different tags are silently omitted. The
	2484	+ tag is ignored. The tag is ignores for fixed-length prefixes.
	2485	+ </summary>
	2486	+ <typeparam name="T">The type of object to deserialize.</typeparam>
	2487	+ <param name="source">The binary stream containing the serialized records.</param>
	2488	+ <param name="style">The prefix style used in the data.</param>
	2489	+ <param name="fieldNumber">The tag of records to return (if non-positive, then no tag is
	2490	+ expected and all records are returned).</param>
	2491	+ <returns>The sequence of deserialized objects.</returns>
	2492	+ </member>
	2493	+ <member name="M:ProtoBuf.Serializer.DeserializeWithLengthPrefix``1(System.IO.Stream,ProtoBuf.PrefixStyle)">
	2494	+ <summary>
	2495	+ Creates a new instance from a protocol-buffer stream that has a length-prefix
	2496	+ on data (to assist with network IO).
	2497	+ </summary>
	2498	+ <typeparam name="T">The type to be created.</typeparam>
	2499	+ <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
	2500	+ <param name="style">How to encode the length prefix.</param>
	2501	+ <returns>A new, initialized instance.</returns>
	2502	+ </member>
	2503	+ <member name="M:ProtoBuf.Serializer.DeserializeWithLengthPrefix``1(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32)">
	2504	+ <summary>
	2505	+ Creates a new instance from a protocol-buffer stream that has a length-prefix
	2506	+ on data (to assist with network IO).
	2507	+ </summary>
	2508	+ <typeparam name="T">The type to be created.</typeparam>
	2509	+ <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
	2510	+ <param name="style">How to encode the length prefix.</param>
	2511	+ <param name="fieldNumber">The expected tag of the item (only used with base-128 prefix style).</param>
	2512	+ <returns>A new, initialized instance.</returns>
	2513	+ </member>
	2514	+ <member name="M:ProtoBuf.Serializer.MergeWithLengthPrefix``1(System.IO.Stream,``0,ProtoBuf.PrefixStyle)">
	2515	+ <summary>
	2516	+ Applies a protocol-buffer stream to an existing instance, using length-prefixed
	2517	+ data - useful with network IO.
	2518	+ </summary>
	2519	+ <typeparam name="T">The type being merged.</typeparam>
	2520	+ <param name="instance">The existing instance to be modified (can be null).</param>
	2521	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	2522	+ <param name="style">How to encode the length prefix.</param>
	2523	+ <returns>The updated instance; this may be different to the instance argument if
	2524	+ either the original instance was null, or the stream defines a known sub-type of the
	2525	+ original instance.</returns>
	2526	+ </member>
	2527	+ <member name="M:ProtoBuf.Serializer.SerializeWithLengthPrefix``1(System.IO.Stream,``0,ProtoBuf.PrefixStyle)">
	2528	+ <summary>
	2529	+ Writes a protocol-buffer representation of the given instance to the supplied stream,
	2530	+ with a length-prefix. This is useful for socket programming,
	2531	+ as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
	2532	+ from an ongoing stream.
	2533	+ </summary>
	2534	+ <typeparam name="T">The type being serialized.</typeparam>
	2535	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2536	+ <param name="style">How to encode the length prefix.</param>
	2537	+ <param name="destination">The destination stream to write to.</param>
	2538	+ </member>
	2539	+ <member name="M:ProtoBuf.Serializer.SerializeWithLengthPrefix``1(System.IO.Stream,``0,ProtoBuf.PrefixStyle,System.Int32)">
	2540	+ <summary>
	2541	+ Writes a protocol-buffer representation of the given instance to the supplied stream,
	2542	+ with a length-prefix. This is useful for socket programming,
	2543	+ as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
	2544	+ from an ongoing stream.
	2545	+ </summary>
	2546	+ <typeparam name="T">The type being serialized.</typeparam>
	2547	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2548	+ <param name="style">How to encode the length prefix.</param>
	2549	+ <param name="destination">The destination stream to write to.</param>
	2550	+ <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	2551	+ </member>
	2552	+ <member name="M:ProtoBuf.Serializer.TryReadLengthPrefix(System.IO.Stream,ProtoBuf.PrefixStyle,System.Int32@)">
	2553	+ <summary>Indicates the number of bytes expected for the next message.</summary>
	2554	+ <param name="source">The stream containing the data to investigate for a length.</param>
	2555	+ <param name="style">The algorithm used to encode the length.</param>
	2556	+ <param name="length">The length of the message, if it could be identified.</param>
	2557	+ <returns>True if a length could be obtained, false otherwise.</returns>
	2558	+ </member>
	2559	+ <member name="M:ProtoBuf.Serializer.TryReadLengthPrefix(System.Byte[],System.Int32,System.Int32,ProtoBuf.PrefixStyle,System.Int32@)">
	2560	+ <summary>Indicates the number of bytes expected for the next message.</summary>
	2561	+ <param name="buffer">The buffer containing the data to investigate for a length.</param>
	2562	+ <param name="index">The offset of the first byte to read from the buffer.</param>
	2563	+ <param name="count">The number of bytes to read from the buffer.</param>
	2564	+ <param name="style">The algorithm used to encode the length.</param>
	2565	+ <param name="length">The length of the message, if it could be identified.</param>
	2566	+ <returns>True if a length could be obtained, false otherwise.</returns>
	2567	+ </member>
	2568	+ <member name="M:ProtoBuf.Serializer.FlushPool">
	2569	+ <summary>
	2570	+ Releases any internal buffers that have been reserved for efficiency; this does not affect any serialization
	2571	+ operations; simply: it can be used (optionally) to release the buffers for garbage collection (at the expense
	2572	+ of having to re-allocate a new buffer for the next operation, rather than re-use prior buffers).
	2573	+ </summary>
	2574	+ </member>
	2575	+ <member name="T:ProtoBuf.Serializer.NonGeneric">
	2576	+ <summary>
	2577	+ Provides non-generic access to the default serializer.
	2578	+ </summary>
	2579	+ </member>
	2580	+ <member name="M:ProtoBuf.Serializer.NonGeneric.DeepClone(System.Object)">
	2581	+ <summary>
	2582	+ Create a deep clone of the supplied instance; any sub-items are also cloned.
	2583	+ </summary>
	2584	+ </member>
	2585	+ <member name="M:ProtoBuf.Serializer.NonGeneric.Serialize(System.IO.Stream,System.Object)">
	2586	+ <summary>
	2587	+ Writes a protocol-buffer representation of the given instance to the supplied stream.
	2588	+ </summary>
	2589	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2590	+ <param name="dest">The destination stream to write to.</param>
	2591	+ </member>
	2592	+ <member name="M:ProtoBuf.Serializer.NonGeneric.Deserialize(System.Type,System.IO.Stream)">
	2593	+ <summary>
	2594	+ Creates a new instance from a protocol-buffer stream
	2595	+ </summary>
	2596	+ <param name="type">The type to be created.</param>
	2597	+ <param name="source">The binary stream to apply to the new instance (cannot be null).</param>
	2598	+ <returns>A new, initialized instance.</returns>
	2599	+ </member>
	2600	+ <member name="M:ProtoBuf.Serializer.NonGeneric.Merge(System.IO.Stream,System.Object)">
	2601	+ <summary>Applies a protocol-buffer stream to an existing instance.</summary>
	2602	+ <param name="instance">The existing instance to be modified (cannot be null).</param>
	2603	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	2604	+ <returns>The updated instance</returns>
	2605	+ </member>
	2606	+ <member name="M:ProtoBuf.Serializer.NonGeneric.SerializeWithLengthPrefix(System.IO.Stream,System.Object,ProtoBuf.PrefixStyle,System.Int32)">
	2607	+ <summary>
	2608	+ Writes a protocol-buffer representation of the given instance to the supplied stream,
	2609	+ with a length-prefix. This is useful for socket programming,
	2610	+ as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
	2611	+ from an ongoing stream.
	2612	+ </summary>
	2613	+ <param name="instance">The existing instance to be serialized (cannot be null).</param>
	2614	+ <param name="style">How to encode the length prefix.</param>
	2615	+ <param name="destination">The destination stream to write to.</param>
	2616	+ <param name="fieldNumber">The tag used as a prefix to each record (only used with base-128 style prefixes).</param>
	2617	+ </member>
	2618	+ <member name="M:ProtoBuf.Serializer.NonGeneric.TryDeserializeWithLengthPrefix(System.IO.Stream,ProtoBuf.PrefixStyle,ProtoBuf.Serializer.TypeResolver,System.Object@)">
	2619	+ <summary>
	2620	+ Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed
	2621	+ data - useful with network IO.
	2622	+ </summary>
	2623	+ <param name="value">The existing instance to be modified (can be null).</param>
	2624	+ <param name="source">The binary stream to apply to the instance (cannot be null).</param>
	2625	+ <param name="style">How to encode the length prefix.</param>
	2626	+ <param name="resolver">Used to resolve types on a per-field basis.</param>
	2627	+ <returns>The updated instance; this may be different to the instance argument if
	2628	+ either the original instance was null, or the stream defines a known sub-type of the
	2629	+ original instance.</returns>
	2630	+ </member>
	2631	+ <member name="M:ProtoBuf.Serializer.NonGeneric.CanSerialize(System.Type)">
	2632	+ <summary>
	2633	+ Indicates whether the supplied type is explicitly modelled by the model
	2634	+ </summary>
	2635	+ </member>
	2636	+ <member name="T:ProtoBuf.Serializer.GlobalOptions">
	2637	+ <summary>
	2638	+ Global switches that change the behavior of protobuf-net
	2639	+ </summary>
	2640	+ </member>
	2641	+ <member name="P:ProtoBuf.Serializer.GlobalOptions.InferTagFromName">
	2642	+ <summary>
	2643	+ <see cref="P:ProtoBuf.Meta.RuntimeTypeModel.InferTagFromNameDefault"/>
	2644	+ </summary>
	2645	+ </member>
	2646	+ <member name="T:ProtoBuf.Serializer.TypeResolver">
	2647	+ <summary>
	2648	+ Maps a field-number to a type
	2649	+ </summary>
	2650	+ </member>
	2651	+ <member name="M:ProtoBuf.Serializers.IProtoSerializer.Write(System.Object,ProtoBuf.ProtoWriter)">
	2652	+ <summary>
	2653	+ Perform the steps necessary to serialize this data.
	2654	+ </summary>
	2655	+ <param name="value">The value to be serialized.</param>
	2656	+ <param name="dest">The writer entity that is accumulating the output data.</param>
	2657	+ </member>
	2658	+ <member name="M:ProtoBuf.Serializers.IProtoSerializer.Read(System.Object,ProtoBuf.ProtoReader)">
	2659	+ <summary>
	2660	+ Perform the steps necessary to deserialize this data.
	2661	+ </summary>
	2662	+ <param name="value">The current value, if appropriate.</param>
	2663	+ <param name="source">The reader providing the input data.</param>
	2664	+ <returns>The updated / replacement value.</returns>
	2665	+ </member>
	2666	+ <member name="M:ProtoBuf.Serializers.IProtoSerializer.EmitWrite(ProtoBuf.Compiler.CompilerContext,ProtoBuf.Compiler.Local)">
	2667	+ <summary>Emit the IL necessary to perform the given actions
	2668	+ to serialize this data.
	2669	+ </summary>
	2670	+ <param name="ctx">Details and utilities for the method being generated.</param>
	2671	+ <param name="valueFrom">The source of the data to work against;
	2672	+ If the value is only needed once, then LoadValue is sufficient. If
	2673	+ the value is needed multiple times, then note that a "null"
	2674	+ means "the top of the stack", in which case you should create your
	2675	+ own copy - GetLocalWithValue.</param>
	2676	+ </member>
	2677	+ <member name="M:ProtoBuf.Serializers.IProtoSerializer.EmitRead(ProtoBuf.Compiler.CompilerContext,ProtoBuf.Compiler.Local)">
	2678	+ <summary>
	2679	+ Emit the IL necessary to perform the given actions to deserialize this data.
	2680	+ </summary>
	2681	+ <param name="ctx">Details and utilities for the method being generated.</param>
	2682	+ <param name="entity">For nested values, the instance holding the values; note
	2683	+ that this is not always provided - a null means not supplied. Since this is always
	2684	+ a variable or argument, it is not necessary to consume this value.</param>
	2685	+ </member>
	2686	+ <member name="P:ProtoBuf.Serializers.IProtoSerializer.ExpectedType">
	2687	+ <summary>
	2688	+ The type that this serializer is intended to work for.
	2689	+ </summary>
	2690	+ </member>
	2691	+ <member name="P:ProtoBuf.Serializers.IProtoSerializer.RequiresOldValue">
	2692	+ <summary>
	2693	+ Indicates whether a Read operation <em>replaces</em> the existing value, or
	2694	+ <em>extends</em> the value. If false, the "value" parameter to Read is
	2695	+ discarded, and should be passed in as null.
	2696	+ </summary>
	2697	+ </member>
	2698	+ <member name="P:ProtoBuf.Serializers.IProtoSerializer.ReturnsValue">
	2699	+ <summary>
	2700	+ Now all Read operations return a value (although most do); if false no
	2701	+ value should be expected.
	2702	+ </summary>
	2703	+ </member>
	2704	+ <member name="T:ProtoBuf.ServiceModel.ProtoBehaviorAttribute">
	2705	+ <summary>
	2706	+ Uses protocol buffer serialization on the specified operation; note that this
	2707	+ must be enabled on both the client and server.
	2708	+ </summary>
	2709	+ </member>
	2710	+ <member name="T:ProtoBuf.ServiceModel.ProtoBehaviorExtension">
	2711	+ <summary>
	2712	+ Configuration element to swap out DatatContractSerilaizer with the XmlProtoSerializer for a given endpoint.
	2713	+ </summary>
	2714	+ <seealso cref="T:ProtoBuf.ServiceModel.ProtoEndpointBehavior"/>
	2715	+ </member>
	2716	+ <member name="M:ProtoBuf.ServiceModel.ProtoBehaviorExtension.#ctor">
	2717	+ <summary>
	2718	+ Creates a new ProtoBehaviorExtension instance.
	2719	+ </summary>
	2720	+ </member>
	2721	+ <member name="M:ProtoBuf.ServiceModel.ProtoBehaviorExtension.CreateBehavior">
	2722	+ <summary>
	2723	+ Creates a behavior extension based on the current configuration settings.
	2724	+ </summary>
	2725	+ <returns>The behavior extension.</returns>
	2726	+ </member>
	2727	+ <member name="P:ProtoBuf.ServiceModel.ProtoBehaviorExtension.BehaviorType">
	2728	+ <summary>
	2729	+ Gets the type of behavior.
	2730	+ </summary>
	2731	+ </member>
	2732	+ <member name="T:ProtoBuf.ServiceModel.ProtoEndpointBehavior">
	2733	+ <summary>
	2734	+ Behavior to swap out DatatContractSerilaizer with the XmlProtoSerializer for a given endpoint.
	2735	+ <example>
	2736	+ Add the following to the server and client app.config in the system.serviceModel section:
	2737	+ <behaviors>
	2738	+ <endpointBehaviors>
	2739	+ <behavior name="ProtoBufBehaviorConfig">
	2740	+ <ProtoBufSerialization/>
	2741	+ </behavior>
	2742	+ </endpointBehaviors>
	2743	+ </behaviors>
	2744	+ <extensions>
	2745	+ <behaviorExtensions>
	2746	+ <add name="ProtoBufSerialization" type="ProtoBuf.ServiceModel.ProtoBehaviorExtension, protobuf-net, Version=1.0.0.255, Culture=neutral, PublicKeyToken=257b51d87d2e4d67"/>
	2747	+ </behaviorExtensions>
	2748	+ </extensions>
	2749	+
	2750	+ Configure your endpoints to have a behaviorConfiguration as follows:
	2751	+
	2752	+ <service name="TK.Framework.Samples.ServiceModel.Contract.SampleService">
	2753	+ <endpoint address="http://myhost:9003/SampleService" binding="basicHttpBinding" behaviorConfiguration="ProtoBufBehaviorConfig"
	2754	+ bindingConfiguration="basicHttpBindingConfig" name="basicHttpProtoBuf" contract="ISampleServiceContract" />
	2755	+ </service>
	2756	+ <client>
	2757	+ <endpoint address="http://myhost:9003/SampleService" binding="basicHttpBinding"
	2758	+ bindingConfiguration="basicHttpBindingConfig" contract="ISampleServiceContract"
	2759	+ name="BasicHttpProtoBufEndpoint" behaviorConfiguration="ProtoBufBehaviorConfig"/>
	2760	+ </client>
	2761	+ </example>
	2762	+ </summary>
	2763	+ </member>
	2764	+ <member name="T:ProtoBuf.ServiceModel.ProtoOperationBehavior">
	2765	+ <summary>
	2766	+ Describes a WCF operation behaviour that can perform protobuf serialization
	2767	+ </summary>
	2768	+ </member>
	2769	+ <member name="M:ProtoBuf.ServiceModel.ProtoOperationBehavior.#ctor(System.ServiceModel.Description.OperationDescription)">
	2770	+ <summary>
	2771	+ Create a new ProtoOperationBehavior instance
	2772	+ </summary>
	2773	+ </member>
	2774	+ <member name="M:ProtoBuf.ServiceModel.ProtoOperationBehavior.CreateSerializer(System.Type,System.Xml.XmlDictionaryString,System.Xml.XmlDictionaryString,System.Collections.Generic.IList{System.Type})">
	2775	+ <summary>
	2776	+ Creates a protobuf serializer if possible (falling back to the default WCF serializer)
	2777	+ </summary>
	2778	+ </member>
	2779	+ <member name="P:ProtoBuf.ServiceModel.ProtoOperationBehavior.Model">
	2780	+ <summary>
	2781	+ The type-model that should be used with this behaviour
	2782	+ </summary>
	2783	+ </member>
	2784	+ <member name="T:ProtoBuf.ServiceModel.XmlProtoSerializer">
	2785	+ <summary>
	2786	+ An xml object serializer that can embed protobuf data in a base-64 hunk (looking like a byte[])
	2787	+ </summary>
	2788	+ </member>
	2789	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.TryCreate(ProtoBuf.Meta.TypeModel,System.Type)">
	2790	+ <summary>
	2791	+ Attempt to create a new serializer for the given model and type
	2792	+ </summary>
	2793	+ <returns>A new serializer instance if the type is recognised by the model; null otherwise</returns>
	2794	+ </member>
	2795	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.#ctor(ProtoBuf.Meta.TypeModel,System.Type)">
	2796	+ <summary>
	2797	+ Creates a new serializer for the given model and type
	2798	+ </summary>
	2799	+ </member>
	2800	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.WriteEndObject(System.Xml.XmlDictionaryWriter)">
	2801	+ <summary>
	2802	+ Ends an object in the output
	2803	+ </summary>
	2804	+ </member>
	2805	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.WriteStartObject(System.Xml.XmlDictionaryWriter,System.Object)">
	2806	+ <summary>
	2807	+ Begins an object in the output
	2808	+ </summary>
	2809	+ </member>
	2810	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.WriteObjectContent(System.Xml.XmlDictionaryWriter,System.Object)">
	2811	+ <summary>
	2812	+ Writes the body of an object in the output
	2813	+ </summary>
	2814	+ </member>
	2815	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.IsStartObject(System.Xml.XmlDictionaryReader)">
	2816	+ <summary>
	2817	+ Indicates whether this is the start of an object we are prepared to handle
	2818	+ </summary>
	2819	+ </member>
	2820	+ <member name="M:ProtoBuf.ServiceModel.XmlProtoSerializer.ReadObject(System.Xml.XmlDictionaryReader,System.Boolean)">
	2821	+ <summary>
	2822	+ Reads the body of an object
	2823	+ </summary>
	2824	+ </member>
	2825	+ <member name="T:ProtoBuf.SubItemToken">
	2826	+ <summary>
	2827	+ Used to hold particulars relating to nested objects. This is opaque to the caller - simply
	2828	+ give back the token you are given at the end of an object.
	2829	+ </summary>
	2830	+ </member>
	2831	+ <member name="T:ProtoBuf.WireType">
	2832	+ <summary>
	2833	+ Indicates the encoding used to represent an individual value in a protobuf stream
	2834	+ </summary>
	2835	+ </member>
	2836	+ <member name="F:ProtoBuf.WireType.None">
	2837	+ <summary>
	2838	+ Represents an error condition
	2839	+ </summary>
	2840	+ </member>
	2841	+ <member name="F:ProtoBuf.WireType.Variant">
	2842	+ <summary>
	2843	+ Base-128 variant-length encoding
	2844	+ </summary>
	2845	+ </member>
	2846	+ <member name="F:ProtoBuf.WireType.Fixed64">
	2847	+ <summary>
	2848	+ Fixed-length 8-byte encoding
	2849	+ </summary>
	2850	+ </member>
	2851	+ <member name="F:ProtoBuf.WireType.String">
	2852	+ <summary>
	2853	+ Length-variant-prefixed encoding
	2854	+ </summary>
	2855	+ </member>
	2856	+ <member name="F:ProtoBuf.WireType.StartGroup">
	2857	+ <summary>
	2858	+ Indicates the start of a group
	2859	+ </summary>
	2860	+ </member>
	2861	+ <member name="F:ProtoBuf.WireType.EndGroup">
	2862	+ <summary>
	2863	+ Indicates the end of a group
	2864	+ </summary>
	2865	+ </member>
	2866	+ <member name="F:ProtoBuf.WireType.Fixed32">
	2867	+ <summary>
	2868	+ Fixed-length 4-byte encoding
	2869	+ </summary>10
	2870	+ </member>
	2871	+ <member name="F:ProtoBuf.WireType.SignedVariant">
	2872	+ <summary>
	2873	+ This is not a formal wire-type in the "protocol buffers" spec, but
	2874	+ denotes a variant integer that should be interpreted using
	2875	+ zig-zag semantics (so -ve numbers aren't a significant overhead)
	2876	+ </summary>
	2877	+ </member>
	2878	+ </members>
	2879	+</doc>
0	2880

...	...	@@ -1,5 +1,9 @@
1	1	git-export-daemon-ok
2	2	bin
	3	+obj
3	4	*.swp
4	5	*.csproj.user
5	6	*.userprefs
	7	+*.suo
	8	+.directory
	9	+*.psess

...	...	@@ -1,4 +1,4 @@
1		-//#define DEVELOPING
	1	+#define DEVELOPING
2	2
3	3	using System;
4	4	using System.Collections.Generic;
...	...	@@ -32,7 +32,7 @@ namespace Boggle
32	32	int minWordLength = 4;
33	33
34	34	char wordListInput = 'Z';
35		- BoggleLists listToUseForLookup;
	35	+ SupportedLists listToUseForLookup;
36	36
37	37	#if !DEVELOPING
38	38	do
...	...	@@ -56,11 +56,11 @@ namespace Boggle
56	56	switch (wordListInput)
57	57	{
58	58	case 'T':
59		- listToUseForLookup = BoggleLists.TWS;
	59	+ listToUseForLookup = SupportedLists.TWS;
60	60	break;
61	61
62	62	case 'Z':
63		- listToUseForLookup = BoggleLists.ZINGARELLI;
	63	+ listToUseForLookup = SupportedLists.ZINGARELLI;
64	64	break;
65	65	default:
66	66	throw new Exception("Unexpected!!");

...	...	@@ -1,4 +1,4 @@
1		-<?xml version="1.0" encoding="utf-8"?>
	1	+<?xml version="1.0" encoding="utf-8"?>
2	2	<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3	3	<PropertyGroup>
4	4	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
...	...	@@ -32,6 +32,9 @@
32	32	<WarningLevel>4</WarningLevel>
33	33	</PropertyGroup>
34	34	<ItemGroup>
	35	+ <Reference Include="protobuf-net">
	36	+ <HintPath>dependencies\protobuf-net.dll</HintPath>
	37	+ </Reference>
35	38	<Reference Include="System" />
36	39	<Reference Include="System.Core" />
37	40	<Reference Include="System.Xml.Linq" />
...	...	@@ -44,6 +47,7 @@
44	47	<Compile Include="Boggle.cs" />
45	48	<Compile Include="BoggleBoard.cs" />
46	49	<Compile Include="BoggleList.cs" />
	50	+ <Compile Include="SupportedLists.cs" />
47	51	<Compile Include="BoggleSolver.cs" />
48	52	<Compile Include="Constants.cs" />
49	53	<Compile Include="ListWord.cs" />

...	...	@@ -1,8 +1,9 @@
1		-
2		-Microsoft Visual Studio Solution File, Format Version 11.00
3		-# Visual Studio 2010
	1	+Microsoft Visual Studio Solution File, Format Version 12.00
	2	+# Visual Studio 2012
4	3	Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Boggle", "Boggle.csproj", "{AB752D5B-37CC-4029-8621-FA970CDD5E2A}"
5	4	EndProject
	5	+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5DA3320C-AD61-449F-B900-9F8B763B9E27}"
	6	+EndProject
6	7	Global
7	8	GlobalSection(SolutionConfigurationPlatforms) = preSolution
8	9	Debug\|x86 = Debug\|x86
...	...	@@ -14,6 +15,12 @@ Global
14	15	{AB752D5B-37CC-4029-8621-FA970CDD5E2A}.Release\|x86.ActiveCfg = Release\|x86
15	16	{AB752D5B-37CC-4029-8621-FA970CDD5E2A}.Release\|x86.Build.0 = Release\|x86
16	17	EndGlobalSection
	18	+ GlobalSection(SolutionProperties) = preSolution
	19	+ HideSolutionNode = FALSE
	20	+ EndGlobalSection
	21	+ GlobalSection(Performance) = preSolution
	22	+ HasPerformanceSessions = true
	23	+ EndGlobalSection
17	24	GlobalSection(MonoDevelopProperties) = preSolution
18	25	StartupItem = Boggle.csproj
19	26	EndGlobalSection

...	...	@@ -1,30 +1,10 @@
1	1	using System;
2	2	using System.Collections.Generic;
3	3	using System.IO;
	4	+using ProtoBuf.Serializers;
4	5
5	6	namespace Boggle
6	7	{
7		- /// <summary>
8		- /// Supported lists.
9		- /// </summary>
10		- public enum BoggleLists
11		- {
12		- /// <summary>
13		- /// Scrabble dictionary for USA, Canada and Thailand
14		- /// </summary>
15		- TWS,
16		-
17		- /// <summary>
18		- /// Scrabble dictionary used world wide except in USA, Canada and Thailand.
19		- /// </summary>
20		- //SOWPODS,
21		-
22		- /// <summary>
23		- /// A huge dictionary found on official Internet Scrabble Club's website (http://www.isc.ro/en/commands/lists.html)
24		- /// </summary>
25		- ZINGARELLI
26		- }
27		-
28	8	public class BoggleList
29	9	{
30	10	/// <summary>
...	...	@@ -42,65 +22,12 @@ namespace Boggle
42	22	/// <summary>
43	23	/// Contains a list of dictionaries that have been loaded, indexed by enum that contains dictionaries we support.
44	24	/// </summary>
45		- private Dictionary<BoggleLists, Dictionary<string, ListWord>> _LoadedDictionaries;
46		-
47		- /// <summary>
48		- /// Determines if we have an absolute path
49		- /// </summary>
50		- /// <param name="filePath">File that contains the list SORTED list of words. Path can be relative or absolute.</param>
51		- /// <returns>The absolute file path that we can use to access it.</returns>
52		- private string GetAbsoluteFilePath(string filePath)
53		- {
54		- //check if the absolute file path exists.
55		- if (!File.Exists(filePath))
56		- {
57		- //try checking if this is a relative file path and prepend current directory's path.
58		- filePath = string.Format("{0}\\{1}", Directory.GetCurrentDirectory(), filePath);
59		- if (!File.Exists(filePath))
60		- {
61		- filePath = string.Empty;
62		- }
63		- }
64		-
65		- return filePath;
66		- }
67		-
68		- /// <summary>
69		- /// Curates the list for use by this solver. Basically culls out words that do not meet the criteria.
70		- /// Criteria: Min_word_length < word_length < Max_word_length. Max_word_length = sideLength^2 + 1.
71		- /// </summary>
72		- /// <param name="filePath"> Path to file that contains the SORTED list of words.
73		- /// It can be relative to current execution directory or absolute.</param>
74		- /// <param name="boardSideLength">Length of the side of board in number of tiles.</param>
75		- /// <param name="minWordLength">Number of alphabets that can be there in the shortest word on the board.</param>
76		- private void CurateList(string filePath, int boardSideLength, int minWordLength)
77		- {
78		- //filePath = GetAbsoluteFilePath(filePath);
79		- //true tells stream reader to auto detect encoding of the file.
80		- StreamReader rawList = new StreamReader(filePath, true);
81		- //Create a new file. Do not append anything.
82		- string curatedFilePath = string.Format("{0}.{1}.{2}", filePath, Constants.CURATED_FILE_SUFFIX, minWordLength.ToString());
83		- StreamWriter curatedList = new StreamWriter(curatedFilePath, false);
84		-
85		- string word;
86		- //write out the words whose number of characters are between the shortest and largest provided length.
87		- while ((word = rawList.ReadLine()) != null)
88		- {
89		- if (word.Length >= minWordLength && word.Length <= boardSideLength * boardSideLength + 1)
90		- {
91		- curatedList.WriteLine(word);
92		- }
93		- }
94		-
95		- curatedList.Flush();
96		- curatedList.Close();
97		- rawList.Close();
98		- }
	25	+ private Dictionary<string, Dictionary<string, ListWord>> _LoadedDictionaries;
99	26
100	27	public BoggleList()
101	28	{
102	29	//Initialize the dictionary containing the lists.
103		- _LoadedDictionaries = new Dictionary<BoggleLists, Dictionary<string, ListWord>>(Enum.GetNames(typeof(BoggleLists)).Length);
	30	+ _LoadedDictionaries = new Dictionary<string, Dictionary<string, ListWord>>(Enum.GetNames(typeof(SupportedLists)).Length);
104	31	}
105	32
106	33	/// <summary>
...	...	@@ -110,26 +37,38 @@ namespace Boggle
110	37	/// <param name="boardSideLength"></param>
111	38	/// <param name="minWordLength"></param>
112	39	/// <returns>A hybird tree containing the words with each level containing one alphabet (or QU)</returns>
113		- public Dictionary<string, ListWord> LoadList(BoggleLists dict, int boardSideLength, int minWordLength, string listRootPath)
	40	+ public void LoadList(SupportedLists dict, int boardSideLength, int minWordLength, string currentWorkingDirectory)
114	41	{
115		- if (_LoadedDictionaries.ContainsKey(dict))
116		- return _LoadedDictionaries[dict];
	42	+ int maxWordLength = boardSideLength * boardSideLength + 1;
	43	+ string dictPath = this.GetSerializedDictPath(dict, minWordLength, maxWordLength, currentWorkingDirectory);
117	44
118		- string filePath = string.Empty;
	45	+ if (_LoadedDictionaries.ContainsKey(dictPath))
	46	+ {
	47	+ _WordList = _LoadedDictionaries[dictPath];
	48	+ return;
	49	+ }
119	50
120		- if (NeedsCuration(dict, minWordLength, listRootPath, ref filePath))
121		- CurateList(filePath, boardSideLength, minWordLength);
	51	+ //Load the seriazlized dictionary if it exists on the disk.
	52	+ if (SerializedDictExists(dictPath))
	53	+ {
	54	+ _LoadedDictionaries.Add(dictPath, DeserializeDict(dictPath));
	55	+ _WordList = _LoadedDictionaries[dictPath];
	56	+ return;
	57	+ }
122	58
123	59	_WordList = new Dictionary<string, ListWord>(27);
124		-
	60	+ string rawListPath = GetWordlistPath(dict);
125	61	//true tells stream reader to auto detect encoding of the file.
126		- StreamReader rawList = new StreamReader(filePath, true);
	62	+ StreamReader rawList = new StreamReader(rawListPath, true);
127	63	string word, substring;
128	64	ListWord prevListWord;
129	65	int startIndex;
130	66
131	67	while ((word = rawList.ReadLine()) != null)
132	68	{
	69	+ //no need to process the word if it cannot logically lie on the board.
	70	+ if (word.Length < minWordLength \|\| word.Length > maxWordLength)
	71	+ continue;
133	72	//First deal with the head node and then deal with following letters.
134	73	startIndex = 0;
135	74	word = word.ToUpper();
...	...	@@ -183,44 +122,63 @@ namespace Boggle
183	122	}
184	123
185	124	//Store it in the collection
186		- _LoadedDictionaries.Add(dict, _WordList);
187		- return _WordList;
	125	+ _LoadedDictionaries.Add(dictPath, _WordList);
	126	+
	127	+ //Writes the dictionary just constructed to disk
	128	+ SerializeDict(_WordList, dictPath);
188	129	}
189	130
190		- /// <summary>
191		- /// Checks to see if the proper file exists that contains the appropriate words.
192		- /// </summary>
193		- /// <param name="list">Type of list to check for.</param>
194		- /// <param name="minWordLength">Minimum number of LETTERS the word should contain. </param>
195		- /// <param name="filePath">Reference to path of file. If the list will need curation, it will store path to source list.
196		- /// If list is there, it will store the path to the curated list.</param>
197		- /// <returns>Whether there is a need to run the curation procedure or not.</returns>
198		- private bool NeedsCuration(BoggleLists list, int minWordLength, string wordlistContainer, ref string filePath)
199		- {
200		- bool needsCuration = false;
201		- switch (list)
	131	+ private string GetSerializedDictPath(SupportedLists list, int minWordLength, int maxWordLength, string currentWorkingDirectory)
202	132	{
203		- case BoggleLists.TWS:
204		- filePath = GetAbsoluteFilePath(string.Format("{0}/{1}.{2}.{3}", filePath, Constants.TWS_FILE_PATH, Constants.CURATED_FILE_SUFFIX, minWordLength.ToString()));
205		- if (filePath == string.Empty)
	133	+ string serializationFolder = string.Format("{0}/{1}", currentWorkingDirectory, Constants.SERIALIZATION_FOLDER);
	134	+ if (!Directory.Exists(serializationFolder))
206	135	{
207		- filePath = string.Format("{0}/{1}", wordlistContainer, Constants.TWS_FILE_PATH);
208		- needsCuration = true;
	136	+ Directory.CreateDirectory(serializationFolder);
	137	+ }
	138	+ string filename = string.Format("{0}/{1}.{2}.{3}.{4}", serializationFolder,
	139	+ list,
	140	+ minWordLength,
	141	+ maxWordLength,
	142	+ Constants.SERIALIZED_FILE_SUFFIX
	143	+ );
	144	+ //File creation is done by serialization function. No need to do it here. In case there is an error and we cannot
	145	+ //load the raw dictionary into our hybrid tree, we would be left with an empty and a useless file.
	146	+ return filename;
209	147	}
210		- break;
211		- case BoggleLists.ZINGARELLI:
212		- filePath = GetAbsoluteFilePath(string.Format("{0}/{1}.{2}.{3}", filePath, Constants.ZINGARELLI_FILE_PATH, Constants.CURATED_FILE_SUFFIX, minWordLength.ToString()));
213		- if (filePath == string.Empty)
	148	+
	149	+ private bool SerializedDictExists(string serializedObjPath)
214	150	{
215		- filePath = string.Format("{0}/{1}", wordlistContainer, Constants.ZINGARELLI_FILE_PATH);
216		- needsCuration = true;
	151	+ return File.Exists(serializedObjPath);
217	152	}
218		- break;
219		- default:
220		- throw new ArgumentException(string.Format("Support for {0} wordlist has not been coded yet :(", list));
	153	+
	154	+ private void SerializeDict(Dictionary<string, ListWord> funkyDict, string serializationPath)
	155	+ {
	156	+ Stream serializationFile = File.Open(serializationPath, FileMode.CreateNew, FileAccess.Write);
	157	+ ProtoBuf.Serializer.Serialize <Dictionary<string, ListWord>>(serializationFile, funkyDict);
	158	+ serializationFile.Flush();
	159	+ serializationFile.Close();
	160	+ }
	161	+
	162	+ private Dictionary<string, ListWord> DeserializeDict(string serializedObjPath)
	163	+ {
	164	+ Stream serializationFile = File.Open(serializedObjPath, FileMode.Open, FileAccess.Read);
	165	+ Dictionary<string, ListWord> funkyDict = ProtoBuf.Serializer.Deserialize<Dictionary<string, ListWord>>(serializationFile);
	166	+ serializationFile.Flush();
	167	+ serializationFile.Close();
	168	+ return funkyDict;
221	169	}
222	170
223		- return needsCuration;
	171	+ private string GetWordlistPath(SupportedLists list)
	172	+ {
	173	+ switch (list)
	174	+ {
	175	+ case SupportedLists.TWS:
	176	+ return Constants.TWS_FILE_PATH;
	177	+ case SupportedLists.ZINGARELLI:
	178	+ return Constants.ZINGARELLI_FILE_PATH;
	179	+ default:
	180	+ throw new ArgumentException(string.Format("Support for {0} wordlist has not been coded yet :(", list));;
	181	+ }
224	182	}
225	183	}
226	184	}

...	...	@@ -2,7 +2,8 @@ namespace Boggle
2	2	{
3	3	static class Constants
4	4	{
5		- public const string CURATED_FILE_SUFFIX = "curated";
	5	+ public const string SERIALIZED_FILE_SUFFIX = "bin";
	6	+ public const string SERIALIZATION_FOLDER = "serializedDictionaries";
6	7	public const int MIN_SIDE_LENGTH = 3;
7	8	public const int MIN_WORD_LENGTH = 3;
8	9	public const int MIN_SCORE = 1;

...	...	@@ -1,10 +1,15 @@
1	1	using System.Collections.Generic;
	2	+using ProtoBuf;
2	3
3	4	namespace Boggle
4	5	{
	6	+ [ProtoContract]
5	7	public class ListWord
6	8	{
	9	+ [ProtoMember(1)]
7	10	public bool IsWord;
	11	+
	12	+ [ProtoMember(2)]
8	13	public Dictionary<string, ListWord> Next;
9	14
10	15	public ListWord()

...	...	@@ -3,7 +3,9 @@ using System.Collections.Generic;
3	3	namespace Boggle
4	4	{
5	5	/// <summary>
6		- /// Equality comparer used for HashSet. No longer used as I switched to Dictionaries.
	6	+ /// Equality comparer used for HashSet. Used to compare two words in the hash set and detect collisions.
	7	+ /// This is needed because we are making HashSet with a custom type and .NET will use expensive
	8	+ /// procedure to determine a unique hash (by treating it as an Object instance) if this is not provided.
7	9	/// </summary>
8	10	public class WordComparer : EqualityComparer<WordOnBoard>
9	11	{

boggleNet