दो संग्रह ए और बी को देखते हुए, मैं आउटपुट करना चाहता हूं:
1. उनका आंतरिक जुड़ाव (जैसे आईडी नामक क्षेत्र पर)
2. ए में वे तत्व जो बी में नहीं पाए जा सके
3. बी में वे तत्व जो ए में नहीं पाए जा सके
ऐसा करने का सबसे कारगर तरीका क्या है?

जब मैं ए में उन तत्वों को कहता हूं जो बी में नहीं पाए जा सकते हैं, तो मेरा मतलब उन तत्वों से है जो बी के साथ "आंतरिक-जुड़े" नहीं हो सके

0
morpheus 3 मार्च 2011, 05:09
क्या A और B एक ही प्रकार के संग्रह हैं?
 – 
Daniel A. White
3 मार्च 2011, 05:14

3 जवाब

सबसे बढ़िया उत्तर

मुझे लगता है कि मैं इसे लिखूंगा:

public class DeltaSet<T>
{
    public ISet<T> FirstItems { get; private set; }
    public ISet<T> SecondItems { get; private set; }
    public ISet<Tuple<T, T>> IntersectedItems { get; private set; }

    // T is the type of the objects, U is the key used to determine equality
    public static DeltaSet<T> GetDeltaSet<T, U>(IDictionary<U, T> first,
                                                IDictionary<U, T> second)
    {
        var firstUniques = new HashSet<T>(
            first.Where(x => !second.ContainsKey(x.Key)).Select(x => x.Value));

        var secondUniques = new HashSet<T>(
            second.Where(x => !first.ContainsKey(x.Key)).Select(x => x.Value));

        var intersection = new HashSet<Tuple<T, T>>(
            second.Where(x => first.ContainsKey(x.Key)).Select(x =>
                Tuple.Create(first[x.Key], x.Value)));

        return new DeltaSet<T> { FirstItems = firstUniques,
                                 SecondItems = secondUniques,
                                 IntersectedItems = intersection };
    }

    public static DeltaSet<IDClass> GetDeltas(IEnumerable<IDClass> first,
                                              IEnumerable<IDClass> second)
    {
        return GetDeltaSet(first.ToDictionary(x => x.ID),
                           second.ToDictionary(x => x.ID));
    }
}
0
mqp 3 मार्च 2011, 05:25

आंतरिक जुड़ाव के लिए, .Join() विस्तार विधि पर एक नज़र डालें: http ://msdn.microsoft.com/en-us/library/bb344797.aspx

दूसरे 2 आउटपुट के लिए, .Except() एक्सटेंशन विधि पर एक नज़र डालें। http://msdn.microsoft.com/en-us/library/bb300779.aspx

अधिकांश LINQ प्रश्नों के उदाहरणों के लिए, इस पृष्ठ पर एक नज़र डालें: http://msdn .microsoft.com/en-us/vcsharp/aa336746

4
Alastair Pitts 3 मार्च 2011, 05:14
दरअसल, उसे Intersect . का इस्तेमाल करना चाहिए
 – 
Chris Pitman
3 मार्च 2011, 05:17
@ क्रिस: यदि वह प्रतिच्छेदन का उपयोग करता है, तो उसे दोनों संग्रहों से सामान्य मान मिलेंगे। 101 नमूने पृष्ठ से: 'यह नमूना एक अनुक्रम बनाने के लिए प्रतिच्छेदन का उपयोग करता है जिसमें दोनों सरणियों द्वारा साझा किए गए सामान्य मान शामिल हैं।'
 – 
Alastair Pitts
4 मार्च 2011, 01:23

मान लें कि आपके पास संग्रह ए में तत्वों के लिए कक्षा ए है और संग्रह बी में कक्षा बी है

class AB {
  public A PartA;
  public B PartB;
  // Constructor
};

public void ManyJoin (List<A> colA, List<B> colB)
{
  List<AB> innerJoin = new List<AB>();
  List<A> leftJoin = new List<A>();
  List<B> rightJoin = new List<B>();
  bool[] foundB = new bool[colB.Count];

  foreach (A itemA in colA)
  {
    int i = colB.FindIndex(itemB => itemB.ID == itemA.ID);
    if (i >= 0)
    {
      innerJoin.Add (new AB(itemA, colB[i]));
      foundB[i] = true;
    }
    else
      leftJoin.Add(itemA);
  }

  for (int j = 0; j < foundB.count; j++)
  {
    if (!foundB[j])
      rightJoin.Add(colB[j]);
  }
}

यह एक संभव तरीका है। यह इष्टतम है या नहीं, मुझे यकीन नहीं है, यह काम करता है।

0
Fun Mun Pieng 3 मार्च 2011, 05:41