.NET හි C # වස්තුවක් JSON නූලක් බවට පත් කරන්නේ කෙසේද?

මට මේ වගේ පන්ති තියෙනවා:

class MyDate
{
    int year, month, day;
}

class Lad
{
    string firstName;
    string lastName;
    MyDate dateOfBirth;
}

Ladවස්තුවක් මේ ආකාරයට JSON නූලක් බවට පත් කිරීමට මම කැමතියි:

{
    "firstName":"Markoff",
    "lastName":"Chaney",
    "dateOfBirth":
    {
        "year":"1901",
        "month":"4",
        "day":"30"
    }
}

(හැඩතල ගැන්වීමකින් තොරව). මට මෙම සබැඳිය හමු විය , නමුත් එය .NET 4 හි නොමැති නාම අවකාශයක් භාවිතා කරයි . මම JSON.NET ගැන ද අසා ඇත්තෙමි , නමුත් ඔවුන්ගේ වෙබ් අඩවිය මේ වන විට අක්‍රිය වී ඇති බව පෙනේ, බාහිර ඩීඑල්එල් ගොනු භාවිතා කිරීමට මා උනන්දු නොවේ.

JSON සංගීත ලේඛකයෙකු අතින් නිර්මාණය කිරීම හැර වෙනත් විකල්ප තිබේද?

ඔබට JavaScriptSerializerපන්තිය භාවිතා කළ හැකිය (යොමු යොමුව එකතු කරන්න System.Web.Extensions):

using System.Web.Script.Serialization;

var json = new JavaScriptSerializer().Serialize(obj);

සම්පූර්ණ උදාහරණයක්:

using System;
using System.Web.Script.Serialization;

public class MyDate
{
    public int year;
    public int month;
    public int day;
}

public class Lad
{
    public string firstName;
    public string lastName;
    public MyDate dateOfBirth;
}

class Program
{
    static void Main()
    {
        var obj = new Lad
        {
            firstName = "Markoff",
            lastName = "Chaney",
            dateOfBirth = new MyDate
            {
                year = 1901,
                month = 4,
                day = 30
            }
        };
        var json = new JavaScriptSerializer().Serialize(obj);
        Console.WriteLine(json);
    }
}

අපි හැමෝම එක ලයිනර් වලට ආදරෙයි

... මෙය නිව්ටන්සොෆ්ට් නුජෙට් පැකේජය මත රඳා පවතී, එය ජනප්‍රිය සහ පෙරනිමි අනුක්‍රමිකකරණයට වඩා හොඳය.

Newtonsoft.Json.JsonConvert.SerializeObject(new {foo = "bar"})

ප්‍රලේඛනය: JSON අනුක්‍රමිකකරණය සහ ඩෙසියරලයිසින් කිරීම

Json.Net පුස්තකාලය භාවිතා කරන්න , ඔබට එය Nuget Packet Manager වෙතින් බාගත හැකිය.

Json String වෙත අනුක්‍රමික කිරීම:

 var obj = new Lad
        {
            firstName = "Markoff",
            lastName = "Chaney",
            dateOfBirth = new MyDate
            {
                year = 1901,
                month = 4,
                day = 30
            }
        };

var jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(obj);

වස්තුවට ආශා කිරීම:

var obj = Newtonsoft.Json.JsonConvert.DeserializeObject<Lad>(jsonString );

DataContractJsonSerializerපන්තිය භාවිතා කරන්න : MSDN1 , MSDN2 .

මගේ උදාහරණය: මෙතැන .

එය මෙන් නොව, JSON නූලකින් වස්තූන් ආරක්ෂිතව අවතක්සේරු කළ හැකිය JavaScriptSerializer. නමුත් පෞද්ගලිකව මම තවමත් Json.NET වලට කැමතියි .

Newtonsoft.json භාවිතා කිරීමෙන් ඔබට මෙය සාක්ෂාත් කරගත හැකිය. NuGet වෙතින් Newtonsoft.json ස්ථාපනය කරන්න. ඊළගට:

using Newtonsoft.Json;

var jsonString = JsonConvert.SerializeObject(obj);

වෝ! JSON රාමුවක් භාවිතා කිරීම වඩා හොඳය :)

Json.NET ( http://james.newtonking.com/json ) භාවිතා කරමින් මගේ උදාහරණය මෙන්න :

using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json;
using System.IO;

namespace com.blogspot.jeanjmichel.jsontest.model
{
    public class Contact
    {
        private Int64 id;
        private String name;
        List<Address> addresses;

        public Int64 Id
        {
            set { this.id = value; }
            get { return this.id; }
        }

        public String Name
        {
            set { this.name = value; }
            get { return this.name; }
        }

        public List<Address> Addresses
        {
            set { this.addresses = value; }
            get { return this.addresses; }
        }

        public String ToJSONRepresentation()
        {
            StringBuilder sb = new StringBuilder();
            JsonWriter jw = new JsonTextWriter(new StringWriter(sb));

            jw.Formatting = Formatting.Indented;
            jw.WriteStartObject();
            jw.WritePropertyName("id");
            jw.WriteValue(this.Id);
            jw.WritePropertyName("name");
            jw.WriteValue(this.Name);

            jw.WritePropertyName("addresses");
            jw.WriteStartArray();

            int i;
            i = 0;

            for (i = 0; i < addresses.Count; i++)
            {
                jw.WriteStartObject();
                jw.WritePropertyName("id");
                jw.WriteValue(addresses[i].Id);
                jw.WritePropertyName("streetAddress");
                jw.WriteValue(addresses[i].StreetAddress);
                jw.WritePropertyName("complement");
                jw.WriteValue(addresses[i].Complement);
                jw.WritePropertyName("city");
                jw.WriteValue(addresses[i].City);
                jw.WritePropertyName("province");
                jw.WriteValue(addresses[i].Province);
                jw.WritePropertyName("country");
                jw.WriteValue(addresses[i].Country);
                jw.WritePropertyName("postalCode");
                jw.WriteValue(addresses[i].PostalCode);
                jw.WriteEndObject();
            }

            jw.WriteEndArray();

            jw.WriteEndObject();

            return sb.ToString();
        }

        public Contact()
        {
        }

        public Contact(Int64 id, String personName, List<Address> addresses)
        {
            this.id = id;
            this.name = personName;
            this.addresses = addresses;
        }

        public Contact(String JSONRepresentation)
        {
            //To do
        }
    }
}

පරීක්ෂණය:

using System;
using System.Collections.Generic;
using com.blogspot.jeanjmichel.jsontest.model;

namespace com.blogspot.jeanjmichel.jsontest.main
{
    public class Program
    {
        static void Main(string[] args)
        {
            List<Address> addresses = new List<Address>();
            addresses.Add(new Address(1, "Rua Dr. Fernandes Coelho, 85", "15º andar", "São Paulo", "São Paulo", "Brazil", "05423040"));
            addresses.Add(new Address(2, "Avenida Senador Teotônio Vilela, 241", null, "São Paulo", "São Paulo", "Brazil", null));

            Contact contact = new Contact(1, "Ayrton Senna", addresses);

            Console.WriteLine(contact.ToJSONRepresentation());
            Console.ReadKey();
        }
    }
}

ප්රතිඵලය:

{
  "id": 1,
  "name": "Ayrton Senna",
  "addresses": [
    {
      "id": 1,
      "streetAddress": "Rua Dr. Fernandes Coelho, 85",
      "complement": "15º andar",
      "city": "São Paulo",
      "province": "São Paulo",
      "country": "Brazil",
      "postalCode": "05423040"
    },
    {
      "id": 2,
      "streetAddress": "Avenida Senador Teotônio Vilela, 241",
      "complement": null,
      "city": "São Paulo",
      "province": "São Paulo",
      "country": "Brazil",
      "postalCode": null
    }
  ]
}

දැන් මම JSON නූලක් ලබාගෙන පන්තියේ ක්ෂේත්‍ර ජනනය කරන ඉදිකිරීම් ක්‍රමය ක්‍රියාත්මක කරමි.

System.Text.Jsonනාම අවකාශයේ නව JSON අනුක්‍රමිකයක් ලබා ගත හැකිය . එය .NET Core 3.0 හවුල් රාමුවට ඇතුළත් කර ඇති අතර .NET Standard හෝ .NET Framework හෝ .NET Core 2.x ඉලක්ක කරගත් ව්‍යාපෘති සඳහා NuGet පැකේජයක ඇත.

උදාහරණ කේතය:

using System;
using System.Text.Json;

public class MyDate
{
    public int year { get; set; }
    public int month { get; set; }
    public int day { get; set; }
}

public class Lad
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public MyDate DateOfBirth { get; set; }
}

class Program
{
    static void Main()
    {
        var lad = new Lad
        {
            FirstName = "Markoff",
            LastName = "Chaney",
            DateOfBirth = new MyDate
            {
                year = 1901,
                month = 4,
                day = 30
            }
        };
        var json = JsonSerializer.Serialize(lad);
        Console.WriteLine(json);
    }
}

මෙම උදාහරණයේ දී අනුක්‍රමික කළ යුතු පන්තිවලට ක්ෂේත්‍රවලට වඩා ගුණ ඇත; මෙම System.Text.Jsonserializer දැනට ක්ෂේත්ර serialize නැත.

ප්‍රලේඛනය:

• System.Text.Json දළ විශ්ලේෂණය
• System.Text.Json භාවිතා කරන්නේ කෙසේද

ඒවා ඉතා විශාල නොවේ නම්, බොහෝ විට ඔබේ නඩුව එය JSON ලෙස අපනයනය කරයි.

එසේම මෙය සියලු වේදිකා අතර අතේ ගෙන යා හැකිය.

using Newtonsoft.Json;

[TestMethod]
public void ExportJson()
{
    double[,] b = new double[,]
        {
            { 110,  120,  130,  140, 150 },
            {1110, 1120, 1130, 1140, 1150},
            {1000,    1,   5,     9, 1000},
            {1110,    2,   6,    10, 1110},
            {1220,    3,   7,    11, 1220},
            {1330,    4,   8,    12, 1330}
        };

    string jsonStr = JsonConvert.SerializeObject(b);

    Console.WriteLine(jsonStr);

    string path = "X:\\Programming\\workspaceEclipse\\PyTutorials\\src\\tensorflow_tutorials\\export.txt";

    File.WriteAllText(path, jsonStr);
}

ඔබ ASP.NET MVC වෙබ් පාලකයක සිටී නම් එය එතරම්ම සරල ය:

string ladAsJson = Json(Lad);

කිසිවෙකු මේ ගැන සඳහන් කර ඇතැයි විශ්වාස කළ නොහැක.

මම සර්විස්ටැක් හි JSON Serializer සඳහා ඡන්දය දෙන්නෙමි:

using ServiceStack;

string jsonString = new { FirstName = "James" }.ToJson();

.NET සඳහා ලබා ගත හැකි වේගවත්ම JSON අනුක්‍රමිකකරණය ද එයයි: http://www.servicestack.net/benchmarks/

C # පන්තියක් ජනනය කිරීම සඳහා මෙම මෙවලම් භාවිතා කරන්න , ඉන්පසු ඔබේ වස්තුව අනුක්‍රමික කිරීමට මෙම කේතය භාවිතා කරන්න:

 var json = new JavaScriptSerializer().Serialize(obj);

එය මේ තරම් පහසු ය (එය ගතික වස්තු සඳහා ද ක්‍රියා කරයි (වස්තුව ටයිප් කරන්න)):

string json = new
System.Web.Script.Serialization.JavaScriptSerializer().Serialize(MYOBJECT);

XML JSON බවට පරිවර්තනය කිරීම සඳහා පහත කේතය භාවිතා කරන්න.

var json = new JavaScriptSerializer().Serialize(obj);

අනුක්‍රමික

 public static void WriteToJsonFile<T>(string filePath, T objectToWrite, bool append = false) where T : new()
{
        var contentsToWriteToFile = JsonConvert.SerializeObject(objectToWrite, new JsonSerializerSettings
        {
            Formatting = Formatting.Indented,
        });
        using (var writer = new StreamWriter(filePath, append))
        {
            writer.Write(contentsToWriteToFile);
        }
}

වස්තුව

namespace MyConfig
{
    public class AppConfigurationSettings
    {
        public AppConfigurationSettings()
        {
            /* initialize the object if you want to output a new document
             * for use as a template or default settings possibly when 
             * an app is started.
             */
            if (AppSettings == null) { AppSettings=new AppSettings();}
        }

        public AppSettings AppSettings { get; set; }
    }

    public class AppSettings
    {
        public bool DebugMode { get; set; } = false;
    }
}

ක්‍රියාත්මක කිරීම

var jsonObject = new AppConfigurationSettings();
WriteToJsonFile<AppConfigurationSettings>(file.FullName, jsonObject);

ප්‍රතිදානය

{
  "AppSettings": {
    "DebugMode": false
  }
}