How to Access Nested Outlook Distribution List Entry Through VSTO?

On the Microsoft exchange server, there can be multiple distribution lists and each list can either directly contain users or it can contain another distribution list nested within it. When we create an Outlook add-in, we may need to access these lists or Outlook users programmatically. Here, I'll describe a couple of ways to access a distribution list entry which is a part of another distribution list entry using Visual Studio Tools for office (VSTO).

The approach described here can be used while fetching first level DL or while fetching user members within any level DL. Both User and Distribution list are derived from the AddressEntry class because of the obvious reason that members of the Distribution list can be both user or another list. The derived class for users is ExchangeUser and the derived class for Distribution List is ExchangeDistributionList.

AddressEntry in turn is obtained from collection AddressEntries properties of AddressList object. Address Lists which contain all the Distribution lists for your exchange server can be obtained as shown below:

var outlook = new Outlook.Application().GetNamespace("MAPI");
            Outlook.AddressLists addrLists = outlook.Application.Session.AddressLists;

Now, consider an example of an exchange server where we have a distribution list hierarchy as:

For Instance, we have to fetch the distribution list — ‘Dev Team Delhi’, ‘Dev Team Mumbai’, and ‘Dev Team Chennai’ — present inside the parent Distribution List ‘Dev Team’ list.

AddressLists (denoted by variable addrLists in above code) does not contain any function to find the AddressList object. AddressLists can be obtained through iterating over complete collection. Sometimes distribution lists can be thousands in number.

In our example of finding members (Distribution list) for ‘Dev Team’ for the distribution list, one approach could be:

public List<string> GetDevTeamByCity()
        {
            List<string> devTeamRegions = new List<string>();
            try
            {
                var outlook = new Outlook.Application().GetNamespace("MAPI");
                Outlook.AddressLists addrLists =
                    outlook.Application.Session.AddressLists; // All Address List collections

                foreach (Outlook.AddressList addrList in addrLists)
                {
                    if (addrList.Name.Equals("All Distribution Lists", StringComparison.OrdinalIgnoreCase))
                    {
                        foreach (Outlook.AddressEntry addrEntry in addrList.AddressEntries)
                        {
                            if ((addrEntry.AddressEntryUserType == Outlook.OlAddressEntryUserType.olExchangeDistributionListAddressEntry)
                             && addrEntry.Name.Equals("Dev Team", StringComparison.OrdinalIgnoreCase)) // Parent DL of Dev Team across regions
                            {

                                foreach (Outlook.AddressEntry regionEntry in addrEntry.Members)
                                {
                                    if (regionEntry.AddressEntryUserType == Outlook.OlAddressEntryUserType.olExchangeDistributionListAddressEntry)
                                    { // Checked for type of DL
                                        devTeamRegions.Add(regionEntry.Name);
                                    }
                                }
                                return devTeamRegions;                               
                            }
                        }
                    }
                }
            }
            catch (System.Exception ex)
            {
                throw;
            }
            return devTeamRegions;
        }

The above code returns required list of Distribution list members in the form of a list of strings. Here, we first find the main Distribution List or AddressList named ‘All Distribution Lists’ from AddressLists collection of outlook. Then we iterate over it and find parent list ‘Dev Team’ for required Distribution lists. Internally, data is fetched from Outlook COM object. This COM object is responsible for interacting with Exchange server.

Also note, in the innermost loop, AddressEntryUserType is checked for the type of olExchangeDistributionListAddressEntry to confirm it is of the type ExchangeDistributionList before returning the list of the string containing ‘Dev Team Delhi’,’Dev Team Mumbai’,’Dev Team Chennai’.

Once the required list is found we may have to delve deeper for finding user member in the list—for instance, finding users in ‘Dev Team Delhi’. For this, the required check should be done for olExchangeUserAddressEntry type and then AddressEntry can be typecasted to ExchangeUser Type as shown below:

 if (userEntry.AddressEntryUserType == Outlook.OlAddressEntryUserType.olExchangeUserAddressEntry)
                                {
                                    Outlook.ExchangeUser userInfo = userEntry.GetExchangeUser();
                                      var  Email = userInfo.PrimarySmtpAddress,
                                      var  FirstName = userInfo.FirstName,
                                      var  LastName = userInfo.LastName
                                }

In the above example with multiple hierarchies of distribution list, there were only three distribution lists. But in a real scenario, there can be thousands of Distribution lists which need to be traversed through forEach loop because each level can have multiple lists.

Here is a second approach to find the distribution list contained within another distribution list.

var outlook = new Outlook.Application().GetNamespace("MAPI");
            Outlook.AddressLists addrLists = outlook.Application.Session.AddressLists; // Same till here

            Outlook.AddressList addrEntryMain = addrLists["All Distribution Lists"]; // finding the main DL directly
            Outlook.AddressEntries addEntries = addrEntryMain.AddressEntries; // Getting AddressEntries property which is list of AddressEntry
            Outlook.AddressEntry Silo = addEntries["Dev Team"]; // Finding directly without foreach loop.
            foreach (Outlook.AddressEntry addrEntry in Silo.Members)
            {
                if (addrEntry.AddressEntryUserType ==
                       Outlook.OlAddressEntryUserType.
                       olExchangeDistributionListAddressEntry)
                {
                    devTeamRegions.Add(addrEntry.Name);
                }
            }

The same results can be obtained from this approach. Here, I directly access ‘Dev Team’ by addEntries [‘Dev Team’].

Concluding Points

The second approach does not require iterating over all the Distribution Lists, making the code simpler and more elegant. Also, in the first approach, the developer may tend to use nested ForEach loop to reach ‘Dev Team’ assuming that it is nested inside ‘Product Team’, while in our case it was directly accessible under ‘All Distribution Lists’. Hierarchy didn’t make any difference here. The approaches which I presented can be used to fetch first Level DL or nested DL or even while fetching the Users within DL. When you have too many DL’s, the second approach shows a significant advantage.