Fatal编程技术网
  • csharp/
  • C#-使用扩展方法进行排序

C#-使用扩展方法进行排序

c#

C#-使用扩展方法进行排序,c#,extension-methods,C#,Extension Methods,我想整理一份名单上的人说 List<Person> persons=new List<Person>(); persons.Add(new Person("Jon","Bernald",45000.89)); persons.Add(new Person("Mark","Drake",346.89)); persons.Add(new Person("Bill","Watts",456.899)); 使用lambda表达式排序的方法是什么 public sta

我想整理一份名单上的人说

List<Person> persons=new List<Person>();
persons.Add(new Person("Jon","Bernald",45000.89));
persons.Add(new Person("Mark","Drake",346.89)); 
persons.Add(new Person("Bill","Watts",456.899));
使用lambda表达式排序的方法是什么

    public static List<Person> SortPeople(this List<Person> lst, 
   CompareOptions opt1,SortOrder ord)

        {
           lst.Sort((p,op1,op2)=>{ how to apply lambda expression here});
        }

公共静态列表排序人员（此列表为lst，
比较选项opt1、排序器ord）
{
lst.Sort（（p，op1，op2）=>{如何在这里应用lambda表达式}）；
}
看起来您正试图调用
列表上的排序方法，该方法接受
比较
委托。这将需要一些工作，因为您首先必须定义一个兼容的比较函数

第一步是基于
CompareOptions
值编写比较函数


private static Comparison<Person> Create(CompareOptions opt) {
  switch (opt) {
    case CompareOptions.ByFirstName: (x,y) => x.FirstName.CompareTo(y.FirstName);
    case CompareOptions.ByLastName: (x,y) => x.LastName.CompareTo(y.LastName);
    case CompareOptions.BySalary: (x,y) => x.Salary - y.Salary;
    default: throw new Exception();
  }
}



private静态比较创建（CompareOptions选项）{
开关（opt）{
case CompareOptions.ByFirstName:（x，y）=>x.FirstName.CompareTo（y.FirstName）；
case CompareOptions.ByLastName:（x，y）=>x.LastName.CompareTo（y.LastName）；
案例比较。按比例：（x，y）=>x.薪资-y.薪资；
默认值：抛出新异常（）；
}
}


默认情况下，此函数将按升序排序。如果希望它是递减的，只需对该值求反即可。所以现在编写SortPeople可以通过以下方法完成


public static List<Person> SortPeople(
   this List<Person> list, 
   CompareOptions opt1,
   SortOrder ord) )
   var original = Create(opt1);
   var comp = original;
   if( ord == SortOrder.Descending ) {
     comp = (x,y) => -(orig(x,y));
   }
   list.Sort(comp);
}



公共静态列表SortPeople(
这个名单,，
比较opt1，
巫师
var original=创建（opt1）；
var comp=原始值；
if（ord==排序器降序）{
comp=（x，y）=>-（原（x，y））；
}
列表.排序（comp）；
}


编辑

在lambda中100%完成的版本


public static List<Person> SortPeople(
   this List<Person> list, 
   CompareOptions opt1,
   SortOrder ord) )

   list.Sort( (x,y) => {
     int comp = 0;
     switch (opt) {
       case CompareOptions.ByFirstName: comp = x.FirstName.CompareTo(y.FirstName);
       case CompareOptions.ByLastName: comp = x.LastName.CompareTo(y.LastName);
       case CompareOptions.BySalary: comp = x.Salary.CompareTo(y.Salary);
       default: throw new Exception();
     }
     if ( ord == SortOrder.Descending ) {
       comp = -comp;
     }
     return comp;
   });
}



公共静态列表SortPeople(
这个名单,，
比较opt1，
巫师
list.Sort（（x，y）=>{
int comp=0；
开关（opt）{
case CompareOptions.ByFirstName:comp=x.FirstName.CompareTo（y.FirstName）；
case CompareOptions.ByLastName:comp=x.LastName.CompareTo（y.LastName）；
case CompareOptions.BySalary:comp=x.Salary.compareoto（y.Salary）；
默认值：抛出新异常（）；
}
if（ord==排序器降序）{
comp=-comp；
}
返回补偿；
});
}

要在lambda中实现此功能，表达式需要形成签名。这将需要2个“Person”实例。您可以这样做：


public static void SortPeople(
    this List<Person> lst, CompareOptions opt1,SortOrder ord)
{
    lst.Sort((left, right) => 
             {
                 int result;
                 // left and right are the two Person instances
                 if (opt1 == CompareOptions.Salary)
                 {
                     result = left.Salary.CompareTo(right.Salary);
                 }
                 else
                 {
                     string compStr1, compStr2;
                     if (opt1 == CompareOptions.FirstName)
                     {
                          compStr1 = left.FirstName;
                          compStr2 = right.FirstName;
                     }
                     else
                     {
                          compStr1 = left.LastName;
                          compStr2 = right.LastName;
                     }
                     result = compStr1.CompareTo(compStr2);
                 }
                 if (ord == SortOrder.Descending)
                     result *= -1;
                 return result;
             });
}



公共静态无效排序人员(
此列表（lst、比较选项opt1、排序器ord）
{
一级排序（（左、右）=>
{
int结果；
//left和right是两个人的实例
如果（opt1==比较选项.Salary）
{
结果=左.薪资.比较（右.薪资）；
}
其他的
{
字符串compStr1，compStr2；
if（opt1==CompareOptions.FirstName）
{
compStr1=left.FirstName；
compStr2=right.FirstName；
}
其他的
{
compStr1=left.LastName；
compStr2=right.LastName；
}
结果=compStr1。与（compStr2）相比；
}
if（ord==排序器降序）
结果*=-1；
返回结果；
});
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
命名空间控制台应用程序2
{
班级计划
{
静态void Main（字符串[]参数）
{
列表人员=新列表（）；
新增（新增人员（“Jon”、“Bernald”，45000.89））；
新增（新人员（“马克”、“德雷克”，346.89））；
新增（新人员（“比尔”，“瓦茨”，456.899））；
persons.SortPeople（CompareOptions.ByFirstName、SortOrder.Ascending）；
persons.ForEach（p=>Console.WriteLine（p.ToString（））；
persons.SortPeople（CompareOptions.ByFirstName、SortOrder.Descending）；
persons.ForEach（p=>Console.WriteLine（p.ToString（））；
persons.SortPeople（CompareOptions.ByLastName、SortOrder.Ascending）；
persons.ForEach（p=>Console.WriteLine（p.ToString（））；
persons.SortPeople（CompareOptions.ByLastName、SortOrder.Descending）；
persons.ForEach（p=>Console.WriteLine（p.ToString（））；
persons.SortPeople（比较选项.按语法，排序者.升序）；
persons.ForEach（p=>Console.WriteLine（p.ToString（））；
persons.SortPeople（比较选项.BySalary，排序器.Descending）；
persons.ForEach（p=>Console.WriteLine（p.ToString（））；
Console.ReadLine（）；
}
}
公共静态类扩展
{
公共静态void SortPeople（此列表lst、比较选项opt1、排序器ord）{
一级排序（（人员p1、人员p2）=>
{
交换机（opt1）
{
案例比较选项.ByFirstName：
return ord==SortOrder.升序？p1.FirstName.CompareTo（p2.FirstName）：p2.FirstName.CompareTo（p1.FirstName）；
案例比较选项.ByLastName：
return ord==SortOrder.升序？p1.LastName.CompareTo（p2.LastName）：p2.LastName.CompareTo（p1.LastName）；
案例比较。按比例：
return ord==SortOrder.singressing？p1.Salary.CompareTo（p2.Salary）：p2.Salary.CompareTo（p1.Salary）；
违约：
返回0；
}
});
}
}
公共阶层人士
{
公共双薪{get；set；}
公共字符串名{get；set；}
公共字符串LastName{get；set；}
公众人物（先串，后串，双薪）
{
这个。薪水=薪水；
this.FirstName=first；
this.LastName=last；
}
公共重写字符串ToString（）
{
返回string.Format（“{0}{1}的薪水为{2}”，this.FirstName，this.LastName，this.salary）；
}
}
公共枚举比较选项{ByFirstName，

public static void SortPeople(
    this List<Person> lst, CompareOptions opt1,SortOrder ord)
{
    lst.Sort((left, right) => 
             {
                 int result;
                 // left and right are the two Person instances
                 if (opt1 == CompareOptions.Salary)
                 {
                     result = left.Salary.CompareTo(right.Salary);
                 }
                 else
                 {
                     string compStr1, compStr2;
                     if (opt1 == CompareOptions.FirstName)
                     {
                          compStr1 = left.FirstName;
                          compStr2 = right.FirstName;
                     }
                     else
                     {
                          compStr1 = left.LastName;
                          compStr2 = right.LastName;
                     }
                     result = compStr1.CompareTo(compStr2);
                 }
                 if (ord == SortOrder.Descending)
                     result *= -1;
                 return result;
             });
}



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

namespace ConsoleApplication2
{
     class Program
    {
    static void Main(string[] args)
    {
        List<Person> persons = new List<Person>(); 
        persons.Add(new Person("Jon", "Bernald", 45000.89)); 
        persons.Add(new Person("Mark", "Drake", 346.89)); 
        persons.Add(new Person("Bill", "Watts", 456.899));

        persons.SortPeople(CompareOptions.ByFirstName, SortOrder.Ascending);

        persons.ForEach(p => Console.WriteLine(p.ToString()));

        persons.SortPeople(CompareOptions.ByFirstName, SortOrder.Descending);

        persons.ForEach(p => Console.WriteLine(p.ToString()));

        persons.SortPeople(CompareOptions.ByLastName, SortOrder.Ascending);

        persons.ForEach(p => Console.WriteLine(p.ToString()));

        persons.SortPeople(CompareOptions.ByLastName, SortOrder.Descending);

        persons.ForEach(p => Console.WriteLine(p.ToString()));

        persons.SortPeople(CompareOptions.BySalary, SortOrder.Ascending);

        persons.ForEach(p => Console.WriteLine(p.ToString()));

        persons.SortPeople(CompareOptions.BySalary, SortOrder.Descending);

        persons.ForEach(p => Console.WriteLine(p.ToString()));

        Console.ReadLine();
    }
}

public static class Extensions
{
    public static void SortPeople(this List<Person> lst, CompareOptions opt1,SortOrder ord){
        lst.Sort((Person p1, Person p2) => 
            {
                switch (opt1)
                {
                    case CompareOptions.ByFirstName:
                        return ord == SortOrder.Ascending ? p1.FirstName.CompareTo(p2.FirstName) : p2.FirstName.CompareTo(p1.FirstName);
                    case CompareOptions.ByLastName:
                        return ord == SortOrder.Ascending ? p1.LastName.CompareTo(p2.LastName) : p2.LastName.CompareTo(p1.LastName);
                    case CompareOptions.BySalary:
                        return ord == SortOrder.Ascending ? p1.Salary.CompareTo(p2.Salary) : p2.Salary.CompareTo(p1.Salary);
                    default:
                        return 0;
                }
            });
    }
}

public class Person
{
    public double Salary { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Person(string first, string last, double salary)
    {
        this.Salary = salary;
        this.FirstName = first;
        this.LastName = last;
    }

    public override string ToString()
    {
        return string.Format("{0} {1} has a salary of {2}", this.FirstName, this.LastName, this.Salary);
    }
}

public enum CompareOptions { ByFirstName, ByLastName, BySalary }
public enum SortOrder { Ascending, Descending }



persons.OrderBy( p => p.FirstName );
persons.OrderByDescending( p => p.Salary);