深度解剖datatable,现实datatable判重、合并、去重和转换

最新推荐文章于 2023-08-30 17:55:14 发布
最新推荐文章于 2023-08-30 17:55:14 发布
阅读量329 收藏 2
点赞数
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42992927/article/details/131802197
版权

1.判断DataTable中数据是否存在重复；

        /// <summary>判断DataTable中数据是否存在重复</summary>
        /// <param name="dt"></param>
        /// <param name="colName"></param>
        /// <returns></returns>
        public static bool IsReData(DataTable dt, string colName)
        {
            try
            {
                if (dt != null && dt.Rows.Count > 0)
                {
                    //对重复的数据进行筛选
                    Hashtable ht = new Hashtable();
                    foreach (DataRow dr in dt.Rows)
                    {
                        string s = dr[colName].ToString();
                        if (!ht.Contains(s))
                        {
                            ht[s] = dr[colName];
                        }
                        else
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            catch
            {
                return false;
            }
        }

2.判断DataTable中指定字段数据是否存在重复；

        /// <summary>判断DataTable中指定字段数据是否存在重复</summary>
        /// <param name="dt"></param>
        /// <param name="colName"></param>
        /// <returns></returns>
        public static bool IsReDatas(DataTable dt, string[] colName)
        {
            try
            {
                bool flag = false;
                if (dt != null && dt.Rows.Count > 0)
                {
                    DataTable _dt = dt.Copy();
                    for (int i = _dt.Rows.Count - 1; i > -1; i--)
                    {
                        Hashtable ht = new Hashtable();
                        for (int j = 0; j < colName.Length; j++)
                        {
                            ht[colName[j]] = _dt.Rows[i][colName[j]].ToString();
                        }
                        _dt.Rows.RemoveAt(i);

                        flag = IsReDatasRow(_dt, colName, ht);

                        if (flag)
                        {
                            return flag;
                        }
                    }
                }

                return flag;
            }
            catch
            {
                return false;
            }
        }
         private static bool IsReDatasRow(DataTable dt, string[] colName, Hashtable colValue)
        {
            try
            {
                if (dt != null && dt.Rows.Count > 0)
                {
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        bool flag = true;
                        for (int j = 0; j < colName.Length; j++)
                        {
                            if (!flag)
                            {
                                break;
                            }
                            if (dt.Rows[i][colName[j]].ToString() == colValue[colName[j]].ToString())
                            {
                                flag = true;
                            }
                            else
                            {
                                flag = false;
                            }
                        }

                        if (flag)
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
            catch
            {
                return false;
            }
        }

3.合并两个结构相同的DataTable；

        /// <summary>
        /// 合并两个结构相同的DataTable
        /// </summary>
        /// <param name="dt1"></param>
        /// <param name="dt2"></param>
        /// <returns></returns>
        public static DataTable UniteSameFrameDataTable(DataTable dt1, DataTable dt2)
        {
            try
            {
                if (dt1 != null && dt1.Rows.Count > 0)
                {
                    if (dt2 != null && dt2.Rows.Count > 0)
                    {
                        DataRow[] foundRows = dt2.Select();
                        for (int i = 0; i < foundRows.Length; i++)
                        {
                            dt1.ImportRow(foundRows[i]);
                        }
                    }
                    return dt1.Copy();
                }
                else
                {
                    return null;
                }
            }
            catch
            {
                return null;
            }
        }

4.去掉DataTable中的重复行

         /// <summary>
        /// 去掉DataTable中的重复行
        /// </summary>
        /// <param name="dt1"></param>
        /// <returns></returns>
        public static DataTable RemoveReData(DataTable dt1)
        {
            try
            {
                if (dt1 != null && dt1.Rows.Count > 0)
                {
                    DataView myDataView = new DataView(dt1);

                    string[] strComuns = new string[dt1.Columns.Count];
                    for (int i = 0; i < dt1.Columns.Count; i++)
                    {
                        strComuns[i] = dt1.Columns[i].ColumnName;
                    }

                    return myDataView.ToTable(dt1.TableName, true, strComuns);

                }
                else
                {
                    return null;
                }
            }
            catch
            {
                return null;
            }
        }

5.去掉DataTable中的指定字段的重复行

        /// <summary>
        /// 去掉DataTable中的指定字段的重复行
        /// </summary>
        /// <param name="dt1"></param>
        /// <param name="idColName"></param>
        /// <returns></returns>
        public static DataTable RemoveReData(DataTable dt1, string[] idColName)
        {
            try
            {
                if (dt1 != null && dt1.Rows.Count > 0)
                {
                    //保存临时值
                    string[] idValue = new string[idColName.Length];
                    for (int k = 0; k < idValue.Length; k++)
                    {
                        idValue[k] = "";
                    }

                    for (int i = dt1.Rows.Count; i > 0; i--)
                    {
                        //判断是否相同行
                        bool flag = true;
                        for (int m = 0; m < idColName.Length; m++)
                        {
                            if (dt1.Rows[i - 1][idColName[m].ToString()].ToString().Trim() != idValue[m].ToString().Trim())
                            {
                                flag = false;
                                break;
                            }
                        }

                        if (flag)
                        {
                            dt1.Rows.RemoveAt(i - 1);
                        }
                        else
                        {
                            for (int n = 0; n < idValue.Length; n++)
                            {
                                idValue[n] = dt1.Rows[i - 1][idColName[n]].ToString();
                            }
                        }
                    }

                    return dt1;
                }
                else
                {
                    return null;
                }
            }
            catch
            {
                return null;
            }
        }

6.去掉DataTable中的重复行,并且汇总；

        /// <summary>
        /// 去掉DataTable中的重复行,并且汇总
        /// </summary>
        /// <param name="dt1"></param>
        /// <param name="idColName">所依据汇总的字段</param>
        /// <param name="sumColName">汇总列名</param>
        /// <returns></returns>
        public static DataTable RemoveReDataAndSum(DataTable dt1,string[] idColName,string[] sumColName)
        {
            try
            {
                if (dt1 != null && dt1.Rows.Count > 0)
                {
                    //保存临时值
                    string[] idValue = new string[idColName.Length];
                    for (int k = 0; k < idValue.Length; k++)
                    {
                        idValue[k] = "";
                    }

                    for (int i = dt1.Rows.Count; i > 0; i--)
                    {
                        //判断是否相同行
                        bool flag = true;
                        for (int m = 0; m < idColName.Length; m++)
                        {
                            if (dt1.Rows[i - 1][idColName[m].ToString()].ToString() != idValue[m].ToString())
                            {
                                flag = false;
                                break;
                            }
                        }

                        if (flag)
                        {
                            for (int j = 0; j < sumColName.Length; j++)
                            {
                                dt1.Rows[i][sumColName[j].ToString()] = Convert.ToInt32(dt1.Rows[i][sumColName[j].ToString()]) + Convert.ToInt32(dt1.Rows[i - 1][sumColName[j].ToString()]);
                            }
                            dt1.Rows.RemoveAt(i - 1);
                        }
                        else
                        {
                            for (int n = 0; n < idValue.Length; n++)
                            {
                                idValue[n] = dt1.Rows[i - 1][idColName[n]].ToString();
                            }
                        }
                    }

                    return dt1;
                }
                else
                {
                    return null;
                }
            }
            catch
            {
                return null;
            }
        }

7.删除dt1中与dt2相同的数据

/// <summary>
        /// 删除dt1中与dt2相同的数据
        /// </summary>
        /// <param name="dt1"></param>
        /// <param name="dt2"></param>
        /// <param name="idFieldName">主键</param>
        /// <returns></returns>
        private DataTable DeleteDoubleTableByID(DataTable dt1, DataTable dt2, string idFieldName)
        {
            try
            {
                if (dt1 != null)
                {
                    string _id = "";
                    DataView dataView = dt1.DefaultView;
                    string filter = "";
                    foreach (DataRow dr in dt2.Rows)
                    {
                        _id += "'" + dr[idFieldName].ToString() + "',";
                    }
                    if (_id != "")
                    {
                        _id = _id.TrimEnd(',');
                    }
                    filter = idFieldName + " not in (" + _id + ")";
                    dataView.RowFilter = filter;

                    dt1 = null;
                    dt1 = dataView.ToTable().Copy();
                }

                return dt1;
            }
            catch
            {
                return null;
            }
        }

8.dataTable分页；

/// <summary> 
        /// DateTable的分页操作 
        /// </summary> 
        /// <param name="dt">要进行分页的DataTable</param> 
        /// <param name="currentPageIndex">当前页数</param> 
        /// <param name="pageSize">一页显示的条数</param> 
        /// <returns>第pageIndex页的数据</returns> 
        public static DataTable SetDataTablePage(DataTable dt, int currentPageIndex, int pageSize)
        {
            if (currentPageIndex == 0)
            {
                return dt.Copy();
            }

            DataTable newdt = dt.Clone();

            int rowbegin = (currentPageIndex - 1) * pageSize;//当前页的第一条数据在dt中的位置 
            int rowend = currentPageIndex * pageSize;//当前页的最后一条数据在dt中的位置 

            if (rowbegin >= dt.Rows.Count)
            {
                return newdt;
            }

            if (rowend > dt.Rows.Count)
            {
                rowend = dt.Rows.Count;
            }

            DataView dv = dt.DefaultView;
            for (int i = rowbegin; i <= rowend - 1; i++)
            {
                newdt.ImportRow(dv[i].Row);
            }

            return newdt;
        }
程序人生lwp
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#中datatable去重的方法
09-04
主要介绍了C#中datatable去重的方法,通过两种不同的方法对比分析了datatable去重的技巧,非常具有实用价值,需要的朋友可以参考下
C#实现DataTable,List和Json转换的方法
09-01
主要介绍了C#实现DataTable,List和Json转换的方法,结合实例形式分析了DataTable、list、DataReader、DataSet等转换成JSON的相关实现技巧,需要的朋友可以参考下
C# DataTable去重，根据列名去重保留其他列
Denny辉的博客
07-17 4045
//去掉重复行 DataView dv = table.DefaultView; table = dv.ToTable(true, new string[] { "name", "code" });此时table 就只有name、code无重复的两行了，如果还需要id值则table = dv.ToTable(true, new string[] { "id","name", "code" });//
C# 对DataTable 的某一列进行去重,并保留其他列,其他列不去重
m0_60580105的博客
08-30 1171
LINQ 来对 DataTable 的某一列进行去重操作，并同时保留其他列
DataTable去重
weixin_30855761的博客
10-12 549
#region datatable去重 /// <summary> /// datatable去重 /// </summary> /// <param name="dtSource">需要去重的datatable</param> /// <para...
DataTable 根据字段去重
.Net9527的技术博客
08-26 515
下面是新的数据行插入到datatable中。
Datatable去重
u011298872的博客
10-20 367
DataView dataView = dtall.DefaultView; DataTable dataTableDistinct = dataView.ToTable(true, "厂家名称");
按照指定字段删除DataTable中的重复行
写代码的蜗牛
07-02 1214
在DataTable中，如果要删除重复行，可以使用如下代码。 DataView dv = new DataView(finalResultSet.ResultDataTable); DataTable dt2 = dv.ToTable(true); 根据现有DataView中的行，创建并返回一个新的DataTable。参数Boolean如果为true，则返回所有列都具有不同值的行，为fals...
c# DataTable与不同结构实体类转换的方法实例
09-04
在C#编程中，`DataTable` 是.NET框架中用于存储和操作数据的一种强大工具，而实体类（Entity Class）则是面向对象编程中用于封装数据的类。在实际项目开发中，尤其是在处理大量数据时，经常需要将 `DataTable` 的...
C#实现DataTable转换成IList的方法
09-02
在C#编程中，将`DataTable`转换为`IList<T>`可以极大地方便我们对数据的操作和处理，因为`IList<T>`是强类型的数据集合，它允许我们以对象的方式进行操作，而不是通过索引访问。下面我们将详细介绍如何实现这个转换...
datatable过滤HTML,去除DataTable重复数据的三种方法
weixin_42356844的博客
06-07 407
去除DataTable重复数据的三种方法https://www.cnblogs.com/sunxi/p/4767577.html第二种中增加变量。 string name,保存 遍历的到的 i的 name值。倒叙遍历，如果 与之相等。那么就移除 i+1的数据业务需求最近做一个把源数据库的数据批次导出到目标数据库。源数据库是采集程序采集而来的原始数据库，所以需要对其进行一些处理(过滤一些为空，长度太...
前端制作表格神器　dataTable 基本用法
weixin_33985507的博客
04-25 1691
1、开始使用DataTables很简单，只需要引入两个文件， 一个css样式文件和DataTables本身的脚本文件。在DataTables CDN上，可以使用下面这两个文件： css http://cdn.datatables.net/1.10.15/css/jquery.dataTables.min.css js http://cdn.datatables.net/1.10.1...
合并DataTable并排除重复数据的方法
weixin_34212762的博客
08-11 2016
2019独角兽企业重金招聘Python工程师标准>>> ...
利用jquery-latest.js实现合并table多列重复行
LYBWWP
03-24 8687
$(function () { // 看过jquery源码就可以发现$.fn就是$.prototype, 只是为了兼容早期版本的插件 // 才保留了jQuery.prototype这个形式 $.fn.mergeCell = function (options) { return this.e
20180322 对DataTable里面的数据进行去重
weixin_30552635的博客
03-22 131
对DataTable里面的数据进行去重 DataTable dt = new DataTable(); dt.Columns.Add("Id", typeof(int)); dt.Columns.Add("Nu", typeof(int)); Random r = new Random(DateTime.Now.M...
Jquery DataTable基本使用
weixin_33937499的博客
03-27 530
1，首先需要引用下面两个文件      &lt;link rel="stylesheet" href="https://cdn.datatables.net/1.10.16/css/jquery.dataTables.min.css" /&gt; &gt; 2，DataTable支持的数据类型 https://www.datatables.net/manual/data/ 2.1 数组 ...
vb datatable 去重
最新发布
09-16
### 回答1： 在 VB.NET 中，可以使用以下方法实现 DataTable 的去重： 1. 使用 DefaultView.ToTable() 方法 使用 DataTable 的 DefaultView.ToTable() 方法可以返回一个新的 DataTable，其中包含了原始 DataTable 中的不重复行。 ```vb Dim dt As New DataTable() ' 假设表中有两列，列名为 Column1 和 Column2 ' 加载数据到 DataTable dt 中 ' ... Dim distinctValues As DataTable = dt.DefaultView.ToTable(True, "Column1", "Column2") ' 返回一个新的 DataTable，其中包含了 dt 中的不重复行 ' True 表示只保留不重复的行，"Column1", "Column2" 表示按照这两列进行去重 ``` 2. 使用 LINQ 查询 可以使用 LINQ 查询语句来筛选出不重复的行，然后将其转换为新的 DataTable。 ```vb Dim dt As New DataTable() ' 假设表中有两列，列名为 Column1 和 Column2 ' 加载数据到 DataTable dt 中 ' ... Dim distinctRows = From row In dt.AsEnumerable() Group row By key = New With {Key .Column1 = row.Field(Of String)("Column1"), Key .Column2 = row.Field(Of String)("Column2")} Into Group Select Group.First() Dim distinctValues As DataTable = distinctRows.CopyToDataTable() ' 返回一个新的 DataTable，其中包含了 dt 中的不重复行 ``` 其中，Group By 子句将 DataTable 中的行按照指定的列进行分组，然后使用 Select 子句选择每个分组中的第一个元素，最后使用 CopyToDataTable() 方法将其转换为新的 DataTable。 ### 回答2： 在VB中，可以使用DataTable实现数据去重的操作。 首先，我们需要创建一个DataTable对象，并添加需要去重的数据。 然后，我们可以使用以下代码进行去重操作： Dim dt As New DataTable() '添加数据到dt中 '创建一个新的DataTable用于存储去重后的数据 Dim newDt As DataTable = dt.DefaultView.ToTable(True) 上述代码中，我们通过dt.DefaultView.ToTable(True)将DataTable dt中的数据按照默认视图进行去重，并将去重后的数据存储到新建的DataTable对象newDt中。 在去重时，默认视图会根据所有列的值进行判断，只有在所有列的值都相同的情况下，才认为是重复数据。 除了使用默认视图进行去重，我们还可以使用LINQ语句来去重。可以通过以下代码进行操作： Dim distinctRows = (From row In dt.AsEnumerable() Select row).Distinct() 使用以上代码，我们可以获取到去重后的数据集合distinctRows，其中的每一行数据都是不重复的。 总结来说，无论是使用默认视图还是LINQ语句，都可以实现在VB中使用DataTable进行数据去重的操作。具体选择哪种方式取决于实际需求和个人喜好。 ### 回答3： 在VB中，要对DataTable进行去重操作，可以使用Distinct()方法。Distinct()方法用于从DataTable中选择不同的行，并创建一个新的DataTable。 下面是一个简单的示例代码，展示了如何使用Distinct()方法来去除DataTable中重复的行： ``` ' 创建一个示意的DataTable Dim dt As New DataTable() dt.Columns.Add("ID", GetType(Integer)) dt.Columns.Add("Name", GetType(String)) dt.Rows.Add(1, "John") dt.Rows.Add(2, "Jane") dt.Rows.Add(1, "John") dt.Rows.Add(3, "Mike") dt.Rows.Add(2, "Jane") ' 使用Distinct()方法创建一个新的去重后的DataTable Dim distinctDT As DataTable = dt.DefaultView.ToTable(True) ' 输出去重后的DataTable For Each row As DataRow In distinctDT.Rows Console.WriteLine(row("ID") & vbTab & row("Name")) Next ``` 运行上述代码将输出结果： ``` 1 John 2 Jane 3 Mike ``` 在代码中，我们创建了一个示意的DataTable，并添加了几行数据，其中有重复的行。然后，我们使用DataTable的DefaultView属性的ToTable方法，传入参数true，创建了一个去重后的新DataTable。最后，我们遍历这个新的DataTable的每一行，并输出相应的字段值。 这样，我们就可以通过Distinct()方法对DataTable进行去重操作。请注意，Distinct()方法将根据各行的值来判断是否为重复行，所以要确保DataTable中的字段值是可比较的。如果需要根据特定的字段进行去重，可以使用DefaultView属性的RowFilter属性来设定过滤条件。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值