C#

Quote:

"It is simply false that the choice of whether to use the stack or the heap has anything fundamentally to do with the type of the thing being stored. The truth is: the choice of allocation mechanism has to do only with the known required lifetime of the storage."

Richard Andrew x64 wrote:

the .NET String class is a reference type, correct?

F-ES Sitecore wrote:

No, it's a value type.

Richard Deeming wrote:

it's easier to think of string as a value type, even though it isn't

OriginalGriff wrote:

You could check the type in a single method and route it to one of two private methods?

public void DoSomething()
    {
    MyClass m = new MyClass();
    List<MyClass> list = new List<MyClass>() { m };
    Console.WriteLine($"{ProcessDepending(list)}, {ProcessDepending(m)}");
    }
public int ProcessDepending<T>(T instance)
    {
    if (instance is System.Collections.IEnumerable collection)
        {
        return ProcessCollection(collection);
        }
    return ProcessInstance(instance);
    }

private int ProcessInstance<T>(T instance)
    {
    return 1;
    }

private int ProcessCollection(IEnumerable collection)
    {
    return 2;
    }

private class MyClass { }

private int ProcessCollection<T>(IEnumerable<T> collection)

public int ProcessDepending<T>(T instance)
    {
    if (instance is IEnumerable<object> collection)
        {
        return ProcessCollection<object>(collection);
        }
    return ProcessInstance(instance);
    }

private int ProcessCollection<T>(IEnumerable<T> collection)
    {
    return 2;
    }

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 ***
}