如何同时从两个不同的列中执行OrderBy，而不使用ThenBy

Question

I have a unique situation where I am trying to do an .OrderBy on an IQueryable. (Forgive me if my definitions are not accurate)

I've got the following:

IQueryable<Source> data = e.Sources.Where(element => element.IsActive == true).OrderBy(el => el.SourceEntityKey);
if (sortDesc.SortDirection == ListSortDirection.Ascending)
{                                                                
     data = data.OrderBy(order => order.EntityBase.EntityName);         
}
else 
{                                 
     data = data.OrderByDescending(order => order.EntityBase.EntityName);
}

The problem is, I can't do this because this is not a value that is actually stored in the database, so it is not supported by LINQ to Entities. Sources are actually a list of people and companies. As a source, they can have a subtype as either a person or company. If they are a company, it has its own table to store the company name. If it is a person, it has its own table and has two columns to store the first and last name. So, somehow I need a way to order these by their name even though the name is not stored the same way in the database. The real values are this:

 EntityBase.Person.FirstName
 EntityBase.Person.LastName
 EntityBase.Company.CompanyName

Another problem is that I can't yet enumerate the list as there is more performed after this. So I need a way to have this done before enumerating to a list.

Thanks for any help

EDIT:

I was trying to simplify to hopefully make things easier... here are my models with the irrelevant trimmed out.

EntityBase:

[MetadataType(typeof(EntityBaseMetaData))]
public partial class EntityBase
{
    [IgnoreDataMember]
    public Person AsPerson
    {
        get
        {
            Person p = new Person();
            try
            {
                p = (Person)this;
            }
            catch
            {
                p = null;
            }
            return p;
        }
    }

    [IgnoreDataMember]
    public Company AsCompany
    {
        get
        {
            Company c = new Company();
            try
            {
                c = (Company)this;
            }
            catch
            {
                c = null;
            }
            return c;
        }
    }                

    [IgnoreDataMember]
    public string EntityName
    {
        get
        {
            string name = "";
            if (this.AsPerson != null)
            {
                name = this.AsPerson.FirstName + " " + this.AsPerson.LastName;
            }
            else if (this.AsCompany != null)
            {
                name = this.AsCompany.CompanyName;
            }

            return name;
        }            
    }        
}

public class EntityBaseMetaData
{
    //[ScaffoldColumn(false)]
    public object EntityBaseKey { get; set; }
}

Person:

[MetadataType(typeof(PersonMetaData))]
    public partial class Person
    {     
    }

    public class PersonMetaData
    {
        [DisplayName("Person ID")]
        public object EntityBaseKey { get; set; }      

        [DisplayName("First Name")]
        public object FirstName { get; set; }

        [DisplayName("Last Name")]
        public object LastName { get; set; }
    }

Company:

[MetadataType(typeof(CompanyMetaData))]
public partial class Company
{      
}

public class CompanyMetaData
{
    [DisplayName("Company ID")]
    public object EntityBaseKey { get; set; }

    [DisplayName("Company Name")]
    public object CompanyName { get; set; }

}

Source:

[MetadataType(typeof(SourceMetaData))]
public partial class Source
{    }

public class SourceMetaData
{   
    [DisplayName("Source ID")]
    public object EntityBaseKey { get; set; }
}

Controller action:

[GridAction(EnableCustomBinding = true)]
public ActionResult Read(GridCommand command)
{
    Entities e = new Entities();            
    IQueryable<Source> data = e.Sources.Where(element => element.IsActive == true).OrderBy(el => el.EntityBaseKey);

    int count = data.Count();

    //Apply Grid Commands
    if (command != null)
    {           
        //Apply data sort
        foreach (SortDescriptor sortDesc in command.SortDescriptors)
        {
            switch (sortDesc.Member)
            {               
                case "SourceName":                                          
                    if (sortDesc.SortDirection == ListSortDirection.Ascending)
                    {                                                                
                        data = data.OrderBy(order => order.EntityBase.EntityName);
                    }
                    else {                                 
                        data = data.OrderByDescending(order => order.EntityBase.EntityName);

                    }
                    break;              
            }
        }

        //Apply paging
        if (command.PageSize > 0)
        {
            data = data.Skip((command.Page - 1) * command.PageSize).Take(command.PageSize);
        }

    }

    List<SourceView> sources = new List<SourceView>();

    foreach (Source s in data.ToList())
    {
        sources.Add(new SourceView
        {
            EntityBaseKey = s.EntityBaseKey,
            SourceName = s.EntityBase.EntityName,           
        });
    }

    return View(new GridModel
    {
        Data = sources,
        Total = count
    });            
}

This is how I would like it to work. Also, there is a lot more filtering and sorting going on that isn't shown. The grid command stuff is for a Telerik grid, from the Telerik Extensions for ASP.Net. It would be much easier if we didn't have to do client side binding, but there is too much database information, so performance with server side binding suffers heavily.

I really appreciate the help.

Answer 1

You could try to define a helper type and use union. I defined a Customer type with two subtypes: company and person:

private static void OrderingTest()
    {
        Database.SetInitializer(new DropCreateDatabaseAlways<Test1Context>());
        var context = new TestContext();

        context.Customers.Add(new Company { Denomination = "A" });
        context.Customers.Add(new Company { Denomination = "C" });
        context.Customers.Add(new Person { LastName = "B" });
        context.Customers.Add(new Person { LastName = "D" });
        context.SaveChanges();

        var a = (from customer in context.Customers.OfType<Company>()
                 select new CustomerInfo { Name = customer.Denomination, Customer = customer }
                )
                .Union
                (from customer in context.Customers.OfType<Person>()
                 select new CustomerInfo { Name = customer.LastName, Customer = customer }
                 );
        var customerInfoList = a.OrderBy(item => item.Name);
        var customers = customerInfoList.ToList().Select(item => item.Customer);
    }

    class CustomerInfo
    {
        public string Name { get; set; }
        public Customer Customer { get; set; }
    }

EDIT:

A couple of observations:

-The two properties added are easier if rewritten like this:

public Person AsPerson
{
    get
    {
        return this as Person;
    }
}

-remember to remove ToList in the controller at:

case "SourceName":                            
List<Source> sources = data.ToList();

if you want your skip and take to happen on the database.

and here is my guess:

I still don't get what the Source entity is for but my suggestion is to add a reverse property named Source to EntityBase so that you can replace:

IQueryable<Source> data = e.Sources.Where(element => element.IsActive == true).OrderBy(el => el.EntityBaseKey);

with:

IQueryable<EntityBase> data = e.Entities.Where(entityBase => entityBase.Source.IsActive).OrderBy(entityBase => entityBase.Source.EntityBaseKey);

Once your collection is a collection of EntityBase you should be able to query with the following:

  var entities = (from entity in data.OfType<Company>()
                  select new EntityBaseInfo { Name = entity.CompanyName, EntityBase = entity }
                 )
                 .Union
                 (from entity in data.OfType<Person>()
                  select new EntityBaseInfo { Name = entity.FirstName + " " + entity.LastName, EntityBase = entity }
                 );
  var orderedEntities = entities.OrderBy(item => item.Name).Select(item => item.EntityBase);

Then you can apply skip and take and in the end when you need to create SourceView you can use:

foreach (EntityBase entity in orderedEntities.ToList())
{
    sources.Add(new SourceView
    {
        EntityBaseKey = entity.Source.EntityBaseKey,
        SourceName = entity.EntityName,           
    });
}

I don't quite get what the Source.EntityBaseKey represents 'cause I miss the full code. I just tried to modify the code posted to be able to use the union. Hope it's useful.

Answer 2

How about you do all of the EF LINQ to Entities work and then sort the resulting list by whatever remaining logic you need, like this:

list.Sort(item => item.PropertyToSortBy);

And you can call it multiple times to sort by one property, then another, etc.

Note: The class T in your List<T> must implement IComparable or IComparable<T> for the simple syntax above to work.