लाइनक के साथ दो ऑब्जेक्ट सूची से एक सूची बनाएं

Question

मेरी निम्नलिखित स्थिति है

class Person
{
    string Name;
    int Value;
    int Change;
}

List<Person> list1;
List<Person> list2;

मुझे 2 सूचियों को एक नई List<Person> स्थिति में संयोजित करने की आवश्यकता है, क्योंकि यह एक ही व्यक्ति है जो संयोजन रिकॉर्ड में उस नाम, सूची 2 में व्यक्ति का मूल्य, परिवर्तन होगा सूची 2 का मूल्य - सूची 1 का मूल्य। यदि कोई डुप्लिकेट नहीं है तो परिवर्तन 0 है

Comments

क्या linq की वास्तव में जरूरत है - linq-ish के भावों के साथ एक अच्छा फोरचेक भी कर सकता है।

— राशॉक

इस टिप्पणी को प्रश्न के शीर्षक के एक संस्करण के रूप में जोड़ना और वास्तविक प्रश्न मेल नहीं खाते: इसका वास्तविक उत्तर माइक का यह उत्तर है । अधिकांश अन्य उत्तर, जबकि उपयोगी, वास्तव में मूल पोस्टर द्वारा प्रस्तुत समस्या को हल नहीं करते हैं।

— जोशुआ

Answer 1

यह लाइनक एक्सटेंशन विधि यूनियन का उपयोग करके आसानी से किया जा सकता है। उदाहरण के लिए:

var mergedList = list1.Union(list2).ToList();

यह एक सूची लौटाएगा जिसमें दो सूचियों को मिला दिया गया है और युगल हटा दिए गए हैं। यदि आप मेरे उदाहरण की तरह संघ विस्तार विधि में एक तुलना निर्दिष्ट नहीं करते हैं, तो यह आपके व्यक्तिगत वर्ग में डिफ़ॉल्ट बराबर और गेटहैशकोड विधियों का उपयोग करेगा। यदि आप उदाहरण के लिए अपनी नाम संपत्ति की तुलना करके व्यक्तियों की तुलना करना चाहते हैं, तो आपको तुलना करने के लिए इन तरीकों को ओवरराइड करना होगा। इसे पूरा करने के लिए निम्न कोड नमूने की जाँच करें। आपको इस कोड को अपने व्यक्ति वर्ग में जोड़ना होगा।

/// <summary>
/// Checks if the provided object is equal to the current Person
/// </summary>
/// <param name="obj">Object to compare to the current Person</param>
/// <returns>True if equal, false if not</returns>
public override bool Equals(object obj)
{        
    // Try to cast the object to compare to to be a Person
    var person = obj as Person;

    return Equals(person);
}

/// <summary>
/// Returns an identifier for this instance
/// </summary>
public override int GetHashCode()
{
    return Name.GetHashCode();
}

/// <summary>
/// Checks if the provided Person is equal to the current Person
/// </summary>
/// <param name="personToCompareTo">Person to compare to the current person</param>
/// <returns>True if equal, false if not</returns>
public bool Equals(Person personToCompareTo)
{
    // Check if person is being compared to a non person. In that case always return false.
    if (personToCompareTo == null) return false;

    // If the person to compare to does not have a Name assigned yet, we can't define if it's the same. Return false.
    if (string.IsNullOrEmpty(personToCompareTo.Name) return false;

    // Check if both person objects contain the same Name. In that case they're assumed equal.
    return Name.Equals(personToCompareTo.Name);
}

यदि आप दो वस्तुओं की तुलना करने के लिए हमेशा नाम का उपयोग करने के लिए अपने व्यक्ति वर्ग की डिफ़ॉल्ट बराबर विधि सेट नहीं करना चाहते हैं, तो आप एक तुलना वर्ग भी लिख सकते हैं जो IEqualityComparer इंटरफ़ेस का उपयोग करता है। फिर आप इस तुलनित्र को लाइनक एक्सटेंशन यूनियन विधि में दूसरे पैरामीटर के रूप में प्रदान कर सकते हैं। इस तरह की तुलनात्मक विधि लिखने के बारे में अधिक जानकारी http://msdn.microsoft.com/en-us/library/system.collections.iequalitycomparer.aspx पर देखी जा सकती है।

Comments

मैं यह नहीं देखता कि यह मूल्यों के विलय के बारे में कैसे सवाल का जवाब देता है।

— वागनर दा सिल्वा

इसका कोई जवाब नहीं है, संघ में केवल दो सेटों में मौजूद आइटम होंगे, दो में से किसी एक सूची में मौजूद कोई तत्व नहीं

— J4N

@ J4N आप शायद के Unionसाथ भ्रमित कर रहे हैं Intersect?

— कोस

संदर्भ के लिए: वहाँ भी है Concatकि डुप्लिकेट मर्ज नहीं करता है

— कोस

क्या आप इस उत्तर को संपादित करने का मन बनायेंगे ताकि यह वास्तव में प्रश्न का उत्तर दे? मुझे यह हास्यास्पद लगता है कि इस सवाल का जवाब न देने के बावजूद एक जवाब बहुत ज्यादा वोट दिया जाता है, सिर्फ इसलिए कि यह शीर्षक और एक बुनियादी Google क्वेरी ("लिन्क मर्ज लिस्ट") का जवाब देता है।

— Rawling

Answer 2

मैंने देखा कि यह प्रश्न 2 वर्षों के बाद उत्तर के रूप में चिह्नित नहीं किया गया था - मुझे लगता है कि निकटतम उत्तर रिचर्ड्स हैं, लेकिन इसे इसके लिए काफी सरल बनाया जा सकता है:

list1.Concat(list2)
    .ToLookup(p => p.Name)
    .Select(g => g.Aggregate((p1, p2) => new Person 
    {
        Name = p1.Name,
        Value = p1.Value, 
        Change = p2.Value - p1.Value 
    }));

हालांकि यह नहीं होगा उस मामले में त्रुटि जहां आपके पास किसी भी सेट में डुप्लिकेट नाम हैं।

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

Comments

यह पोस्ट वास्तव में प्रश्न का उत्तर देती है, और इसे अच्छी तरह से करती है।

— दर्शन

यह स्वीकृत उत्तर होना चाहिए। उत्तर के लिए इतने उत्थान वाले प्रश्न को कभी नहीं देखा, जो पूछे गए प्रश्न का उत्तर न दें!

— टोड मेनियर

अच्छा उत्तर। मैं इसमें एक छोटा परिवर्तन कर सकता हूं, इसलिए मान वास्तव में list2 से मान है, और इसलिए कि यदि आपके पास डुप्लिकेट है तो परिवर्तन जारी रहता है: मान सेट करें = P2.Value और बदलें = p1.Change + P2.Value - 1-1 .Value

— रवि देसाई

Answer 3

आप सिर्फ उपयोग क्यों नहीं करते Concat ?

कॉनैट, लिनक का एक हिस्सा है और ए करने से ज्यादा कुशल है AddRange()

आपके मामले में:

List<Person> list1 = ...
List<Person> list2 = ...
List<Person> total = list1.Concat(list2);

Comments

आप कैसे जानते हैं कि यह अधिक कुशल है?

— जेरी निक्सन

@ जेरी निक्सन ने उसे परीक्षण नहीं किया, लेकिन स्पष्टीकरण तर्कसंगत लगता है। stackoverflow.com/questions/1337699/…

— Nullius

stackoverflow.com/questions/100196/net-listt-concat-vs-addrange -> ग्रेग की टिप्पणी: Actually, due to deferred execution, using Concat would likely be faster because it avoids object allocation - Concat doesn't copy anything, it just creates links between the lists so when enumerating and you reach the end of one it transparently takes you to the start of the next! यह मेरी बात है।

— J4N

और फायदा यह भी है कि अगर आप Entity Framework का उपयोग करते हैं, तो यह C # साइड के बजाय SQL साइड पर किया जा सकता है।

— J4N

इसका असली कारण यह नहीं है कि यह वास्तव में दोनों सूची में मौजूद किसी भी वस्तु का विलय नहीं करता है।

— माइक गोअली ने

Answer 4

यह लिनक है

var mergedList = list1.Union(list2).ToList();

यह सामान्य है (AddRange)

var mergedList=new List<Person>();
mergeList.AddRange(list1);
mergeList.AddRange(list2);

यह नॉर्मली (फोरचेक) है

var mergedList=new List<Person>();

foreach(var item in list1)
{
    mergedList.Add(item);
}
foreach(var item in list2)
{
     mergedList.Add(item);
}

यह नॉर्मली (फॉरच्यू-डब्लिस) है

var mergedList=new List<Person>();

foreach(var item in list1)
{
    mergedList.Add(item);
}
foreach(var item in list2)
{
   if(!mergedList.Contains(item))
   {
     mergedList.Add(item);
   }
}

Answer 5

ऐसा करने के लिए कुछ टुकड़े हैं, यह मानते हुए कि प्रत्येक सूची में डुप्लिकेट नहीं हैं, नाम एक विशिष्ट पहचानकर्ता है, और न ही सूची का आदेश दिया गया है।

एकल सूची प्राप्त करने के लिए सबसे पहले एक परिशिष्ट विस्तार विधि बनाएं:

static class Ext {
  public static IEnumerable<T> Append(this IEnumerable<T> source,
                                      IEnumerable<T> second) {
    foreach (T t in source) { yield return t; }
    foreach (T t in second) { yield return t; }
  }
}

इस प्रकार एकल सूची प्राप्त कर सकते हैं:

var oneList = list1.Append(list2);

फिर नाम पर समूह

var grouped = oneList.Group(p => p.Name);

फिर एक बार एक समूह को संसाधित करने के लिए प्रत्येक समूह को एक सहायक के साथ संसाधित कर सकता है

public Person MergePersonGroup(IGrouping<string, Person> pGroup) {
  var l = pGroup.ToList(); // Avoid multiple enumeration.
  var first = l.First();
  var result = new Person {
    Name = first.Name,
    Value = first.Value
  };
  if (l.Count() == 1) {
    return result;
  } else if (l.Count() == 2) {
    result.Change = first.Value - l.Last().Value;
    return result;
  } else {
    throw new ApplicationException("Too many " + result.Name);
  }
}

जिसे प्रत्येक तत्व पर लागू किया जा सकता है grouped:

var finalResult = grouped.Select(g => MergePersonGroup(g));

(चेतावनी: अप्राप्त)

Comments

आपका Appendआउट-ऑफ-द-बॉक्स का लगभग सटीक डुप्लिकेट है Concat।

— रॉलिंग

@ रॉलिंग: यह है, किसी कारण से मैं गायब रहा Enumerable.Concatऔर इस तरह इसे फिर से लागू कर रहा हूं ।

— रिचर्ड

Answer 6

आपको पूर्ण बाहरी जुड़ाव जैसा कुछ चाहिए। System।

var dict1 = list1.ToDictionary(l1 => l1.Name);
var dict2 = list2.ToDictionary(l2 => l2.Name);
    //get the full list of names.
var names = dict1.Keys.Union(dict2.Keys).ToList();
    //produce results
var result = names
.Select( name =>
{
  Person p1 = dict1.ContainsKey(name) ? dict1[name] : null;
  Person p2 = dict2.ContainsKey(name) ? dict2[name] : null;
      //left only
  if (p2 == null)
  {
    p1.Change = 0;
    return p1;
  }
      //right only
  if (p1 == null)
  {
    p2.Change = 0;
    return p2;
  }
      //both
  p2.Change = p2.Value - p1.Value;
  return p2;
}).ToList();

Answer 7

क्या आपकी समस्या के लिए निम्न कोड काम करता है? मैंने सूचियों के संयोजन को करने के लिए थोड़ा सा linq के साथ एक foreach का उपयोग किया है और यह मान लिया है कि लोग समान हैं यदि उनके नाम मेल खाते हैं, और ऐसा लगता है कि रन होने पर अपेक्षित मानों को प्रिंट करना है। Resharper किसी भी सुझाव की पेशकश नहीं करता है कि फॉर्च्यूनर को linq में परिवर्तित करें ताकि यह संभवतः उतना ही अच्छा हो जितना कि यह इस तरह से कर पाएगा।

public class Person
{
   public string Name { get; set; }
   public int Value { get; set; }
   public int Change { get; set; }

   public Person(string name, int value)
   {
      Name = name;
      Value = value;
      Change = 0;
   }
}


class Program
{
   static void Main(string[] args)
   {
      List<Person> list1 = new List<Person>
                              {
                                 new Person("a", 1),
                                 new Person("b", 2),
                                 new Person("c", 3),
                                 new Person("d", 4)
                              };
      List<Person> list2 = new List<Person>
                              {
                                 new Person("a", 4),
                                 new Person("b", 5),
                                 new Person("e", 6),
                                 new Person("f", 7)
                              };

      List<Person> list3 = list2.ToList();

      foreach (var person in list1)
      {
         var existingPerson = list3.FirstOrDefault(x => x.Name == person.Name);
         if (existingPerson != null)
         {
            existingPerson.Change = existingPerson.Value - person.Value;
         }
         else
         {
            list3.Add(person);
         }
      }

      foreach (var person in list3)
      {
         Console.WriteLine("{0} {1} {2} ", person.Name,person.Value,person.Change);
      }
      Console.Read();
   }
}

Answer 8

public void Linq95()
{
    List<Customer> customers = GetCustomerList();
    List<Product> products = GetProductList();

    var customerNames =
        from c in customers
        select c.CompanyName;
    var productNames =
        from p in products
        select p.ProductName;

    var allNames = customerNames.Concat(productNames);

    Console.WriteLine("Customer and product names:");
    foreach (var n in allNames)
    {
        Console.WriteLine(n);
    }
}