从 JSON 文件在 C# 中创建一个类

Question

我对 C# 很陌生，虽然我在几年前曾涉足 VB。

我创建了一个带有多行文本框的基本 Windows 窗体，并将文本文件的内容写入文本框：

public Form1()
    {
        InitializeComponent();

        List<string> lines = File.ReadAllLines(@"X:\Log Files\01.log").ToList();

        lines.ForEach(l => {

            textBox1.AppendText(l);
            textBox1.AppendText(Environment.NewLine);
                    });

    }

我这样做是为了看到我实际上正在读取文件的内容。我知道……你们都对这种惊人的技巧印象深刻。

所以，下面是文本文件中的一些行：

{ "timestamp":"2020-01-03T00:20:22Z", "event":"Rank", "Rank1":3, "Rank2":8 }
{ "timestamp":"2020-01-03T00:20:22Z", "event":"Progress", "Task1":56, "Task2":100 }
{ "timestamp":"2020-01-03T00:20:22Z", "event":"Reputation", "Nation":75.000000, "State":75.000000 }
{ "timestamp":"2020-01-03T00:20:27Z", "event":"Music", "MusicTrack":"NoTrack" }

我想根据事件类型创建对象。比如：

   public Progress(int time, int t1, int t2)
   {
        this.timestamp = time;  //'time' is the timestamp value from the line
        this.task1 = t1;        //'t1' is the Task1 value from the line
        this.task2 = t2;        //'t2' is the Task2 value from the line
   }

读取文件时，它会使用event 字段并使用它来确定要实例化的类。将保留该行的 timestamp，然后将每个事件的字段填充为类的属性。

我已将Newtonsoft.Json 安装到 Visual Studio 中，并且我认为它本身就具备执行此操作的能力。

但是，我在文档中看不到如何执行此操作。

谁能指点我正确的方向？

谢谢！！

Answer 1

此代码适用于我的机器。您需要为 .log 文件中的所有附加事件添加事件子类（派生自 BaseEvent 的事件子类，即 RankEvent），并为这些添加属性到 JsonEvent 类，并向EventType 并更新 switch statement。

我是怎么做到的：

1. 我从您的 .log 文件中复制了每一行
2. 即{ "timestamp":"2020-01-03T00:20:22Z", "event":"Rank", "Rank1":3, "Rank2":8 }
3. 我转到 here 并将该行粘贴到左侧窗口中以获取 C# 类，然后我从所有行中创建了一个组合 JsonEvent 类。
4. 我制作了primitive typesnullable，因为在每次解析循环之后，一些属性将为空
5. 我创建了一个基类BaseEvent 具有公共属性（在本例中为Timestamp）
6. 我为每个事件创建了BaseEvent 的子类，即RankEvent
7. 我创建了一个事件枚举 EventType 来解析 "event" 属性。
8. 我遍历了所有行，对于每一行，我将行反序列化为 JsonEvent C# 类 (jsonEvent) 并查看 EventType 以了解我应该创建哪个子类。
9. 对于每个循环，我将一个子类 (newEvent) 解析/反序列化为 List<BaseEvent> eventList 的列表
10. 循环完成后，eventList 变量被填充并准备好在程序的其余部分中使用。

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;

namespace StackOverFlow
{
    public class Program
    {
        static void Main(string[] args)
        {
            var file = @"X:\Log Files\01.log";
            var eventList = ParseEvents(file);
            //TODO Do something
        }

        private static List<BaseEvent> ParseEvents(string file)
        {
            //TODO Encapsulate in a try & catch and add a logger for error handling
            var eventList = new List<BaseEvent>();
            var lines = File.ReadAllLines(file).ToList();
            foreach (var line in lines)
            {
                var jsonEvent = JsonConvert.DeserializeObject<JsonEvent>(line);
                BaseEvent newEvent;
                switch (jsonEvent.EventType)
                {
                    case EventType.Rank:
                        newEvent = new RankEvent(jsonEvent);
                        eventList.Add(newEvent);
                        break;
                    case EventType.Progress:
                        newEvent = new ProgressEvent(jsonEvent);
                        eventList.Add(newEvent);
                        break;
                    case EventType.Reputation:
                        newEvent = new ReputationEvent(jsonEvent);
                        eventList.Add(newEvent);
                        break;
                    case EventType.Music:
                        newEvent = new MusicEvent(jsonEvent);
                        eventList.Add(newEvent);
                        break;

                    //TODO Add more cases for each EventType

                    default:
                        throw new Exception(String.Format("Unknown EventType: {0}", jsonEvent.EventType));
                }
            }

            return eventList;
        }
    }

    //TODO Move classes/enums to a separate folder

    [JsonConverter(typeof(StringEnumConverter))]
    public enum EventType
    {
        [EnumMember(Value = "Rank")]
        Rank,
        [EnumMember(Value = "Progress")]
        Progress,
        [EnumMember(Value = "Reputation")]
        Reputation,
        [EnumMember(Value = "Music")]
        Music,

        //TODO Add more enum values for each "event"
    }

    public abstract class BaseEvent
    {
        public BaseEvent(DateTime timestamp)
        {
            Timestamp = timestamp;
        }
        public DateTime Timestamp { get; set; }
    }

    public class RankEvent : BaseEvent
    {
        public RankEvent(JsonEvent jsonEvent) : base(jsonEvent.Timestamp)
        {
            Rank1 = jsonEvent.Rank1.Value;
            Rank2 = jsonEvent.Rank2.Value;
        }
        public int Rank1 { get; set; }
        public int Rank2 { get; set; }
    }

    public class ProgressEvent : BaseEvent
    {
        public ProgressEvent(JsonEvent jsonEvent) : base(jsonEvent.Timestamp)
        {
            Task1 = jsonEvent.Task1.Value;
            Task2 = jsonEvent.Task2.Value;
        }
        public int Task1 { get; set; }
        public int Task2 { get; set; }
    }

    public class ReputationEvent : BaseEvent
    {
        public ReputationEvent(JsonEvent jsonEvent) : base(jsonEvent.Timestamp)
        {
            Nation = jsonEvent.Nation.Value;
            State = jsonEvent.State.Value;
        }
        public double Nation { get; set; }
        public double State { get; set; }
    }

    public class MusicEvent : BaseEvent
    {
        public MusicEvent(JsonEvent jsonEvent) : base(jsonEvent.Timestamp)
        {
            MusicTrack = jsonEvent.MusicTrack;
        }
        public string MusicTrack { get; set; }
    }

    //TODO Add more derived sub classes of the BaseEvent

    [JsonObject]
    public class JsonEvent
    {
        [JsonProperty("timestamp")]
        public DateTime Timestamp { get; set; }
        [JsonProperty("event")]
        public EventType EventType { get; set; }
        public int? Rank1 { get; set; }
        public int? Rank2 { get; set; }
        public int? Task1 { get; set; }
        public int? Task2 { get; set; }
        public double? Nation { get; set; }
        public double? State { get; set; }
        public string MusicTrack { get; set; }

        //TODO Add more properties
    }
}

eventList快看：

补充阅读：

将 Json 解析为 C#

How can I parse JSON with C#?

https://www.jerriepelser.com/blog/deserialize-different-json-object-same-class/

在 Visual Studio 中调试

（总是用 F9 在一行上设置断点，然后按 F5 并用 F10/F11 单步执行您的代码，它可以深入了解代码的行为方式）

https://docs.microsoft.com/en-us/visualstudio/debugger/navigating-through-code-with-the-debugger?view=vs-2019

从 Json 创建 C# 类的工具：

https://app.quicktype.io/#l=cs&r=json2csharp

https://marketplace.visualstudio.com/items?itemName=DangKhuong.JSONtoC

---

更新： 我制作了一个额外的脚本，为您创建上述 C# 子类：

只要运行这个脚本，所有的类（包括Program.cs）都会被创建。

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

namespace CreateFiles
{
    public class Program
    {
        static void Main(string[] args)
        {
            var file = @"X:\Log Files\01.log";
            var desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            //Change outPutPath to your choosing
            var outPutPath = Path.Combine(desktop, "Temp");
            //Change namespaceName to your choosing
            var namespaceName = "StackOverFlow";
            var uniqueList = GetUniqueEventTypeList(file);
            CreateBaseClass(outPutPath, namespaceName);
            CreateEventClasses(uniqueList, outPutPath, namespaceName);
            CreateEnumClass(uniqueList, outPutPath, namespaceName);
            CreateJsonEventClass(uniqueList, outPutPath, namespaceName);
            CreateProgramClass(uniqueList, outPutPath, namespaceName);
            Console.WriteLine($"\nParsing done! Classes parsed to {outPutPath}");
            Console.WriteLine("Press any key to continue.");
            Console.ReadLine();
        }

        private static List<string> GetUniqueEventTypeList(string file)
        {
            var lines = File.ReadAllLines(file).ToList();
            var uniqueEventTypes = new List<string>();
            var uniqueList = new List<string>();

            foreach (var line in lines)
            {
                var json = JObject.Parse(line);
                var eventType = json["event"].Value<string>();
                if (!uniqueEventTypes.Exists(e => e.Equals(eventType)))
                {
                    uniqueEventTypes.Add(eventType);
                    uniqueList.Add(line);
                }
            }
            return uniqueList;
        }

        private static void CreateEventClasses(List<string> lines, string path, string namespaceName)
        {
            foreach (var line in lines)
            {
                var jObj = JObject.Parse(line);
                CreateEventClass(jObj, path, namespaceName);
            }
        }

        public class ParseClass
        {
            public ParseClass(KeyValuePair<string, JToken> obj)
            {
                Name = obj.Key;
                SetType(obj.Value);
            }
            public string Name { get; set; }
            public string Type { get; set; }
            public bool IsPrimitive { get; set; }

            private void SetType(JToken token)
            {
                switch (token.Type)
                {
                    case JTokenType.Integer:
                        Type = "int";
                        IsPrimitive = true;
                        break;
                    case JTokenType.Float:
                        Type = "double";
                        IsPrimitive = true;
                        break;
                    case JTokenType.String:
                        Type = "string";
                        IsPrimitive = false;
                        break;
                    case JTokenType.Boolean:
                        Type = "bool";
                        IsPrimitive = true;
                        break;
                    case JTokenType.Date:
                        Type = "DateTime";
                        IsPrimitive = true;
                        break;
                    case JTokenType.Guid:
                        Type = "Guid";
                        IsPrimitive = true;
                        break;
                    case JTokenType.Uri:
                        Type = "Uri";
                        IsPrimitive = false;
                        break;
                    default:
                        throw new Exception($"Unknown type {token.Type}");
                }
            }
        }

        private static void CreateProgramClass(List<string> lines, string path, string namespaceName)
        {
            Directory.CreateDirectory(path);
            var className = "Program";
            var fileName = $"{className}.cs";
            var file = Path.Combine(path, fileName);

            try
            {
                // Create a new file     
                using (FileStream fsStream = new FileStream(file, FileMode.Create))
                using (StreamWriter sw = new StreamWriter(fsStream, Encoding.UTF8))
                {
                    //The Program class needed these bytes in the beginning to work
                    sw.WriteLine("using Newtonsoft.Json;");
                    sw.WriteLine("using System;");
                    sw.WriteLine("using System.Collections.Generic;");
                    sw.WriteLine("using System.IO;");
                    sw.WriteLine("using System.Linq;");
                    sw.WriteLine("");
                    sw.WriteLine($"namespace {namespaceName}");
                    sw.WriteLine("{");
                    sw.WriteLine($"    public class {className}");
                    sw.WriteLine("    {");
                    sw.WriteLine($"        static void Main(string[] args)");
                    sw.WriteLine("        {");
                    sw.WriteLine("            var file = @\"X:\\Log Files\\01.log\";");
                    sw.WriteLine("            var eventList = ParseEvents(file);");
                    sw.WriteLine("            //TODO Do something");
                    sw.WriteLine("        }");
                    sw.WriteLine("");
                    sw.WriteLine("        private static List<BaseEvent> ParseEvents(string file)");
                    sw.WriteLine("        {");
                    sw.WriteLine("            //TODO Encapsulate in a try & catch and add a logger for error handling");
                    sw.WriteLine("            var eventList = new List<BaseEvent>();");
                    sw.WriteLine("            var lines = File.ReadAllLines(file).ToList();");
                    sw.WriteLine("");
                    sw.WriteLine("            foreach (var line in lines)");
                    sw.WriteLine("            {");
                    sw.WriteLine("                var jsonEvent = JsonConvert.DeserializeObject<JsonEvent>(line);");
                    sw.WriteLine("                BaseEvent newEvent;");
                    sw.WriteLine("                switch (jsonEvent.EventType)");
                    sw.WriteLine("                {");
                    foreach (var line in lines)
                    {
                        var jObj = JObject.Parse(line);
                        var eventType = jObj["event"].Value<string>();
                        sw.WriteLine($"                    case EventType.{eventType}:");
                        sw.WriteLine($"                        newEvent = new {eventType}Event(jsonEvent);");
                        sw.WriteLine($"                        eventList.Add(newEvent);");
                        sw.WriteLine($"                        break;");
                    }
                    sw.WriteLine("                    default:");
                    sw.WriteLine("                        throw new Exception(String.Format(\"Unknown EventType: {0} \", jsonEvent.EventType));");
                    sw.WriteLine("                }");
                    sw.WriteLine("            }");
                    sw.WriteLine("            return eventList;");
                    sw.WriteLine("        }");
                    sw.WriteLine("    }");
                    sw.WriteLine("}");
                }
                Console.WriteLine($"Created {fileName}.");
            }
            catch (Exception Ex)
            {
                Console.WriteLine(Ex.ToString());
            }
        }

        private static void CreateEnumClass(List<string> lines, string path, string namespaceName)
        {
            Directory.CreateDirectory(Path.Combine(path));
            var className = "EventType";
            var fileName = $"{className}.cs";
            var file = Path.Combine(path, fileName);
            FileInfo fi = new FileInfo(file);

            try
            {
                // Check if file already exists. If yes, throw exception.     
                if (fi.Exists)
                {
                    throw new Exception($"{file} already exists!");
                }

                // Create a new file     
                using (FileStream fsStream = new FileStream(file, FileMode.Create))
                using (StreamWriter sw = new StreamWriter(fsStream, Encoding.UTF8))
                {
                    sw.WriteLine("using Newtonsoft.Json;");
                    sw.WriteLine("using Newtonsoft.Json.Converters;");
                    sw.WriteLine("using System.Runtime.Serialization;");
                    sw.WriteLine("");
                    sw.WriteLine($"namespace {namespaceName}");
                    sw.WriteLine("{");
                    sw.WriteLine($"    [JsonConverter(typeof(StringEnumConverter))]");
                    sw.WriteLine($"    public enum {className}");
                    sw.WriteLine("    {");
                    foreach (var line in lines)
                    {
                        var jObj = JObject.Parse(line);
                        var eventType = jObj["event"].Value<string>();
                        sw.WriteLine($"        [EnumMember(Value = \"{eventType}\")]");
                        sw.WriteLine($"        {eventType},");
                    }
                    sw.WriteLine("    }");
                    sw.WriteLine("}");
                }
                Console.WriteLine($"Created {fileName}.");
            }
            catch (Exception Ex)
            {
                Console.WriteLine(Ex.ToString());
            }
        }

        private static void CreateJsonEventClass(List<string> lines, string path, string namespaceName)
        {

            Directory.CreateDirectory(path);
            var className = "JsonEvent";
            var fileName = $"{className}.cs";
            var file = Path.Combine(path, fileName);
            FileInfo fi = new FileInfo(file);

            var propertyList = new List<ParseClass>();
            foreach (var line in lines)
            {
                var jObject = JObject.Parse(line);
                foreach (var obj in jObject)
                {
                    if (!(obj.Key.Equals("event") || obj.Key.Equals("timestamp")))
                    {
                        propertyList.Add(new ParseClass(obj));
                    }
                }
            }

            try
            {
                // Check if file already exists. If yes, throw exception.     
                if (fi.Exists)
                {
                    throw new Exception($"{file} already exists!");
                }
                // Create a new file     
                using (FileStream fsStream = new FileStream(file, FileMode.Create))
                using (StreamWriter sw = new StreamWriter(fsStream, Encoding.UTF8))
                {
                    sw.WriteLine("using Newtonsoft.Json;");
                    sw.WriteLine("using System;");
                    sw.WriteLine("");
                    sw.WriteLine($"namespace {namespaceName}");
                    sw.WriteLine("{");
                    sw.WriteLine($"    [JsonObject]");
                    sw.WriteLine($"    public class {className}");
                    sw.WriteLine("{");
                    sw.WriteLine("        [JsonProperty(\"timestamp\")]");
                    sw.WriteLine("        public DateTime Timestamp { get; set; }");
                    sw.WriteLine("        [JsonProperty(\"event\")]");
                    sw.WriteLine("        public EventType EventType { get; set; }");
                    foreach (var property in propertyList)
                    {
                        var type = property.IsPrimitive ? property.Type + "?" : property.Type;
                        sw.WriteLine("        public " + type + " " + property.Name + " { get; set; }");
                    }
                    sw.WriteLine("    }");
                    sw.WriteLine("}");
                }
                Console.WriteLine($"Created {fileName}.");
            }
            catch (Exception Ex)
            {
                Console.WriteLine(Ex.ToString());
            }
        }

        private static void CreateBaseClass(string path, string namespaceName)
        {
            Directory.CreateDirectory(path);
            var className = $"BaseEvent";
            var fileName = $"{className}.cs";
            var file = Path.Combine(path, fileName);

            FileInfo fi = new FileInfo(file);

            try
            {
                // Check if file already exists. If yes, throw exception.     
                if (fi.Exists)
                {
                    throw new Exception($"{file} already exists!");
                }

                // Create a new file     
                using (StreamWriter sw = fi.CreateText())
                {
                    sw.WriteLine($"using System;");
                    sw.WriteLine("");
                    sw.WriteLine($"namespace {namespaceName}");
                    sw.WriteLine("{");
                    sw.WriteLine($"    public abstract class BaseEvent");
                    sw.WriteLine("    {");
                    sw.WriteLine($"        public BaseEvent(DateTime timestamp)");
                    sw.WriteLine("        {");
                    sw.WriteLine($"            Timestamp = timestamp;");
                    sw.WriteLine("        }");
                    sw.WriteLine("        public DateTime Timestamp { get; set; }");
                    sw.WriteLine("    }");
                    sw.WriteLine("}");
                }
                Console.WriteLine($"Created {fileName}.");
            }
            catch (Exception Ex)
            {
                Console.WriteLine(Ex.ToString());
            }
        }

        private static void CreateEventClass(JObject jObject, string path, string namespaceName)
        {
            Directory.CreateDirectory(path);
            var eventName = $"{jObject["event"].Value<string>()}";
            var className = $"{eventName}Event";
            var fileName = $"{className}.cs";
            var file = Path.Combine(path, fileName);

            FileInfo fi = new FileInfo(file);

            var propertyList = new List<ParseClass>();
            foreach (var obj in jObject)
            {
                if (!(obj.Key.Equals("event") || obj.Key.Equals("timestamp")))
                {
                    propertyList.Add(new ParseClass(obj));
                }
            }

            try
            {
                // Check if file already exists. If yes, throw exception.     
                if (fi.Exists)
                {
                    throw new Exception($"{file} already exists!");
                }

                // Create a new file     
                using (FileStream fsStream = new FileStream(file, FileMode.Create))
                using (StreamWriter sw = new StreamWriter(fsStream, Encoding.UTF8))
                {
                    sw.WriteLine($"namespace {namespaceName}");
                    sw.WriteLine("{");
                    sw.WriteLine($"    public class {className} : BaseEvent");
                    sw.WriteLine("    {");
                    sw.WriteLine($"        public {className}(JsonEvent jsonEvent) : base(jsonEvent.Timestamp)");
                    sw.WriteLine("        {");
                    foreach (var property in propertyList)
                    {
                        var name = property.IsPrimitive ? $"{property.Name}.Value" : $"{property.Name}";
                        sw.WriteLine($"            {property.Name} = jsonEvent.{name};");
                    }
                    sw.WriteLine("        }");
                    foreach (var property in propertyList)
                    {
                        sw.WriteLine("        public " + property.Type + " " + property.Name + " { get; set; }");
                    }
                    sw.WriteLine("    }");
                    sw.WriteLine("}");
                }
                Console.WriteLine($"Created {fileName}.");
            }
            catch (Exception Ex)
            {
                Console.WriteLine(Ex.ToString());
            }
        }
    }
}

Answer 2

我可以在这里想到两种可能性。两者都不是很漂亮：

1. 创建一个包含所有属性的类
2. 检查每一行是否出现关键字（如 Rank、Task、 国家）。在此基础上，您可以选择要创建的类。

我想到了第三种选择。您可以为 Json.net 编写自己的转换器：

• https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-converters-how-to
• https://www.newtonsoft.com/json/help/html/CustomJsonConverter.htm