The current solution works in a specific context, but there is further room for potential error. Without sorting the list, we should not assume a specific order; even if we have set it up in that way. Unaccounted logic or later changes may alter the order in one of the lists, which results in a false negative when comparing the elements of each list using a single index value.

The solution is fairly simple. Just sort the list, before you compare values in it. This is straight forward, if we are using List<int>; int values already know how to sort themselves, in a list. If we ever want the same functionality from a List<t> of custom types, we need to make use of the System.IComparable<in t> interface.

Sorting a List<t>

We sort a List<t> with the method List<t>.Sort(). Sorting both lists before comparing values guarantees that if the lists both contain the same set of values, they will also be in the same order.

private bool DoListsMatch(List<int> list1, List<int> list2)
{
    var areListsEqual = true;

    if (list1.Count != list2.Count)
        return false;

    list1.Sort(); // Sort list one
    list2.Sort(); // Sort list two

    for (var i = 0; i < list1.Count; i++)
    {
        if (list2[i] != list1[i])
        {
            areListsEqual = false;
        }
    }

    return areListsEqual;
}

Using System.IComparable<in t> to make custom types compatible with List<t>.Sort()

Should we want to perform the same function on a list that contains custom types, we need to add the System.IComparable<in t> interface to that type. This interface only contains one method that needs to be implemented in the class - public int CompareTo(t other). This method compares the local type with the other type, and returns an int value representing the the placement of the local type in comparison to the other type.

For the example, I will simply use a custom class that stores an int. You can set this CompareTo() method up in any way you like, specific to the types you use inside that class. You may want to compare ID numbers, or compare distances to a particular position, or even a given name.

class MyInt : IComparable<MyInt>
{
    int value;

    public int CompareTo(MyInt other)
    {
        return value.CompareTo(other.value);
    }
}

private bool DoListsMatch(List<MyInt> list1, List<MyInt> list2)
{
    // ...
}

As a final note, with the use of a custom implementation of int CompareTo(t other), it is worth considering the possibility of error if two unique t values can still compare with each-other as equal. If the same two values would not return a value of true when compared as valueA == valueB¹, there is still a possibility of incorrect output, when comparing both lists. If CompareTo() returns a value of 0, the items will not sort in any particular order (in relation to eachother), in the list. As such, we can not guarantee the order of the list¹.

¹ If the two items also return true when compared using the == operator, the previous checks will still correctly identify the objects as equal, and this will be a non-event.

Sort first and comprare elements

using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class ABCD : MonoBehaviour
{
    public void Test()
    {
        List<int> A = new List<int>() { 1, 3, 5 };
        List<int> B = new List<int>() { 5, 3, 1 };
    }

    bool IsSame(List<int> A, List<int> B)
    {
        if (A.Count != B.Count)
        {
            return false;
        }

        List<int> ASort = A.ToList();
        ASort.Sort();
        List<int> BSort = B.ToList();
        BSort.Sort();

        for (int i = 0; i < ASort.Count; i++)
        {
            if(ASort[i] != BSort[i])
            {
                return false;
            }
        }

        return true;
    }
}

You can use the Intersect method. Here is a simple console application

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var nums1 = new int[] { 2, 4, 6, 8, 10, 9 };
        var nums2 = new int[] { 1, 3, 6, 9, 12, 2 };

        if (nums1.Intersect(nums2).Any()) // check if there is equal items
        {
            var equalItems = nums1.Intersect(nums2); // get list of equal items (2, 6, 9)

            // ...
        }
    }
}

You can use linq to query your collections e.g. ListOfThings.Where(t => t.Property == "value").Count() would give you number of things where Property is "value".

Using linq:

foreach (var component in rendererComponents.Where(r => r.gameObject.tag != "ignoreRend"))