Comparing two list of different types (reference types) using C#

I have written a program that can be used to compare two lists of different types (reference types). My approach is to first convert the lists to a common intermediate type. Once both lists are converted to an intermediate type, they can be, at first, sorted and then compared based on different criteria. I have checked if both of them have equal number of elements and if they are sequentially equal using standard function from List library.

internal class Program
{
    private static void Main(string[] args)
    {
        bool areEqual;
        //list of type Students
        var listPerson = new List<Student>()
        {
            new Student("Shakti", "Saxena"),
            new Student("Kavin", "Spacey"),
            new Student("Robin", "Wright")
        };


        //list of types Employee
        var listEmplyoees = new List<Emplyoee>()
        {
            new Emplyoee("Kavin", "Spacey"),
            new Emplyoee("Robin", "Wright"),
            new Emplyoee("Shakti", "Saxena")
        };

        var listEmployeeConverted = CreateAListOfCommanType(listEmplyoees);
        var listPersonConverted = CreateAListOfCommanType(listPerson);

        listEmployeeConverted.Sort();
        listPersonConverted.Sort();

        CompareTwoList(listPersonConverted, listEmployeeConverted, out areEqual);

        Console.WriteLine(areEqual ? "Two lists are equal" : "Two lists are not equal");

        Console.ReadKey();
    }

    /// <summary>
    /// Compare two list
    /// </summary>
    /// <param name="listPersonConverted"></param>
    /// <param name="listEmployeeConverted"></param>
    /// <param name="areEqual"></param>
    /// <returns></returns>
    private static void CompareTwoList(List<Person> listPersonConverted, List<Person> listEmployeeConverted,
        out bool areEqual)
    {
        if (listPersonConverted.Count() != listEmployeeConverted.Count())
        {
            areEqual = false;
        }
        areEqual = listPersonConverted.SequenceEqual(listEmployeeConverted);
    }

    /// <summary>
    /// Convert a list to a commontype
    /// </summary>
    /// <param name="listPerson"></param>
    /// <returns></returns>
    private static List<Person> CreateAListOfCommanType(List<Student> listPerson)
    {
        var p =
            listPerson.Select(person => new Person() { MainName = person.Firstname, LastName = person.LastName })
                .ToList();
        return p;
    }

    /// <summary>
    /// Convert a list to a commontype
    /// </summary>
    /// <param name="listEmplyoees"></param>
    /// <returns></returns>
    private static List<Person> CreateAListOfCommanType(List<Emplyoee> listEmplyoees)
    {
        var p =
            listEmplyoees.Select(
                employee => new Person() { MainName = employee.Name, LastName = employee.LastName }).ToList();
        return p;
    }
}


internal class Person : IComparable, IEquatable<Person>
{
    private string _mainName;

    public string MainName
    {
        get { return _mainName; }
        set { _mainName = value; }
    }

    public string LastName
    {
        get { return _lastName; }
        set { _lastName = value; }
    }

    private string _lastName;

    public Person(string mainName, string lastName)
    {
        _mainName = mainName;
        _lastName = lastName;
    }

    public Person()
    {
    }


    public int CompareTo(object obj)
    {
        if (obj == null) return 1;

        Person other = obj as Person;
        if (other == null) return 0;

        int result = string.Compare(this.MainName, other.MainName, StringComparison.Ordinal);

        if (result == 0)
        {
            result = string.Compare(this.LastName, other.LastName, StringComparison.Ordinal);
        }

        return result;
    }

    public bool Equals(Person other)
    {
        if (object.ReferenceEquals(other, null)) return false;

        if (object.ReferenceEquals(this, other))
            return true;
        if (this.MainName.Equals(other.MainName) && this.LastName.Equals(other.LastName))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

/// <summary>
/// Student Class
/// </summary>
internal class Student
{
    private string _firstname;

    private string _lastName;

    public Student()
    {
    }

    public Student(string firstname, string lastname)
    {
        _firstname = firstname;
        _lastName = lastname;
    }

    public string Firstname
    {
        get { return _firstname; }
        set { _firstname = value; }
    }

    public string LastName
    {
        get { return _lastName; }
        set { _lastName = value; }
    }
}

/// <summary>
/// Employee class
/// </summary>
internal class Emplyoee
{
    private string _name;

    private string _lastName;

    public Emplyoee(string name, string lastname)
    {
        _name = name;
        _lastName = lastname;
    }

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public string LastName
    {
        get { return _lastName; }
        set { _lastName = value; }
    }
}

Code is self-explanatory and complete and is available for download.