【C#】实现Json转Lua (Json2Lua)

关键词: C#、JsonToLua、Json2Lua、对象序列化Lua

前提需引入NewtonsofJson，引入方法可先在Visual Studio 2019

将Newtonsoft.Json.dll文件导入Unity的Plugins下。
Json格式字符串转Lua格式字符串，效果如下：

json字符串

{
	"1": "asd",
	"2": true,
	"3": 1.5,
	"4": 123,
	"a": {
		"b": "c",
		"d": [1, 2, 3]
	}
}

lua字符串 (.lua文件一般直接return {}表 故会加上 "return " 如果不需要可以自行修改代码。)

return {
	[1] = "asd",
	[2] = true,
	[3] = 1.5,
	[4] = 123,
	a = {
		b = "c",
		d = { 1, 2, 3 }
	}
}

 使用方法：

string json = "{\"1\":\"asd\",\"2\":true,\"3\":1.5,\"4\":123,\"a\":{\"b\":\"c\",\"d\":[1,2,3]}}";
string lua = Milk.Json.MilkJsonUtility.Json2Lua(json, true);

类说明：

LuaObject：封装Json基础类型对象，核心GetString方法返回对象的字符串形式。
LuaTable：封装JsonArray或JsonObject类型对象，主要是将数组或对象内的成员封装为LuaObject存储起来，数组存储于list，对象成员存储于map，核心GetString方法返回表的字符串形式。
LuaTable类静态方法：public static LuaTable CreateFromJson(string json)
        由该方法进行转化json为lua，使用JObject.Parse(json)转为Json对象，后经过判断是数组还是对象类型进行使用不同函数转化（JsonArray2LuaTable、JsonObject2LuaTable）
JsonArray2LuaTable：将Json数组成员一一转化为LuaTable
JsonObject2LuaTable：将Json对象成员一一转化为LuaTable

namespace Milk.Json
{
    public static class MilkJsonUtility
    {
        /// <summary>
        /// 将Json格式字符串转成Lua表形式字符串
        /// </summary>
        /// <param name="json"></param>
        /// <param name="indented">是否缩进</param>
        /// <returns></returns>
        public static string Json2Lua(string json, bool indented = false)
        {
            var table = LuaTable.CreateFromJson(json);
            return $"return {table.GetString(indented)}";
        }
    }
}
using System;
using System.Collections.Generic;
using System.Text;

namespace Milk.Json
{
    public enum LuaValueType
    {
        Table,
        String,
        Num,
        Boolean,
        nil
    }
}
using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json.Linq;

namespace Milk.Json
{
    public class LuaTable
    {
        //存放table中的有序部分
        private List<LuaObject> list = new List<LuaObject>();

        //存放table中的无序部分
        private Dictionary<string, LuaObject> map = new Dictionary<string, LuaObject>();

        //所在层级
        private int layer = 0;

        public LuaTable(int _layer)
        {
            layer = _layer + 1;
        }

        #region 有序数组添加

        /// <summary>
        /// [有序]添加string value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(string value)
        {
            list.Add(new LuaObject(value));
        }

        /// <summary>
        /// [有序]num value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(int value)
        {
            list.Add(new LuaObject(value));
        }

        /// <summary>
        /// [有序]num value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(float value)
        {
            list.Add(new LuaObject(value));
        }

        /// <summary>
        /// [有序]bool value
        /// </summary>
        /// <param name="value"></param>
        public void AddItem(bool value)
        {
            list.Add(new LuaObject(value));
        }

        public void AddItem(LuaTable value)
        {
            list.Add(new LuaObject(value));
        }

        /// <summary>
        /// 加入nil
        /// </summary>
        public void AddItemNil()
        {
            list.Add(new LuaObject());
        }

        #endregion


        #region Key_Value添加

        public void AddItem(string key, string value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }

        public void AddItem(string key, int value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }

        public void AddItem(string key, float value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }

        public void AddItem(string key, bool value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }

        public void AddItem(string key, LuaTable value)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject(value));
            }
        }

        public void AddItemNil(string key)
        {
            //查重
            if (!map.ContainsKey(key))
            {
                map.Add(key, new LuaObject());
            }
        }

        #endregion

        private bool IsNumeric(string str)
        {
            int number;
            return int.TryParse(str, out number);
        }

        private string IndentedLayer(string str, bool indented, int change = 0)
        {
            if (indented)
            {
                for (int i = 0; i < layer + change; i++)
                {
                    str = "\t" + str;
                }
            }
            return str;
        }

        public string GetString(bool indented = false)
        {
            string str = "{";
            bool hasList = list.Count > 0;
            bool hasMap = map.Count > 0;
            bool isNeedIndented = false;
            if (indented && (hasList || hasMap))
            {
                isNeedIndented = true;
                if (hasList)
                {
                    LuaValueType type = list[0].GetLuaValueType();
                    if (type == LuaValueType.Boolean || type == LuaValueType.Num)
                    {
                        isNeedIndented = false;
                    }
                }
                if (isNeedIndented)
                    str += "\n";
            }
            if (hasList)
            {
                int count = 0;
                foreach (var item in list)
                {
                    count++;
                    if (!isNeedIndented)
                    {
                        if (indented && count == 1)
                            str += " ";
                        str += item.GetString(indented);
                        if (count < list.Count)
                            str += ",";
                        if (indented)
                            str += " ";
                    }
                    else
                    {
                        str += IndentedLayer(item.GetString(indented), indented);
                        if (count < list.Count)
                            str += ",";
                        if (indented)
                            str += "\n";
                    }
                }
            }

            if (hasMap)
            {
                int count = 0;
                foreach (var item in map)
                {
                    count++;
                    var key = item.Key.Replace('$', '_');
                    if (IsNumeric(key))
                    {
                        key = $"[{key}]";
                    }
                    if (indented)
                        str += IndentedLayer($"{key} = {item.Value.GetString(indented)}", indented);
                    else
                        str += IndentedLayer($"{key}={item.Value.GetString(indented)}", indented);
                    if (count < map.Count)
                        str += ",";
                    if (indented)
                        str += "\n";
                }
            }

            if (!isNeedIndented)
            {
                str += "}";
            }
            else
            {
                str += IndentedLayer("}", indented, -1);
            }

            return str;
        }

        public static LuaTable CreateFromJson(string json)
        {
            var jsonObject = JObject.Parse(json);
            if (jsonObject.Type == JTokenType.Array)
            {
                return JsonArray2LuaTable(jsonObject.ToObject<JArray>(), 0);
            }
            else
            {
                return JsonObject2LuaTable(jsonObject, 0);
            }
        }

        /// <summary>
        /// 递归方法
        /// </summary>
        static LuaTable JsonObject2LuaTable(JObject jsonObj, int layer)
        {
            var curLuaTable = new LuaTable(layer);

            //构建无序Table(lua表 key-value形式)
            foreach (var item in jsonObj)
            {
                switch (item.Value.Type)
                {
                    case JTokenType.Boolean:
                        curLuaTable.AddItem(item.Key, (bool)item.Value);
                        break;
                    case JTokenType.Array:
                        curLuaTable.AddItem(item.Key, JsonArray2LuaTable(item.Value.ToObject<JArray>(), layer + 1));
                        break;
                    case JTokenType.String:
                        curLuaTable.AddItem(item.Key, (string)item.Value);
                        break;
                    case JTokenType.Date: //转成string
                        curLuaTable.AddItem(item.Key, (string)item.Value);
                        break;
                    case JTokenType.Float:
                        curLuaTable.AddItem(item.Key, (float)item.Value);
                        break;
                    case JTokenType.Integer:
                        curLuaTable.AddItem(item.Key, (int)item.Value);
                        break;
                    case JTokenType.None:
                        curLuaTable.AddItemNil(item.Key);
                        break;
                    case JTokenType.Null:
                        curLuaTable.AddItemNil(item.Key);
                        break;
                    case JTokenType.Object:
                        curLuaTable.AddItem(item.Key, JsonObject2LuaTable(item.Value.ToObject<JObject>(), layer + 1));
                        break;
                    case JTokenType.TimeSpan:
                        curLuaTable.AddItem(item.Key, (float)item.Value);
                        break;
                }
            }

            return curLuaTable;
        }

        static LuaTable JsonArray2LuaTable(JArray jsonArray, int layer)
        {
            var curLuaTable = new LuaTable(layer);
            //构建有序Table(lua表)
            foreach (var item in jsonArray)
            {
                //检查子项类型
                switch (item.Type)
                {
                    case JTokenType.Boolean:
                        curLuaTable.AddItem((bool)item);
                        break;
                    case JTokenType.Array:
                        curLuaTable.AddItem(JsonArray2LuaTable(item.ToObject<JArray>(), layer + 1));
                        break;
                    case JTokenType.String:
                        curLuaTable.AddItem((string)item);
                        break;
                    case JTokenType.Object:
                        curLuaTable.AddItem(JsonObject2LuaTable(item.ToObject<JObject>(), layer + 1));
                        break;
                    case JTokenType.Date:
                        curLuaTable.AddItem((string)item);
                        break;
                    case JTokenType.Float:
                        curLuaTable.AddItem((float)item);
                        break;
                    case JTokenType.Integer:
                        curLuaTable.AddItem((int)item);
                        break;
                    case JTokenType.None:
                        curLuaTable.AddItemNil();
                        break;
                    case JTokenType.Null:
                        curLuaTable.AddItemNil();
                        break;
                    case JTokenType.TimeSpan:
                        curLuaTable.AddItem((float)item);
                        break;
                }
            }

            return curLuaTable;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Text;

namespace Milk.Json
{
    public class LuaObject
    {
        private LuaValueType type;

        private float valueNumber;
        private string valueString;
        private bool valueBoolean;
        private LuaTable valueTable;

        public LuaObject(string value)
        {
            type = LuaValueType.String;
            valueString = value;
        }

        public LuaObject(float value)
        {
            type = LuaValueType.Num;
            valueNumber = value;
        }

        public LuaObject(int value)
        {
            type = LuaValueType.Num;
            valueNumber = value;
        }

        public LuaObject(bool value)
        {
            type = LuaValueType.Boolean;
            valueBoolean = value;
        }

        public LuaObject(LuaTable value)
        {
            type = LuaValueType.Table;
            valueTable = value;
        }

        public LuaObject()
        {
            type = LuaValueType.nil;
        }

        public string GetString(bool indented = false)
        {
            switch (type)
            {
                case LuaValueType.Table:
                    return valueTable.GetString(indented);
                //break;
                case LuaValueType.Boolean:
                    if (valueBoolean)
                    {
                        return "true";
                    }
                    else
                    {
                        return "false";
                    }
                //break;
                case LuaValueType.Num:
                    return valueNumber.ToString();
                //break;
                case LuaValueType.String:
                    return "\""+ valueString+"\"";
                case LuaValueType.nil:
                    return "nil";
                default:
                    return "";
            }
        }

        public LuaValueType GetLuaValueType()
        {
            return type;
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/941100.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Windows平台C++部署 vcpkg 安装protobuf + gRPC实现图像传输

Windows平台C++部署 vcpkg 安装protobuf + gRPC实现图像传输

vcpkg 安装 https://github.com/microsoft/vcpkg.git.\bootstrap-vcpkg.bat vcpkg --version参考&#xff1a;Windows安装vcpkg教程&#xff08;VS2022&#xff09; protocbuf 安装与编译 vcpkg install grpc:x64-windowsprotocbuf 安装与编译 vcpkg install protobuf proto…
阅读更多...
ScottPlot学习的常用笔记-02

ScottPlot学习的常用笔记-02

ScottPlot学习的常用笔记-02 写在前面Why&Target&#xff1a;这里记一些杂项。上下文&背景 先记一下这几个小时的新收获先说一下&#xff0c;为什么可开发可视工具缩放的问题ScottPlot5.0起步.net Core: WinExe.Net Framework也是可以的 写在前面 Why&Target&…
阅读更多...
CTF_1

CTF_1

CTF_Show 萌新赛 1.签到题 <?php if(isset($_GET[url])){system("curl https://".$_GET[url].".ctf.show"); }else{show_source(__FILE__); }?> 和 AI 一起分析 1.if(isset($_GET[url]))检查GET请求中是否存在名为url的参数。 curl 2.curl…
阅读更多...
【Spring】Spring框架之-AOP

【Spring】Spring框架之-AOP

目录 1. AOP的引入 2. AOP相关的概念 2.1 AOP概述 2.2 AOP的优势 2.3. AOP的底层原理--目前先不具体阐述&#xff0c;后面讲 3. Spring的AOP技术-配置文件方式 3.1 AOP相关的术语 3.2 基本准备工作 3.3 AOP配置文件方式的入门 3.4 切入点的表达式 3.5 AOP的通知类型 …
阅读更多...
我的2024年度总结

我的2024年度总结

称着这个周末&#xff0c;写一篇2024年度总结&#xff0c;主要记录我过去一年的成长经历以及自己的一些收获。 过去一年的经历&#xff0c;可谓刻骨铭心&#xff0c;一个是24考研惨败&#xff0c;一个是毕设的准备&#xff0c;一个是省考的陪考&#xff0c;一个是找工作的焦虑…
阅读更多...
Java 中的字符串

Java 中的字符串

目录 Java 中的字符串字符串的创建字符串的比较字符串的拼接如何定义一个空的字符串 Java 中的字符串 字符串的创建 在 Java 中&#xff0c;可以通过以下几种方式创建字符串&#xff1a; 1.使用字符串字面量&#xff1a; String str "Hello, World!";2.使用 new…
阅读更多...
数说故事聚焦“卖车”场景，推出AI汽车销售转化解决方案

数说故事聚焦“卖车”场景，推出AI汽车销售转化解决方案

没错&#xff0c;“卖车”我们也在行&#xff0c;为某车企“保住”了新车上市的订单。 深耕汽车行业多年&#xff0c;该车企10月份刚发布一款新能源车&#xff0c;其前期已经拥有了大量的保有客户和线上多渠道获取的潜在客户&#xff0c;然而&#xff0c;仍面临两大难题&#x…
阅读更多...
javaEE-多线程编程-3

javaEE-多线程编程-3

目录 java 常见的包 : 回调函数: 什么是线程: 第一个线程: 验证多线程执行: 内核: 调用sleep()方法: 执行结果分析: 线程创建的几种方式: 1.继承Thread类,重写run()方法. 2.实现Runnable接口,重写run()方法. 3.继承Thread类,重写run()方法.但使用匿名内部类 4.实现…
阅读更多...
FFmpeg 框架简介和文件解复用

FFmpeg 框架简介和文件解复用

文章目录 ffmpeg框架简介libavformat库libavcodec库libavdevice库 复用&#xff08;muxers&#xff09;和解复用&#xff08;demuxers&#xff09;容器格式FLVScript Tag Data结构&#xff08;脚本类型、帧类型&#xff09;Audio Tag Data结构&#xff08;音频Tag&#xff09;V…
阅读更多...
芯片级IO (Pad) Ring IP Checklist

芯片级IO (Pad) Ring IP Checklist

SoC top顶层数字后端实现都会涉及到IO Ring &#xff08;PAD Ring&#xff09;的设计。这里面包括VDD IO,VDDIO IO, Signal IO, Corner IO&#xff0c;Filler IO&#xff0c;IO power cut cell等等。 数字后端零基础入门系列 | Innovus零基础LAB学习Day2 数字IC后端实现TOP F…
阅读更多...
圣诞快乐（h5 css js（圣诞树））

圣诞快乐（h5 css js（圣诞树））

一&#xff0c;整体设计思路 圣诞树h5&#xff08;简易&#xff09; 1.页面布局与样式&#xff1a; 页面使用了全屏的黑色背景&#xff0c;中央显示圣诞树&#xff0c;树形由三层绿色的三角形组成&#xff0c;每一层的大小逐渐变小。树干是一个棕色的矩形&#xff0c;位于三角…
阅读更多...
Linux应用开发————mysql数据库表

Linux应用开发————mysql数据库表

mysql数据库表操作 查看表的结构 mysql> desc / describe 表名; 或者&#xff1a; mysql> show create table 表名; 常见数据库引擎&#xff1a; innodb, myISAM... 删除表 mysql> drop tabl…
阅读更多...
移动网络（2,3,4,5G）设备TCP通讯调试方法

移动网络（2,3,4,5G）设备TCP通讯调试方法

背景&#xff1a; 当设备是移动网络设备连接云平台的时候&#xff0c;如果服务器没有收到网络数据&#xff0c;移动物联设备发送不知道有没有有丢失数据的时候&#xff0c;需要一个抓取设备出来的数据和服务器下发的数据的方法。 1.服务器系统是很成熟的&#xff0c;一般是linu…
阅读更多...
Unity中的委托和事件（UnityAction、UnityEvent）

Unity中的委托和事件（UnityAction、UnityEvent）

委托和事件 &#x1f392;什么是委托&#xff0c;委托的关键字是Delegate&#xff0c;委托是一种函数的容器&#xff0c;运行将函数做为变量来进行传递 通过Delegate关键字我们声明了一个无参无返回的委托&#xff0c;通过这个委托我们可以存储无参无返回的函数 public deleg…
阅读更多...
基于SpringBoot的“交流互动系统”的设计与实现（源码+数据库+文档+PPT)

基于SpringBoot的“交流互动系统”的设计与实现（源码+数据库+文档+PPT)

基于SpringBoot的“交流互动系统”的设计与实现&#xff08;源码数据库文档PPT) 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SpringBoot 工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 系统展示 系统功能图 管理员登录界面图 个人信息界面图 个人…
阅读更多...
LeetCode hot100-93

LeetCode hot100-93

https://leetcode.cn/problems/longest-palindromic-substring/description/?envTypestudy-plan-v2&envIdtop-100-liked 5. 最长回文子串 给你一个字符串 s&#xff0c;找到 s 中最长的回文子串。状态定义 我们用一个二维数组 dp[i][j] 表示子串 s[i…j] 是否是回文&…
阅读更多...
C语言入门指南：从零开始的编程之路

C语言入门指南：从零开始的编程之路

记得我刚开始接触编程时,也像很多初学者一样充满疑惑。编程看起来很神奇,但要如何开始呢?经过多年编程经验的积累,今天和大家分享如何入门C语言编程。 C语言诞生于1972年,由Dennis Ritchie在贝尔实验室开发。它的出现彻底改变了计算机编程的历史。虽然现在有很多更新的编程语…
阅读更多...
详解Redis的String类型及相关命令

详解Redis的String类型及相关命令

目录 SET GET MGET MSET SETNX SET和SETNX和SETXX对比 INCR INCRBY DECR DECRBY INCRBYFLOAT APPEND GETRANGE SETRANGE STRLEN 内部编码 SET 将 string 类型的 value 设置到 key 中。如果 key 之前存在&#xff0c;则覆盖&#xff0c;⽆论原来的数据类型是什么…
阅读更多...
SpringBoot使用 AOP 实现自定义日志记录并保存在Mysql

SpringBoot使用 AOP 实现自定义日志记录并保存在Mysql

本文主要介绍在 Spring Boot 中使用 AOP 实现自定义日志记录并保存在 Mysql 的方法。先阐述记录日志的重要性及传统方式的弊端&#xff0c;提出新方式&#xff0c;即通过创建自定义注解、切面类等&#xff0c;将重要日志存到数据库&#xff0c;还给出了创建日志表、注解类、切面…
阅读更多...
对golang的io型进程进行off-cpu分析

对golang的io型进程进行off-cpu分析

背景&#xff1a; 对于不能占满所有cpu核数的进程&#xff0c;进行on-cpu的分析是没有意义的&#xff0c;因为可能程序大部分时间都处在阻塞状态。 实验例子程序&#xff1a; 以centos8和golang1.23.3为例&#xff0c;测试下面的程序&#xff1a; pprof_netio.go package m…
阅读更多...
最新文章

Copyright @ 2022~2023