LINQ之ThenBy,ThenByDescending

最新推荐文章于 2023-12-29 17:03:43 发布
最新推荐文章于 2023-12-29 17:03:43 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： C# 文章标签： .net c# linq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39162826/article/details/112980940
版权

返回LINQ大全首页

目录

ThenBy()

使用指定的比较器按升序对序列中的元素执行后续排序。

简单来说就是对使用过OrderBy和OrderByDescending的返回序列进行二次排序。（第一次排序优先级最高，如1，2，2，3，二次排序会对2，2排序）

注意不能直接在数组或List上使用。

MSDN

升序：

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class Program
{
    static void Main( string[] args )
    {
        string[] fruits = { "grape", "passionfruit", "banana", "mango", "orange", "raspberry", "apple", "blueberry" };

        //以排列字符串的长度升序
        IOrderedEnumerable<string> orderByFruits    = fruits.OrderBy( value => value.Length );
        //以字母升序对长度相同的项目进行排序。
        IOrderedEnumerable<string> thenByFruits     = orderByFruits.ThenBy( value => value );

        System.Console.WriteLine("fruits  :{0}", fruits.Text());
        System.Console.WriteLine("orderBy :{0}", orderByFruits.Text());
        System.Console.WriteLine("thenBy  :{0}", thenByFruits.Text());

        System.Console.ReadKey();
    }

    public static string Text( this IEnumerable i_source )
    {
        string text = string.Empty;
        foreach( var value in i_source )
        {
            text += string.Format( "[{0}], ", value );
        }
        return text;
    }
} 



fruits :[grape], [passionfruit], [banana], [mango], [orange], [raspberry], [apple], [blueberry],
orderBy :[grape], [mango], [apple], [banana], [orange], [raspberry], [blueberry], [passionfruit],
thenBy :[apple], [grape], [mango], [banana], [orange], [blueberry], [raspberry], [passionfruit],

ThenByDescending()

降序：

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class Program
{
    static void Main( string[] args )
    {
        string[] fruits = { "grape", "passionfruit", "banana", "mango", "orange", "raspberry", "apple", "blueberry" };

        //以排列字符串的长度升序
        IOrderedEnumerable<string> orderByFruits    = fruits.OrderBy( value => value.Length );
        //以字母降序对长度相同的项目进行排序。
        IOrderedEnumerable<string> thenByFruits     = orderByFruits.ThenByDescending( value => value );

        System.Console.WriteLine("fruits  :{0}", fruits.Text());
        System.Console.WriteLine("orderBy :{0}", orderByFruits.Text());
        System.Console.WriteLine("thenBy  :{0}", thenByFruits.Text());

        System.Console.ReadKey();
    }

    public static string Text( this IEnumerable i_source )
    {
        string text = string.Empty;
        foreach( var value in i_source )
        {
            text += string.Format( "[{0}], ", value );
        }
        return text;
    }
}



fruits :[grape], [passionfruit], [banana], [mango], [orange], [raspberry], [apple], [blueberry],
orderBy :[grape], [mango], [apple], [banana], [orange], [raspberry], [blueberry], [passionfruit],
thenBy :[mango], [grape], [apple], [orange], [banana], [raspberry], [blueberry], [passionfruit],

你也可以指定类中的某元素排序。

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class Program
{
    private class Parameter
    {
        public int      ID      { get; set; }
        public string   Name    { get; set; }
        public int      Age     { get; set; }

        public override string ToString()
        {
            return string.Format( "ID:{0}, Age:{1}, Name:{2},", ID, Age, Name );
        }
    }

    static void Main( string[] args )
    {
        Parameter[] persons =
        {
            new Parameter() { ID = 0, Age = 30, Name = "A" },
            new Parameter() { ID = 1, Age = 25, Name = "B" },
            new Parameter() { ID = 2, Age = 18, Name = "C" },
            new Parameter() { ID = 1, Age = 30, Name = "D" },
            new Parameter() { ID = 1, Age = 25, Name = "E" },
            new Parameter() { ID = 2, Age = 15, Name = "F" },
        };

        IOrderedEnumerable<Parameter> orderByID     = persons.OrderBy( value => value.ID );
        IOrderedEnumerable<Parameter> thenByAge     = orderByID.ThenBy( value => value.Age );
        IOrderedEnumerable<Parameter> thenByName    = orderByID.ThenByDescending( value => value.Name );


        System.Console.WriteLine("persons    :{0}", persons.Text());
        System.Console.WriteLine("orderByID  :{0}", orderByID.Text());
        System.Console.WriteLine("thenByAge  :{0}", thenByAge.Text());
        System.Console.WriteLine("thenByName :{0}", thenByName.Text());

        System.Console.ReadKey();
    }

    public static string Text( this IEnumerable i_source )
    {
        string text = string.Empty;
        foreach( var value in i_source )
        {
            text += string.Format( "[{0}], ", value );
        }
        return text;
    }
} 


persons :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:B,], [ID:2, Age:18, Name:C,], [ID:1, Age:30, Name:D,], [ID:1, Age:25, Name:E,], [ID:2, Age:15, Name:F,],
orderByID :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:B,], [ID:1, Age:30, Name:D,], [ID:1, Age:25, Name:E,], [ID:2, Age:18, Name:C,], [ID:2, Age:15, Name:F,],
thenByAge :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:B,], [ID:1, Age:25, Name:E,], [ID:1, Age:30, Name:D,], [ID:2, Age:15, Name:F,], [ID:2, Age:18, Name:C,],
thenByName :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:E,], [ID:1, Age:30, Name:D,], [ID:1, Age:25, Name:B,], [ID:2, Age:15, Name:F,], [ID:2, Age:18, Name:C,],

但是如果直接使用为实现IComparable的类进行比较则会报错。

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class Program
{
    private class Parameter
    {
        public int      ID      { get; set; }
        public string   Name    { get; set; }
        public int      Age     { get; set; }

        public override string ToString()
        {
            return string.Format( "ID:{0}, Age:{1}, Name:{2},", ID, Age, Name );
        }
    }

    static void Main( string[] args )
    {
        Parameter[] persons =
        {
            new Parameter() { ID = 0, Age = 30, Name = "A" },
            new Parameter() { ID = 1, Age = 25, Name = "B" },
            new Parameter() { ID = 2, Age = 18, Name = "C" },
            new Parameter() { ID = 1, Age = 30, Name = "D" },
            new Parameter() { ID = 1, Age = 25, Name = "E" },
            new Parameter() { ID = 2, Age = 15, Name = "F" },
        };

        IOrderedEnumerable<Parameter> orderByID     = persons.OrderBy( value => value.ID );
        IOrderedEnumerable<Parameter> thenByParam   = orderByID.ThenBy( value => value );
        
        try
        {
            thenByParam.Any();
        }
        catch( System.Exception i_exception )
        {
            System.Console.WriteLine( "{0}", i_exception );
            System.Console.ReadKey();
            return;
        }
        
        System.Console.WriteLine("persons     :{0}", persons.Text());
        System.Console.WriteLine("orderByID   :{0}", orderByID.Text());
        System.Console.WriteLine("thenByParam :{0}", thenByParam.Text());

        System.Console.ReadKey();
    }

    public static string Text( this IEnumerable i_source )
    {
        string text = string.Empty;
        foreach( var value in i_source )
        {
            text += string.Format( "[{0}], ", value );
        }
        return text;
    }
}

System.ArgumentException

通过实现IComparable，可以将其直接排序。

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class Program
{
    private class Parameter : System.IComparable<Parameter>
    {
        public int      ID      { get; set; }
        public string   Name    { get; set; }
        public int      Age     { get; set; }

        public int CompareTo( Parameter i_other )
        {
            if( i_other == null )
            {
                return -1;
            }

            int compareID   = ID - i_other.ID;
            if( compareID != 0 )
            {
                return compareID;
            }

            int compareAge  = Age - i_other.Age;
            if( compareAge != 0 )
            {
                return compareAge;
            }
            
            return string.Compare( Name, i_other.Name );
        }

        public override string ToString()
        {
            return string.Format( "ID:{0}, Age:{1}, Name:{2},", ID, Age, Name );
        }
    }

    static void Main( string[] args )
    {
        Parameter[] persons =
        {
            new Parameter() { ID = 0, Age = 30, Name = "A" },
            new Parameter() { ID = 1, Age = 25, Name = "B" },
            new Parameter() { ID = 2, Age = 18, Name = "C" },
            new Parameter() { ID = 1, Age = 30, Name = "D" },
            new Parameter() { ID = 1, Age = 25, Name = "E" },
            new Parameter() { ID = 2, Age = 15, Name = "F" },
        };

        IOrderedEnumerable<Parameter> orderByID     = persons.OrderBy( value => value.ID );
        IOrderedEnumerable<Parameter> thenByParam   = orderByID.ThenBy( value => value );

        System.Console.WriteLine("persons     :{0}", persons.Text());
        System.Console.WriteLine("orderByID   :{0}", orderByID.Text());
        System.Console.WriteLine("thenByParam :{0}", thenByParam.Text());

        System.Console.ReadKey();
    }

    public static string Text( this IEnumerable i_source )
    {
        string text = string.Empty;
        foreach( var value in i_source )
        {
            text += string.Format( "[{0}], ", value );
        }
        return text;
    }
}

persons :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:B,], [ID:2, Age:18, Name:C,], [ID:1, Age:30, Name:D,], [ID:1, Age:25, Name:E,], [ID:2, Age:15, Name:F,],
orderByID :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:B,], [ID:1, Age:30, Name:D,], [ID:1, Age:25, Name:E,], [ID:2, Age:18, Name:C,], [ID:2, Age:15, Name:F,],
thenByParam :[ID:0, Age:30, Name:A,], [ID:1, Age:25, Name:B,], [ID:1, Age:25, Name:E,], [ID:1, Age:30, Name:D,], [ID:2, Age:15, Name:F,], [ID:2, Age:18, Name:C,],

即使是string、int等也可以通过IComparer自定义比较规则。

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class Program
{
    private class CompareString : IComparer<string>
    {
        public int Compare( string i_lhs, string i_rhs )
        {
            bool isInitiallyG_L = !string.IsNullOrEmpty( i_lhs ) ? i_lhs.StartsWith( "g" ) : false;
            bool isInitiallyG_R = !string.IsNullOrEmpty( i_rhs ) ? i_rhs.StartsWith( "g" ) : false;

            if( isInitiallyG_L && !isInitiallyG_R )
            {
                return -1;
            }
            if( !isInitiallyG_L && isInitiallyG_R )
            {
                return 1;
            }
            
            return string.Compare( i_lhs, i_rhs );
        }
    }
    static void Main( string[] args )
    {
        string[] fruits = { "grape", "passionfruit", "banana", "mango", "orange", "raspberry", "apple", "blueberry" };

        IOrderedEnumerable<string> orderByFruits    = fruits.OrderBy( value => value.Length );
        
        CompareString compare = new CompareString();
        IOrderedEnumerable<string> thenByFruits     = orderByFruits.ThenBy( value => value, compare);

        System.Console.WriteLine("fruits  :{0}", fruits.Text());
        System.Console.WriteLine("orderBy :{0}", orderByFruits.Text());
        System.Console.WriteLine("thenBy  :{0}", thenByFruits.Text());

        System.Console.ReadKey();
    }

    public static string Text( this IEnumerable i_source )
    {
        string text = string.Empty;
        foreach( var value in i_source )
        {
            text += string.Format( "[{0}], ", value );
        }
        return text;
    }
}

fruits :[grape], [passionfruit], [banana], [mango], [orange], [raspberry], [apple], [blueberry],
orderBy :[grape], [mango], [apple], [banana], [orange], [raspberry], [blueberry], [passionfruit],
thenBy :[grape], [apple], [mango], [banana], [orange], [blueberry], [raspberry], [passionfruit],
我寄人间雪满头丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LINQ标准查询操作符（一）——select、SelectMany、Where、OrderBy、OrderByDescending、ThenBy、ThenByDescending和Reverse...
weixin_34143774的博客
04-22 304
一、投影操作符 1. Select Select操作符对单个序列或集合中的值进行投影。下面的示例中使用select从序列中返回Employee表的所有列： //查询语法 var query = from e in db.Employees where e.FirstName.StartsWith("M") selec...
【前端技术】还在为前端js排序多列而发愁吗？一文教你学会使用thenBy.js
W's play ground
05-07 999
什么是thenBy.js thenBy.js是一个javascript微型库，它可以对多列的数组进行排序（且可以满足不同列按不同的升序或降序进行排序）。它使用原生JavaScript的sort();方法，但不同的是thenBy.js可以传入多个函数例如firstBy().thenBy().thenBy()组成的函数来对数组进行多列排序。 如何安装 1.使用npm或yarn安装...
LINQ标准查询操作符（一）——select、SelectMany、Where、OrderBy、OrderByDescending、ThenBy、ThenByDescending和Reverse
11-03 2882
一、投影操作符 1. Select Select操作符对单个序列或集合中的值进行投影。下面的示例中使用select从序列中返回Employee表的所有列： using (NorthwindDataContext db=new NorthwindDataContext()) { //查询语法 var query = from e in db.Employees
.NET(C#) Linq ThenBy和ThenByDescending的使用
weixin_42098295的博客
02-23 385
Linq是Language Integrated Query的简称，它是微软在.NET Framework 3.5里面新加入的特性，用以简化查询查询操作。本文主要介绍.NET(C#) 中Linq的ThenBy和ThenByDescending操作符。 原文地址：.NET(C#) Linq ThenBy和ThenByDescending的使用 ...
转载LINQ系列OrderBy(), ThenBy()简介
weixin_30814319的博客
11-07 395
前言 前面两篇分别介绍了 Where() 与 Select() ，这篇则是要介绍 OrderBy() 与 ThenBy() ，这几个东西看起来最像 SQL 上会用到的语法，但切记一点，这边介绍的是 LINQ to Objects, 不是 LINQ to SQL or Entity Framework，这些 LINQ API 与 SQL 一点关系都没有，真要讲，是跟 foreach 与 delega...
.NET：OrderBy和ThenBy
weixin_33969116的博客
06-08 300
.NET中OrderBy和ThenBy的语义是不同的，如：list.OrderBy(x=&gt;x.A).OrderBy(x=&gt;x.B)，那么最终只会根据B进行排序；list.OrderBy(x=&gt;x.A).ThenBy(x=&gt;x.B)，那么最终会先根据A、再根据B进行排序，类似sql中的order by 语句。   还不知道ThenBy是如何实现的，闲了得自己动手写写。...
C# linq查询之动态OrderBy用法实例
09-03
这里需要几个自定义的扩展方法，如`OrderByDescending`、`ThenBy`和`ThenByDescending`，它们接收一个字符串参数`property`，表示要排序的属性名，以及一个`methodName`，表示排序方式（升序或降序）： ```csharp ...
LINQ Method Syntax_linq_源码
10-04
LINQ的方法语法是其两种主要查询语法之一，另一种是查询表达式语法。 **二、方法语法基础** 1. **Enumerable类和Queryable类**：LINQ的方法语法基于两个关键接口——`System.Linq.Enumerable`和`System.Linq....
LINQ 标准查询操作符
10-29
4. **ThenByDescending**：与`ThenBy`类似，但用于降序排序次键。 5. **Reverse**：`Reverse`操作符用于反转输入序列的元素顺序。 除了以上介绍的操作符，LINQ还提供了其他一些重要的操作符，如`GroupBy`用于分组...
C# Linq lambda表达式.doc
11-06
使用`OrderBy()`或`OrderByDescending()`进行升序或降序排序，`ThenBy()`或`ThenByDescending()`可以对多个字段进行排序： ```csharp List<ValueObject> temp = (from c in lstDict where c.CodeNo == id && c.Is...
Linq排序
03-31
如果需要根据多个字段进行排序，可以链式调用`ThenBy()`和`ThenByDescending()`方法。这些方法同样接受lambda表达式，按照它们被调用的顺序决定排序的优先级。 ```csharp var multiSortedData = unsortedData....
LINQ 按多个字段排序（orderby、thenby、Take）
weixin_30613343的博客
01-22 414
orderby 子句解析为 OrderBy()方法，orderby descending 子句解析为OrderBy Descending()方法： var racers = Formula1.GetChampions(). Where(r = > r.Country == "Brazil"). OrderByDescending(r = > r.Wins). Select(r = &...
LINQ 学习路程 -- 查询操作 ThenBy & ThenByDescending
weixin_30414305的博客
03-22 84
IList<Student> studentList = new List<Student>() { new Student() { StudentID = 1, StudentName = "John", Age = 18 } , new Student() { StudentID = 2, StudentName = "Steve", Age...
lambda OrderBy ThenBy ThenByDescending 多条件排序
zq爱生活爱代码的博客
03-01 1100
List<Person> array = new List<Person>(); array.Add(new Student("aa",15,150)); array.Add(new Student("aa",15,150)); array.Add(new Student("aa",12,150));...
Scala数组函数二（dropRight~intersect）
qq_43012693的博客
10-27 1121
dropRight 功能同drop，去掉尾部的n个元素 val a=Array(1,2,3,4,5) a.dropRight(2) Array[Int] = Array(1, 2, 3) dropWhile 去除当前数组中符合条件的元素，前提条件是，需要从当前数组的第一个元素起就要满足调酒，直到碰到第一个不满足条件的元素结束。 val a=Array(3,2,3,4) scala> val b=a.dropWhile(_>2) b: Array[Int] = Array(2, 3, 4) sc
LINQ使用Orderby、ThenBy实现多字段的排序
热门推荐
pan_junbiao的博客
11-06 2万+
LINQ中的排序操作符，包括：OrderBy、OrderByDescending、ThenBy、ThenByDescending、Reverse，提供了升序或者降序排序。 OrderBy：按升序对序列的元素进行排序。 OrderByDescending：按降序对序列的元素排序。 ThenBy：按升序对序列中的元素执行后续排序。 ThenByDescending：按降序对序列中的元素执行后续排序。 ...
linQ 八大子句
萧莯技术知识博客
04-02 233
a.LINQ查询简介　LINQ查询表达式的基本语法很容易掌握，它使用C#常见的语言构造，从外观上看，和我们常用的SQL类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建LINQ表达式。b.什么是LINQ的数据源　　LINQ的数据源可以是数据库对象或是XML流等，也可以使实现了IEnumerable或者泛型IEnumberable&lt;T&gt;接口的集合对...
C#中使用OrderBy和ThenBy等方法对List集合进行排序
Pei_hua100的专栏
08-18 3514
在C#的List操作中，针对List对象集合的排序我们可以使用OrderBy、OrderByDescending、ThenBy、ThenByDescending等方法按照特定的对象属性进行排序，其中Orderby表示按指定的第一个属性升序排序，OrderByDescending表示按指定的第一个属性降序排序，如果排序需要使用到不止一个条件的时候，可先使用OrderBy或者OrderByDescending方法排序完成后，再在方法链中调用ThenBy或者ThenByDescending对第二个条件排序，The
C#多条件排序OrderBy、ThenBy
最新发布
yhx956058885的博客
12-29 2023
有多个排序条件，其实不用单独自己写排序方法的，C#内置了排序方法：引用命名空间System.Linq正向排序的方法：OrderBy首要条件；ThenBy次要条件，可以连续多个使用同理，逆向排序对应的方法是OrderByDescending、ThenByDescending正向排序和逆向排序可以交叉使用。
linq之like操作
05-31
在LINQ中，可以使用Like操作符来进行模糊查询。但是需要注意的是，Like操作符并不是标准的LINQ操作符，因此需要使用第三方库或自定义查询扩展方法来实现。 以下是一个自定义查询扩展方法的示例，可以实现Like操作符： ```csharp public static class LinqExtensions { public static IQueryable<T> WhereLike<T>(this IQueryable<T> query, Expression<Func<T, string>> propertySelector, string value) { var method = typeof(string).GetMethod("Contains", new[] { typeof(string) }); var containsExpression = Expression.Call(propertySelector.Body, method, Expression.Constant(value)); var lambda = Expression.Lambda<Func<T, bool>>(containsExpression, propertySelector.Parameters); return query.Where(lambda); } } ``` 使用示例： ```csharp var users = context.Users.WhereLike(u => u.Name, "John"); ``` 上述代码将会查询出所有名字中包含“John”的用户。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我寄人间雪满头丶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值