Remove duplicates from List of class objects, based on string array instance property

class RowData
{
    string Name;
    string[] Aliases;
}

List<RowData> rowData = new List<RowData>();
rowData.Add(new RowData { Name = "John Doe", Aliases = new string[] { "johndoe", "jdoe" } });
rowData.Add(new RowData { Name = "Jane Doe", Aliases = new string[] { "janedoe", "jdoe" } });
rowData.Add(new RowData { Name = "John Doe", Aliases = new string[] { "johndoe", "jdoe" } });

List<string[]> aliasList;

foreach(var row in in rowData)
{
    if(aliasList.Any(obj => obj.SequenceEqual(row.Aliases)))
    {
        continue;
    }
    aliasList.Add(row.Aliases);

    MakeRow(row.Name, row.Aliases);
}

Final result should only contain item at index 0 & 1 of List, as Aliases of items at index 0 & 2 are equal

I’ve tried different ways of filtering out rows where Aliases are common from the list of objects of type RowData, but this is the best way I was able to do this. Is there any better way of doing this using LINQ?

I would use a custom IEqualityComparer<RowData> which you can use for many LINQ methods. In this case you can use it for Distinct:

public class RowDataAliasComparer : IEqualityComparer<RowData>
{
    public bool Equals(RowData x, RowData y)
    {
        if (x?.Aliases == null && y?.Aliases == null)
        {
            return true;
        }

        if (x?.Aliases == null || y?.Aliases == null)
        {
            return false;
        }

        return x.Aliases.OrderBy(a => a).SequenceEqual(y.Aliases.OrderBy(a => a));
    }

    public int GetHashCode(RowData obj)
    {
        if (obj?.Aliases?.Any() != true)
        {
            return int.MinValue;
        }

        unchecked
        {
            int hash = 0;
            foreach (string alias in obj.Aliases.OrderBy(a => a))
                hash ^= (alias?.GetHashCode() ?? 0);
            return hash;
        }
    }
}

So the code to remove the duplicates is easy:

rowData = rowData.Distinct(new RowDataAliasComparer()).ToList();

Another option is to use DistinctBy() that might be a bit cleaner. This is order-sensitive implementation. It's easy to make it insensitive by using OrderBy()

public class StringArrayComparer : IEqualityComparer<IEnumerable<string>>
{
    public bool Equals(IEnumerable<string>? x, IEnumerable<string>? y)
        => Enumerable.SequenceEqual(x, y);

    public int GetHashCode(IEnumerable<string> obj)
    {
        // copy of GetHashCode() method of Tim Schmelter's answer
        if (obj.Any() != true)
        {
            return int.MinValue;
        }

        unchecked
        {
            int hash = 0;
            foreach (string alias in obj)
                hash ^= (alias?.GetHashCode() ?? 0);
            return hash;
        }
    }
}

and usage

var filteredRows = rowData.DistinctBy(s => s.Aliases, new StringArrayComparer());

You can use linq and string.Join

var _result= rowData.GroupBy(d => 
          new { d.Name, v = string.Join("|", d.Aliases) 
              }).Select(g => g.First()).ToList();

Try this code

List<RowData> rowData = new List<RowData>();
rowData.Add(new RowData { Name = "John Doe", Aliases = new string[] { "johndoe", "jdoe" } });
rowData.Add(new RowData { Name = "Jane Doe", Aliases = new string[] { "janedoe", "jdoe" } });
rowData.Add(new RowData { Name = "John Doe", Aliases = new string[] { "johndoe", "jdoe" } });

List<RowData> distinctData = rowData
    .GroupBy(x => new { x.Name, x.Aliases })
    .Select(group => group.First())
    .ToList();