Using T type parameter to clone a collection

Question

I want to clone a collection with the following method and I want to know if it can be optimized:

public T CloneCollection<T>(IEmployees employees) where T : IEmployees, new()
{
    T collection = new T();
    foreach (IEmployee employee in employees)
    {
        collection.Add(employee);
    }
    return collection;
}

These are the other classes which are related to the method above:

public class RegularEmployee : Entities, IEmployee
{
//properties
}

public class User : Entities, IEmployee
{
//properties
}

public class Manager : Entities, IEmployee
{
//properties
}

public class ManagerCollection : List<Manager>, IEmployees
{
   void Add(IEmployee employee);
}

public class RegularEmployeeCollection : List<RegularEmployee>, IEmployees
{
   void Add(IEmployee employee);
}

public class UserCollection : List<User>, IEmployees
{
   void Add(IEmployee employee);
}

Answer 1

You can replace your loop with AddRange():

public T CloneCollection<T>(IEmployees employees) where T : IEmployees, new()
{
    T collection = new T();
    collection.AddRange(employees);
}

Additional thought:

Note that your solution and this solution are simply cloning the list and not the items in the list. If you update an Employee, the employee will be modified in both lists. If this is NOT the desired behavior, you will need to clone each employee as well.

Answer 2

Review

Your code does not clone a collection. It creates one and assigns the values of the specified source collection to it. It also lacks proper generics to make this usable for other types of collections.

public T CloneCollection<T>(IEmployees employees) where T : IEmployees, new()
{
    // creates a target collection
    T collection = new T();

    // assigns items from source to target
    foreach (IEmployee employee in employees)
    {
        collection.Add(employee);
    }
    return collection;
}

Cloning a collection is ambiguously defined. It does not state whether the items should be cloned as well.

Shallow Clone

A shallow clone of a collection is a new instance, holding references to the same items as the source collection.

public static T ShallowClone<T, TItem>(T source) where T : ICollection<TItem>, new()
{
    var target = new T();
    foreach (var item in source)
    {
        target.Add(item);
    }
    return target;
}

I don't really see a use case for this. It's better using common collections or creating overloaded constructors on custom collections that take IEnumerable<T> as input. If your custom collection inherits from List<T> you should take advantage of AddRange.

Deep Clone

A deep clone of a collection is a new instance with clones of the source items. Make sure the items implement ICloneable. If you want to provide deep-cloning for items that do not implement this interface, you'd have to create an overload of DeepClone that uses a default strategy for deep-cloning items. This is elaborated in this post.

public static T DeepClone<T, TItem>(T source) 
    where T : ICollection<TItem>, new()
    where TItem : ICloneable
{
    var target = new T();
    foreach (var item in source)
    {
        target.Add(item == null ? null : item.Clone());
    }
    return target;
}

Checking input for null is left out for brevity.