Cannot convert from custom object to object or dynamic

There are a couple of issues here, both related to variance.

This won't work because List<T>, or any other class in .NET for that matter, does not support variance.

In other words T has to be a specific type, and does not respect inheritance / substitutability as with non-generic types.

Similarly, for Dictionary<TKey, TValue>, TValue is not variant, so you can't simply use object as the value.

IEnumerable<out T> on the other hand is covariant so you could do this:

public IEnumerable<IDictionary> getDifferentItems()
{
   yield return getEmployees();
   yield return getCustomers();
}

IDictionary is used, as it is the only common ancestor (other than object) to Dictionary<string, Employee> and Dictionary<string, Customer>.

This may satisfy your requirements, but you don't make clear whay you are trying to achive with your getDifferentItems method.

More information on variance can be found here.

I'd personally make an interface, such as IPerson that has all the properties of Employees and Customers, such as Name, Address, ID, etc.

Set up your Customer and employee classes to implement IPerson

Then use a IPerson in your dictionary and you can add to the objects to that.

Here's some code:

public class Employee : IPerson
    {
        public int ID { get; set; }

        public string Name { get; set; }
    }

    public class Customer : IPerson
    {
        public int ID { get; set; }

        public string Name { get; set; }
    }

    public interface IPerson
    {
        int ID { get; set; }

        string Name { get; set; }
    }
    public class Test
    {
        public void MyTest()
        {
            List<Dictionary<string, IPerson>> listOfItems = new List<Dictionary<string, IPerson>>();

            Dictionary<string, IPerson> myEmployees = new Dictionary<string, IPerson>();
            string someString = "blah";
            Employee e = new Employee();
            e.Name = "Bob";
            e.ID = 1;

            myEmployees.Add(someString, e);

            Dictionary<string, IPerson> myCustomers = new Dictionary<string, IPerson>();
            string someOtherString = "blah";
            Customer c = new Customer();
            c.Name = "Robert";
            c.ID = 2;

            myCustomers.Add(someOtherString, c);

            listOfItems.Add(myEmployees);
            listOfItems.Add(myCustomers);
        }
    }

Here is another solution :

    public class Test
    {
        Dictionary<string, object> listOfItems = new Dictionary<string, object>();
        List<Employee> employees = new List<Employee>();
        List<customer> customers = new List<customer>();
        public Dictionary<string, object> getEmployees()
        {
            return employees.GroupBy(x => x.name, y => (object)y).ToDictionary(x => x.Key, y => y.FirstOrDefault());

        }//This method returns a dictionary of string as a key and Employee as a value.
        public Dictionary<string, object> getCustomers()
        {
            return customers.GroupBy(x => x.name, y => (object)y).ToDictionary(x => x.Key, y => y.FirstOrDefault());
        } //same principal 
        public Dictionary<string, object> getDifferentItems()
        {
            listOfItems = getEmployees();
            listOfItems.Concat(getCustomers());
            return listOfItems;
        }
    }
    public class Employee
    {
        public string name { get;set;}
    }
    public class customer
    {
        public string name { get;set;}
    }