Unire due elenchi di diversi tipi e ordinarli per data

Question

ho un primo elenco di entità simile a questo:

public partial class Networking :EntityBase 
{ 

    public virtual int NetWorkingId 
    { 
     get; 
     set; 
    } 

    public virtual string NetWorkingParam 
    { 
     get; 
     set; 
    } 

    public virtual System.DateTime NetWorkingDate 
    { 
     get; 
     set; 
    } 
} 

E ho un secondo elenco di entità simile a questo:

public partial class PrivateNetwork :EntityBase 
{ 
    public virtual int PrivateNetworkId 
    { 
     get; 
     set; 
    } 

    public virtual int ContaId 
    { 
     get { return _contaId; } 
     set 
     { 
      if (_contaId != value) 
      { 
       if (Contact != null && Contact.ContaId != value) 
       { 
        Contact = null; 
       } 
       _contaId = value; 
      } 
     } 
    } 

    public virtual Nullable<System.DateTime> DateCreation 
    { 
     get; 
     set; 
    } 
} 

I vuoi raccogliere questi due elenchi in uno e ordinare tutti gli elementi per data.

È possibile?

Answer 1

Questo problema potrebbe essere facilmente risolto utilizzando il polimorfismo; utilizzare una classe base comune o un'interfaccia per entrambe le classi, che ha la proprietà DateTime su cui si desidera ordinare.

Esempio:

public abstract class NetworkingBase : EntityBase 
{ 
    public DateTime DateToSortOn { get; set; } 
} 

o

public interface INetworking 
{ 
    public DateTime DateToSortOn { get; set; } 
} 

e poi fare le vostre classi derivano da NetworkingBase o implementare INetworking:

public partial class Networking : NetworkingBase 
{ 
    ... 
} 

public partial class PrivateNetwork : NetworkingBase 
{ 
    ... 
} 

o

public partial class Networking : EntityBase, INetworking 
{ 
    ... 
} 

public partial class PrivateNetwork : EntityBase, INetworking 
{ 
    ... 
} 

Fare un LINQ Union o Concat e quindi un OrderBy sulla raccolta risultante.

Answer 2

Si può fare questo, anche se non è molto carina, e si finisce con un IEnumerable<object> modo da avere per verificare il tipo di ogni oggetto prima è possibile utilizzarlo:

IEnumerable<object> sorted = myNetworkingList 
    .Concat<object>(myPrivateNetworkList) 
    .OrderBy(n => n is Networking 
       ? (DateTime?)((Networking)n).NetWorkingDate 
       : ((PrivateNetwork)n).DateCreation); 

foreach (object either in sorted) 
{ 
    if (either is Networking) 
     // Networking; do something 
    else 
     // PrivateNetwork; do something else 
} 

Answer 3

creare un'interfaccia che ha la data e implementare in entrambe le classi. Dopo che lo smistamento è facile.

public interface INetwork 
{ 
    DateTime? Date { get; } 
} 

public partial class Networking :EntityBase, INetwork 
{ 
    public DateTime? Date 
    { 
     get { return NetWorkingDate; } 
    } 
} 

public partial class PrivateNetwork :EntityBase, INetwork 
{ 
    public DateTime? Date 
    { 
     get { return DateCreation; } 
    } 
} 

var commonList = new List<INetwork>(); 
// Add instances of PrivateNetwork and Networking to the list 

var orderedByDate = commonList.OrderBy(n => n.Date); 

Answer 4

Quello che avrei dovuto chiedere prima è. . .

Cosa vuoi fare dopo averli ordinati?

La risposta a questo potrebbe avere un grande impatto sulla potenziale soluzione.

Se la risposta è qualcosa come ho bisogno di visualizzare un elenco delle date, dove è necessario solo le date in ordine. In tal caso, non è necessario unire i due elenchi, è possibile ottenere una sequenza delle sole date ordinate e utilizzarle ad es.

var orderedDates = networks.Select(n => n.NetworkingDate) 
        .Union(privateNetworks.Select(n => n.DateCreation)) 
        .OrderBy(date => date); 

Se la risposta è ho bisogno di visualizzare un elenco di link che mostra la data che si collega alla Id dell'oggetto, e qualcosa per identificare il tipo di oggetto, allora si potrebbe ottenere via con qualcosa di molto come sopra, con un oggetto Anonimo.

var orderedDates = networks.Select(n => new {Date = n.NetworkingDate, Id = n.NetWorkingId, NetworkType = n.GetType().Name}) 
        .Union(privateNetworks.Select(n => new {Date = n.DateCreation, Id = n.PrivateNetWorkingId, NetworkType = n.GetType().Name})) 
        .OrderBy(n => n.Date); 

Tuttavia, se la risposta è ho bisogno di inviare un comando di spegnimento() per le 10 reti più antiche allora si ha realmente bisogno di una soluzione polimorfico, dove si ha un unico tipo che è possibile chiamare un Metodo Shutdown(), che verrà risolto con il metodo specifico Shutdown() sui tipi che stai utilizzando.

Una soluzione polimorfico di utilizzare solo se l'utente khellang's answer non funziona per voi

Da un commento su un'altra risposta

@BinaryWorrier Ho scelto questa risposta perché ho già record in il database, quindi se scelgo di aggiungere una nuova interfaccia, come faccio a trattare con i record già archiviati prima di aggiungere l'interfaccia?

Trovo difficile credere che il vostro ORM non permetterà di aggiungere un'interfaccia per una classe entità e non - in qualche modo - segnano l'interfaccia e/o è membro quindi sono ignorati dal ORM.

Tuttavia, supponendo che non sia possibile aggiungere una nuova interfaccia o classe base, è ancora possibile farlo in modo polimorfico.

aggiungere l'interfaccia, aggiungere una classe che implementa l'interfaccia che per ciascuna delle vostre classi di rete (i Abstractor classi), poi trasformare le classi di rete in Abstractor classi, aggiungendoli a un List<INetwork> e smistamento quella lista.

public interface INetwork 
{ 
    DateTime? Date { get; } 
} 

public class PrivateNetworkAbstractor 
    :INetwork 
{ 
    private PrivateNetwork network; 
    public PrivateNetworkAbstractor(PrivateNetwork network) 
    { 
     this.network = network; 
    } 
    public DateTime? Date 
    { 
     get { return network.DateCreation; } 
    } 
} 

public class NetworkingAbstractor 
    : INetwork 
{ 
    private Networking networking; 
    public NetworkingAbstractor(Networking networking) 
    { 
     this.networking = networking; 
    } 
    public DateTime? Date 
    { 
     get { return networking.NetWorkingDate; } 
    } 
} 
... 

public IEnumerable<INetwork> MergenSort(IEnumerable<Networking> generalNetWorks, IEnumerable<PrivateNetwork> privateNetWorks) 
{ 
    return generalNetWorks.Select(n => new NetworkingAbstractor(n)).Cast<INetwork>() 
    .Union(privateNetWorks.Select(n => new PrivateNetworkAbstractor(n)).Cast<INetwork>()) 
    .OrderBy(n=> n.Date); 
} 

Answer 5

Prima soluzione sta usando tipo anonimo

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

namespace Example1 
{ 
    class Program 
    { 
     class Human 
     { 
      public string Name { get; set; } 
      public string Hobby { get; set; } 
      public DateTime DateOfBirth { get; set; } 
     } 
     class Animal 
     { 
      public string Name { get; set; } 
      public string FavouriteFood { get; set; } 
      public DateTime DateOfBirth { get; set; } 
     } 

     static void Main(string[] args) 
     { 
      var humans = new List<Human> 
      { 
       new Human 
       { 
        Name = "Kate", 
        Hobby = "Fitness", 
        DateOfBirth = DateTime.Now.AddYears(-27), 
       }, 
       new Human 
       { 
        Name = "John", 
        Hobby = "Cars", 
        DateOfBirth = DateTime.Now.AddYears(-32), 
       }, 
      }; 

      var animals = new List<Animal> 
      { 
       new Animal 
       { 
        Name = "Fluffy", 
        FavouriteFood = "Grain", 
        DateOfBirth = DateTime.Now.AddYears(-2), 
       }, 
       new Animal 
       { 
        Name = "Bongo", 
        FavouriteFood = "Beef", 
        DateOfBirth = DateTime.Now.AddYears(-6), 
       }, 
      }; 

      var customCollection = (from human in humans 
            select new 
             { 
              Name = human.Name, 
              Date = human.DateOfBirth, 
             } 
             ).Union(from animal in animals 
               select new 
                { 
                 Name = animal.Name, 
                 Date = animal.DateOfBirth, 
                }).OrderBy(x => x.Date); 


      foreach (dynamic customItem in customCollection) 
       Console.WriteLine(String.Format("Date: {0}, Name: {1}",  customItem.Date, customItem.Name)); 

      Console.Read(); 
     } 
    } 
} 

o senza tipo anonimo (creata CustomClass):

... 
class CustomClass 
     { 
      public string Name { get; set; } 
      public DateTime Date { get; set; } 
     } 
... 
var customCollection = (from human in humans 
            select new CustomClass 
             { 
              Name = human.Name, 
              Date = human.DateOfBirth, 
             } 
             ).Union(from animal in animals 
               select new CustomClass 
                { 
                 Name = animal.Name, 
                 Date = animal.DateOfBirth, 
                }).OrderBy(x => x.Date); 


      foreach (CustomClass customItem in customCollection) 
       Console.WriteLine(String.Format("Date: {0}, Name: {1}", customItem.Date, customItem.Name)); 

... 

Answer 6

ho semplicemente aggiunto una classe base e assegnato come il genitore di entrambi classi della lista. e poi semplice ha fatto il sindacato. ha fatto il trucco