使用Sqlsugar实现项目

原创 已于 2022-01-27 02:05:39 修改 · 455 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linq #c# #microsoft

于 2022-01-26 08:29:58 首次发布
本文详细介绍了如何在C#项目中利用Sqlsugar库进行数据库操作，涵盖了连接配置、实体映射、CRUD操作以及 LINQ 查询的使用方法，旨在提升开发效率并简化数据访问层的代码。 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using xktComm.Common;
using xktComm.DataConvert;
using xktNodeSettings;
using xktNodeSettings.Node.Modbus;
using xktNodeSettings.Node.Variable;

namespace CMStestMdbus
{
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();
            modbusTCPList = ModbusTCPCFG.LoadXmlFile(settingPath);
            SqlSugarService.SetConnectionStr("Data Source=" + Application.StartupPath + str2);
            InitialInfo();
            Communication();

        }

        string str2 = "\\config\\ZgTestData.db;Pooling=true;FailIfMissing=false";
        //配置文件路径
        private string settingPath = Application.StartupPath + "\\settings\\settingsss.xml";

        InsertDataSQLite objInsert = new InsertDataSQLite(10000);//10秒1次

        private string ipAddress = "127.0.0.1";
        private int port = 502;

        //private CancellationTokenSource cts = new CancellationTokenSource();



        /// <summary>
        /// 通讯函数
        /// </summary>
        private void Communication()
        {
            if (modbusTCPList.Count>0)//有modbusTCP节点
            {
                foreach (var dev in modbusTCPList) //遍历modbusTCP节点
                {
                    if (dev.IsActive)
                    {
                        dev.cts = new CancellationTokenSource();
                        Task.Run(async () =>
                        {
                            while (!dev.cts.IsCancellationRequested)//默认是false
                            {
                                if (dev.IsConnected) //放解析
                                {
                                    CommonMethods.TCPisConnected = dev.IsConnected;
                                    foreach (var gp in dev.ModbusTCPGroupList)//遍历每一个组
                                    {
                                        if (gp.IsActive)
                                        {
                                            //读取数据
                                            byte[] res = null;
                                            //线圈存储区
                                            if (gp.StoreArea == ModbusStoreArea.输入线圈 || gp.StoreArea == ModbusStoreArea.输出线圈)
                                            {
                                                //读取
                                                switch (gp.StoreArea)
                                                {
                                                    case ModbusStoreArea.输出线圈:
                                                        res = dev.modtcp.ReadOutputStatus(gp.Start, gp.Length);
                                                        break;
                                                    case ModbusStoreArea.输入线圈:
                                                        res = dev.modtcp.ReadInputStatus(gp.Start, gp.Length);
                                                        break;
                                                    default:
                                                        break;
                                                }

                                                //解析

                                                //判断
                                                if (res != null && res.Length == ((gp.Length % 8 == 0) ? gp.Length / 8 : gp.Length / 8 + 1))
                                                {
                                                    dev.ErrorTimes = 0;
                                                    foreach (var variable in gp.varList)
                                                    {
                                                        //验证地址并解析地址
                                                        if (VerifyModbusAddress(true, variable.VarAddress, out int start, out int offset))
                                                        {
                                                            //真正的地址偏移
                                                            start -= gp.Start;

                                                            switch (variable.VarType)
                                                            {
                                                                case DataType.Bool:
                                                                    variable.Value = BitLib.GetBitArrayFromByteArray(res, false)[start];
                                                                    break;
                                                                default:
                                                                    break;
                                                            }

                                                            //包含就替换，否则就添加
                                                            if (CommonMethods.CurrentPLCValue.ContainsKey(variable.Name))
                                                            {
                                                                CommonMethods.CurrentPLCValue[variable.Name] = variable.Value;
                                                            }
                                                            else
                                                            {
                                                                CommonMethods.CurrentPLCValue.Add(variable.Name, variable.Value);
                                                            }

                                                        }
                                                    }

                                                }
                                                else
                                                {
                                                    dev.ErrorTimes++;

                                                    if (dev.ErrorTimes >= dev.MaxErrorTimes)
                                                    {
                                                        dev.IsConnected = false;
                                                        CommonMethods.TCPisConnected = dev.IsConnected;
                                                    }

                                                }
                                            }

                                            //寄存器存储区
                                            else
                                            {
                                                //读取
                                                switch (gp.StoreArea)
                                                {
                                                    case ModbusStoreArea.保持寄存器:
                                                        res = dev.modtcp.ReadKeepReg(gp.Start, gp.Length);
                                                        break;
                                                    case ModbusStoreArea.输入寄存器:
                                                        res = dev.modtcp.ReadInputReg(gp.Start, gp.Length);
                                                        break;
                                                    default:
                                                        break;
                                                }


                                                if (res != null && res.Length == gp.Length * 2)
                                                {
                                                    dev.ErrorTimes = 0;
                                                    foreach (var variable in gp.varList)
                                                    {
                                                        if (VerifyModbusAddress(false, variable.VarAddress, out int start, out int offset))
                                                        {
                                                            start -= gp.Start;

                                                            start *= 2;

                                                            //2开始读取50个寄存器

                                                            //第一个变量地址是2，索引是0   （2-2）*2
                                                            //第二个变量地址是4，索引是4   （4-2）*2
                                                            //第三个变量地址是6，索引是8   （6-2）*2


                                                            switch (variable.VarType)
                                                            {
                                                                case DataType.Bool:
                                                                    variable.Value = BitLib.GetBitFrom2ByteArray(res, start, offset, true);
                                                                    break;
                                                                case DataType.Byte:
                                                                    variable.Value = ByteLib.GetByteFromByteArray(res, start);
                                                                    break;
                                                                case DataType.Short:
                                                                    variable.Value = ShortLib.GetShortFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.UShort:
                                                                    variable.Value = UShortLib.GetUShortFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.Int:
                                                                    variable.Value = IntLib.GetIntFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.UInt:
                                                                    variable.Value = UIntLib.GetUIntFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.Float:
                                                                    variable.Value = FloatLib.GetFloatFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.Double:
                                                                    variable.Value = DoubleLib.GetDoubleFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.Long:
                                                                    variable.Value = LongLib.GetLongFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.ULong:
                                                                    variable.Value = ULongLib.GetULongFromByteArray(res, start, dev.DataFormat);
                                                                    break;
                                                                case DataType.String:
                                                                    variable.Value = StringLib.GetStringFromByteArray(res, start, offset, Encoding.ASCII);
                                                                    break;
                                                                case DataType.ByteArray:
                                                                    variable.Value = StringLib.GetHexStringFromByteArray(res, start, offset);
                                                                    break;
                                                                case DataType.HexString:
                                                                    variable.Value = StringLib.GetHexStringFromByteArray(res, start, offset);
                                                                    break;
                                                                default:
                                                                    break;
                                                            }

                                                            //包含就替换，否则就添加
                                                            if (CommonMethods.CurrentPLCValue.ContainsKey(variable.Name))
                                                            {
                                                                CommonMethods.CurrentPLCValue[variable.Name] = variable.Value;
                                                            }
                                                            else
                                                            {
                                                                CommonMethods.CurrentPLCValue.Add(variable.Name, variable.Value);
                                                            }
                                                        }
                                                    }
                                                }

                                                else
                                                {
                                                    dev.ErrorTimes++;

                                                    if (dev.ErrorTimes >= dev.MaxErrorTimes)
                                                    {
                                                        dev.IsConnected = false;
                                                        CommonMethods.TCPisConnected = dev.IsConnected;
                                                    }
                                                }
                                            }


                                        }
                                    }
                                }
                                else
                                {
                                    //延时
                                    if (!dev.FirstConnect)//如果不是第一次连接
                                    {
                                        await Task.Delay(dev.ReConnectTime);
                                        dev.modtcp?.DisConnect();
                                    }
                                    //第一次 连接
                                    //初始化通信对象
                                    dev.modtcp = new xktComm.Modbus.ModbusTcp();
                                    dev.modtcp.ConnectTimeOut = dev.ConnectTimeOut;//设置连接超时时间
                                    //设置间隔时间
                                    await Task.Delay(200);
                                    //设置数据格式
                                    dev.modtcp.DataFormat = dev.DataFormat;
                                    //建立连接
                                    dev.IsConnected = dev.modtcp.Connect(dev.ServerURL, dev.Port);
                                    dev.FirstConnect = false;
                                    await Task.Delay(200);
                                }
                            }
                        }, dev.cts.Token);
                    }
                }
            }
        }

        /// <summary>
        /// 验证IP地址函数
        /// </summary>
        /// <param name="isBit"></param>
        /// <param name="address"></param>
        /// <param name="start"></param>
        /// <param name="offset"></param>
        /// <returns></returns>
        private bool VerifyModbusAddress(bool isBit, string address, out int start, out int offset)
        {
            if (isBit)
            {
                offset = 0;
                return int.TryParse(address, out start);
            }
            else
            {
                if (address.Contains('.'))
                {
                    string[] result = address.Split('.');
                    if (result.Length == 2)
                    {
                        bool val = true;
                        int res = 0;
                        val = val && int.TryParse(result[0], out res);
                        start = res;
                        val = val && int.TryParse(result[1], out res);
                        offset = res;
                        return val;
                    }
                    else
                    {
                        start = 0;
                        offset = 0;
                        return false;
                    }
                }
                else
                {
                    offset = 0;
                    return int.TryParse(address, out start);
                }
            }
        }

        //设备集合
        private List<NodeModbusTCP> modbusTCPList = new List<NodeModbusTCP>();



        /// <summary>
        /// 初始化相关信息
        /// </summary>
        private void InitialInfo()
        {

            foreach (var dev in modbusTCPList)
            {
                foreach (var gp in dev.ModbusTCPGroupList)
                {
                    foreach (var variable in gp.varList)
                    {
                        if (variable.Config.ArchiveEnable)//API改变
                        {
                            CommonMethods.storeVariList.Add(variable);
                        }
                    }
                }
            }

            //自己修改IP地址
            //modbusTCPList[0].ServerURL = ipAddress;

            //....


        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using xktNodeSettings.Node.Modbus;
using xktNodeSettings.Node.Variable;

namespace CMStestMdbus
{
    public class CommonMethods
    {
        public static Dictionary<string, object> CurrentPLCValue = new Dictionary<string, object>();
        //TCP标志位
        public static bool TCPisConnected = false;

        public static int CacheCount = 600;//10分钟, 每秒一条

        //归档变量集合
        public static List<ModbusTCPVariable> storeVariList = new List<ModbusTCPVariable>();

        public static List<List<Cache>> CacheList = new List<List<Cache>>();
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace CMStestMdbus
{
    public class InsertDataSQLite
    {
        System.Timers.Timer t;

        int count = 0;

        public InsertDataSQLite(int Interval)
        {
            t = new System.Timers.Timer(Interval);
            t.Elapsed += T_Elapsed;
            t.AutoReset = true;
            t.Enabled = true;
            t.Start();
            count = CommonMethods.CacheCount; //默认为600
        }

        private void T_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (CommonMethods.TCPisConnected)
            {
                InsertActualData();
                //if (DateTime.Now.Minute == 0 && DateTime.Now.Second == 0)//整点插入
                //{
                //    InsertDataHourReport();
                //}
            }
        }
        #region 插入实时数据

        
        private void InsertActualData()
        {
            if (CommonMethods.CurrentPLCValue != null && CommonMethods.CurrentPLCValue.Count > 0)
            {
                List<ActualData> actualDataArray = new List<ActualData>();
                
                List<Cache> cache = new List<Cache>();
                ////FileVarModbusList归档变量集合 在commonMethos里创建的静态变量, 归档, 意味着存入数据库
                //归档信息在json里面存储

                foreach (var item in CommonMethods.storeVariList)//FileVarModbusList归档集合
                {
                    string varName = item.Name;//modbus 点表中的名称
                    string remark = item.Description; //注释
                    double value = 0.0;
                    if (!CommonMethods.CurrentPLCValue.ContainsKey(varName))
                    {
                        value = 0.0;

                    }
                    else
                    {
                        value = Convert.ToDouble(CommonMethods.CurrentPLCValue[varName]);
                    }
                    DateTime dt = DateTime.Now;
                    actualDataArray.Add(new ActualData()
                    {
                        InsertTime = dt,
                        VarName = varName,
                        Value = Convert.ToString(value),
                        Remark = remark
                    });

                    cache.Add(new Cache()
                    {
                        InsertTime = dt,
                        VarName = varName,
                        Value = value.ToString(),
                        Remark = remark
                    });
                }

                var count = new ActualDataProvider().Insert(actualDataArray); //向数据库插入数据

                if (CommonMethods.CacheList.Count <= count)//如果Count小于600
                {
                    CommonMethods.CacheList.Add(cache);//集合的集合
                }
                else
                {
                    CommonMethods.CacheList.RemoveAt(0);//把第一个去掉
                    CommonMethods.CacheList.Add(cache);//继续添加
                }


            }
        }
        #endregion

        #region 插入小时数据
        //private void InsertDataHourReport()
        //{
        //    List<string> array = new List<string>();
        //    foreach (var item in CommonMethods.storeVariList)
        //    {//ModbusTCPVariable
        //        double value = 0.0;
        //        if (CommonMethods.CurrentPLCValue.ContainsKey(item.Name))
        //        {
        //            string Res = CommonMethods.CurrentPLCValue[item.Name].ToString();//键值对,a[key]为值,存了19个变量的值
        //            if (Res.Length == 0)
        //            {
        //                value = 0.0;

        //            }
        //            else
        //            {
        //                value = Convert.ToDouble(Res);
        //            }
        //            array.Add(value.ToString("f1"));
        //        }

        //        ReportData reportData = new ReportData()
        //        {
        //            J0GCB11CF101 = array[0],
        //            J0GCB12CF101 = array[1],
        //            J0GCB13CF101 = array[2],
        //            J0GCB20CT101 = array[3],
        //            J0GCB20CQ101_NTU = array[4],
        //            J0GCB10CP102 = array[5],
        //            J0GCB21CF101 = array[6],
        //            J0GCB21CF102 = array[7],
        //            J0GCB21CP101 = array[8],
        //            J0GCB21CP102 = array[9],
        //            J0GCB21CQ101_NTU = array[10],
        //            J0GCB22CF101 = array[11],
        //            J0GCB22CF102 = array[12],
        //            J0GCB22CP101 = array[13],
        //            J0GCB22CP102 = array[14],
        //            J0GCB22CQ101_NTU = array[15],
        //            J0GCB31CL101 = array[16],
        //            J0GCB32CL101 = array[17],
        //            J0GCB50CP101 = array[18]
        //        };

        //        var conut = new ReportDataProvider().Insert(reportData);
        //    }
        //}
        #endregion
    }
}


<?xml version="1.0" encoding="utf-8"?>
<Settings>
  <NodeClass Name="PLC设备" Description="各种PLC控制设备">
    <DeviceNode Name="西门子PLC" Description="空压系统1#PLC" DeviceType="30" ConnectTimeOut="2000" ReConnectTime="5000" CreateTime="2022/1/26 5:03:03" InstallationDate="2022/1/26 5:03:03" IsActive="True" MaxErrorTimes="1" KeyWay="VarName" UseAlarmCheck="False" IpAddress="192.168.10.134" Port="502" PlcType="S71500" Rack="0" Slot="0" IsUseMultiRead="false" />
  </NodeClass>
  <NodeClass Name="OPC客户端" Description="OPC相关客户端" />
  <NodeClass Name="Modbus客户端" Description="Modbus相关客户端">
    <ModbusNode Name="Modbus TCP Client" Description="1#软水系统" ModbusType="2000" ConnectTimeOut="2000" CreateTime="2022/1/26 7:01:52" ReConnectTime="5000" InstallationDate="2022/1/26 7:01:52" IsActive="True" MaxErrorTimes="1" KeyWay="VarName" UseAlarmCheck="False" ServerURL="192.168.10.134" Port="502" DataFormat="ABCD">
      <ModbusGroup Name="读_读写" Description="Float_Bool" Type="ModbusTCP" StoreArea="保持寄存器" Length="15" Start="0" SlaveID="1" IsActive="true">
        <Variable Name="J0GCB11CF101" Description="1号活性碳过滤器入口水流量" Type="ModbusTCP" VarAddress="0" Scale="1" Offset="0" Start="0" AccessProperty="只读" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="Float" />
        <Variable Name="J0GCB12CF101" Description="2号活性碳过滤器入口水流量" Type="ModbusTCP" VarAddress="2" Scale="1" Offset="0" Start="0" AccessProperty="只读" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="Float" />
        <Variable Name="J0GCB13CF101" Description="3号活性碳过滤器入口水流量" Type="ModbusTCP" VarAddress="4" Scale="1" Offset="0" Start="0" AccessProperty="只读" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="Float" />
        <Variable Name="J0GCB20CT101" Description="超滤装置进口母管水温度" Type="ModbusTCP" VarAddress="6" Scale="1" Offset="0" Start="0" AccessProperty="只读" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="Float" />
        <Variable Name="J0GCB20CQ101_NTU" Description="超滤装置进口母管浊度" Type="ModbusTCP" VarAddress="8" Scale="1" Offset="0" Start="0" AccessProperty="只读" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="Float" />
        <Variable Name="J0GCB31CL101" Description="1号超滤出水水箱水位" Type="ModbusTCP" VarAddress="10" Scale="1" Offset="0" Start="0" AccessProperty="读写" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="UShort" />
        <Variable Name="J0GCB32CL101" Description="2号超滤出水水箱水位" Type="ModbusTCP" VarAddress="11" Scale="1" Offset="0" Start="0" AccessProperty="读写" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="UShort" />
        <Variable Name="J0GCB50CP101" Description="超滤出水升压泵出口母管压" Type="ModbusTCP" VarAddress="12" Scale="1" Offset="0" Start="0" AccessProperty="读写" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="UShort" />
        <Variable Name="J0GCB60CF101" Description="超滤反洗水泵出口母管流量" Type="ModbusTCP" VarAddress="13" Scale="1" Offset="0" Start="0" AccessProperty="读写" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="UShort" />
        <Variable Name="J0GCB60CP101" Description="超滤反洗水泵出口母管压力" Type="ModbusTCP" VarAddress="14" Scale="1" Offset="0" Start="0" AccessProperty="读写" AlarmEnable="False" ArchiveEnable="True" SetLimitEnable="False" ArchivePeriod="2" VarType="UShort" />
      </ModbusGroup>
    </ModbusNode>
  </NodeClass>
  <NodeClass Name="Custom客户端" Description="Custom相关客户端" />
  <NodeClass Name="服务器" Description="自定义服务器" />
</Settings>

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMStestMdbus
{
    public class ActualDataProvider
    {
        public int Delete(ActualData t)
        {
            if (t == null) return 0;
            ActualData model = SqlSugarHelper.db.Queryable<ActualData>().Where(item => item.Id == t.Id).First();
            if (model == null) return 0;

            int count = SqlSugarHelper.db.Deleteable<ActualData>(model).ExecuteCommand();
            return count;
        }

        //public int Insert(ActualData t)
        //{
        //    int count = SqlSugarHelper.db.Insertable<ActualData>(t).ExecuteCommand();
        //    return count;
        //}

        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        /// 
        public int Insert(List<ActualData> t)
        {
            if (t == null) return 0;
            ////if (t.Value == null) return 0;
            ////方法1
            //foreach (var item in t.ToArray())
            //{
            //    SqlSugarHelper.db.Insertable<ActualData>(item).ExecuteCommand();
            //}
            ////方法2
            int count = SqlSugarHelper.db.Insertable(t.ToArray()).ExecuteCommand();//官方推荐的
            return count;
        }


        public List<ActualData> Select()
        {
            DateTime day = DateTime.Now.AddDays(-1);
            return SqlSugarHelper.db.Queryable<ActualData>().Where(u => SqlFunc.Between(u.InsertTime, day,DateTime.Now)).ToList();
            //return SqlSugarHelper.db.Queryable<ActualData>().ToList();
        }

        public int Update(ActualData t)
        {
            if (t == null) return 0;
            ActualData model = SqlSugarHelper.db.Queryable<ActualData>().Where(item => item.Id == t.Id).First();
            if (model == null) return 0;
            model.Value = t.Value;
            model.Remark = t.Remark;
            model.VarName = t.VarName;
            int count = SqlSugarHelper.db.Updateable<ActualData>(model).ExecuteCommand();
            return count;
        }
    }
}


using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMStestMdbus
{
    public class SqlSugarHelper
    {
        public static string ConnectionString = string.Empty; //必填, 数据库连接字符串
        public static SqlSugarClient db
        {
            get => new SqlSugarClient(new ConnectionConfig()
            {
                ConnectionString = ConnectionString,
                DbType = SqlSugar.DbType.Sqlite,         //必填, 数据库类型
                IsAutoCloseConnection = true,       //默认false, 时候知道关闭数据库连接, 设置为true无需使用using或者Close操作
                InitKeyType = InitKeyType.SystemTable    //默认SystemTable, 字段信息读取, 如：该属性是不是主键，是不是标识列等等信息
            });
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMStestMdbus
{
    public class SqlSugarService
    {
        /// <summary>
        /// 设置连接字符串
        /// </summary>
        /// <param name="ConnectionStr"></param>
        public static void SetConnectionStr(string ConnectionStr)
        {
            SqlSugarHelper.ConnectionString = ConnectionStr;
        }
    }
}

//SqlSugarService.SetConnectionStr("Data Source=" + Application.StartupPath + "\\Config\\ScadaData.db;Pooling=true;FailIfMissing=false");
SqlSugar 1.项目安装
DotNeter-Hpf的博客
05-18 912
文章目录Nuget安装SqlSugar Nuget安装SqlSugar [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sd3XvAqy-1652883748437)(en-resource://database/1879:1)] 详细说明 SqlSugar .Net Framework可用 需手动安装驱动 SqlSugarCore .Net Core / .NET5 /.NET6可用 会自动安装常用数据库驱动 若要使用无驱动，可以用 SqlSugarCoreNoDr
SqlSugar:基于SQLSugar框架在 .Net环境中搭建PostgreSQL数据库访问、操作的框架，C#连接访问PostgreSQL数据库
weixin_46540714的博客
05-27 7069
本文描述了在.Net环境中使用SQLSugar框架连接及访问PostgreSQL数据库的详细操作过程，主要包括四个步骤：1 下载SqlSugar包 2 创建初始化并连接数据库工具类 3 创建数据操作类 4调用操作类访问数据库。
一套使用sqlsugar的企业级web应用框架
03-24
该程序是一套集成了管理软件系统前后台框架，底层使用了国内孙凯旋开发的sqlsugar数据模型框架，该框架吸收了EF中使用lambda表达式的查询方式,同时性能上与手写sql的Dapper框架同样高效，可以说是.net数据模型里最成熟的框架。该系统是作者（王立群）经过多个项目，不断优化改进而提炼形成，实现了菜单管理，用户角色管理的基础框架。开发者可以在此基础上按照系统设计好的分层与数据访问方式，快速构建企业级web应用系统。
深入浅出 SQLSugar：快速掌握高效 .NET ORM 框架
最新发布
2509_94000887的博客
11-06 815
通过链式操作简化常见数据库操作。优化底层 SQL 执行效率。兼容 SQL Server、MySQL、SQLite、PostgreSQL、Oracle 等。支持事务、动态表名、分页、多表联查等高级特性。SQLSugar 支持通过特性映射数据库表和字段。[SugarTable("Users")] // 指定数据库表名为 "Users"[SugarColumn(IsPrimaryKey = true, IsIdentity = true)] // 主键且自增set;set;set;
ORM--SqlSugar
08-11 290
这个是很久之前就开始用的一款ORM，挺好用的，推荐~ 关键词： SqlSugar：一款小巧，并且功能齐全的ORM 参考手册网址：http://www.codeisbug.com/Home/Doc 多表关联查询： List<resource> resource = db.Queryable<resource>() ...
SQLSUGAR
安宇轩~
09-15 371
1
精选资源
.Net Core2.1 使用SqlSugar对SqlServer数据库操作
07-04
在.NET Core 2.1开发环境中，SqlSugar是...总之，.NET Core 2.1项目使用SqlSugar和三层架构进行数据库操作，实现了高效、简洁的代码组织。通过这种方式，开发者可以专注于业务逻辑，而不用过于关注底层的数据操作细节。
精选资源
C#.net8创建webapi，使用SqlSugar，仓储模式，DTO，服务层，控制层的综合应用【可联系作者购买】
03-26
C#.net8创建webapi，使用SqlSugar，仓储模式，DTO，服务层，控制层的综合应用。 1.付费下载后，博主保证能运行成功，不成功可以联系博主。 2.也可以私下单独联系博主进行付费下载。
精选资源
WPF+Mvvm项目入门完整教程-基于SqlSugar的数据库实例（三）
10-17
在本教程中，我们将深入探讨如何在WPF（Windows Presentation Foundation）项目中使用MVVM（Model-View-ViewModel）设计模式，并结合SqlSugar ORM（Object-Relational Mapping）框架以及MySql数据库，实现一个完整的...
sqlsugar 实现的项目
06-28
### 回答1： SQLSugar是一个轻量级的ORM（对象关系映射）框架，用于实现.NET平台上与数据库的交互。使用SQLSugar可以简化数据库操作，...在项目中使用 SQLSugar，我能够轻松地与数据库进行交互，从而实现了项目的需求。
SqlSugar
慕苏苏的博客
01-02 1422
真正实现零sql查询速度快于EF支持【低代码】模式支持多种数据库。
sqlSugar源码
02-20
sqlSugar3.5.3.4源码
sqlsugar快速开发demo
08-03
SqlSugar是一款轻量级、高性能、以及支持.NET 4.+和ASP.NET Core一款ORM框架。另外还支持了MySql、Sqlserver、Sqlite和Oracle
SqlSugar-SqlSugar5.zip
07-07
很多人都会问您这款ORM有哪些特点,有什么竞争力，我归纳出以上几点供你参考 1、高性能 ,不夸张的说，去掉Sql在数据库执行的时间，SqlSugar是EF数倍性能，另外在批量操作和一对多查询上也有不错的SQL优化 2、高扩展性 ，支持自定义拉姆达函数解析、扩展数据类型、支持自定义实体特性，外部缓存等 3、稳定性和技术支持， 虽然不是官方ORM, 但在稳定性上也是有着数年用户积累，如果遇到问题可以在GITHUB提出来，会根据紧急度定期解决 4、功能全面，虽然SqlSugar小巧可功能并不逊色于EF框架 5、创新、持续更新 ，向下兼容
轻量级.Net ORM SqlSuger项目实战
05-25 612
SqlSuger，清垃圾ORM实战例子。 //添加引用 using SqlSugar; //在构造函数中实例化SqlSuger clinet = new SqlSugarClient(new ConnectionConfig() { InitKeyType = InitKeyType.Attribute, ConnectionString = "........
SqlSugar 开源项目使用教程
gitblog_00477的博客
08-15 626
SqlSugar 是一个 .NET 的开源 ORM 框架，其 GitHub 仓库的目录结构清晰，便于开发者理解和使用。以下是主要的目录结构及其介绍： ``` SqlSugar/ ├── src/ │ ├── SqlSugar/ │ │ ├── Attributes/ │ │ ├── Cache/ │ │ ├── DataBase/ │ │ ├── DbAdo/...
SqlSugar-使用SqlSugar进行多数据库操作
赵玉的专栏
07-11 3253
使用SqlSugar进行多数据库操作主要涉及配置多个数据库连接、创建多个实例，并根据业务需求选择相应的实例来执行数据库操作。需要注意的是，跨库查询和分布式事务处理可能需要额外的考虑和配置。此外，还应注意每个数据库的性能和负载情况，以确保系统的稳定性和性能。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值