C#

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

Randor wrote:

First let's get on the same page.

// For Richard Andrew x64
//

#pragma comment(lib, "adsiid.lib")
#pragma comment(lib, "Activeds.lib")

#include <iostream>
#include <windows.h>
#include <atlbase.h>
#include <activeds.h>
#include <iads.h>
#include <adshlp.h>
#include <strsafe.h>

INT main()
{
    IADsClass* pClass = NULL;
    IADs* pADs;
    BSTR bstrSchema;
    VARIANT var;
    IEnumVARIANT* pEnumerator = NULL;
    IADsContainer* pContainer = NULL;
    ULONG count;
    IADs* pChild = NULL;
    WCHAR ad_path[MAX_PATH] = { 0 };
    WCHAR computer_name[MAX_COMPUTERNAME_LENGTH] = { 0 };

    count = MAX_COMPUTERNAME_LENGTH;
    GetComputerName(computer_name, &count);
    
    count = MAX_PATH;
    if (SUCCEEDED(CoInitialize(NULL)))
    {
        if (SUCCEEDED(StringCchPrintfW(ad_path, count, L"WinNT://%s,computer", computer_name)))
        {
            if (SUCCEEDED(ADsGetObject(ad_path, IID_IADsContainer, (void**)&pContainer)))
            {
                if (SUCCEEDED(ADsBuildEnumerator(pContainer, &pEnumerator)))
                {
                    VariantInit(&var);
                    while (SUCCEEDED(ADsEnumerateNext(pEnumerator, 1, &var, &count)) && count == 1)
                    {
                        if (SUCCEEDED(V_DISPATCH(&var)->QueryInterface(IID_IADs, (void**)&pChild)))
                        {
                            BSTR bstrClass;
                            pChild->get_Class(&bstrClass);

                            if (CComBSTR(bstrClass) == CComBSTR(L"User"))
                            {
                                IADsUser* user = nullptr;
                                if (SUCCEEDED(pChild->QueryInterface(&user)))
                                {
                                    VARIANT_BOOL is_disabled;
                                    user->get_AccountDisabled(&is_disabled);
                                    if (VARIANT_FALSE == is_disabled)
                                    {
                                        BSTR bstrName;
                                        pChild->get_Name(&bstrName);
                                        std::wcout << bstrName << std::endl;
                                        SysFreeString(bstrName);
                                        pChild->Release();
                                    }
                                }
                            }
                            pChild->Release();
                        }
                        VariantClear(&var);
                    }
                    ADsFreeEnumerator(pEnumerator);
                }
                pContainer->Release();
            }
        }
    }

    CoUninitialize();
    return 0;
}