C#

private IEnumerable<T> DoSomething<T>(
    Func<T,T> func,
    params T[] args)
{
    foreach (T t in args)
    {
        yield return func(t);
    }
}

private IEnumerable<T> DoSomething<T>(
    Func<T,T> func,
    IEnumerable<T> args)
{
    return DoSomething(func, args.ToArray());
}

// sample calls
    //var t1 =  DoSomething(
        //t => t * 3, 
        //1,2,3,4,5);

    //var t2 =  DoSomething(
        //t => t * 3, Enumerable.Range(6, 10));

#realJSOP wrote:

I'm not returning a collection of generics, so it can't pick the appropriate overload.

MyMethod(Enumerable.Range(1, 42)); // Calls IEnumerable overload
MyMethod(new[] { 1, 2, 3 }); // Calls T overload
MyMethod(new List<int> { 1, 2, 3 }); // Calls T overload

MyMethod(Enumerable.Range(1, 42)); // Calls IEnumerable overload
MyMethod((new[] { 1, 2, 3 }).AsEnumerable()); // Calls IEnumerable overload
MyMethod((new List<int> { 1, 2, 3 }).AsEnumerable()); // Calls IEnumerable overload

// note: being lazy here by omitting the generic <int> metadata in the method calls 
//... something I would not allow my students to do !

            var t0 =  DoSomething(
                t => t * 3, 
                100).ToList();

           var t1 =  DoSomething(
                t => t * 3, 
                1,2,3,4,5).ToList();

            var t2 =  DoSomething(
                t => t * 3, Enumerable.Range(6, 10)).ToList();

            var t3 =  DoSomething(
                t => t * 3, new[] { 11, 12, 13 }).ToList();

            var t4 =  DoSomething(
                t => t * 3, new List<int> { 14, 15, 16 }).ToList();

public static void Foo<T>(T value) => Console.WriteLine("Foo a single value");
public static void Foo<T>(IEnumerable<T> values) => Console.WriteLine("Foo multiple values");

public static void Bar()
{
    Foo(42); // Calls Foo(T) - Correct
    Foo(Enumerable.Range(1, 42)); // Calls Foo(IEnumerable) - Correct
    
    Foo(new[] { 1, 2, 3 }); // Calls Foo(T) - *** INCORRECT ***
    Foo(new List<int> { 1, 2, 3 }); // Calls Foo(T) - *** INCORRECT ***
    
    Foo((new[] { 1, 2, 3 }).AsEnumerable()); // Calls Foo(IEnumerable) - Correct
    Foo((new List<int> { 1, 2, 3 }).AsEnumerable()); // Calls Foo(IEnumerable) - Correct
}

public static void Foo<T>(IEnumerable<T> value) => Console.WriteLine($"Foo<{typeof(T)}>(IEnumerable<{typeof(T)}>)";
public static void Foo<T>(params T[] value) => Console.WriteLine($"Foo<{typeof(T)}>(params {typeof(T)}[])";

public static void Bar()
{
    Foo(42); // Foo<int>(params) - Correct
    Foo(Enumerable.Range(1, 42)); // Foo<int>(IEnumerable) - Correct
    Foo(new[] { 1, 2, 3 }); // Foo<int>(params) - Correct
    Foo(new List<int> { 1, 2, 3 }); // Foo<List<int>>(params) - *** INCORRECT ***
}

MyMethod(data.AsEnumerable());

MyMethod((IEnumerable<int>)data);

public void MyMethod<T>(List<T> data)
{
    MyMethod<T>((IEnumerable<T>)data);

}