विभिन्न प्रकार के दो सूचियों में शामिल होने और तारीख

Question

द्वारा उन्हें सॉर्ट मैं इस तरह की संस्थाओं के पहली सूची है:

public partial class Networking :EntityBase 
{ 

    public virtual int NetWorkingId 
    { 
     get; 
     set; 
    } 

    public virtual string NetWorkingParam 
    { 
     get; 
     set; 
    } 

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

और मैं इस तरह की संस्थाओं के दूसरी सूची:

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; 
    } 
} 

मैं इन दो सूचियों को एक में एकत्र करना चाहते हैं और सभी तत्वों को तिथि के अनुसार क्रमबद्ध करना चाहते हैं।

क्या यह संभव है?

Answer 1

इस समस्या को आसानी से polymorphism का उपयोग करके हल किया जा सकता है; दोनों कक्षाओं के लिए एक सामान्य बेस क्लास या इंटरफ़ेस का उपयोग करें, जिसमें DateTime संपत्ति है जिसे आप सॉर्ट करना चाहते हैं।

उदाहरण:

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

या

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

और फिर अपनी कक्षाओं NetworkingBase से निकाले जाते हैं बनाने या लागू INetworking:

public partial class Networking : NetworkingBase 
{ 
    ... 
} 

public partial class PrivateNetwork : NetworkingBase 
{ 
    ... 
} 

या

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

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

परिणामी संग्रह पर एक LINQ Union या Concat और फिर OrderBy करें।

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 2

आप ताकि आप प्रत्येक आइटम के प्रकार की जांच करने से पहले आप इसे उपयोग कर सकते हैं, हालांकि यह नहीं बहुत सुंदर है यह कर सकते हैं, और आपको किसी IEnumerable<object> साथ खत्म और दोनों वर्गों में लागू करें। उस सॉर्टिंग के बाद आसान है।

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 3

एक अंतरफलक तिथि है कि बनाएँ:

Answer 4

मुझे पहले क्या पूछा जाना चाहिए था। । ।

आप उन्हें हल करने के बाद क्या करना चाहते हैं?

इसका उत्तर संभावित समाधान पर बड़ा प्रभाव डाल सकता है।

यदि उत्तर जैसा कुछ है तो मुझे की तिथियों की एक सूची प्रदर्शित करने की आवश्यकता है, जहां आपको केवल तारीखों की आवश्यकता है। यदि ऐसा है तो आपको दो सूचियों को मर्ज करने की आवश्यकता नहीं है, आप केवल आदेशित तिथियों का अनुक्रम प्राप्त कर सकते हैं और इसका उपयोग कर सकते हैं।

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

अगर जवाब मैं दिनांक उस वस्तु की पहचान के लिए लिंक दिखा लिंक की एक सूची प्रदर्शित करने के लिए की जरूरत है, और कुछ वस्तु के प्रकार की पहचान करना है, तो आप कुछ के साथ दूर हो सकता है बहुत उपरोक्त की तरह, एक अज्ञात वस्तु के साथ।

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); 

लेकिन अगर जवाब है मैं तुम सच में एक बहुरूपी समाधान है, जहां आप एक ही प्रकार है कि आप एक कॉल कर सकते हैं की आवश्यकता है तो 10 सबसे पुराने नेटवर्क करने के लिए एक बंद() कमांड भेजने की जरूरत है Shutdown() विधि, जो आप जिस प्रकार का उपयोग कर रहे हैं उस पर विशिष्ट Shutdown() विधि का समाधान करेगा।

केवल उपयोग करने के लिए करता है, तो उपयोगकर्ता khellang's answer एक और उत्तर

@BinaryWorrier मैं इस सवाल का जवाब चुना है पर के लिए आप

काम नहीं करता है एक टिप्पणी से, क्योंकि मैं पहले से ही में रिकॉर्ड एक बहुरूपी समाधान डेटाबेस, इसलिए यदि मैं एक नया इंटरफ़ेस जोड़ना चुनता हूं तो मैं इंटरफ़ेस जोड़ने से पहले रिकॉर्ड किए गए रिकॉर्ड के साथ कैसे सौदा करूँगा? किसी भी तरह - -

मैं यह मुश्किल विश्वास है कि अपने ORM आप एक इकाई वर्ग और नहीं के लिए एक इंटरफेस को जोड़ने के लिए अनुमति नहीं दी जाएगी पाते हैं कि इंटरफ़ेस निशान और/या तो वे ORM द्वारा नजरअंदाज कर दिया रहे हैं यह सदस्य है।

हालांकि, मानते हुए कि आप एक नया इंटरफ़ेस या बेस क्लास नहीं जोड़ सकते हैं, फिर भी आप यह polymorphically कर सकते हैं।

इंटरफ़ेस जोड़ें, इंटरफ़ेस है कि आपके नेटवर्क वर्गों (Abstractor वर्ग) से प्रत्येक के लिए, तो Abstractor वर्गों में नेटवर्क वर्गों को बदलने को लागू करने के लिए उन्हें एक List<INetwork> को जोड़ने और उस सूची छँटाई एक वर्ग जोड़ें।

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

पहले समाधान गुमनाम प्रकार उपयोग कर रहा है

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(); 
     } 
    } 
} 

या (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

मैं बस एक आधार वर्ग जोड़ा गया है और दोनों के माता पिता के रूप में यह सौंपा सूची की कक्षाएं और फिर संघ ने सरल किया। इसने चाल बनाई