精华内容
下载资源
问答
  • 使用LINQ检索重复

    2019-06-04 09:18:37
    日常工作的时候,我们经常遇到需要检索一组数据中是否有重复值的情况,再根据具体情况进行相应的操作。如果不使用LINQ,那我们就得使用一层一层的foreach循环来做,不但麻烦、工作效率低(因为你得绕啊~~绕啊~~~),...

    日常工作的时候,我们经常遇到需要检索一组数据中是否有重复值的情况,再根据具体情况进行相应的操作。如果不使用LINQ,那我们就得使用一层一层的foreach循环来做,不但麻烦、工作效率低(因为你得绕啊~~绕啊~~~),而且容易出bug。使用LINQ就方便得多。

    举个我前天在工作中遇到的例子吧。当时是这样的——我需要查看一下用户新插入的值是否已经存在于数据库当中,如果有,就提醒客户不能插入这个值(实际上这个值是PK)。因为在进入页面的时候,我已经把目前数据库里所有的值都读出来、放在一个DataTable里了,所以在用户保存的时候,我没必要连接数据库进行查询,只需要检索当前这个DataTable就OK了。

    假设这个DataTable有3列,分别是ID、Name、Age,ID是PK。使用foreach的笨办法,是这样:

    1. foreach (DataRow r1 in table.Rows)
    2. {
    3.     foreach (DataRow r2 in table.Rows)
    4.     {
    5.         if (r2 != r1 && r2["ID"].ToString() == r1["ID"].ToString())
    6.         {
    7.             Console.WriteLine("Warning!");
    8.             return false// 检验失败
    9.         }
    10.     }
    11. }

    如果写成这样,需要注意两点:

    • 必需要有r2 != r1这个条件,不然当一个DataRow“自己遇到自己”的时候,无论如何都会return false的
    • 必需把r1["ID"]和r2["ID"]转换成string(如果你确定它是int,那转成int也行)再进行比较,不然r1["ID"]和r2["ID"]是两个object,调用==操作符,比较的是这两个对象是否是同一个对象——当然不是!所以,永远也不会return false

    上面这种笨办法适用于两种情况:

    1. 需要比较简单、只要有重复值立刻撤退的情况
    2. 公司把代码行数与程序工资挂钩的情况

    使用LINQ可以更简单地完成上面的任务,而且还可以衍生出很多附加功能:

    我们把需求稍微改动一下,改成检验Age有没有重复的,如果有、每个值有几个重复。如果用foreach循环,那我们就要在循环内部加上一个Dictionay,以Age为Key,并对每个Key进行计数了。

    使用LINQ中的GroupBy操作,就能轻松解决这个问题。源码如下:

    1. // 水之真谛
    2. // [url]http://blog.csdn.net/FantasiaX[/url]
    3. using System;
    4. using System.Collections.Generic;
    5. using System.Linq;
    6. using System.Text;
    7. using System.Data;
    8. namespace ConsoleApplication1
    9. {
    10.     class Program
    11.     {
    12.         static void Main(string[] args)
    13.         {
    14.             DataTable table = new DataTable();
    15.             table.Columns.Add(new DataColumn("ID"typeof(int)));
    16.             table.Columns.Add(new DataColumn("Name"typeof(string)));
    17.             table.Columns.Add(new DataColumn("Age"typeof(int)));
    18.             int[] ids = new int[] { 1, 2, 3, 4, 5, 6 };
    19.             string[] names = new string[] { "Tim""Yan""Xiao Chen""Miao""Big Ma""Little Ma" };
    20.             int[] ages = new int[] { 28, 24, 28, 22, 27, 22 };
    21.             for (int i = 0; i < 6; i++)
    22.             {
    23.                 DataRow row = table.NewRow();
    24.                 row["ID"] = ids[i];
    25.                 row["Name"] = names[i];
    26.                 row["Age"] = ages[i];
    27.                 table.Rows.Add(row);
    28.             }
    29.             // 使用foreach
    30.             Dictionary<intint> dic = new Dictionary<intint>();
    31.             foreach (DataRow row in table.Rows)
    32.             {
    33.                 if (!dic.Keys.Contains(Convert.ToInt32(row["Age"])))
    34.                 {
    35.                     dic.Add(Convert.ToInt32(row["Age"]), 1);
    36.                 }
    37.                 else
    38.                 {
    39.                     dic[Convert.ToInt32(row["Age"])]++;
    40.                 }
    41.             }
    42.             foreach (var item in dic)
    43.             {
    44.                 Console.WriteLine("{0}, {1}", item.Key, item.Value);
    45.             }
    46.             Console.WriteLine("=========================================");
    47.             // 使用LINQ (隐式数据类型)
    48.             var ageGroups = table.Rows.Cast<DataRow>().GroupBy(row => Convert.ToInt32(row["Age"]));
    49.             foreach (var group in ageGroups)
    50.             {
    51.                 Console.WriteLine("{0}, {1}", group.Key.ToString(), group.Count().ToString());
    52.             }
    53.             Console.WriteLine("=========================================");
    54.             // 使用LINQ (显式数据类型)
    55.             IEnumerable<IGrouping<int, DataRow>> ageGroups2 = table.Rows.Cast<DataRow>().GroupBy(row => Convert.ToInt32(row["Age"]));
    56.             foreach (IGrouping<int, DataRow> group in ageGroups2)
    57.             {
    58.                 Console.WriteLine("{0}, {1}", group.Key.ToString(), group.Count().ToString());
    59.             }
    60.             Console.WriteLine("=========================================");
    61.             // 很酷的写法
    62.             var ageGroups3 = from row in table.Rows.Cast<DataRow>() group row by Convert.ToInt32(row["Age"]) into resultCollection select resultCollection;
    63.             foreach (var group in ageGroups3)
    64.             {
    65.                 Console.WriteLine("{0}, {1}", group.Key.ToString(), group.Count().ToString());
    66.             }
    67.             Console.WriteLine("=========================================");
    68.             // 比较BT的写法
    69.             foreach (var group in from row in table.Rows.Cast<DataRow>() group row by Convert.ToInt32(row["Age"]) into resultCollection select resultCollection)
    70.             {
    71.                 Console.WriteLine("{0}, {1}", group.Key.ToString(), group.Count().ToString());
    72.             }
    73.         }
    74.     }
    75. }

    其中最核心的一句是:var ageGroups = table.Rows.Cast<DataRow>().GroupBy(row => Convert.ToInt32(row["Age"]));

    意思是告诉LINQ解析器说“请以Convert.ToInt32(row["Age"])为Key,对row们进行分组,并把这些组放在名为ageGroups的集合中去”。为了不让程序记忆太多的数据类型,C# 3.0提供了var隐式数据类型语法——程序员可以不知道是什么类型、但编译器对类型却清清楚楚。实际上,GroupBy()操作后的结果是一个以IGrouping<int, DataRow> 为元素的IEnumerable<IGrouping<int, DataRow>> 集合。

    因为GroupBy()操作正好对应有LINQ关键字,所以才有最近两种改写。并不是每个LINQ操作都有对应的LINQ关键字,不知道C# 4.0会不会有所扩展。

    BTW,因为LINQ操作只能应用在可枚举的集合类型上,而DataTable.Rows集合是个普通集合、不具有可枚举性,所以需要Cast一下。

    如果这时候客户的需求再改成:列出Age相同的人的Name,那么使用foreach循环的复杂度就有点儿失控了(估计程序员的情绪也比较失控)……而使用LINQ则只需要对每个group进行一下枚举。

    展开全文
  • c# linq 重复取得 长期以来, LINQ是.NET软件工程生态系统中发生的最好的事情之一。 通过在Visual Studio 2008中引入lambda表达式和monad ,它使C#语言跃居Java之前,Java在当时是第6版,但仍在讨论泛型类型擦除的...
    c# linq 重复取得

    c# linq 重复取得

    长期以来, LINQ是.NET软件工程生态系统中发生的最好的事情之一。 通过在Visual Studio 2008中引入lambda表达式monad ,它使C#语言跃居Java之前,Java在当时是第6版,但仍在讨论泛型类型擦除的优缺点。 这项成就主要归功于荷兰计算机科学家兼染料专家Erik Meijer并获得其认可,他现在正从事其他项目

    Erik Meijer,Tye染料专家。图片由Ade Oshineye提供。根据CC-BY-SA许可

    Erik Meijer,Tye染料专家。 Ade Oshineye摄。 根据CC-BY-SA许可

    Java现在在哪里?

    随着即将发布的Java 8和JSR-355 ,我们仍然需要LINQ吗? 自上个十年中期以来,已经进行了许多尝试来将LINQ优点引入Java。 当时, QuaereLambdaj似乎是在图书馆级别(而不是语言级别)上有希望的实现。 实际上,大量流行的Stack Overflow问题暗示了有多少Java人员(现在仍然是!)实际上正在寻找等同的东西:

    有趣的是,“ LINQ”甚至已经成为EL 3.0

    但是我们真的需要LINQ吗?

    LINQ有一个主要缺陷,该缺陷被宣传为一项功能,但在我们看来,这将不可避免地导致“下一个大阻抗失配” 。 LINQ受SQL启发,这根本不是一件好事。 LINQ最流行于LINQ-to-Objects ,这是查询.NET中集合的一种好方法。 但是, HaskellScala的成功表明,“集合查询”的真正功能本质倾向于使用除SELECTWHEREGROUP BYHAVING之外的其他术语。 他们使用的术语包括“折叠”,“地图”,“ flatMap”,“ reduce”等等。 另一方面,LINQ使用GROUP BY和“ skip”,“ take”(而不是OFFSETFETCH )等术语的混合体。

    实际上,除了良好的旧SQL分区外部联接,分组集框架窗口函数之外,没有什么比功能真理更重要的了。 这些构造仅仅是SQL开发人员希望看到的结果的声明。 它们不是独立的函数,实际上包含要在任何给定上下文中执行的逻辑。 而且,窗口函数只能在SELECTORDER BY子句中使用,这在以声明方式进行思考时很明显,但是如果您没有SQL上下文,这也很奇怪。 具体来说, SELECT子句中的窗口函数会影响整个执行计划,以及采用索引来预取正确数据的方式。

    相反,真正的函数式编程对内存中集合的作用比SQL还要多。 使用SQLesque API进行集合查询是一个狡猾的决定,目的是欺骗“传统”人员采用函数式编程。 但是,使集合和SQL表查询可以混淆的希望令人失望,因为这样的构造不会产生所需SQL执行计划

    相反,真正的函数式编程对内存中集合的作用比SQL还要多。 使用SQLesque API进行集合查询只是错误的决定。 令人失望的是,收集和SQL表查询可能会混淆在一起,因为这样的构造将不可避免地产生可怕SQL执行计划

    但是,如果我

    这很简单。 当您执行SQL时,有两个基本选择。

    • “自上而下”进行操作,将大部分精力放在Java域模型上。 在这种情况下,请使用Hibernate / JPA通过Java 8 Streams API查询和转换Hibernate结果。
    • “自下而上”进行操作,将大部分精力放在您SQL /关系域模型上。 在这种情况下,请使用JDBC或jOOQ,然后再次使用Java 8 Streams API转换结果。

    此处对此进行了更详细的说明: http : //www.hibernate-alternative.com

    拥抱未来!

    虽然.NET在Java上已经“领先”了一段时间,但这不是由于LINQ本身引起的。 这主要是由于引入了lambda表达式以及lambda对* ALL * API的影响。 LINQ只是如何构造此类API的一个示例,尽管LINQ赢得了大多数赞誉。

    但是我对Java 8的新Streams API以及它将如何包含Java生态系统中的某些功能编程感到更加兴奋。 Informatech在一篇非常好的博客文章中说明了常见的LINQ表达式如何转换为Java 8 Streams API表达式。

    所以,不要回头。 停止羡慕.NET开发人员。 使用Java 8,我们将不需要LINQ或任何试图以“统一查询”为基础来模仿LINQ的API,这对于真正的“查询目标阻抗不匹配”来说是一个更好的称呼。 我们需要真正SQL来进行关系数据库查询,并且需要Java 8 Streams API来进行内存中集合的功能转换。 而已。 使用Java 8!

    参考: Java 8是否仍需要LINQ? 还是比LINQ更好? 从我们的JCG合作伙伴Lukas Eder在JAVA,SQL和JOOQ博客中获得。

    翻译自: https://www.javacodegeeks.com/2013/11/does-java-8-still-need-linq-or-is-it-better-than-linq.html

    c# linq 重复取得

    展开全文
  • 通过Linq查找重复数据

    千次阅读 2019-04-28 16:54:00
    一、模拟初始化集合数据 List<Student> students = new List<Student>() { new Student(){ Age=18,Name="jom"}, new Student(){ Age=28,Name="bom"}, ...

    一、模拟初始化集合数据

     List<Student> students = new List<Student>()
                {
                 new Student(){  Age=18,Name="jom"},
                 new Student(){  Age=28,Name="bom"},
                 new Student(){  Age=18,Name="day"},
                 new Student(){  Age=38,Name="jim"},
                 new Student(){  Age=38,Name="lxsh"}, };

    二、将集合数据按照年龄分组并取出分组大于1的

      var sameAges = students.GroupBy(g => g.Age).Where(s => s.Count() > 1).ToList();

    三、将年龄相同的打印出来

     sameAges.ForEach(s => {
                                   Console.WriteLine($"*******年龄为{s.Key}一共{ s.Count()}人*******");
                                   s.ForEach(o => Console.WriteLine(o.Name));
                   });

    四、运行效果

     

    转载于:https://www.cnblogs.com/lxshwyan/p/10784972.html

    展开全文
  • 使用LINQ,如何从List<int>检索包含重复项不止一次及其值的列表?

    本文翻译自:C# LINQ find duplicates in List

    使用LINQ,如何从List<int>检索包含重复项不止一次及其值的列表?


    #1楼

    参考:https://stackoom.com/question/1fP0S/C-LINQ在列表中查找重复项


    #2楼

    The easiest way to solve the problem is to group the elements based on their value, and then pick a representative of the group if there are more than one element in the group. 解决问题的最简单方法是根据元素的值对其进行分组,如果组中有多个元素,则选择该组的代表。 In LINQ, this translates to: 在LINQ中,这转换为:

    var query = lst.GroupBy(x => x)
                  .Where(g => g.Count() > 1)
                  .Select(y => y.Key)
                  .ToList();
    

    If you want to know how many times the elements are repeated, you can use: 如果您想知道元素重复了多少次,可以使用:

    var query = lst.GroupBy(x => x)
                  .Where(g => g.Count() > 1)
                  .Select(y => new { Element = y.Key, Counter = y.Count() })
                  .ToList();
    

    This will return a List of an anonymous type, and each element will have the properties Element and Counter , to retrieve the information you need. 这将返回一个匿名类型的List ,并且每个元素都将具有属性ElementCounter ,以检索所需的信息。

    And lastly, if it's a dictionary you are looking for, you can use 最后,如果您要查找的是字典,则可以使用

    var query = lst.GroupBy(x => x)
                  .Where(g => g.Count() > 1)
                  .ToDictionary(x => x.Key, y => y.Count());
    

    This will return a dictionary, with your element as key, and the number of times it's repeated as value. 这将返回一个字典,将您的元素作为键,并将其重复的次数作为值。


    #3楼

    You can do this: 你可以这样做:

    var list = new[] {1,2,3,1,4,2};
    var duplicateItems = list.Duplicates();
    

    With these extension methods: 使用这些扩展方法:

    public static class Extensions
    {
        public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
        {
            var grouped = source.GroupBy(selector);
            var moreThan1 = grouped.Where(i => i.IsMultiple());
            return moreThan1.SelectMany(i => i);
        }
    
        public static IEnumerable<TSource> Duplicates<TSource, TKey>(this IEnumerable<TSource> source)
        {
            return source.Duplicates(i => i);
        }
    
        public static bool IsMultiple<T>(this IEnumerable<T> source)
        {
            var enumerator = source.GetEnumerator();
            return enumerator.MoveNext() && enumerator.MoveNext();
        }
    }
    

    Using IsMultiple() in the Duplicates method is faster than Count() because this does not iterate the whole collection. 在Duplicates方法中使用IsMultiple()比Count()更快,因为这不会迭代整个集合。


    #4楼

    Another way is using HashSet : 另一种方法是使用HashSet

    var hash = new HashSet<int>();
    var duplicates = list.Where(i => !hash.Add(i));
    

    If you want unique values in your duplicates list: 如果要在重复项列表中使用唯一值:

    var myhash = new HashSet<int>();
    var mylist = new List<int>(){1,1,2,2,3,3,3,4,4,4};
    var duplicates = mylist.Where(item => !myhash.Add(item)).ToList().Distinct().ToList();
    

    Here is the same solution as a generic extension method: 这是与通用扩展方法相同的解决方案:

    public static class Extensions
    {
      public static IEnumerable<TSource> GetDuplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector, IEqualityComparer<TKey> comparer)
      {
        var hash = new HashSet<TKey>(comparer);
        return source.Where(item => !hash.Add(selector(item))).ToList();
      }
    
      public static IEnumerable<TSource> GetDuplicates<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
      {
        return source.GetDuplicates(x => x, comparer);      
      }
    
      public static IEnumerable<TSource> GetDuplicates<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> selector)
      {
        return source.GetDuplicates(selector, null);
      }
    
      public static IEnumerable<TSource> GetDuplicates<TSource>(this IEnumerable<TSource> source)
      {
        return source.GetDuplicates(x => x, null);
      }
    }
    

    #5楼

    Find out if an enumerable contains any duplicate : 找出可枚举是否包含任何重复项

    var anyDuplicate = enumerable.GroupBy(x => x.Key).Any(g => g.Count() > 1);
    

    Find out if all values in an enumerable are unique : 找出可枚举中的所有值是否唯一

    var allUnique = enumerable.GroupBy(x => x.Key).All(g => g.Count() == 1);
    

    #6楼

    I created a extention to response to this you could includ it in your projects, I think this return the most case when you search for duplicates in List or Linq. 我创建了一个扩展名以响应此问题,您可以将其包括在项目中,我认为当您在List或Linq中搜索重复项时,这种情况最常见。

    Example: 例:

    //Dummy class to compare in list
    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Surname { get; set; }
        public Person(int id, string name, string surname)
        {
            this.Id = id;
            this.Name = name;
            this.Surname = surname;
        }
    }
    
    
    //The extention static class
    public static class Extention
    {
        public static IEnumerable<T> getMoreThanOnceRepeated<T>(this IEnumerable<T> extList, Func<T, object> groupProps) where T : class
        { //Return only the second and next reptition
            return extList
                .GroupBy(groupProps)
                .SelectMany(z => z.Skip(1)); //Skip the first occur and return all the others that repeats
        }
        public static IEnumerable<T> getAllRepeated<T>(this IEnumerable<T> extList, Func<T, object> groupProps) where T : class
        {
            //Get All the lines that has repeating
            return extList
                .GroupBy(groupProps)
                .Where(z => z.Count() > 1) //Filter only the distinct one
                .SelectMany(z => z);//All in where has to be retuned
        }
    }
    
    //how to use it:
    void DuplicateExample()
    {
        //Populate List
        List<Person> PersonsLst = new List<Person>(){
        new Person(1,"Ricardo","Figueiredo"), //fist Duplicate to the example
        new Person(2,"Ana","Figueiredo"),
        new Person(3,"Ricardo","Figueiredo"),//second Duplicate to the example
        new Person(4,"Margarida","Figueiredo"),
        new Person(5,"Ricardo","Figueiredo")//third Duplicate to the example
        };
    
        Console.WriteLine("All:");
        PersonsLst.ForEach(z => Console.WriteLine("{0} -> {1} {2}", z.Id, z.Name, z.Surname));
        /* OUTPUT:
            All:
            1 -> Ricardo Figueiredo
            2 -> Ana Figueiredo
            3 -> Ricardo Figueiredo
            4 -> Margarida Figueiredo
            5 -> Ricardo Figueiredo
            */
    
        Console.WriteLine("All lines with repeated data");
        PersonsLst.getAllRepeated(z => new { z.Name, z.Surname })
            .ToList()
            .ForEach(z => Console.WriteLine("{0} -> {1} {2}", z.Id, z.Name, z.Surname));
        /* OUTPUT:
            All lines with repeated data
            1 -> Ricardo Figueiredo
            3 -> Ricardo Figueiredo
            5 -> Ricardo Figueiredo
            */
        Console.WriteLine("Only Repeated more than once");
        PersonsLst.getMoreThanOnceRepeated(z => new { z.Name, z.Surname })
            .ToList()
            .ForEach(z => Console.WriteLine("{0} -> {1} {2}", z.Id, z.Name, z.Surname));
        /* OUTPUT:
            Only Repeated more than once
            3 -> Ricardo Figueiredo
            5 -> Ricardo Figueiredo
            */
    }
    
    展开全文
  • Linq判断集合是否有重复字段

    千次阅读 2019-12-12 11:18:27
    list.GroupBy(p => p.PropertyName).Where(i => i.Count() > 1).Count() > 0
  • 使用Exists 或者any 在一个集合中调用另一个集合去看,对比的要点就是集合之间都有的字段也就是要查找重复数据的体现。 举例:俩个集合 list1 list2 俩个集合要找重复的数据 也就是 A B俩个字段是否有重复的数据 ...
  • 前段时间做一个项目就是定时下载节目列表进行对文件时间和名字进行新旧对比进行去重复,众所周知,我们在Linq中去重复数据都用Distinct()做。但如果想多个条件进行对比去除重复数据,我们应该怎么办呢?请看下文,...
  • 方案一 var query = lst.GroupBy(x=>x) .Where(g=>g.Count()>1) .Select(y=>y.Key) .ToList(); 如果还需要找出重复的元素个数: var query = lst.GroupBy(x=>x) ...
  • 这是执行前和执行后想要的效果 以下是用Sql语句实现的代码: select goodsno, goodsspec,SUM([count]) as count from goods ...下面这个则是用Linq实现的代码: var res = (from l in picModel ...
  • 1, 两个List泛型用Linq重复数据 Code: List<string> lstA = new List<string> { "E00401501B652563", "E00401501B652564", "E00401501B652565", "E00401501B652566", "E00401501B652567", "E004....
  • //重复元素:3,4,5 //不重复元素:1,8,9 int[] arr = { 1, 3, 3, 3, 4, 5, 4, 5, 8, 9, 3 }; //不重复元素 var unique = arr.GroupBy(i => i) .Where(g => g.Count() == 1) .Select(g => g.Ele.....
  • var data = (from u in _stone_storageService.LoadSearchData(roleQuery).AsEnumerable() select new { ... 以S_Number字段去除重复值,其余字段可以有重复值。 求大神指教!!!
  • where g.Count() >= 2 //加上这句只取出重复的,不加这句取出不重复的 select new { pmid=g.Key.pmmid, ptime=g.Key.pmtime, pdate=g.Key.pmdate }; foreach (var item in programmeSame) { context....
  • 使用Linq查找重复

    2018-11-07 15:22:00
    使用Linq查找重复   1 namespace RemoveTheSame 2 { 3 class Program 4 { 5 static void Main(string[] args) 6 { 7 List&lt;User&gt; list = new List&lt;User&gt;() 8 ...
  • if (items.Count() > 0)//存在重复数据 { string SameSapComCode = string.Empty; foreach (var item in items) { SameSapComCode += item.sapComCode + ";\n"; } SameSapComCode = SameSapComCode.TrimEnd(';'); ...
  • c#,winform代码, 用linq方式在一组文件夹及两组文件夹中查找重复文件,并可移动或删除重复文件 成品,在10万级别以上文件中试用,效果良好
  • var result = query.GroupBy(x=>x.F1,(key, group)=>group.OrderBy(y=>y.F2).First()); 排序部分也可以考虑放在query中事先做好。
  • LINQ重复值验证

    2009-08-01 11:27:00
    原文地址  ... Code   //  很酷的写法   var ageGroups3  =  from row  ...只是LINQ粗浅的应用 还是支持原创 不全部挂上来 转载于:https://www.cnblogs.com/ruyi/archive/2009/08/01/1536425.html
  • var list = new List(); for (int i = 0; i ; i++) { if (i ) { list.Add(new { a = 1, b = 2 }); } else {
  • Lambda表达式(三):LINQ初步 Lambda表达式(四):Lambda表达式与Expression树 如何利用 C# 实现 K 最邻近算法? 如何利用 C# 实现 K-D Tree 结构? 如何利用 C# + KDTree 实现 K 最邻近算法? 如何利用...
  • s.Where((x, i) => s.FindIndex(z => z.ArticleTitle == x.ArticleTitle) == i).ToList(); 转载于:https://www.cnblogs.com/NotEnough/p/10839942.html
  • 添加一个扩展方法public static IEnumerable DistinctBy (this IEnumerable source, Func keySelector) { HashSet seenKeys = new HashSet(); foreach (TSource element in source) { if (seenKeys.Add
  • Linq去除重复的数据

    千次阅读 2013-11-06 16:29:17
    Linq去除重复的数据
  • C#LINQ在List中发现重复

    2021-01-12 04:33:15
    linq中,这转换为:var query = lst.GroupBy(x=>x).Where(g=>g.Count()>1).Select(y=>y.Key).ToList();如果你想知道元素重复的次数,你可以使用:var query = lst.GroupBy(x=>x)....
  • linq Distinct 去除重复数据

    千次阅读 2015-04-17 18:43:00
    转载:... 只可惜linq默认不支持.Distinct(p =&gt; p.ID); 试想如果能写成下面的样子,是不是更简单优雅: var p1 = products.Distinct(p =&gt; p.ID); var p2 = product...
  • 未过滤前: 过滤后(仅会过滤掉完全一样的数据): ...DataTable dt = this.JsonToDataTable("[{\"Code\":\"SortId\",\"Name\":\"SortId\"},{\"Code\":\"SortCode\",\"Name\":\"编号\"},{\"Code\":\...
  • LINQ排除重复的list 免费下载
  • //要去重的 list<T> listTest; var resultlist= listTest.GroupBy(p =>p.Id).Select(g => g.First()).ToList(); 思路先分组,再每组取第一个。 转载于:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,127
精华内容 7,250
关键字:

linq重复