基于C#实现Json转Lua的操作指南
更新时间：2024年12月19日 10:06:22 作者：两水先木示
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式,它的语法基于 JavaScript 对象表示法,简单、易读,同时被许多编程语言支持,本文给大家介绍了如何基于C#实现Json转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;
}
}
}到此这篇关于基于C#实现Json转Lua的操作指南的文章就介绍到这了,更多相关C# Json转Lua内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
一般我们来说呢，对于加密，我们分为可逆和不可逆。可逆加密又可分为对称加密（AES、DES等）和非对称加密（RSA），还有就是一些编码加密等（BASE64）；不可逆的呢，大部分又都称为摘要算法（MD5、SHA）。本文将用C#实现AES算法，需要的可以参考一下2022-08-08
这篇文章主要介绍了C#委托delegate实例解析,对C#的委托做了较为深入的剖析,很适合初学者学习,需要的朋友可以参考下2014-08-08
本文主要介绍了C# Telnet协议实现与源码解析,包括创建Socket连接、命令交互、数据传输和异常处理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2026-05-05
这篇文章主要介绍了C#给图片添加水印的方法,以完整实例形式分析了C#实现文字及图像水印、缩略图、图片剪切等相关技巧,需要的朋友可以参考下2015-12-12
这篇文章主要介绍了C#实现斐波那契数列的几种方法整理，主要介绍了递归，循环，公式和矩阵法等，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2018-09-09
这篇文章主要为大家详细介绍了如何将.NET8.0应用程序转换成Windows服务,文中的示例代码讲解详细,有需要的小伙伴可以跟随小编一起学习一下2024-01-01
下面小编就为大家分享一篇C# 启动 SQL Server 服务的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2017-12-12
这篇文章主要为大家详细介绍了UGUI实现卡片椭圆方向滚动效果，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2019-03-03
这篇文章介绍了C#序列化与反序列化集合对象并实现版本控制的方法，文中通过示例代码介绍的非常详细。对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下2022-09-09
RtlAdjustPrivilege() 这玩意是在 NTDLL.DLL 里的一个不为人知的函数,MS没有公开,原因就是这玩意实在是太NB了,以至于不需要任何其他函数的帮助,仅凭这一个函数就可以获得进程ACL的任意权限!2011-06-06
最新评论