C#

#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);

}

Richard Andrew x64 wrote:

What is the property I should be checking for to determine which listed accounts are the "human" accounts, and which are machine accounts?

Richard Andrew x64 wrote:

Which functions would I use to do this?

foreach (DirectoryEntry childEntry in computerEntry.Children)
{
	if (childEntry.SchemaClassName == "User")
	{
		IADsUser coronavirus = childEntry.NativeObject as IADsUser;
		//Access your properties here
	}
}