C# Dictionary.ToJson方法代码示例

        public override HttpRequest Build(string path)
        {
            var request = base.Build(path);
            request.Method = HttpMethod.POST;
            request.Headers.Accept = "application/json-rpc, application/json";
            request.Headers.ContentType = "application/json-rpc";

            var message = new Dictionary<string, object>();
            message["jsonrpc"] = "2.0";
            message["method"] = Method;
            message["params"] = Parameters;
            message["id"] = CreateNextId();

            request.Body = message.ToJson();

            return request;
        }

        public static void Test_Serialize_Dictionary_02(DictionaryRepresentation dictionaryRepresentation)
        {
            // json Dictionary
            // DictionaryRepresentation.Dynamic or DictionaryRepresentation.Document
            // { "toto1" : "tata1", "toto2" : "tata2" }
            // DictionaryRepresentation.ArrayOfArrays
            // [["toto1", "tata1"], ["toto2", "tata2"]]
            // DictionaryRepresentation.ArrayOfDocuments
            // [{ "k" : "toto1", "v" : "tata1" }, { "k" : "toto2", "v" : "tata2" }]
            Trace.WriteLine();
            Trace.WriteLine("Test_Serialize_Dictionary_02");
            Dictionary<string, string> dictionary = new Dictionary<string, string>();
            dictionary.Add("toto1", "tata1");
            dictionary.Add("toto2", "tata2");
            //DictionaryRepresentation dictionaryRepresentation = DictionaryRepresentation.ArrayOfDocuments;
            Trace.WriteLine("DictionaryRepresentation : {0}", dictionaryRepresentation);
            Trace.WriteLine("Dictionary json :");
            string json = dictionary.ToJson(new DictionarySerializationOptions(dictionaryRepresentation));
            Trace.WriteLine(json);

            Trace.WriteLine("Deserialize json :");
            Dictionary<string, string> dictionary2 = BsonSerializer.Deserialize<Dictionary<string, string>>(json);
            string json2 = dictionary2.ToJson(new DictionarySerializationOptions(dictionaryRepresentation));
            Trace.WriteLine(json2);
            Trace.WriteLine("comparison of Dictionary json and Deserialize json : {0}", json == json2 ? "identical" : "different");
        }

 public void BroadcastExpireCache(string cacheName, string key, string itemKey)
 {
     var args = new Dictionary<string, object>() { { "clientId", ClientId }, { "cacheName", cacheName }, { "key", key }, { "itemKey", itemKey } };
     var subscriber = _multiplexer.GetSubscriber();
     subscriber.Publish("RedisNotifier.expireItemCache", args.ToJson());
     log(Logging.LoggingLevel.Detailed, "Broadcasting ExpireCache: {0}:{1}", key, itemKey);
 }

 public void BroadcastMessage(string message)
 {
     var args = new Dictionary<string, object>() { { "clientId", ClientId }, { "message", message } };
     var subscriber = _multiplexer.GetSubscriber();
     subscriber.Publish("RedisNotifier.serverMessage", args.ToJson());
     log(Logging.LoggingLevel.Detailed, "Broadcasting Message: " + message);
 }

        /// <summary>
        /// Returns the environment data as json.
        /// </summary>
        /// <returns>a JSON formatted string</returns>
        public static string GetEnvDataAsJson( System.Web.HttpRequest request, string rockUrl )
        {
            var envData = new Dictionary<string, string>();
            envData.Add( "AppRoot", rockUrl );
            envData.Add( "Architecture", ( IntPtr.Size == 4 ) ? "32bit" : "64bit" );
            envData.Add( "AspNetVersion", Environment.Version.ToString() );
            envData.Add( "IisVersion", request.ServerVariables["SERVER_SOFTWARE"] );
            envData.Add( "ServerOs", Environment.OSVersion.ToString() );

            try { envData.Add( "SqlVersion", Rock.Data.DbService.ExecuteScaler( "SELECT SERVERPROPERTY('productversion')" ).ToString() ); }
            catch {}

            try
            {
                using ( var rockContext = new RockContext() )
                {
                    var entityType = EntityTypeCache.Read( "Rock.Security.BackgroundCheck.ProtectMyMinistry", false, rockContext );
                    if ( entityType != null )
                    {
                        var pmmUserName = new AttributeValueService( rockContext )
                            .Queryable().AsNoTracking()
                            .Where( v =>
                                v.Attribute.EntityTypeId.HasValue &&
                                v.Attribute.EntityTypeId.Value == entityType.Id &&
                                v.Attribute.Key == "UserName" )
                            .Select( v => v.Value )
                            .FirstOrDefault();
                        if ( !string.IsNullOrWhiteSpace( pmmUserName ) )
                        {
                            envData.Add( "PMMUserName", pmmUserName );
                        }
                    }
                }
            }
            catch { }

            return envData.ToJson();
        }

        public void SendLetter(UpdateLetter updateLetter)
        {
            var letter = updateLetter.CreateLetter();
            letter.ReplyTime = SqlDateTime.MinValue.Value;
            using (var content = new DefaultContext())
            {
                content.Letters.Add(letter);
                content.SaveChanges();
            }
            var dic = new Dictionary<string, string>();
            dic.Add("ActionName", "Reply");
            dic.Add("letter", letter.ToJson());

            var resString = HttpWebResponseUtility.CreatePostHttpResponse("http://second.eagle.com/api/Message", dic.ToJson(), 30000);
            if (string.IsNullOrEmpty(resString) || resString == "0")
            {
                Flag = false;
                Message = "消息无响应";
                return;
            }
            var result = resString.ToDeserialize<Cells>();
            if (!result.Flag)
            {
                Flag = false;
                Message = result.Message;
                return;
            }
            Flag = true;
        }

        protected virtual void SendCancelResult()
        {
            var dictionary = new Dictionary<string, object>();
            dictionary[Constants.CancelledKey] = true;
            if (!string.IsNullOrEmpty(this.CallbackID))
            {
                dictionary[Constants.CallbackIdKey] = this.CallbackID;
            }

            this.Callback(new ResultContainer(dictionary.ToJson()));
        }

 public static void Test_Serialize_Dictionary_01()
 {
     // json Dictionary
     // { "toto1" : "tata1", "toto2" : "tata2" }
     Trace.WriteLine();
     Trace.WriteLine("Test_Serialize_Dictionary_01");
     Dictionary<string, string> dictionary = new Dictionary<string, string>();
     dictionary.Add("toto1", "tata1");
     dictionary.Add("toto2", "tata2");
     Trace.WriteLine("Dictionary json :");
     string json = dictionary.ToJson();
     Trace.WriteLine(json);
 }

        public static void RegisterControlPresenter(this HtmlHelper helper, Models.IClientControl model, string clientType, string instanceName, Dictionary<string, object> properties = null)
        {
            properties = properties == null ? new Dictionary<string, object>() : properties;
            RegisterCoreScripts(helper);

            if (!string.IsNullOrEmpty(model.ScriptPath))
                HtmlExtensions.RegisterScript(helper, model.ScriptPath + clientType + ".js", true);

            properties["id"] = model.ClientId;  //todo: not necessary now... same as ns?
            properties["ns"] = model.ClientId;

            //Properties["user"] = Services.Account.GetClientUser();
            //var ser = new System.Web.Script.Serialization.JavaScriptSerializer();   //no binders for date conversions...
            HtmlExtensions.RegisterDocumentReadyScript(helper, model.ClientId + "Presenter", string.Format("videre.widgets.register('{0}', {1}, {2});", model.ClientId, clientType, properties.ToJson(ignoreType: "client")));
        }

        public void ToJsonTest()
        {
            Dictionary<string, object> data = new Dictionary<string, object>();
            data.Add("Name", "11");
            data.Add("Teacher", new { Name = "theacher", Couse = "English" });
            data.Add("Family", new Dictionary<string, object>()
                                    {
                                        {"facther",new {Name="john",Birthday=new DateTime(1979,1,1)}},
                                        {"mother",new {Name="Hellen",Birthday=new DateTime(1979,1,1)}},
                                    });
            var expect = "{\"Name\":\"11\",\"Teacher\":{\"Name\":\"theacher\",\"Couse\":\"English\"},\"Family\":{\"facther\":{\"Name\":\"john\",\"Birthday\":\"\\/Date(283968000000)\\/\"},\"mother\":{\"Name\":\"Hellen\",\"Birthday\":\"\\/Date(283968000000)\\/\"}}}";

            var target = data.ToJson(false);
            Assert.AreEqual(expect, target);
        }

        internal static JsonObject Generate(IEnumerable<FieldInput> fields)
        {
            var jsonObject = new JsonObject();
            var list = new Dictionary<string, object>();

            if (fields != null)
            {
                foreach (var f in fields.Where(f => f.Value != null))
                {
                    list.Add(f.Id, ComplexIssueInputFieldValueJsonGenerator.GenerateFieldValueForJson(f.Value));
                }
            }

            jsonObject.Add("fields", list.ToJson());
            return jsonObject;
        }

        public XDocument Call(string url, HttpMethod method, Dictionary<string, object> data, bool requiresAuthentication)
        {
            if (requiresAuthentication && (string.IsNullOrEmpty(this.publicKey) || string.IsNullOrEmpty(this.privateKey)))
            {
                throw new MyGengoException("This API requires authentication. Both a public and private key must be specified.");
            }

            var parameters = new Dictionary<string, string>();
                        parameters.Add("api_key", this.publicKey);

                        if (requiresAuthentication)
                        {
                            parameters.Add("ts", DateTime.UtcNow.SecondsSinceEpoch().ToString());
                            parameters.Add("api_sig", Sign(parameters["ts"]));
                        }

                        if (data != null)
                        {
                            parameters.Add("data", data.ToJson());
                        }

            string queryString = MakeQueryString(parameters);
            string xml = SendRequest(method, url, queryString);

            XDocument doc;
            try
            {
                doc = XDocument.Parse(xml);
            }
            catch (Exception x)
            {
                var mgx = new MyGengoException("The response returned by myGengo is not valid XML", x);
                mgx.Data.Add("url", url);
                mgx.Data.Add("response", xml);
                throw mgx;
            }

            if (doc.Root.Element("opstat").Value == "error")
            {
                XElement error = doc.Root.Element("err");
                throw new MyGengoException(string.Format("{0} (error code {1})", error.Element("msg").Value, error.Element("code").Value));
            }

            return doc;
        }

        internal void IncrementVotableVersion()
        {

            foreach (var subscriber in subscribedUsers)
            {
                var votablePropsDict = new Dictionary<string, dynamic>() { 
                    { "Id", Id }, 
                    { "PositiveVotesCount", PositiveVotesCount }, 
                    { "NegativeVotesCount", NegativeVotesCount }
                };
                var opDict = new Dictionary<string, object>() { { "operation", 'u' }, { "entity", votablePropsDict } };

                var socket = subscriber.Value.connection;
                var serialized = opDict.ToJson();
                socket.Send(serialized);

            }
        }

 public void Work(string sqlText)
 {
     var restPace = new RestPace();
     restPace.ID = Guid.NewGuid();
     restPace.SqlCommand = sqlText;
     restPace.SendTime = DateTime.Now;
     restPace.ReceiveTime = SqlDateTime.MinValue.Value;
     restPace.RestaurantId = RestaurantId;
     restPace.ReceiptText = new List<List<string>>().ToJson();
     using (var restContext = new DefaultContext())
     {
         restContext.RestPaces.Add(restPace);
         restContext.SaveChanges();
     }
     var dic = new Dictionary<string, string>();
     dic.Add("messageID", restPace.ID.ToString());
     dic.Add("text", sqlText);
     PushCommandToRest(dic.ToJson());
 }

 /// <summary>
 /// Executes the scripted event.
 /// </summary>
 /// <param name="eventType">Type of the event.</param>
 /// <param name="taskId">The task id.</param>
 /// <param name="name">The name.</param>
 /// <param name="sourceCode">The source code.</param>
 /// <param name="language">The language.</param>
 /// <param name="sender">The sender.</param>
 /// <param name="scriptArguments">The <see cref="System.EventArgs"/> instance containing the event data.</param>
 /// <param name="preview">if set to <c>true</c> [preview].</param>
 /// <returns></returns>
 public static Dictionary<string, object> ExecuteScriptedEvent(string eventType, Guid taskId, string name, string sourceCode, string language, object sender, EventArgs scriptArguments, bool preview)
 {
     ("EVENT " + eventType + " > delegate " + name + "(" + taskId.ToString() + ")").Debug(10);
     Dictionary<string, object> j = new Dictionary<string, object>();
     string consoleOutput = "";
     string errorNumber = "";
     string errorJSON = "";
     DateTime startDate = DateTime.Now;
     List<object> errors = new List<object>();
     object[] args = { sender, scriptArguments };
     object obj = Admin.ExecuteScript(sourceCode, language, "script", "main", ref args, ref errors);
     if(errors.Count == 0) {
         if(consoleOutput.Length > 0) {
             if(obj.GetType() == typeof(string)) {
                 consoleOutput = (string)obj;
             }
             Dictionary<string, object> err = new Dictionary<string, object>();
             err.Add("errorNumber", 0);
             err.Add("errorText", "EVENT " + eventType + " > delegate " + name + " completed without error.");
             (" --------------------------------------------------").Debug(6);
             (" |		MESSAGE FROM " + name).Debug(6);
             (" --------------------------------------------------").Debug(6);
             (consoleOutput).Debug(6);/*MESSAGE!*/
             (" --------------------------------------------------").Debug(6);
             err.Add("line", 0);
             errorNumber = "0";
             errorJSON = err.ToJson();
             err["errorText"].Debug(6);
         }
     } else {
         errorJSON = errors.ToJson();
         errorNumber = (string)((Dictionary<string, object>)(errors[0]))["errorNumber"].ToString();
         errorJSON.Debug(6);
     }
     if(!preview) {
         updateEventTaskStatus(taskId, startDate, false, DateTime.Now, errorNumber, errorJSON);
     }
     j.Add("error", errorNumber);
     j.Add("errors", errors);
     j.Add("console", consoleOutput);
     return j;
 }