Unity 连接 MySql 显示表格Simple TableUI

目录

一、Unity 中 DataTable 的使用

二、Simple TableUI 的使用

三、Unity 读取 MySql 数据库

四、显示表格并实现分页功能

结束

---

效果：

一、Unity 中 DataTable 的使用

C# 中 DataTable 类位于命名空间 System.Data ，在 Winform、WPF 等开发中，用的非常多，在 Unity 5.6.X 或者更低的版本中，是无法直接使用的，也不要在 Visual Studio 中去引用 System.Data.dll，不然在 Unity 里会报错，错误比如：

InvalidProgramException: Invalid IL code in System.Data.DataTable:get_Columns (): IL_0000: ret

下面来介绍一下，在 Unity 里低版本中如何使用 DataTable，在后面的案例中，Unity 版本使用的是 Unity 2020.3.45f1 ，因为要用到 Simple TableUI 插件，在 5.x 版本并不支持，所以这里对 5.x 中如何使用 DataTable 做一个简单的介绍吧。

在 Unity 5.x 中，项目中必须要先添加 System.Data.dll，System.Data.dll 位置在 Unity 的安装目录，比如下图中的路径

将 System.Data.dll 直接拖动到项目的 Plugins 目录中，打开 VS 后，如果自动添加了 System.Data 这个引用则为成功

在 Unity 更高的版本中，不必主动添加 System.Data 这个DLL，默认就会有，为了更好的开发，将 .net 版本改为 .NET 4.x 写代码会更加的方便

打开Visual Studio 2022 编辑器，就会看到默认已经添加了 System.Data

 新建一个脚本 Test，用来测试是否可用

1.  
   using System;
2.  
   using System.Data;
3.  
   using System.Collections;
4.  
   using System.Collections.Generic;
5.  
   using UnityEngine;
6.  
    
7.  
   public class Test : MonoBehaviour {
8.  
    
9.  
   void Start () {
10.  
    DataTable dt = new DataTable("Name");
11.  
    dt.Columns.Add(new DataColumn("ID", typeof(Int32)));
12.  
    dt.Columns.Add(new DataColumn("Name", typeof(string)));
13.  
    dt.Columns.Add(new DataColumn("Sex", typeof(string)));
14.  
    dt.Columns.Add(new DataColumn("Addr", typeof(string)));
15.  
     
16.  
    //添加一行数据到列中
17.  
    DataRow dr = dt.NewRow();
18.  
    dr["ID"] = 1;
19.  
    dr["Name"] = "张三";
20.  
    dr["Sex"] = "未知";
21.  
    dr["addr"] = "泰国";
22.  
     
23.  
    //添加一行数据到表单中
24.  
    dt.Rows.Add(dr);
25.  
     
26.  
    Debug.Log("列表行数：" dt.Rows.Count);
27.  
     
28.  
    string sex = dt.Rows[0][2].ToString();
29.  
    Debug.Log("性别：" sex);
30.  
    }
31.  
     
32.  
    void Update () {
33.  
     
34.  
    }
35.  
    }

将其挂在一个游戏物体上，运行：

 打印出来了，嘿嘿，这就说明 DataTable 可以使用了

二、Simple TableUI 的使用

Simple TableUI 插件是免费的，另外它还有一个付费版本叫 TableUI，当前的案例就用 Simple TableUI 作为示范，Unity 版本为  Unity 2020.3.45f1

 将资源添加完成后，在项目里，我们导入插件，就会发现，插件会报错

错误的是，没有找到对应的枚举

解决这个问题很简单，去掉前面的下划线就行了，这样就不报错了

导入后，先打开 官方的 Demo 看看

这时，就会默认弹出一个框，询问你是否导入 TextMesh Pro ，因为 Simple TableUI 插件用到了 TextMesh Pro，所以点击 Import TMP Essentials 

然后，项目会多出一个文件夹

这时候，打开场景，在 Canvas 里就可以看到对应的表单了 

使用起来也是比较简单的，我这里做一下介绍

row 给表格添加一行

- row 表格减少一行

column 给表格添加一列

- column 给表格减少一列

右边的三个输入框，加一个 apply 按钮，是改变哪一行，那一列的内容

官方的这个 demo 的场景我就不动了，我们打开 Unity 默认添加的场景

默认位置有点偏，点击 Reset Position 重置位置

 

如果这时候运行，依然会报错：

There is no 'CanvasRenderer' attached to the "Borders" game object, but a script is trying to access it.
You probably need to add a CanvasRenderer to the game object "Borders". Or your script needs to check if the component is attached before using it.

下面，我们找到 Borders 游戏物体

添加 Canvas Renderer 组件，将 Cull Transparent Mesh 的勾去掉

这时候运行，就不会报错了

三、Unity 读取 MySql 数据库

在第一节中，使用的 DataTable 是自己添加的数据，其实更多的时候，数据是从数据库中读取出来的，下面就介绍，如何从 mysql 中读取数据，并在 unity 中打印出来。

如果你的电脑没有安装 mysql ，请先安装，再继续接下来的教程

mysql 数据库

这个表在后面的源码中会有提供。或者你可以用自己的数据库，在后面的代码中，改下 SQL 语句就行了。

在 unity 里要想读取 mysql 数据库，配置还是非常的麻烦的，需要另外创建一个 C# Winfrom 项目，并在 NuGet 里面安装 Mysql.Data ，伴随着也是下载一大堆插件，我们需要做的就是复制这些相关的 dll 到 unity 中。

安装完成后的插件有这么多

在这个 winform 项目的根目录 packages 中，我们需要把对应的 dll 复制到 unity  中

复制 dll 过来后的 Unity --> Plugins 目录

将这些 dll 添加完成后，如果 unity 控制台没有报错，则为成功，不想这么麻烦也没关系，可以直接用我源码中的 dll 就好。

关于 C# 如何连接 MySql 数据库，我之前有写过教程，有兴趣的可以去试试。点击跳转 

另外，如果你想用 Unity 读取 SqlServer 数据库，我同样也写过类似的帖子，点击跳转

接下来，在 Unity 中创建一个脚本 MySqlHelper

1.  
   using MySql.Data.MySqlClient;
2.  
   using System.Data;
3.  
   using System;
4.  
    
5.  
   public class MySqlHelper
6.  
   {
7.  
   private static string connstr = "server=127.0.0.1;database=world;username=root;password=123456;";
8.  
    
9.  
    
10.  
    #region 执行查询语句，返回MySqlDataReader
11.  
     
12.  
    /// <summary>
13.  
    /// 执行查询语句，返回MySqlDataReader
14.  
    /// </summary>
15.  
    /// <param name="sqlString"></param>
16.  
    /// <returns></returns>
17.  
    public static MySqlDataReader ExecuteReader(string sqlString)
18.  
    {
19.  
    MySqlConnection connection = new MySqlConnection(connstr);
20.  
    MySqlCommand cmd = new MySqlCommand(sqlString, connection);
21.  
    MySqlDataReader myReader = null;
22.  
    try
23.  
    {
24.  
    connection.Open();
25.  
    myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
26.  
    return myReader;
27.  
    }
28.  
    catch (System.Data.SqlClient.SqlException e)
29.  
    {
30.  
    connection.Close();
31.  
    throw new Exception(e.Message);
32.  
    }
33.  
    finally
34.  
    {
35.  
    if (myReader == null)
36.  
    {
37.  
    cmd.Dispose();
38.  
    connection.Close();
39.  
    }
40.  
    }
41.  
    }
42.  
    #endregion
43.  
     
44.  
    #region 执行带参数的查询语句，返回 MySqlDataReader
45.  
     
46.  
    /// <summary>
47.  
    /// 执行带参数的查询语句，返回MySqlDataReader
48.  
    /// </summary>
49.  
    /// <param name="sqlString"></param>
50.  
    /// <param name="cmdParms"></param>
51.  
    /// <returns></returns>
52.  
    public static MySqlDataReader ExecuteReader(string sqlString, params MySqlParameter[] cmdParms)
53.  
    {
54.  
    MySqlConnection connection = new MySqlConnection(connstr);
55.  
    MySqlCommand cmd = new MySqlCommand();
56.  
    MySqlDataReader myReader = null;
57.  
    try
58.  
    {
59.  
    PrepareCommand(cmd, connection, null, sqlString, cmdParms);
60.  
    myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
61.  
    cmd.Parameters.Clear();
62.  
    return myReader;
63.  
    }
64.  
    catch (System.Data.SqlClient.SqlException e)
65.  
    {
66.  
    connection.Close();
67.  
    throw new Exception(e.Message);
68.  
    }
69.  
    finally
70.  
    {
71.  
    if (myReader == null)
72.  
    {
73.  
    cmd.Dispose();
74.  
    connection.Close();
75.  
    }
76.  
    }
77.  
    }
78.  
    #endregion
79.  
     
80.  
    #region 执行sql语句,返回执行行数
81.  
     
82.  
    /// <summary>
83.  
    /// 执行sql语句,返回执行行数
84.  
    /// </summary>
85.  
    /// <param name="sql"></param>
86.  
    /// <returns></returns>
87.  
    public static int ExecuteSql(string sql)
88.  
    {
89.  
    using (MySqlConnection conn = new MySqlConnection(connstr))
90.  
    {
91.  
    using (MySqlCommand cmd = new MySqlCommand(sql, conn))
92.  
    {
93.  
    try
94.  
    {
95.  
    conn.Open();
96.  
    int rows = cmd.ExecuteNonQuery();
97.  
    return rows;
98.  
    }
99.  
    catch (MySql.Data.MySqlClient.MySqlException e)
100.  
     {
101.  
     conn.Close();
102.  
     //throw e;
103.  
     Console.WriteLine(e.Message);
104.  
     }
105.  
     finally
106.  
     {
107.  
     cmd.Dispose();
108.  
     conn.Close();
109.  
     }
110.  
     }
111.  
     }
112.  
      
113.  
     return -1;
114.  
     }
115.  
     #endregion
116.  
      
117.  
     #region 执行带参数的sql语句，并返回执行行数
118.  
      
119.  
     /// <summary>
120.  
     /// 执行带参数的sql语句，并返回执行行数
121.  
     /// </summary>
122.  
     /// <param name="sqlString"></param>
123.  
     /// <param name="cmdParms"></param>
124.  
     /// <returns></returns>
125.  
     public static int ExecuteSql(string sqlString, params MySqlParameter[] cmdParms)
126.  
     {
127.  
     using (MySqlConnection connection = new MySqlConnection(connstr))
128.  
     {
129.  
     using (MySqlCommand cmd = new MySqlCommand())
130.  
     {
131.  
     try
132.  
     {
133.  
     PrepareCommand(cmd, connection, null, sqlString, cmdParms);
134.  
     int rows = cmd.ExecuteNonQuery();
135.  
     cmd.Parameters.Clear();
136.  
     return rows;
137.  
     }
138.  
     catch (System.Data.SqlClient.SqlException E)
139.  
     {
140.  
     throw new Exception(E.Message);
141.  
     }
142.  
     finally
143.  
     {
144.  
     cmd.Dispose();
145.  
     connection.Close();
146.  
     }
147.  
     }
148.  
     }
149.  
     }
150.  
     #endregion
151.  
      
152.  
     #region 执行查询语句，返回DataSet
153.  
      
154.  
     /// <summary>
155.  
     /// 执行查询语句，返回DataSet
156.  
     /// </summary>
157.  
     /// <param name="sql"></param>
158.  
     /// <returns></returns>
159.  
     public static DataSet GetDataSet(string sql)
160.  
     {
161.  
     using (MySqlConnection conn = new MySqlConnection(connstr))
162.  
     {
163.  
     DataSet ds = new DataSet();
164.  
     try
165.  
     {
166.  
     conn.Open();
167.  
     MySqlDataAdapter DataAdapter = new MySqlDataAdapter(sql, conn);
168.  
     DataAdapter.Fill(ds);
169.  
     }
170.  
     catch (Exception ex)
171.  
     {
172.  
     //throw ex;
173.  
     Console.WriteLine(ex.Message);
174.  
     }
175.  
     finally
176.  
     {
177.  
     conn.Close();
178.  
     }
179.  
     return ds;
180.  
     }
181.  
     }
182.  
     #endregion
183.  
      
184.  
     #region 执行带参数的查询语句，返回DataSet
185.  
      
186.  
     /// <summary>
187.  
     /// 执行带参数的查询语句，返回DataSet
188.  
     /// </summary>
189.  
     /// <param name="sqlString"></param>
190.  
     /// <param name="cmdParms"></param>
191.  
     /// <returns></returns>
192.  
     public static DataSet GetDataSet(string sqlString, params MySqlParameter[] cmdParms)
193.  
     {
194.  
     using (MySqlConnection connection = new MySqlConnection(connstr))
195.  
     {
196.  
     MySqlCommand cmd = new MySqlCommand();
197.  
     PrepareCommand(cmd, connection, null, sqlString, cmdParms);
198.  
     using (MySqlDataAdapter da = new MySqlDataAdapter(cmd))
199.  
     {
200.  
     DataSet ds = new DataSet();
201.  
     try
202.  
     {
203.  
     da.Fill(ds, "ds");
204.  
     cmd.Parameters.Clear();
205.  
     }
206.  
     catch (System.Data.SqlClient.SqlException ex)
207.  
     {
208.  
     throw new Exception(ex.Message);
209.  
     }
210.  
     finally
211.  
     {
212.  
     cmd.Dispose();
213.  
     connection.Close();
214.  
     }
215.  
     return ds;
216.  
     }
217.  
     }
218.  
     }
219.  
     #endregion
220.  
      
221.  
     #region 执行带参数的sql语句，并返回 object
222.  
      
223.  
     /// <summary>
224.  
     /// 执行带参数的sql语句，并返回object
225.  
     /// </summary>
226.  
     /// <param name="sqlString"></param>
227.  
     /// <param name="cmdParms"></param>
228.  
     /// <returns></returns>
229.  
     public static object GetSingle(string sqlString, params MySqlParameter[] cmdParms)
230.  
     {
231.  
     using (MySqlConnection connection = new MySqlConnection(connstr))
232.  
     {
233.  
     using (MySqlCommand cmd = new MySqlCommand())
234.  
     {
235.  
     try
236.  
     {
237.  
     PrepareCommand(cmd, connection, null, sqlString, cmdParms);
238.  
     object obj = cmd.ExecuteScalar();
239.  
     cmd.Parameters.Clear();
240.  
     if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
241.  
     {
242.  
     return null;
243.  
     }
244.  
     else
245.  
     {
246.  
     return obj;
247.  
     }
248.  
     }
249.  
     catch (System.Data.SqlClient.SqlException e)
250.  
     {
251.  
     throw new Exception(e.Message);
252.  
     }
253.  
     finally
254.  
     {
255.  
     cmd.Dispose();
256.  
     connection.Close();
257.  
     }
258.  
     }
259.  
     }
260.  
     }
261.  
      
262.  
     #endregion
263.  
      
264.  
     /// <summary>
265.  
     /// 执行存储过程,返回数据集
266.  
     /// </summary>
267.  
     /// <param name="storedProcName">存储过程名</param>
268.  
     /// <param name="parameters">存储过程参数</param>
269.  
     /// <returns>DataSet</returns>
270.  
     public static DataSet RunProcedureForDataSet(string storedProcName, IDataParameter[] parameters)
271.  
     {
272.  
     using (MySqlConnection connection = new MySqlConnection(connstr))
273.  
     {
274.  
     DataSet dataSet = new DataSet();
275.  
     connection.Open();
276.  
     MySqlDataAdapter sqlDA = new MySqlDataAdapter();
277.  
     sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
278.  
     sqlDA.Fill(dataSet);
279.  
     connection.Close();
280.  
     return dataSet;
281.  
     }
282.  
     }
283.  
      
284.  
     /// <summary>
285.  
     /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
286.  
     /// </summary>
287.  
     /// <param name="connection">数据库连接</param>
288.  
     /// <param name="storedProcName">存储过程名</param>
289.  
     /// <param name="parameters">存储过程参数</param>
290.  
     /// <returns>SqlCommand</returns>
291.  
     private static MySqlCommand BuildQueryCommand(MySqlConnection connection, string storedProcName,
292.  
     IDataParameter[] parameters)
293.  
     {
294.  
     MySqlCommand command = new MySqlCommand(storedProcName, connection);
295.  
     command.CommandType = CommandType.StoredProcedure;
296.  
     foreach (MySqlParameter parameter in parameters)
297.  
     {
298.  
     command.Parameters.Add(parameter);
299.  
     }
300.  
     return command;
301.  
     }
302.  
      
303.  
     #region 装载MySqlCommand对象
304.  
      
305.  
     /// <summary>
306.  
     /// 装载MySqlCommand对象
307.  
     /// </summary>
308.  
     private static void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, string cmdText,
309.  
     MySqlParameter[] cmdParms)
310.  
     {
311.  
     if (conn.State != ConnectionState.Open)
312.  
     {
313.  
     conn.Open();
314.  
     }
315.  
     cmd.Connection = conn;
316.  
     cmd.CommandText = cmdText;
317.  
     if (trans != null)
318.  
     {
319.  
     cmd.Transaction = trans;
320.  
     }
321.  
     cmd.CommandType = CommandType.Text; //cmdType;
322.  
     if (cmdParms != null)
323.  
     {
324.  
     foreach (MySqlParameter parm in cmdParms)
325.  
     {
326.  
     cmd.Parameters.Add(parm);
327.  
     }
328.  
     }
329.  
     }
330.  
     #endregion
331.  
      
332.  
     }

创建一个 Test 脚本，用来调用数据库查询

1.  
   using System.Data;
2.  
   using UnityEngine;
3.  
    
4.  
   public class Test : MonoBehaviour
5.  
   {
6.  
    
7.  
   void Start()
8.  
   {
9.  
   string sql = "SELECT * FROM city LIMIT 10";
10.  
    DataSet dataSet = MySqlHelper.GetDataSet(sql);
11.  
    DataTable dt = dataSet.Tables[0];
12.  
    if (dt.Rows.Count > 0)
13.  
    {
14.  
    foreach (DataRow row in dt.Rows)
15.  
    {
16.  
    string columnStr = string.Empty;
17.  
    foreach (DataColumn column in dt.Columns)
18.  
    {
19.  
    columnStr = row[column] " | ";
20.  
    }
21.  
    Debug.Log(columnStr);
22.  
    }
23.  
    }
24.  
    }
25.  
     
26.  
    // Update is called once per frame
27.  
    void Update()
28.  
    {
29.  
     
30.  
    }
31.  
    }

在场景中创建一个空物体 GameObject，将 Test 脚本挂在上面

点击运行：

我们看看数据库，可以看到，数据成功的读取了，这样就完成了读取数据库部分

四、显示表格并实现分页功能

找到 Table 游戏物体

这里我们将列表改为 5 列，6行，只要拖动滚动条，在 Scene 界面就能看到对应的效果了。

 我们在 Canvas 中添加两个按钮，上一页和下一页

Scene 界面效果

在之前创建的 Test 脚本中，加入下面代码

1.  
   using System.Data;
2.  
   using UnityEngine;
3.  
   using UnityEngine.UI;
4.  
   using UnityEngine.UI.TableUI;
5.  
    
6.  
   public class Test : MonoBehaviour
7.  
   {
8.  
   public Button Button_PageUp;
9.  
   public Button Button_PageDown;
10.  
    public TableUI TableUIs;
11.  
     
12.  
    //从数据库读取的数据
13.  
    private DataTable DT;
14.  
    //每页的行数
15.  
    private int RowsOfPage = 5;
16.  
    //总页数
17.  
    private int TotalPages = 0;
18.  
    //当前的页数
19.  
    private int Page = 1;
20.  
    //最后一页会空多少行
21.  
    private int Remainder;
22.  
     
23.  
    void Start()
24.  
    {
25.  
    Button_PageUp.onClick.AddListener(OnClick_PageUp);
26.  
    Button_PageDown.onClick.AddListener(OnClick_PageDown);
27.  
     
28.  
    string sql = "SELECT * FROM city LIMIT 15";
29.  
    DataSet dataSet = MySqlHelper.GetDataSet(sql);
30.  
    DT = dataSet.Tables[0];
31.  
    if (DT.Rows.Count > 0)
32.  
    {
33.  
    Debug.Log("总长度：" DT.Rows.Count);
34.  
     
35.  
    TotalPages = (DT.Rows.Count RowsOfPage -1) / RowsOfPage;
36.  
    Debug.Log("总页数：" TotalPages);
37.  
     
38.  
    Remainder = DT.Rows.Count % RowsOfPage;
39.  
    if (Remainder > 0) Remainder -= 1;
40.  
    Debug.Log("余数：" Remainder);
41.  
     
42.  
    //显示列名
43.  
    for (int i = 0; i < DT.Columns.Count; i )
44.  
    {
45.  
    string title = DT.Columns[i].ColumnName;
46.  
    TableUIs.GetCell(0, i).text = title;
47.  
    }
48.  
     
49.  
    ShowTable(DT, Page);
50.  
    }
51.  
    }
52.  
     
53.  
     
54.  
    private void OnClick_PageUp()
55.  
    {
56.  
    if (Page - 1 <= 0) return;
57.  
     
58.  
    Page--;
59.  
    ShowTable(DT, Page);
60.  
    }
61.  
     
62.  
     
63.  
    private void OnClick_PageDown()
64.  
    {
65.  
    if(Page 1 > TotalPages) return;
66.  
     
67.  
    Page ;
68.  
    ShowTable(DT, Page);
69.  
    }
70.  
     
71.  
     
72.  
    private void ShowTable(DataTable dt, int page)
73.  
    {
74.  
    if (dt == null)
75.  
    {
76.  
    Debug.Log("DataTable 不能为空");
77.  
    return;
78.  
    }
79.  
    if(page <= 0 || page > TotalPages)
80.  
    {
81.  
    Debug.Log("页数超出了范围");
82.  
    return;
83.  
    }
84.  
     
85.  
    //清空表格
86.  
    for (int i = 1; i <= RowsOfPage; i )
87.  
    {
88.  
    for (int j = 0; j < RowsOfPage; j )
89.  
    {
90.  
    TableUIs.GetCell(i, j).text = string.Empty;
91.  
    }
92.  
    }
93.  
     
94.  
    int end = page * RowsOfPage;
95.  
    int start = end - RowsOfPage;
96.  
     
97.  
    if (page == TotalPages)
98.  
    end = end - Remainder;
99.  
     
100.  
     int row = 0;
101.  
     for (int i = start; i < end; i )
102.  
     {
103.  
     DataRow dr = DT.Rows[i];
104.  
     row ;
105.  
     for (int j = 0; j < dt.Columns.Count; j )
106.  
     {
107.  
     TableUIs.GetCell(row, j).text = dr[j].ToString();
108.  
     }
109.  
     }
110.  
     }
111.  
      
112.  
      
113.  
     private void OnDestroy()
114.  
     {
115.  
     Button_PageUp.onClick.RemoveAllListeners();
116.  
     Button_PageDown.onClick.RemoveAllListeners();
117.  
     }
118.  
      
119.  
     }

给脚本对应的字段赋值

现在点击运行，就能看到效果了

源码：点击下载

结束

如果这个帖子对你有所帮助，欢迎 关注 点赞 留言

end

这篇好文章是转载于：学新通技术网