AD 조직 구조 (Organizational Unit) 의 나무 구 조 를 구성 하 는 또 다른 방법

AD 조직 구조 (Organizational Unit · 이하 OU) 의 트 리 구 조 를 구성 하 는 또 다른 방법 이다.이전 방법 은 다음 을 참조 하 십시오. 귀속 구조 AD 조직 구조 (Organizational Unit) 의 트 리 구 조 는 두 개의 dll 를 인용 해 야 합 니 다.

using System.DirectoryServices;  
using System.DirectoryServices.ActiveDirectory; 

트 리 노드 클래스 정의:

    public class OuTreeNode
    {
        public string Name { get; set; }
        public string Id { get; set; }
        private List<OuTreeNode> _children = new List<OuTreeNode>();

        public List<OuTreeNode> Children
        {
            get { return _children; }
            set { _children = value; }
        }
    }

이런 종류의 이름 은 OuTreeNode 입 니 다. 그 중에서 OU 노드 의 기본 정 보 를 저장 합 니 다. 여기 서 OU 의 name, id, 하위 노드 의 목록 을 정의 합 니 다.
이전에 재 귀적 으로 OU 를 찾 는 방법 과 달리 이 방법 은 조 회 를 사용 하여 모든 OU 를 한 번 에 조회 한 다음 에 이 OU 를 옮 겨 다 니 면 조직 구조 트 리 를 만 들 수 있다.기본 적 인 사고방식 은 OU 대상 의 distinguishedName 을 이용 하여 OU 가 루트 노드 에 대한 상대 적 인 경 로 를 구성 하 는 것 이다. 이 경 로 는 xml 표 의 xpath 로 서 이 xpath 에 따라 xml 를 구성 할 수 있 고 마지막 으로 xml 표를 통 해 OU 트 리 를 재 귀적 으로 구성 할 수 있다.이것 은 xml 조회 에 대한 역방향 응용 입 니 다. 일반적으로 xml 표를 지정 하고 xpath 를 사용 하여 그 중의 노드 를 조회 합 니 다. 이번 에는 xpath 를 사용 하여 xml 표를 구성 합 니 다.
우선 OU 의 distinguished Name 을 상대 경로 로 변환 하 는 방법 이 필요 합 니 다.

        private static string FormatDNToRelativePath(string rawDn)
        {
            StringBuilder path = new StringBuilder();
            rawDn = rawDn.Replace(" ", "_").Replace("&", "_");
            string[] dnParts = rawDn.Split(new[] { ',' });
            foreach (string part in dnParts)
            {
                if (part.StartsWith("OU", StringComparison.OrdinalIgnoreCase))
                {
                    string name = XmlConvert.EncodeName((part.Split(new char[] {'='})[1]));
                    path.Insert(0, string.Format("/{0}", name));
                }
            }
            string domainName = string.Empty;
            using (Domain root = Domain.GetCurrentDomain())
            {
                domainName = root.Name;
            }
            path.Insert(0, string.Format("{0}", domainName));
            return path.ToString();
        }

이 방법 은 "OU = Office 1, OU = Dev Department, DC = Test, DC = com" 과 같은 상대 경 로 를 Test. Com \ Dev Department \ \ Office 1 과 같이 xml 표 에 의 해 OU 트 리 를 구성 할 수 있 습 니 다. 문자 전의 문제 가 있 습 니 다. AD 에서 OU 의 이름 은 임의의 문 자 를 사용 할 수 있 지만 xml 이 안 되 므 로 OU 의 이름 을 전의 해 야 합 니 다.XmlConvert. EncodeName 방법 을 사용 하여 이 를 한 다음 트 리 를 구성 할 때 다시 의 미 를 바 꿉 니 다.
최종 사용자 에 게 보 여 주 려 면 OU 의 정 보 를 가 져 와 야 합 니 다. 예 를 들 어 OU 의 name 과 id 만 가 져 옵 니 다. 그 중에서 name 도 전의 가 필요 합 니 다. name 은 xml 의 속성 으로 저장 되 기 때 문 입 니 다.

        private static string GetName(DirectoryEntry entry)
        {
            return XmlConvert.EncodeLocalName(entry.Properties["name"].Value.ToString());
        }

        private static string GetId(DirectoryEntry entry)
        {
            byte[] bytes = entry.Properties["ObjectGuid"].Value as byte[];
            Guid id = new Guid(bytes);
            return id.ToString();
        }

그 다음 에 모든 OU 의 상대 적 인 경로 와 이 OU 의 부모 노드 의 상대 적 인 경 로 를 얻 을 수 있 습 니 다. 이 경 로 는 xpath 로 볼 수 있 고 OU 노드 를 xml 의 정확 한 위치 에 추가 할 수 있 습 니 다.

        private static string GetPath(DirectoryEntry entry)
        {
            string xPath = string.Format("/{0}", FormatDNToRelativePath(entry.Properties["distinguishedName"].Value.ToString()));
            return xPath;

        }

        private static string GetParentPath(DirectoryEntry entry, string name)
        {
            string path = FormatDNToRelativePath(entry.Properties["distinguishedName"].Value.ToString());
            if (path.LastIndexOf(name) != -1)
            {
                path = path.Remove(path.LastIndexOf(name));
            }

            string parentPath = string.Format("/{0}", path);
            parentPath = parentPath.Substring(0, parentPath.LastIndexOf('/'));

            return parentPath;
        }

이런 방법 이 있 으 면 OU 트 리 를 구성 할 수 있 습 니 다. 다음은 코드 입 니 다. 구체 적 인 절 차 는 설명 을 참조 하 십시오.

        public static OuTreeNode GetOuTree()
        {
            XmlDocument xmlDoc = new XmlDocument(); //    XmlDocument
            XmlElement rootElement = null;
            string domainName = string.Empty;
            using (Domain domain = Domain.GetCurrentDomain())
            {
                rootElement = xmlDoc.CreateElement(domain.Name);
                xmlDoc.AppendChild(rootElement); // domain       

                using (DirectorySearcher ds = new DirectorySearcher(domain.GetDirectoryEntry(), "(objectClass=organizationalUnit)", null,
                    SearchScope.Subtree))
                {
                    SearchResultCollection src = ds.FindAll(); //    ，        OU
                    
                    foreach (SearchResult result in src)  //  OU
                    {
                        using (DirectoryEntry ouEntry = result.GetDirectoryEntry())
                        {
                            try
                            {
                                string nodeName = GetName(ouEntry); //  OU name
                                string nodeId = GetId(ouEntry);  //  OU guid
                                string xPathParent = GetParentPath(ouEntry, nodeName); //  OU         
                                string xPath = GetPath(ouEntry); //  OU     

                                if (xmlDoc.SelectSingleNode(xPath) == null)  //     OU，   xml   ，            
                                {
                                    XmlElement newElement = xmlDoc.CreateElement(nodeName); //  OU  
                                    newElement.SetAttribute("name", nodeName);  // name        
                                    newElement.SetAttribute("guid", nodeId);    // gud        
                                    XmlNode parent = xmlDoc.SelectSingleNode(xPathParent); //         ，         OU  append  
                                    if (parent != null)
                                        parent.AppendChild(newElement);
                                }
                            }
                            catch
                            {
                            }
                        }
                    }
                }
            }

            OuTreeNode tree = BuildOuTree(xmlDoc); //  xml    OU 
            return tree;
        }        

이전 구조의 xml 문서 에 따라 나 무 를 재 귀적 으로 구성 합 니 다.

        private static OuTreeNode BuildOuTree(XmlDocument tempXml)
        {
            OuTreeNode root = new OuTreeNode();
            using (Domain domain = Domain.GetCurrentDomain())
            {
                root.Name = domain.Name;
            }
            GetOUTreeNode(root, tempXml.FirstChild);
            return root;
        }


        private static void GetOUTreeNode(OuTreeNode root, XmlNode tempXml)
        {
            foreach (XmlNode xmlNode in tempXml.ChildNodes)
            {
                OuTreeNode childNode = new OuTreeNode() { Name = XmlConvert.DecodeName(xmlNode.Attributes["name"].Value), Id = xmlNode.Attributes["guid"].Value }; //    name      。
                root.Children.Add(childNode);
                GetOUTreeNode(childNode, xmlNode);
            }
        }

이런 방법 을 사용 하 는 장점 은 한 번 에 모든 OU 를 얻 고 AD 를 방문 하 는 횟수 를 줄 이 며 AD 를 방문 하 는 것 이 느 린 상황 에 적용 하 는 것 이다. 그러나 이 방법 은 문제 가 있다. 바로 OU 를 잃 어 버 리 는 것 이다. xml 을 구축 할 때 부모 노드 가 만 들 지 않 고 하위 노드 를 처리 할 수 있 기 때문이다. 이 문 제 를 해결 하기 위해 조회 한 OU 목록 을 조회 할 수 있다.먼저 정렬 을 하고 'canonicalName' 속성 에 따라 정렬 하면 부모 노드 가 반드시 하위 노드 가 추가 되 기 전에 존재 하 는 지 확인 할 수 있 습 니 다.
또한 이 방법 을 조금 만 고치 면 OU 구조의 xml 파일 을 내 보 낼 수 있 고 AD 와 다른 시스템 의 데이터 교환 에 사용 할 수 있 습 니 다.