C# JsonWriter.WriteObjectStart方法代码示例

        public static void ToNetMsg(Dictionary<long, F3_NetServerInfo> servers, ref NetOutgoingMessage netMsg)
        {
            netMsg.Write((byte)NetDataType.eDATA_REQUEST_SERVER_LIST);

            StringBuilder sb = new StringBuilder();
            JsonWriter writer = new JsonWriter(sb);

            writer.WriteObjectStart();
            writer.WritePropertyName("servers");
            writer.WriteArrayStart();

            for (int i = 0; i < servers.Count; i++)
            {
                F3_NetServerInfo info = servers.ElementAt(i).Value;
                writer.WriteObjectStart();

                writer.WritePropertyName("UUID");
                writer.Write(servers.ElementAt(i).Key);

                writer.WritePropertyName("serverName");
                writer.Write(info.m_serverName);

                writer.WritePropertyName("type");
                writer.Write((int)info.m_serverType);

                writer.WritePropertyName("internal_ip");
                writer.Write(info.m_serverInternalAdress.Address.ToString());

                writer.WritePropertyName("internal_port");
                writer.Write(info.m_serverInternalAdress.Port);

                writer.WritePropertyName("external_ip");
                writer.Write(info.m_serverExternalAdress.Address.ToString());

                writer.WritePropertyName("external_port");
                writer.Write(info.m_serverExternalAdress.Port);

                writer.WritePropertyName("maxPlayers");
                writer.Write(info.m_maxPlayers);

                writer.WritePropertyName("currentPlayers");
                writer.Write(info.m_currentNbPlayers);

                writer.WritePropertyName("token");
                writer.Write(info.m_NATtoken);

                writer.WriteObjectEnd();
            }

            writer.WriteArrayEnd();
            writer.WriteObjectEnd();

            netMsg.Write(sb.ToString());
        }

        public static void LitJsonWriterObjects ()
        {
            for (int j = 0; j < Common.Iterations; j++) {
                StringBuilder output = new StringBuilder ();
                JsonWriter writer = new JsonWriter (new StringWriter (output));

                int n = Common.SampleObject.Length;
                for (int i = 0; i < n; i += 2) {
                    switch ((char) Common.SampleObject[i]) {
                    case '{':
                        writer.WriteObjectStart ();
                        break;

                    case '}':
                        writer.WriteObjectEnd ();
                        break;

                    case '[':
                        writer.WriteArrayStart ();
                        break;

                    case ']':
                        writer.WriteArrayEnd ();
                        break;

                    case 'P':
                        writer.WritePropertyName (
                            (string) Common.SampleObject[i + 1]);
                        break;

                    case 'I':
                        writer.Write (
                            (int) Common.SampleObject[i + 1]);
                        break;

                    case 'D':
                        writer.Write (
                            (double) Common.SampleObject[i + 1]);
                        break;

                    case 'S':
                        writer.Write (
                            (string) Common.SampleObject[i + 1]);
                        break;

                    case 'B':
                        writer.Write (
                            (bool) Common.SampleObject[i + 1]);
                        break;

                    case 'N':
                        writer.Write (null);
                        break;
                    }
                }

            }
        }

        public void ErrorObjectClosingTest()
        {
            JsonWriter writer = new JsonWriter ();

            writer.WriteObjectStart ();
            writer.WritePropertyName ("foo");
            writer.Write ("bar");
            writer.WriteArrayEnd ();
        }

 public static string generateReadParamJson()
 {
     System.Text.StringBuilder sb = new System.Text.StringBuilder();
     JsonWriter writer = new JsonWriter(sb);
     writer.WriteObjectStart();
     writer.WritePropertyName("action");
     writer.Write("get");
     writer.WritePropertyName("id");
     writer.Write("SC9008637");
     writer.WritePropertyName("page");
     writer.Write("channel_param");
     writer.WriteObjectEnd();
     return sb.ToString();
 }

 public string ListStepDefinitionsAsJson()
 {
     StringBuilder sb = new StringBuilder();
     JsonWriter writer = new JsonWriter(sb);
     writer.WriteArrayStart();
     foreach (StepDefinition sd in _stepDefinitions)
     {
         writer.WriteObjectStart();
         writer.WritePropertyName("id");
         writer.Write(sd.Id);
         writer.WritePropertyName("regexp");
         writer.Write(sd.Pattern);
         writer.WriteObjectEnd();
     }
     writer.WriteArrayEnd();
     return sb.ToString();
 }

        public void ObjectTest()
        {
            JsonWriter writer = new JsonWriter ();

            string json = "{\"flavour\":\"strawberry\",\"color\":\"red\"," +
                "\"amount\":3}";

            writer.WriteObjectStart ();
            writer.WritePropertyName ("flavour");
            writer.Write ("strawberry");
            writer.WritePropertyName ("color");
            writer.Write ("red");
            writer.WritePropertyName ("amount");
            writer.Write (3);
            writer.WriteObjectEnd ();

            Assert.AreEqual (writer.ToString (), json);
        }

        public void NestedObjectsTest()
        {
            JsonWriter writer = new JsonWriter ();

            string json = "{\"book\":{\"title\":" +
                "\"Structure and Interpretation of Computer Programs\"," +
                "\"details\":{\"pages\":657}}}";

            writer.WriteObjectStart ();
            writer.WritePropertyName ("book");
            writer.WriteObjectStart ();
            writer.WritePropertyName ("title");
            writer.Write (
                "Structure and Interpretation of Computer Programs");
            writer.WritePropertyName ("details");
            writer.WriteObjectStart ();
            writer.WritePropertyName ("pages");
            writer.Write (657);
            writer.WriteObjectEnd ();
            writer.WriteObjectEnd ();
            writer.WriteObjectEnd ();

            Assert.AreEqual (writer.ToString (), json);
        }

        private object ReadValue(JsonReader reader, out Type type)
        {
            if (reader.Token == JsonToken.Boolean) {
                type = typeof (bool);
                return (bool) reader.Value;
            }
            if (reader.Token == JsonToken.Int) {
                type = typeof (int);
                return (int) reader.Value;
            }
            if (reader.Token == JsonToken.Long) {
                type = typeof (long);
                return (long) reader.Value;
            }
            if (reader.Token == JsonToken.Double) {
                type = typeof (double);
                return (double) reader.Value;
            }
            if (reader.Token == JsonToken.String) {
                type = typeof (string);
                return reader.Value;
            }
            if (reader.Token == JsonToken.Null) {
                //TODO: should we use a different type in this case? eg. DBNull
                type = typeof (object);
                return null;
            }

            if (reader.Token == JsonToken.ArrayStart)
                return ReadArray(reader, out type);

            if (reader.Token == JsonToken.ObjectStart) {
                StringBuilder sb = new StringBuilder();
                JsonWriter jsonWriter = new JsonWriter(sb);
                jsonWriter.WriteObjectStart();

                IJsonRpcTypeResolver resolver;
                ReadInto(reader, jsonWriter, true, out type, out resolver);

                jsonWriter.TextWriter.Flush();

                if (resolver == null)
                    throw new FormatException();

                JsonReader jsonReader = new JsonReader(sb.ToString());
                return resolver.ReadValue(jsonReader, type);
            }

            throw new FormatException();
        }

        public static string JMap(Map m)
        {
            LitJson.JsonWriter js = new LitJson.JsonWriter();
            js.PrettyPrint = true;
            js.IndentValue = 2;
            js.WriteObjectStart();
            js.WritePropertyName("min");
            js.WriteObjectStart();
            js.WritePropertyName("x");
            js.Write(m.min.x);
            js.WritePropertyName("y");
            js.Write(m.min.y);
            js.WriteObjectEnd();
            js.WritePropertyName("max");
            js.WriteObjectStart();
            js.WritePropertyName("x");
            js.Write(m.max.x);
            js.WritePropertyName("y");
            js.Write(m.max.y);
            js.WriteObjectEnd();
            js.WritePropertyName("tiles");
            js.WriteArrayStart();
            List<Map.Tile> tiles = m.GetTiles();
            foreach(Map.Tile t in tiles) {
                js.WriteObjectStart();
                // Key
                js.WritePropertyName("key");
                js.WriteObjectStart();
                js.WritePropertyName("x");
                js.Write(t.hexCoord.x);
                js.WritePropertyName("y");
                js.Write (t.hexCoord.y);
                js.WriteObjectEnd();
                //End of Key
                // Value
                js.WritePropertyName("value");
                js.WriteObjectStart();
                js.WritePropertyName("tileType");
                js.Write(t.spriteType.ToString());
                js.WritePropertyName("penalty");
                js.Write(t.penalty.ToString());
                js.WritePropertyName("visibility");
                js.Write(t.visibility.ToString());
                js.WriteObjectEnd();
                // End of Value
                js.WriteObjectEnd();
            }
            js.WriteArrayEnd();
            js.WritePropertyName("towns");
            js.WriteArrayStart();
            List<Map.Town> towns = m.GetTowns();
            foreach (Map.Town t in towns) {
                js.WriteObjectStart();
                // Key
                js.WritePropertyName("key");
                js.WriteObjectStart();
                js.WritePropertyName("x");
                js.Write(t.hexCoord.x);
                js.WritePropertyName("y");
                js.Write (t.hexCoord.y);
                js.WriteObjectEnd();
                // End of Key
                // Value
                js.WritePropertyName("value");
                js.WriteObjectStart();
                js.WritePropertyName("playerSide");
                js.Write(t.team);
                js.WriteObjectEnd();
                // End of Value
                js.WriteObjectEnd();
            }
            js.WriteArrayEnd();

            // TODO Units

            js.WriteObjectEnd();
            return js.ToString();
        }

    public static string GetSchedule(IDbConnection db)
    {
        TimeSpan t = DateTime.UtcNow - new DateTime(1970, 1, 1);
        long today = (long)t.TotalSeconds;
        StringBuilder sb = new StringBuilder();
        LitJson.JsonWriter writer = new LitJson.JsonWriter(sb);
        writer.WriteObjectStart();
        writer.WritePropertyName("bookings");
        writer.WriteArrayStart();
        using (IDbCommand command = db.CreateCommand())
        {
            command.CommandText = "select id, day, [from], till,  _user, _meetingroom, users_notified, users_to_be_notified, users_checkedin from booking where day>= @Day order by day, [from]";
            IDbDataParameter p = command.CreateParameter();
            p.ParameterName = "@Day";
            p.Value = today;
            command.Parameters.Add(p);
            using (IDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    new MeetingRoomBooking(reader).Write(writer);
                }
            }
        }
        writer.WriteArrayEnd();

        writer.WritePropertyName("rooms");
        writer.WriteObjectStart();
        List<MeetingRoom> MeetingRooms = new List<MeetingRoom>();
        MeetingRooms = MeetingRoom.List(db);
        foreach (MeetingRoom meetingRoom in MeetingRooms)
        {
            writer.WritePropertyName(meetingRoom.Id.ToString());
            meetingRoom.Write(writer);
        }
        writer.WriteObjectEnd();
        writer.WritePropertyName("users");
        writer.WriteObjectStart();
        List<User> Users = new List<User>();
        Users = User.list(db);
        foreach (User user in Users)
        {
            writer.WritePropertyName(user.Email);
            user.Write(writer);
        }
        writer.WriteObjectEnd();
        writer.WriteObjectEnd();
        return sb.ToString();
    }

 public void WriteResponse(string id, Response resp, Exception error, StreamWriter sw)
 {
     JsonWriter writer = new JsonWriter(sw);
     writer.WriteObjectStart();
     writer.WritePropertyName("id");
     writer.Write(id);
     if (error == null)
     {
         writer.WritePropertyName("error");
         writer.Write(null);
         writer.WritePropertyName("result");
         if (resp == null)
             writer.Write(null);
         else
             resp.Write(writer, false);
     }
     else
     {
         writer.WritePropertyName("result");
         writer.Write(null);
         writer.WritePropertyName("error");
         writer.Write(string.Format("{0}\n{1}", error.Message, error.StackTrace.ToString()));
     }
     writer.WriteObjectEnd();
 }

        public void ErrorPropertyExpectedTest()
        {
            JsonWriter writer = new JsonWriter ();

            writer.WriteObjectStart ();
            writer.Write (10);
            writer.WriteObjectEnd ();
        }

        private void Serialize(Message message, JsonWriter writer, bool inStream)
        {
            if (!inStream) {
                writer.WriteObjectStart();
                writer.WritePropertyName("jsonrpc");
                writer.Write("1.0");
            }

            if (message.Attributes.Contains("id")) {
                writer.WritePropertyName("id");
                // TODO: we presume is a number castable to int4 ...
                writer.Write((int)message.Attributes["id"]);
            }

            if (message is MessageStream) {
                writer.WritePropertyName("stream");
                writer.WriteArrayStart();
                foreach (Message m in ((MessageStream)message)) {
                    Serialize(m, writer, true);
                }
                writer.WriteArrayEnd();
            } else if (message.MessageType == MessageType.Request) {
                writer.WritePropertyName("method");
                writer.Write(message.Name);
                writer.WritePropertyName("params");
                writer.WriteArrayStart();
                foreach (MessageArgument argument in message.Arguments) {
                    WriteValue(argument, writer);
                }
                writer.WriteArrayEnd();
            } else {
                writer.WritePropertyName("result");
                IList<MessageArgument> args = message.Arguments;
                if (args.Count == 0) {
                    writer.Write(null);
                } else if (args.Count == 1) {
                    if (message.HasError) {
                        writer.Write(null);
                        writer.WritePropertyName("error");
                        writer.WriteObjectStart();
                        writer.WritePropertyName("message");
                        writer.Write(message.ErrorMessage);
                        writer.WritePropertyName("source");
                        writer.Write(message.Error.Source);
                        writer.WritePropertyName("stackTrace");
                        //TODO: does the string needs to be normalized?
                        writer.Write(message.ErrorStackTrace);
                        writer.WriteObjectEnd();
                    } else {
                        WriteValue(args[0], writer);
                        writer.WritePropertyName("error");
                        writer.Write(null);
                    }
                } else {
                    // here we are sure we don't have an error, so skip
                    // any check about it
                    writer.WriteArrayStart();
                    foreach (MessageArgument argument in message.Arguments) {
                        WriteValue(argument, writer);
                    }
                    writer.WriteArrayEnd();
                }
            }

            if (!inStream)
                writer.WriteObjectEnd();
        }

        public void UpdateIssue(IssueUpdate update, NetworkCredential credential,
            Action<string> stdout, Action<string> stderr)
        {
            var client = new WebClient();
            client.Headers.Add("Content-Type", "application/json");
            client.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(credential.UserName + ":" + credential.Password)));

            var jsonRPCQuery = new JsonWriter();
            jsonRPCQuery.WriteObjectStart();
            jsonRPCQuery.WritePropertyName("method");
            jsonRPCQuery.Write("ticket.update");
            jsonRPCQuery.WritePropertyName("params");
            jsonRPCQuery.WriteArrayStart();
            jsonRPCQuery.Write(update.Issue.Id);
            jsonRPCQuery.Write(update.Comment);
            jsonRPCQuery.WriteObjectStart();
            jsonRPCQuery.WritePropertyName("action");
            jsonRPCQuery.Write("resolve");
            jsonRPCQuery.WritePropertyName("action_resolve_resolve_resolution");
            jsonRPCQuery.Write("fixed");
            jsonRPCQuery.WriteObjectEnd();
            jsonRPCQuery.Write(true);
            jsonRPCQuery.WriteArrayEnd();
            jsonRPCQuery.WriteObjectEnd();

            client.UploadString(this.RPCUrl(), jsonRPCQuery.ToString());
        }

        public void PrettyPrintTest()
        {
            JsonWriter writer = new JsonWriter ();

            string json = @"
            [
            {
            ""precision"" : ""zip"",
            ""Latitude""  : 37.7668,
            ""Longitude"" : -122.3959,
            ""City""      : ""SAN FRANCISCO""
            },
              {
            ""precision"" : ""zip"",
            ""Latitude""  : 37.371991,
            ""Longitude"" : -122.02602,
            ""City""      : ""SUNNYVALE""
              }
            ]";

            writer.PrettyPrint = true;

            writer.WriteArrayStart ();
            writer.WriteObjectStart ();
            writer.WritePropertyName ("precision");
            writer.Write ("zip");
            writer.WritePropertyName ("Latitude");
            writer.Write (37.7668);
            writer.WritePropertyName ("Longitude");
            writer.Write (-122.3959);
            writer.WritePropertyName ("City");
            writer.Write ("SAN FRANCISCO");
            writer.WriteObjectEnd ();

            writer.IndentValue = 2;

            writer.WriteObjectStart ();
            writer.WritePropertyName ("precision");
            writer.Write ("zip");
            writer.WritePropertyName ("Latitude");
            writer.Write (37.371991);
            writer.WritePropertyName ("Longitude");
            writer.Write (-122.02602);
            writer.WritePropertyName ("City");
            writer.Write ("SUNNYVALE");
            writer.WriteObjectEnd ();
            writer.WriteArrayEnd ();

            Assert.AreEqual (writer.ToString (), json);
        }