首页 > 数据库 >使用C# asp.net core 同步数据库

使用C# asp.net core 同步数据库

时间:2024-02-01 15:25:54浏览次数:29  
标签:core asp string tempTable C# tableName targetDb var sourceDataTable

代码片段: 文末附链接。

using DataSync.Core;
using Furion.Logging.Extensions;
using Microsoft.Data.SqlClient;
using Microsoft.Extensions.Logging;
using System.Data;
namespace DataSync.Application.DataSync.Services
{
    public class DataSyncServices : IDataSyncData, ITransient
    {
        private readonly object lockObj = new object();
        /// <summary>
        /// 客户端向服务端同步
        /// </summary>
        /// <param name="clientConn"></param>
        /// <param name="serviceConn">目标数据库</param>
        /// <returns></returns>
        public string SyncDataForClient(string clientConn, string serviceConn)
        {
            return SyncData(clientConn, serviceConn);
        }
        /// <summary>
        /// 服务端向客户端同步
        /// </summary>
        /// <param name="serviceConn"></param>
        /// <param name="clientConn"></param>
        /// <returns></returns>
        public string SyncDataForServer(string serviceConn, string clientConn)
        {
            return SyncData(serviceConn, clientConn);
        }
        /// <summary>
        /// 数据同步
        /// </summary>
        private string SyncData(string sourceConn, string targetConn)
        {
            try
            {

                //源数据库 数据源链接
                SqlSugarScope sourceDb = new SqlSugarScope(new ConnectionConfig()
                {
                    DbType = SqlSugar.DbType.SqlServer,
                    ConnectionString = sourceConn,
                    IsAutoCloseConnection = true,
                    AopEvents = new AopEvents
                    {
                        OnLogExecuting = (sql, ps) =>
                        {
#if DEBUG
                            Log.Information($"语句:{sql},参数:{(ps.Any() ? "[" : string.Empty) + string.Join("|", ps.Select(m => $"{m.ParameterName}={m.Value}")) + (ps.Any() ? "]" : string.Empty)}");
#endif
                        }
                    }
                });
                //目标数据库 数据源链接
                SqlSugarScope targetDb = new SqlSugarScope(new ConnectionConfig()
                {
                    DbType = SqlSugar.DbType.SqlServer,
                    ConnectionString = targetConn,
                    IsAutoCloseConnection = true,
                    AopEvents = new AopEvents
                    {
                        OnLogExecuting = (sql, ps) =>
                        {
#if DEBUG
                            Log.Information($"语句:{sql},参数:{(ps.Any() ? "[" : string.Empty) + string.Join("|", ps.Select(m => $"{m.ParameterName}={m.Value}")) + (ps.Any() ? "]" : string.Empty)}");
#endif
                        }
                    }
                });
                //使用sqlsugar 初始化目标数据库
                targetDb.DbMaintenance.CreateDatabase();
                var tableNames = sourceDb.DbMaintenance.GetTableInfoList(false).Select(t => t.Name).ToList(); // 调用函数获取所有表名
                var syncBlackTable = App.GetConfig<List<string>>("SyncBlackTable");
                tableNames = tableNames.Except(syncBlackTable).ToList();
                //多线程
                Parallel.ForEach(tableNames, tableName =>
                {
                    lock (lockObj)
                    {
                        // 根据表名从源数据库中获取数据并存入 DataTable
                        var targetdataTable = DataTableHelper.FetchDataFromTable(tableName, sourceDb);
                        //判断数据表在目标库是否存在
                        var flagTargetTab = targetDb.DbMaintenance.IsAnyTable(tableName);
                        if (!flagTargetTab)
                        {
                            // 创建表的SQL语句
                            var createTableSql = $"CREATE TABLE {tableName} (";
                            if (targetdataTable != null && targetdataTable.Rows.Count > 0)
                            {
                                //目标数据库写入-先移除数据同步标识
                                DataBaseInfoService.DatatableRemoveCloumns(targetdataTable);
                                // 遍历DataTable的列
                                foreach (DataColumn column in targetdataTable.Columns)
                                {
                                    string columnName = column.ColumnName;
                                    string dataType = DataBaseInfoService.GetSqlDataType(column.DataType);

                                    createTableSql += $"{columnName} {dataType}, ";
                                }
                                createTableSql = createTableSql.TrimEnd(',', ' ') + ")";
                                // 创建表
                                targetDb.Ado.ExecuteCommand(createTableSql);

                                ("TargetTable : " + tableName + ",创建成功").LogInformation();
                                //    }
                                //}
                            }
                        }
                        //AppSys
                        if (tableName.ToUpper().Equals("APPSYS"))
                        {
                            AppSysDataSync.SyncData(tableName, sourceDb, targetDb);
                        }
                        var selectCountSql = $"SELECT COUNT(*) FROM {tableName} ";

                        var sourceCount = sourceDb.Ado.GetInt(selectCountSql);

                        var middleCount = targetDb.Ado.GetInt(selectCountSql);
                        //增量
                        if (sourceCount > middleCount)
                        {
                            //  commandTarget.Connection = connTarget;
                            // commandTarget.CommandType = CommandType.Text;
                            //查询数据
                            var selectTableSql = $"SELECT * FROM {tableName}";
                            //创建datatable(源数据)
                            var sourceDataTable = sourceDb.Ado.GetDataTable(selectTableSql);

                            if (sourceDataTable != null && sourceDataTable.Rows.Count > 0)
                            {
                                //新增列 MD5
                                DataBaseInfoService.DataTableAddColumsMd5(sourceDataTable);
                            }
                            //创建datatable(目标表数据)
                            var targetDataTable = targetDb.Ado.GetDataTable(selectTableSql);

                            if (targetDataTable != null && targetDataTable.Rows.Count > 0)
                            {
                                //新增列 MD5
                                DataBaseInfoService.DataTableAddColumsMd5(targetDataTable);
                            }
                            // 计算差集
                            var tempTable = new DataTable();
                            var tempExceptTable = (from source in sourceDataTable.AsEnumerable()
                                                   where
                                                   !(from target in targetDataTable.AsEnumerable() select target.Field<string>("MD5")).Contains(
                                                   source.Field<string>("MD5"))
                                                   select source);
                            if (tempExceptTable != null && tempExceptTable.Count() > 0)
                            {
                                tempTable = tempExceptTable.CopyToDataTable();
                            }
                            //批量插入数据
                            if (tempTable != null && tempTable.Rows.Count > 0)
                            {
                                //目标数据库写入-先移除数据同步标识,MD5标识
                                DataBaseInfoService.DatatableRemoveCloumns(tempTable);
                                var connTarget = new SqlConnection(targetConn);
                                DataBaseInfoService.DataBulkCopy(connTarget, tableName, tempTable);

                                //  TargetDataScope.Db.Fastest<DataTable>().AS(tableName).BulkCopy(tempTable);
                            }
                        }
                        //删除
                        else if (sourceCount < middleCount)
                        {
                            //查询数据
                            var selectTableSql = $"SELECT * FROM {tableName}";
                            //创建datatable(源数据)
                            var sourceDataTable = sourceDb.Ado.GetDataTable(selectTableSql);

                            if (sourceDataTable != null && sourceDataTable.Rows.Count > 0)
                            {
                                //新增列 MD5
                                DataBaseInfoService.DataTableAddColumsMd5(sourceDataTable);
                            }
                            //创建datatable
                            var taergetTable = targetDb.Ado.GetDataTable(selectTableSql);
                            if (taergetTable != null && taergetTable.Rows.Count > 0)
                            {
                                //新增列 MD5
                                DataBaseInfoService.DataTableAddColumsMd5(taergetTable);
                            }
                            // 计算差集
                            var tempTable = new DataTable();
                            var tempExceptTable = (from target in taergetTable.AsEnumerable()
                                                   where
                                                   !(from source in sourceDataTable.AsEnumerable() select source.Field<string>("MD5")).Contains(
                                                   target.Field<string>("MD5"))
                                                   select target);
                            if (tempExceptTable != null && tempExceptTable.Count() > 0)
                            {
                                tempTable = tempExceptTable.CopyToDataTable();
                            }
                            if (tempTable != null && tempTable.Rows.Count > 0)
                            {
                                //获取主键字段
                                var PrimaryKeyName = targetDb.DbMaintenance.GetPrimaries(tableName);
                                //DataTableHelper.GetPrimaryKeyFieldName(tableName, connTarget);
                                //获取自增列
                                var Identities = targetDb.DbMaintenance.GetIsIdentities(tableName);
                                if (PrimaryKeyName != null && PrimaryKeyName.Count > 0)
                                {
                                    foreach (DataRow row in tempTable.Rows)
                                    {
                                        var deleteDataSql = DataTableHelper.ConstructDeleteSql(tableName, PrimaryKeyName, Identities, row);
                                        //$"DELETE FROM {tableName} WHERE {PrimaryKeyName} ='{row[PrimaryKeyName[0]]}'";
                                        //目标数据数据操作对象
                                        targetDb.Ado.ExecuteCommand(deleteDataSql);

                                    }
                                }
                            }
                        }
                        //更新
                        else
                        {
                            //判断是否存在需要更新的记录
                            //和目标表比较取差集
                            //查询数据
                            var selectTableSql = $"SELECT * FROM {tableName}";
                            //创建datatable(源数据)
                            var sourceDataTable = sourceDb.Ado.GetDataTable(selectTableSql);
                            if (sourceDataTable != null && sourceDataTable.Rows.Count > 0)
                            {
                                //新增列 MD5
                                DataBaseInfoService.DataTableAddColumsMd5(sourceDataTable);
                            }
                            //创建datatable(目标表数据)
                            var targetDataTable = targetDb.Ado.GetDataTable(selectTableSql);
                            if (targetDataTable != null && targetDataTable.Rows.Count > 0)
                            {
                                //新增列 MD5
                                DataBaseInfoService.DataTableAddColumsMd5(targetDataTable);
                            }
                            // 计算差集
                            var tempTable = new DataTable();
                            var tempExceptTable = (from source in sourceDataTable.AsEnumerable()
                                                   where
                                                   !(from target in targetDataTable.AsEnumerable() select target.Field<string>("MD5")).Contains(
                                                   source.Field<string>("MD5"))
                                                   select source);
                            if (tempExceptTable != null && tempExceptTable.Count() > 0)
                            {
                                tempTable = tempExceptTable.CopyToDataTable();
                            }
                            if (tempTable != null && tempTable.Rows.Count > 0)
                            {
                                //删除标识列和MD5列
                                DataBaseInfoService.DatatableRemoveCloumns(tempTable);
                                //获取目标表主键字段
                                var PrimaryKeyName = targetDb.DbMaintenance.GetPrimaries(tableName);
                                //获取自增列
                                var Identities = targetDb.DbMaintenance.GetIsIdentities(tableName);
                                //DataTableHelper.GetPrimaryKeyFieldName(tableName, connTarget);
                                foreach (DataRow dataRow in tempTable.Rows)
                                {
                                    var updateDataSql = DataTableHelper.ConstructUpdateSql(tableName, PrimaryKeyName, Identities, dataRow);
                                    targetDb.Ado.ExecuteCommand(updateDataSql);

                                }
                            }
                        }
                    }
                });
            }
            catch (Exception ex)
            {
                ("Error occurred while connecting to database or fetching data from tables.\n" + ex.Message).LogError();
                return "同步失败。详见错误日志!";
            }
            return "同步完成!";
        }

    }
}

  Gitee: https://gitee.com/ltf_free/sync-data.git

标签:core,asp,string,tempTable,C#,tableName,targetDb,var,sourceDataTable
From: https://www.cnblogs.com/100234ltf/p/18001324

相关文章

  • 强连通分量(SCC,Strongly Connected Components)学习笔记 & edited in 2024.01.31
    更新日志upd2024.01.31写好文章基本内容upd2024.01.31发表于洛谷upd2024.02.01同步发表于CSDNupd2024.02.01同步发表于博客园cnblogs强连通分量(SCC,StronglyConnectedComponents)定义强连通有向图(DAG)中若其中两点$x$,$y$能彼此到达(不一定是直接连边),称$x$和......
  • stack
    stack的定义与结构栈,是一种后进先出的数据结构,头文件<stack>只可以包含一个类型,只可以执行元素压到栈顶,或弹出栈顶的操作。stack的常用函数push(x)在栈顶插入元素xpop()弹出栈顶元素top()返回栈顶元素empty()检查栈是否为空size()返回栈中元素个数,不可遍历如果将一个数组......
  • vector
    vector的定义与特性为动态数组,可以存储一系列相同类型的元素。头文件<vector>vector<类型>变量名;会根据元素数量自动分配内存空间可以使用索引访问,索引(下标)从0开始,最后一个元素的索引为size()-1,但是不可以写成i<=size()-1,因为size为整数未定型,这样写会变得很大,会出问题,可以......
  • 在Java中重写hashCode()方法
    而在重写equals()方法时,总要重写hashCode()方法,原因总结下有以下两点:1.使用hashcode方法提前校验,可以避免每一次比对都调用equals方法,提高效率2.保证是同一个对象,如果重写了equals方法,而没有重写hashcode方法,会出现equals相等的对象,hashcode不相等的情况,重写hashcode方法就是为了......
  • react-native中memo、useMemo、useCallback 你真的用明白了吗
    memo的作用在React的渲染流程中,一般来说,父组件的某个状态发生改变,那么父组件会重新渲染,父组件所使用的所有子组件,都会强制渲染。而在某些场景中,子组件并没有使用父组件传入的没有发生更改的状态时,子组件重新渲染是没有必要的。因此有了React.memomemo的使用memo是个高阶......
  • js获取/设置css变量
    -<!DOCTYPEhtml><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width,initial-scale=1.0"><title>Document</title><st......
  • js处理excel数据
    借助xlsx实现js读取处理excel数据,并输出excel文件<inputtype="file"@change="fn"/>import*asXLSXfrom'xlsx'fn(e){letfileObj=e.target.files[0]constfileReader=newFileReader()fileReader.readAsArrayBuffer(fileObj)fileR......
  • CF1753D 题解
    因为最后要找的是“腾出空位”的最小代价。所以不妨把“障碍的移动”转化为“空位的移动”。令\(f_{x,y}\)为:使得\((x,y)\)为空,至少需要多少代价。下面来找转移方程,显然转移方程与空格子移动有关。所以观察空格子移动的规律。若当前格子\((x,y)\)为L。以\((x,y+1)\)......
  • 上下文切换(context switch)
    上下文切换(contextswitch)1、平均负载高CPU使用率高I/O使用率低---->原因:计算密集型(CPU使用密集)2、平均负载高CPU使用率低I/O使用率高---->原因:I/O密集型3、平均负载高CPU使用率低I/O使用率高多进程iowait较高---->原因:大量进程挤占多个进程竞争......
  • CPU使用率--上篇
    CPU使用率CPU使用率是衡量计算机CPU资源利用程度的指标,表示CPU在一段时间内执行计算任务的占用情况。它可以帮助我们了解系统的负载情况,优化程序性能,以及监控系统的健康状况。CPU使用率通常以百分比表示,表示CPU在某个时间段内用于执行计算任务的时间占总时间的比例。例如,如果CPU......