Get email addresses from distribution list using c#

If the computer you run this from is joined to the same domain as the group you're looking for, then you don't need to figure out the LDAP path. You can just do:

var search = new DirectorySearcher();

If your computer is not joined to the same domain, then you just use the domain name:

var entry = new DirectoryEntry("LDAP://domainname.com");

This requires that there is no firewall blocking port 389 between your computer and the domain controller(s). If you need to pass credentials, then do that:

var entry = new DirectoryEntry("LDAP://domainname.com", username, password);

The credentials can be any user on the domain.

That said, there are a lot of inefficiencies in your code that will make it run much slower than needed. I wrote an article about this that can help you update your code: Active Directory: Better Performance

Is EWS approach a good way?

If it works, it works. I'm not an expert on EWS (although I have used it), but I'm fairly certain that's using Basic Authentication, which is going to be disabled in October.

If all the Mailboxes are on Office365 then i would suggest you use the Graph API instead eg https://docs.microsoft.com/en-us/graph/api/group-list-members?view=graph-rest-1.0&tabs=http . There are several advantage in terms of security eg you could use Application permissions and all you need is access to the directory while if you did the same thing in EWS it would require full access to at least one mailbox.

LDAP will be best performing of the 3 if ultimate speed in the only thing that is important.

My complete solution for future reference. :)

EWS Way - For expanding Exchange Distribution Lists

public class SomeHelper
{
    private static ExchangeService _exchangeService = null;
    
    public static async Task<HashSet<string>> GetExchangeDistributionListMembersAsync(IEnumerable<string> dlNames)
    {
        var allEmailAddresses = new HashSet<string>();

        foreach (var dlName in dlNames)
        {
            if (!SomeCache.TryGetCachedItem(dlName, out var dlMembers))
            {
                var groupEmailAddresses = new List<string>();
                var exchangeService = await GetExchangeServiceAsync();

                try
                {
                    var myGroupMembers = exchangeService.ExpandGroup(dlName);
                    // Add the group members.
                    foreach (var address in myGroupMembers.Members)
                    {
                        groupEmailAddresses.Add(address.Address);
                    }
                }
                catch (Exception ex)
                {
                    //If it can't expand the dlName, just return it.
                    groupEmailAddresses.Add(dlName);
                    //groupEmailAddresses.Add($"Attempting to expand '{dlName}' resulted in error message: '{ex.Message}'.");
                }

                // Cache the groupEmailAddresses for 7 days.
                // Because Distribution Lists rarely change and expanding DL is an expensive operation.- AshishK Notes
                SomeCache.AddItemToCache(dlName, groupEmailAddresses, 10080);
                allEmailAddresses.UnionWith(groupEmailAddresses);
            }
            else
            {
                allEmailAddresses.UnionWith((List<string>)dlMembers);
            }
        }

        return allEmailAddresses;
    }
    
    private static async Task<ExchangeService> GetExchangeServiceAsync()
    {
        if (_exchangeService == null)
        {
            _exchangeService = new ExchangeService();
            var exchangeUrl = "https://outlook.office365.com/ews/exchange.asmx";
            var cred = new WebCredentials("sharedmailbox@domain.com", "some_password");
            _exchangeService.Credentials = cred;

            //_exchangeService.AutodiscoverUrl("sharedmailbox@domain.com");
            _exchangeService.Url = new Uri(exchangeUrl);

            _exchangeService.TraceEnabled = true;
            _exchangeService.TraceFlags = TraceFlags.All;

            return _exchangeService;
        }
        else
        {
            return _exchangeService;
        }
    }
}

public class SomeCache
{
    private static readonly ObjectCache _cache = MemoryCache.Default;

    public static void AddItemToCache(string key, object itemToAdd, int cacheDurationMinutes)
    {
        var _policy = new CacheItemPolicy
        {
            Priority = CacheItemPriority.Default,
            AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(cacheDurationMinutes)
        };

        _cache.Set(key, itemToAdd, _policy);
    }

    public static bool TryGetCachedItem(string key, out object cachedObject)
    {
        try
        {
            cachedObject = _cache[key] as object;
        }
        catch (Exception ex)
        {
            cachedObject = null;
        }
        return !(cachedObject == null);
    }
}

LDAP Way - For expanding Active Directory Groups

public static List<string> GetADGroupDistributionListMembers(string adGroupName)
{
    var returnResult = new List<string>();
    var entry = GetDirectoryEntry();
    DirectorySearcher groupSearch = new DirectorySearcher(entry)
    {
        Filter = "(SAMAccountName=" + adGroupName + ")"
    };
    groupSearch.PropertiesToLoad.Add("member");
    SearchResult groupResult = groupSearch.FindOne(); // getting members who belong to the adGroupName
    if (groupResult != null)
    {
        for (int iSearchLoop = 0; iSearchLoop < groupResult.Properties["member"].Count; iSearchLoop++)
        {
            string userName = groupResult.Properties["member"][iSearchLoop].ToString();
            int index = userName.IndexOf(',');
            userName = userName.Substring(0, index).Replace("CN=", "").ToString(); // the name of the user will be fetched.

            DirectorySearcher search = new DirectorySearcher(entry)
            {
                Filter = "(name=" + userName + ")"
            };
            search.PropertiesToLoad.Add("mail");
            SearchResult result = search.FindOne(); //finding the mail id
            if (result != null)
            {
                returnResult.Add(result.Properties["mail"][0].ToString());
            }
        }
    }

    return returnResult;
}

public static DirectoryEntry GetDirectoryEntry()
{
    DirectoryEntry entryRoot = new DirectoryEntry("LDAP://RootDSE");
    string Domain = (string)entryRoot.Properties["defaultNamingContext"][0];
    DirectoryEntry de = new DirectoryEntry
    {
        Path = "LDAP://" + Domain,
        AuthenticationType = AuthenticationTypes.Secure
    };

    return de;
}