public void Example()
        {
            #region Usage
            // person.json, has a relative external schema reference 'address.json'
            // --------
            // {
            //   'type': 'object',
            //   'properties': {
            //     'name': {'type':'string'},
            //     'addresses': {
            //       'type': 'array',
            //       'items': {'$ref': 'address.json'}
            //     }
            //   }
            // }
            // --------

            using (StreamReader file = File.OpenText(@"c:\person.json"))
            using (JsonTextReader reader = new JsonTextReader(file))
            {
                JSchemaUrlResolver resolver = new JSchemaUrlResolver();

                JSchema schema = JSchema.Load(reader, new JSchemaReaderSettings
                {
                    Resolver = resolver,
                    // where the schema is being loaded from
                    // referenced 'address.json' schema will be loaded from disk at 'c:\address.json'
                    BaseUri = new Uri(@"c:\person.json")
                });

                // validate JSON
            }
            #endregion
        }

    public void ReadFrom()
    {
      JObject o = (JObject)JToken.ReadFrom(new JsonTextReader(new StringReader("{'pie':true}")));
      Assert.AreEqual(true, (bool)o["pie"]);

      JArray a = (JArray)JToken.ReadFrom(new JsonTextReader(new StringReader("[1,2,3]")));
      Assert.AreEqual(1, (int)a[0]);
      Assert.AreEqual(2, (int)a[1]);
      Assert.AreEqual(3, (int)a[2]);

      JsonReader reader = new JsonTextReader(new StringReader("{'pie':true}"));
      reader.Read();
      reader.Read();

      JProperty p = (JProperty)JToken.ReadFrom(reader);
      Assert.AreEqual("pie", p.Name);
      Assert.AreEqual(true, (bool)p.Value);

      JConstructor c = (JConstructor)JToken.ReadFrom(new JsonTextReader(new StringReader("new Date(1)")));
      Assert.AreEqual("Date", c.Name);
      Assert.IsTrue(JToken.DeepEquals(new JValue(1), c.Values().ElementAt(0)));

      JValue v;

      v = (JValue)JToken.ReadFrom(new JsonTextReader(new StringReader(@"""stringvalue""")));
      Assert.AreEqual("stringvalue", (string)v);

      v = (JValue)JToken.ReadFrom(new JsonTextReader(new StringReader(@"1")));
      Assert.AreEqual(1, (int)v);

      v = (JValue)JToken.ReadFrom(new JsonTextReader(new StringReader(@"1.1")));
      Assert.AreEqual(1.1, (double)v);
    }

        public void Example()
        {
            #region Usage
            string json = @"{ 'name': 'Admin' }{ 'name': 'Publisher' }";

            IList<Role> roles = new List<Role>();

            JsonTextReader reader = new JsonTextReader(new StringReader(json));
            reader.SupportMultipleContent = true;

            while (true)
            {
                if (!reader.Read())
                    break;

                JsonSerializer serializer = new JsonSerializer();
                Role role = serializer.Deserialize<Role>(reader);

                roles.Add(role);
            }

            foreach (Role role in roles)
            {
                Console.WriteLine(role.Name);
            }

            // Admin
            // Publisher
            #endregion

            Assert.AreEqual(2, roles.Count);
            Assert.AreEqual("Admin", roles[0].Name);
            Assert.AreEqual("Publisher", roles[1].Name);
        }

        public static void ReadLargeJson()
        {
            using (var jsonFile = System.IO.File.OpenText("large.json"))
            using (JsonTextReader jsonTextReader = new JsonTextReader(jsonFile))
            {
                JsonSerializer serializer = new JsonSerializer();
                serializer.Deserialize<IList<PerformanceTests.RootObject>>(jsonTextReader);
            }

            Console.WriteLine("Press any key to start deserialization");
            Console.ReadKey();
            Console.WriteLine("Deserializing...");

            Stopwatch sw = new Stopwatch();
            sw.Start();

            for (int i = 0; i < 5; i++)
            {
                using (var jsonFile = System.IO.File.OpenText("large.json"))
                using (JsonTextReader jsonTextReader = new JsonTextReader(jsonFile))
                {
                    JsonSerializer serializer = new JsonSerializer();
                    serializer.Deserialize<IList<PerformanceTests.RootObject>>(jsonTextReader);
                }
            }

            sw.Stop();

            Console.WriteLine("Finished. Total seconds: " + sw.Elapsed.TotalSeconds);
        }

 private static void AssertImport(object expected, string input)
 {
     JsonTextReader reader = new JsonTextReader(new StringReader(input));
     Type expectedType = expected.GetType();
     object o = JsonImporterStock.Get(expectedType).Import(reader);
     Assert.IsInstanceOfType(expectedType, o);
     Assert.AreEqual(expected, o);
 }

    public void CheckInnerReader()
    {
      string json = "{'name':'James','hobbies':['pie','cake']}";
      JsonReader reader = new JsonTextReader(new StringReader(json));

      JsonValidatingReader validatingReader = new JsonValidatingReader(reader);
      Assert.AreEqual(reader, validatingReader.Reader);
    }

 private static void AssertImport(object expected, string input)
 {
     JsonTextReader reader = new JsonTextReader(new StringReader(input));
     Type expectedType = expected.GetType();
     ImportContext context = new ImportContext();
     object o = context.Import(expectedType, reader);
     Assert.IsInstanceOfType(expectedType, o);
     Assert.AreEqual(expected, o);
 }

        public void Load()
        {
            JsonReader reader = new JsonTextReader(new StringReader("new Date(123)"));
            reader.Read();

            JConstructor constructor = JConstructor.Load(reader);
            Assert.AreEqual("Date", constructor.Name);
            Assert.IsTrue(JToken.DeepEquals(new JValue(123), constructor.Values().ElementAt(0)));
        }

        private void ReaderValidation()
        {
            JsonTextReader reader = new JsonTextReader(new StringReader(Json));
            JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
            validatingReader.Schema = Schema;

            while (validatingReader.Read())
            {
            }
        }

 private static void AssertImport(object expected, string input)
 {
     JsonTextReader reader = new JsonTextReader(new StringReader(input));
     GuidImporter importer = new GuidImporter();
     object o = importer.Import(new ImportContext(), reader);
     Assert.IsTrue(reader.EOF, "Reader must be at EOF.");
     if (expected != null)
         Assert.IsInstanceOfType(typeof(Guid), o);
     Assert.AreEqual(expected, o);
 }

    public void Example()
    {
      JObject o1 = JObject.Parse(File.ReadAllText(@"c:\videogames.json"));

      // read JSON directly from a file
      using (StreamReader file = File.OpenText(@"c:\videogames.json"))
      using (JsonTextReader reader = new JsonTextReader(file))
      {
        JObject o2 = (JObject) JToken.ReadFrom(reader);
      }
    }

        public void CanReadComma()
        {
            // arrange
            var reader = new JsonTextReader(new StringReader(","));

            // act
            var token = reader.NextToken();

            // assert
            Assert.Equal(JsonToken.Comma, token);
        }

        public void CanReadDecimal()
        {
            // arrange
            var reader = new JsonTextReader(new StringReader("123.456"));

            // act
            var token = reader.NextToken();

            // assert
            Assert.Equal(new JsonToken(JsonTokenKind.Fractional, "123.456"), token);
        }

        public void CanReadBooleanTrue()
        {
            // arrange
            var reader = new JsonTextReader(new StringReader("true"));

            // act
            var token = reader.NextToken();

            // assert
            Assert.Equal(JsonToken.True, token);
        }

        public void ReadDollarQuoteStringWithTag()
        {
            string json = @"{""NameOfStore"":$tag$Forest's Bakery And Cafe$tag$}";

            JsonTextReader jsonTextReader = new JsonTextReader(new StringReader(json));
            jsonTextReader.Read();
            jsonTextReader.Read();
            jsonTextReader.Read();

            Assert.AreEqual(@"Forest's Bakery And Cafe", jsonTextReader.Value);
        }

    public void Example()
    {
      // read file into a string and parse JsonSchema from the string
      JsonSchema schema1 = JsonSchema.Parse(File.ReadAllText(@"c:\schema.json"));

      // read JsonSchema directly from a file
      using (StreamReader file = File.OpenText(@"c:\schema.json"))
      using (JsonTextReader reader = new JsonTextReader(file))
      {
        JsonSchema schema2 = JsonSchema.Read(reader);
      }
    }

        public void LoadFile()
        {
#region LoadFile
            using (StreamReader file = File.OpenText(@"c:\person.json"))
            using (JsonTextReader reader = new JsonTextReader(file))
            {
                JSchema schema = JSchema.Load(reader);

                // validate JSON
            }
            #endregion
        }

        private JSchemaValidatingReader CreateReader(string json, JSchema schema, out IList<SchemaValidationEventArgs> errors)
        {
            JsonReader reader = new JsonTextReader(new StringReader(json));

            List<SchemaValidationEventArgs> localErrors = new List<SchemaValidationEventArgs>();

            JSchemaValidatingReader validatingReader = new JSchemaValidatingReader(reader);
            validatingReader.ValidationEventHandler += (sender, args) => { localErrors.Add(args); };
            validatingReader.Schema = schema;

            errors = localErrors;
            return validatingReader;
        }

        public void Example()
        {
            #region Usage
            // read file into a string and parse JSchema from the string
            JSchema schema1 = JSchema.Parse(File.ReadAllText(@"c:\schema.json"));

            // load JSchema directly from a file
            using (StreamReader file = File.OpenText(@"c:\schema.json"))
            using (JsonTextReader reader = new JsonTextReader(file))
            {
                JSchema schema2 = JSchema.Load(reader);
            }
            #endregion
        }

        private void ParseRequest(string request)
        {
            using (var stringReader = new StringReader(request))
            using (var reader = new JsonTextReader(stringReader))
            {
                reader.DateParseHandling = DateParseHandling.None;

                // Messages parsed as a dictionary with the following
                // parameters:
                //
                //   'r': Request type: 0, 1 or 2
                //   'a': Association ID when the request type is 1 or 2
                //   't': Message type
                //   'p': Payload

                if (!reader.Read())
                    throw new HttpException("Invalid request");

                if (reader.TokenType == JsonToken.StartObject)
                {
                    ProcessMessageRequest(reader);
                }
                else if (reader.TokenType == JsonToken.StartArray)
                {
                    ReadToken(reader, JsonToken.String);

                    string action = (string)reader.Value;

                    ReadToken(reader, JsonToken.EndArray);

                    switch (action)
                    {
                        case "close":
                            _client.Dispose();
                            break;

                        default:
                            throw new HttpException("Invalid request");
                    }
                }
                else
                {
                    throw new HttpException("Invalid request");
                }

                if (reader.Read())
                    throw new HttpException("Invalid request");

            }
        }