c# - सी#में सरणी की तुलना करने का सबसे आसान तरीका




.net arrays (8)

जावा में, Arrays.equals () दो बुनियादी सरणी की सामग्री की तुलना करने की अनुमति देता है (ओवरलोड सभी मूल प्रकारों के लिए उपलब्ध हैं)।

सी # में ऐसी कोई चीज है? सी # में दो सरणी की सामग्री की तुलना करने का कोई "जादू" तरीका है?


इसके अलावा सरणी (और टुपल्स) के लिए आप .NET 4.0: IStructuralComparable और IStructuralEquatable से नए इंटरफेस का उपयोग कर सकते हैं। उनका उपयोग करके आप केवल सरणी की समानता की जांच नहीं कर सकते बल्कि उनकी तुलना भी कर सकते हैं।

static class StructuralExtensions
{
    public static bool StructuralEquals<T>(this T a, T b)
        where T : IStructuralEquatable
    {
        return a.Equals(b, StructuralComparisons.StructuralEqualityComparer);
    }

    public static int StructuralCompare<T>(this T a, T b)
        where T : IStructuralComparable
    {
        return a.CompareTo(b, StructuralComparisons.StructuralComparer);
    }
}

{
    var a = new[] { 1, 2, 3 };
    var b = new[] { 1, 2, 3 };
    Console.WriteLine(a.Equals(b)); // False
    Console.WriteLine(a.StructuralEquals(b)); // True
}
{
    var a = new[] { 1, 3, 3 };
    var b = new[] { 1, 2, 3 };
    Console.WriteLine(a.StructuralCompare(b)); // 1
}

कुछ अनुप्रयोगों के लिए बेहतर हो सकता है:

string.Join("", arr1) == string.Join("", arr2)

मैंने इसे विजुअल स्टूडियो में किया और यह पूरी तरह से काम किया; इस कोड को कम से कम इंडेक्स द्वारा सरणी इंडेक्स की तुलना करना।

private void compareButton_Click(object sender, EventArgs e)
        {
            int[] answer = { 1, 3, 4, 6, 8, 9, 5, 4, 0, 6 };
            int[] exam = { 1, 2, 3, 6, 8, 9, 5, 4, 0, 7 };

            int correctAnswers = 0;
            int wrongAnswers = 0;

            for (int index = 0; index < answer.Length; index++)
            {
                if (answer[index] == exam[index])
                {
                    correctAnswers += 1;
                }
                else
                {
                    wrongAnswers += 1;
                }
            }

            outputLabel.Text = ("The matching numbers are " + correctAnswers +
                "\n" + "The non matching numbers are " + wrongAnswers);
        }

आउटपुट होगा; मिलान संख्या 7 हैं गैर मिलान संख्या 3 हैं


यदि आप null इनपुट को अच्छी तरह से संभालना चाहते हैं, और वस्तुओं के क्रम को अनदेखा करना चाहते हैं, तो निम्न समाधान आज़माएं:

static class Extensions
{
    public static bool ItemsEqual<TSource>(this TSource[] array1, TSource[] array2)
    {
        if (array1 == null && array2 == null)
            return true;
        if (array1 == null || array2 == null)
            return false;
        return array1.Count() == array2.Count() && !array1.Except(array2).Any();
    }
}

परीक्षण कोड इस तरह दिखता है:

class Program
{
    static void Main(string[] args)
    {
        int[] a1 = new int[] { 1, 2, 3 };
        int[] a2 = new int[] { 3, 2, 1 };
        int[] a3 = new int[] { 1, 3 };
        int[] a4 = null;
        int[] a5 = null;
        int[] a6 = new int[0];

        Console.WriteLine(a1.ItemsEqual(a2)); // Output: True.
        Console.WriteLine(a2.ItemsEqual(a3)); // Output: False.
        Console.WriteLine(a4.ItemsEqual(a5)); // Output: True. No Exception.
        Console.WriteLine(a4.ItemsEqual(a3)); // Output: False. No Exception.
        Console.WriteLine(a5.ItemsEqual(a6)); // Output: False. No Exception.
    }
}

यूनिट परीक्षणों के लिए, आप Assert.AreEqual बजाय CollectionAssert.AreEqual उपयोग कर सकते हैं।

यह शायद सबसे आसान तरीका है।


LINQ में LINQ उपयोग करें।

int[] arr1 = new int[] { 1,2,3};
int[] arr2 = new int[] { 3,2,1 };

Console.WriteLine(arr1.SequenceEqual(arr2)); // false
Console.WriteLine(arr1.Reverse().SequenceEqual(arr2)); // true

.NET 4.0 और उच्चतर के लिए आप StructuralComparisons कॉम्पैरिसन प्रकार का उपयोग करके सरणी या टुपल्स में तत्वों की तुलना कर सकते हैं:

object[] a1 = { "string", 123, true };
object[] a2 = { "string", 123, true };

Console.WriteLine (a1 == a2);        // False (because arrays is reference types)
Console.WriteLine (a1.Equals (a2));  // False (because arrays is reference types)

IStructuralEquatable se1 = a1;
//Next returns True
Console.WriteLine (se1.Equals (a2, StructuralComparisons.StructuralEqualityComparer)); 

आप SequenceEqual उपयोग कर सकते हैं। यह किसी भी IEnumerable<T> , सिर्फ सरणी के लिए काम करता है।







compare