.Net - Utilisez DataContractJsonSerializer pour les opérations de sérialisation et de désérialisation de base

Dans la vie quotidienne, nous utilisons souvent le processus de sérialisation d'un objet de type T en Json, puis de renvoi des données liées à la page. Dans chaque entretien, on me demande probablement comment sérialiser ? La réponse est toujours encapsulée au niveau du bas, oublions ça, faisons une simple châtaigne pour s'amuser, de manière à boucher la bouche de l'intervieweur.

Lors de la sérialisation et de la désérialisation, l'objet DataContractJsonSerializer est principalement utilisé, puis combiné avec MemoryStream, c'est ok.

Sans plus attendre, commençons par une version simple des châtaignes génériques. Après cela, nous améliorerons progressivement :

  public static class JsonConvert
    {
        /// <summary>
        /// Converts the obj to json.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t">The t.</param>
        /// <returns>System.String.</returns>
        /// <remarks>Editor：v-liuhch CreateTime：2015/6/21 21:40:55</remarks>
        public static string ConvertObjToJson<T>(T t)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(t.GetType());

            try 
	        {	        
		    using (MemoryStream ms=new MemoryStream())
                    {
                        ser.WriteObject(ms,t);
                        string strJson=Encoding.UTF8.GetString(ms.ToArray());
                        return strJson;
                     }

	        }
	        catch (IOException)
	        {
                     //自己处理异常吧
		        return null;
	        }
            
        
        }

        /// <summary>
        /// Jsons the deserialize.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strJson">The STR json.</param>
        /// <returns>``0.</returns>
        /// <remarks>Editor：v-liuhch CreateTime：2015/6/21 21:46:37</remarks>
        public static T JsonDeserialize<T>(string strJson)
            where T:class //约束T为class,也可以放宽类型，这里只是个例子，写着玩儿的，欧巴们，此处可改
        {

            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));

            try
            {
                using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(strJson)))
                {
                    T obj = ser.ReadObject(ms) as T;
                    return obj;
                }
            }
            catch (IOException e)
            {
                //自己处理异常吧
                return null;
            }
           
        }
    }

<. 🎜>Ensuite on écrit une classe pour tester :

//[Serializable]
   public  class Student
    {
       public string StudentId { get; set; }
       public string Name { get; set; }
       public int age { get; set; }
       public string Address { get; set; }
    }

Code du test :

  protected void Page_Load(object sender, EventArgs e)
        {
            Student student = new Student()
            {

                StudentId = "110",
                Name = "水田如雅",
                age = 20,
                Address = "北京朝阳区"
            };

            #region 序列化测试
                string strStudentJson = JsonConvert.ConvertObjToJson<Student>(student);
                Response.Write(strStudentJson);
                
            #endregion

            #region 反序列化测试
                //{"Address":"北京朝阳区","Name":"水田如雅","StudentId":"110","age":20}
                string strJson = "{\"Address\":\"北京朝阳区\",\"Name\":\"水田如雅\",\"StudentId\":\"110\",\"age\":20}";
                Student newStudent = JsonConvert.JsonDeserialize<Student>(strJson);

        Response.Write(@"<br/><br/>" + newStudent.Address + "<br/>" + newStudent.Name + "<br/>" + newStudent.StudentId + "<br/>" + newStudent.age.ToString());



            #endregion

        }

Regardez les résultats :

Je ne sais pas si vous ne l'avez pas remarqué, mais autrefois, tous les objets que l'on pouvait sérialiser devait être marqué avec [Sérialisable]. C'est une fonctionnalité, mais je l'ai vérifiée dans la classe d'étudiant, pourquoi en écrire une vous-même et l'exécuter pour voir ce qui se passe. La raison n'est pas expliquée. Les enfants paresseux peuvent attendre que l'affiche soit de meilleure humeur et mettre à jour le blog ! De plus, dans cet exemple, seuls les types simples sont sérialisés, et les situations complexes ne sont pas prises en compte.

Ce qui précède est le contenu de .Net - utilisant DataContractJsonSerializer pour les opérations de sérialisation et de désérialisation de base. Pour plus de contenu connexe, veuillez faire attention au PHP. Site chinois (www.php.cn) !