/// <summary>
        ///     Processes the "member" property of groups and converts the resulting list of distinguishednames to TypedPrincipals
        /// </summary>
        /// <param name="distinguishedName"></param>
        /// <param name="members"></param>
        /// <param name="objectName"></param>
        /// <returns></returns>
        public IEnumerable <TypedPrincipal> ReadGroupMembers(string distinguishedName, string[] members,
                                                             string objectName = "")
        {
            // If our returned array has a length of 0, one of two things is happening
            // The first possibility we'll look at is we need to use ranged retrieval, because AD will not return
            // more than a certain number of items. If we get nothing back from this, then the group is empty
            if (members.Length == 0)
            {
                _log.LogTrace("Member property for {ObjectName} is empty, trying range retrieval",
                              objectName);
                foreach (var member in _utils.DoRangedRetrieval(distinguishedName, "member"))
                {
                    _log.LogTrace("Got member {DN} for {ObjectName} from ranged retrieval", member, objectName);
                    var res = _utils.ResolveDistinguishedName(member);

                    if (res == null)
                    {
                        yield return new TypedPrincipal
                               {
                                   ObjectIdentifier = member.ToUpper(),
                                   ObjectType       = Label.Base
                               }
                    }
                    ;
                    else
                    {
                        yield return(res);
                    }
                }
            }
            else
            {
                //If we're here, we just read the data directly and life is good
                foreach (var member in members)
                {
                    _log.LogTrace("Got member {DN} for {ObjectName}", member, objectName);
                    var res = _utils.ResolveDistinguishedName(member);

                    if (res == null)
                    {
                        yield return new TypedPrincipal
                               {
                                   ObjectIdentifier = member.ToUpper(),
                                   ObjectType       = Label.Base
                               }
                    }
                    ;
                    else
                    {
                        yield return(res);
                    }
                }
            }
        }
        /// <summary>
        ///     Reads the "gplink" property from a SearchResult and converts the links into the acceptable SharpHound format
        /// </summary>
        /// <param name="gpLink"></param>
        /// <returns></returns>
        public IEnumerable <GPLink> ReadContainerGPLinks(string gpLink)
        {
            if (gpLink == null)
            {
                yield break;
            }

            foreach (var link in Helpers.SplitGPLinkProperty(gpLink))
            {
                var enforced = link.Status.Equals("2");

                var res = _utils.ResolveDistinguishedName(link.DistinguishedName);

                if (res == null)
                {
                    _log.LogTrace("Failed to resolve DN {DN}", link.DistinguishedName);
                    continue;
                }

                yield return(new GPLink
                {
                    GUID = res.ObjectIdentifier,
                    IsEnforced = enforced
                });
            }
        }