95992828九五至尊2

域服务指标九五至尊老品牌值信赖

三月 18th, 2019  |  九五至尊老品牌值信赖

局域网计算机控制中央

 

能够在DC上控制全部局域网能源(总计机 、用户、设备)

.Net平台操作活动目录Active
Directory,使用System.DirectoryServices.ActiveDirectory,重假若User OU
和Group的操作。

大中型企管必备。

代码运维了一年多,还尚未出现难题,应该算是经过了认证。

最终,它仍可以够让开发职员集成LDAP身份验证,使用域账号登录使用。

更新的代码在www.codeplex.com/ADBlock

也正是说,此公司的有着系统,都得以用你的处理器账号来拓展登录,授权。

/*
 * Copyright [2008]. Sherwin Zhu. sherwinzhu@126.com
 *
 * http://www.gnu.org/licenses/lgpl-3.0.txt
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an “AS IS” BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Collections.Generic;
using System.Text;
using System.DirectoryServices;
using System.Collections;
using System.DirectoryServices.ActiveDirectory;

九五至尊老品牌值信赖 1

namespace TB.ADBlock
{
    /// <summary>
    /// 用于开展AD管理里的目的,提供操作AD的静态方法。
    /// </summary>
    /// <remarks>
    /// 那里ADs帕特h能够是LDAP://DN和LDAP://<GUID>二种格局,但不防止这种样式。
    /// 一般方法均提供2种方式,一种是用参数提供的用户地点标识,一种是用暗中同意的用户身份标识。
    /// 默许用户地方标识取决于当前经过的用户地点标识。
    /// </remarks>
    public class ADManager
    {
        #region 域信息

<<Program.cs>>

        /// <summary>
        /// 将本人的域名称(friendly domain name)转换为合格的域名称(fully qualified domain name)。
        /// eg:tb — > tb.com
        /// </summary>
        /// <param name=”friendlyDomainName”>友好的域名称(friendly domain name)。
        /// 可以是:
        /// 域控制器的 DNS 名称。
        /// ADAM 服务器的 DNS 名称和 LDAP 端口号(如 adam_instance.fabrikam.com:389)。
        /// 域的 DNS 名称,如 sales.corp.fabrikam.com。
        /// 林的 DNS 名称,如 corp.fabrikam.com。
        /// 应用程序分区的 DNS 名称。
        /// 与劳务连接点关联的重中之重字之一,该服务连接点由安插集的 ADAM 实例注册。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns></returns>
        public static string FriendlyDomainToLdapDomain(string friendlyDomainName, string userName, string password)
        {
            string ldapPath = null;
            try
            {
                DirectoryContext objContext = null;
                if (UseDefaultIdentity(userName, password))
                    objContext = new DirectoryContext(DirectoryContextType.Domain, friendlyDomainName);
                else
                    objContext = new DirectoryContext(DirectoryContextType.Domain, friendlyDomainName, userName, password);

 

                ldapPath = System.DirectoryServices.ActiveDirectory.Domain.GetDomain(objContext).Name;
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            return ldapPath;
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.DirectoryServices;
using System.Collections;
using System.Text.RegularExpressions;

        /// <summary>
        /// 将协调的域名称(friendly domain name)转换为合格的域名称(fully qualified domain name)。
        /// eg:tb — > tb.com
        /// </summary>
        /// <param name=”friendlyDomainName”>友好的域名称(friendly domain name)。
        /// 可以是:
        /// 域控制器的 DNS 名称。
        /// ADAM 服务器的 DNS 名称和 LDAP 端口号(如 adam_instance.fabrikam.com:389)。
        /// 域的 DNS 名称,如 sales.corp.fabrikam.com。
        /// 林的 DNS 名称,如 corp.fabrikam.com。
        /// 应用程序分区的 DNS 名称。
        /// 与劳动连接点关联的重点字之一,该服务连接点由布署集的 ADAM 实例注册。</param>
        /// <returns></returns>
        public static string FriendlyDomainToLdapDomain(string friendlyDomainName)
        {
            return FriendlyDomainToLdapDomain(friendlyDomainName, null, null);
        }

namespace ActiveDirectoryDome
{
    class Program
    {
        static void Main(string[] args)
        {
            if (TryAuthenticate(“prepat.net”, “administrator”,
“yclb2009@”))
            {
                Console.WriteLine(“登陆成功!”);
            }
            else
            {
                Console.WriteLine(“登陆失利!”);
            }
           
Console.WriteLine(“*******************************************************”);
            List<string> group = new List<string>();
            group = GetADGroups(“administrator”, “prepat.net”,
“administrator”, “yclb2009@”);
            foreach (string temp in group)
            {
                Console.WriteLine(“组名称:”+temp.ToString());
            }

        /// <summary>
        /// 获取当前用户上下文的 Forest 对象中的全体域名称。
        /// </summary>
        /// <returns></returns>
        public static List<string> EnumerateDomains()
        {
            List<string> alDomains = new List<string>();
            Forest currentForest = Forest.GetCurrentForest();
            DomainCollection myDomains = currentForest.Domains;

            Console.ReadLine();
        }

            foreach (System.DirectoryServices.ActiveDirectory.Domain objDomain in myDomains)
            {
                alDomains.Add(objDomain.Name);
            }
            return alDomains;
        }

        /// <summary>
        /// 验证AD用户是还是不是登陆成功
        /// </summary>
        /// <param name=”domain”>域名称</param>
        /// <param name=”username”>用户名</param>
        /// <param name=”password”>密码</param>
        /// <returns>重返登陆状态</returns>
        public static bool TryAuthenticate(string domain, string
username, string password)
        {
            bool isLogin = false;
            try
            {
                DirectoryEntry entry = new
DirectoryEntry(string.Format(“LDAP://{0}”, domain), username,
password);
                entry.RefreshCache();
                isLogin = true;
            }
            catch
            {
                isLogin = false;
            }
            return isLogin;
        }

        /// <summary>
        /// 获取当前用户上下文的 Forest 对象中负有的大局目录。 
        /// </summary>
        /// <returns></returns>
        public static List<string> EnumerateGlobalCatalogs()
        {
            List<string> alGCs = new List<string>();
            Forest currentForest = Forest.GetCurrentForest();
            foreach (GlobalCatalog gc in currentForest.GlobalCatalogs)
            {
                alGCs.Add(gc.Name);
            }
            return alGCs;
        }

        /// <summary>
        /// 取用户所对应的用户组
        /// </summary>
        /// <param name=”userName”>用户名称</param>
        /// <param name=”domain”>域</param>
        /// <param name=”adusername”>登陆用户</param>
        /// <param name=”adpassword”>登陆密码</param>
        /// <returns></returns>
        public static List<string> GetADGroups(string
userName,string domain,string adusername,string adpassword)
        {
            List<string> groups = new List<string>();
            try
            {
                var entry = new
DirectoryEntry(string.Format(“LDAP://{0}”, domain), adusername,
adpassword);
                entry.RefreshCache();

        /// <summary>
        /// 获取当前用户地方标识的 Domain 对象中的域控制器。
        /// </summary>
        /// <returns></returns>
        public static List<string> EnumerateDomainControllers()
        {
            List<string> alDcs = new List<string>();
            System.DirectoryServices.ActiveDirectory.Domain domain = System.DirectoryServices.ActiveDirectory.Domain.GetCurrentDomain();
            foreach (DomainController dc in domain.DomainControllers)
            {
                alDcs.Add(dc.Name);
            }
            return alDcs;
        }

                DirectorySearcher search = new
DirectorySearcher(entry);
                search.PropertiesToLoad.Add(“memberof”);
                search.Filter = string.Format(“sAMAccountName={0}”,
userName);
                SearchResult result = search.FindOne();

        #endregion

                if (result != null)
                {
                    ResultPropertyValueCollection c =
result.Properties[“memberof”];
                    foreach (var a in c)
                    {
                        string temp = a.ToString();
                        Match match = Regex.Match(temp,
@”CN=\s*(?<g>\w*)\s*.”);
                        groups.Add(match.Groups[“g”].Value);
                    }
                }
            }
            catch
            {
            }
            return groups;
        }
    }
}

        #region Common

        /// <summary>
        /// 检验钦点的DirectoryEntry是或不是留存
        /// </summary>
        /// <param name=”path”>ADsPath,自动添加LDAP_IDENTITY。完全转义过的。</param>
        /// <returns></returns>
        public static bool Exists(string path)
        {
            if (path.StartsWith(ParaMgr.LDAP_IDENTITY))
                return DirectoryEntry.Exists(path);
            else
                return DirectoryEntry.Exists(ParaMgr.LDAP_IDENTITY + path);

        }

        /// <summary>
        /// 移动DirectoryEntry到内定地方。
        /// </summary>
        /// <param name=”objectPath”>要活动的DirectoryEntry的ADsPath。必须是DN方式。完全转义过的。</param>
        /// <param name=”newLocationPath”>移动到的地点的ADsPath。必须是DN方式。完全转义过的。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用默许用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <remarks>被挪动的对象和要活动到的职分对象必须运用DN格局的途径创造,不能够动用GUID方式的途径,否则会抓住那几个。</remarks>
        public static void Move(string objectPath, string newLocationPath, string userName, string password)
        {
            if (!Exists(objectPath))
                throw new EntryNotExistException(“供给被活动的目的不设有。”);

            DirectoryEntry de = null;
            try
            {
                de = GetByPath(objectPath, userName, password);

                Move(de, newLocationPath, userName, password);
            }
            catch
            {
                throw;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 移动DirectoryEntry到钦定地点,使用暗许用户身份标识。
        /// </summary>
        /// <param name=”objectPath”>要运动的DirectoryEntry的ADsPath。必须是DN情势。完全转义过的。</param>
        /// <param name=”newLocationPath”>移动到的地点的ADsPath。必须是DN格局。完全转义过的。</param>
        public static void Move(string objectPath, string newLocationPath)
        {
            Move(objectPath, newLocationPath, null, null);
        }

        /// <summary>
        /// 移动DirectoryEntry到内定地点。
        /// </summary>
        /// <param name=”de”>要运动的DirectoryEntry对象</param>
        /// <param name=”newLocationPath”>移动到的职位的ADsPath。必须是DN方式。完全转义过的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <remarks>被活动的靶子和要运动到的岗位对象必须利用DN形式的门路创造,不能够选择GUID形式的门道,不然会吸引那些。</remarks>
        internal static void Move(DirectoryEntry de, string newLocationPath, string userName, string password)
        {
            if (!Exists(newLocationPath))
                throw new EntryNotExistException(“移动到的职位对象不设有。”);

            DirectoryEntry newLocation = null;
            try
            {
                newLocation = GetByPath(newLocationPath, userName, password);

                string newLocationDN = Utils.EscapeDNBackslashedChar(newLocation.Properties[BaseObject.PROPERTY_DN].Value.ToString());
                string deDN = Utils.EscapeDNBackslashedChar(de.Properties[BaseObject.PROPERTY_DN].Value.ToString());
                if (Exists(Utils.GenerateDN(Utils.GetRDN(deDN), deDN)))
                    throw new 萨姆e奥迪Q3DNException(“移动到的职位下存在同名对象。”);

                de.MoveTo(newLocation);

                de.CommitChanges();
            }
            catch (InvalidOperationException ioe)   // 钦命的 DirectoryEntry 不是容器。
            {
                throw new NotContainerException(ioe.Message, ioe);
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (newLocation != null)
                {
                    newLocation.Close();
                    newLocation.Dispose();
                }
            }
        }

        /// <summary>
        /// 获取应用程序设置的暗中认可域。
        /// </summary>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中认可用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns></returns>
        public static DirectoryEntry GetAppSetDomain(string userName, string password)
        {
            return GetByDN(ParaMgr.ADFullPath, userName, password);
        }

        /// <summary>
        /// 获取应用程序设置的私下认可域,使用私下认可用户地方标识。
        /// </summary>
        /// <returns></returns>
        public static DirectoryEntry GetAppSetDomain()
        {
            return GetAppSetDomain(null, null);
        }

        // 根据用户名和密码,判断是还是不是应当利用暗许用户身份标识。
        private static bool UseDefaultIdentity(string userName, string password)
        {
            if (String.IsNullOrEmpty(userName))
                return true;
            else
                return false;
        }

        #endregion

        #region Get & Search

        /// <summary>
        /// 获取DirectoryEntry
        /// </summary>
        /// <param name=”schema”>自定义格局</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootDN”>根对象DN,null表示全数域。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用私下认可用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>假如不存在,重返null。</returns>
        internal static DirectoryEntry Get(string schema, string objectClass, string objectCategory, string rootDN, string userName, string password)
        {
            DirectoryEntry de = GetByDN((String.IsNullOrEmpty(rootDN) ? (ParaMgr.ADFullPath) : rootDN), 
                userName, password);

            DirectorySearcher deSearch = new DirectorySearcher();
            deSearch.SearchRoot = de;
            if (!String.IsNullOrEmpty(objectClass) ||
                !String.IsNullOrEmpty(objectCategory) ||
                !String.IsNullOrEmpty(schema))
            {
                deSearch.Filter = String.Format(“(&{0}{1}{2})”,
                    ((!String.IsNullOrEmpty(objectClass)) ? String.Format(“(objectClass={0})”, objectClass) : “”),
                    ((!String.IsNullOrEmpty(objectCategory)) ? String.Format(“(objectCategory={0})”, objectCategory) : “”),
                    ((!String.IsNullOrEmpty(schema)) ? String.Format(“({0})”, schema) : “”)
                    );
            }
            deSearch.SearchScope = SearchScope.Subtree;
            SearchResult results = deSearch.FindOne();
            DirectoryEntry rde = null;
            if (results != null)
                rde = GetByPath(results.Path);
            else
                rde = null;

            de.Close();
            de.Dispose();

            return rde;
        }

        /// <summary>
        /// 获取DirectoryEntry,使用暗中认可用户身份标识。
        /// </summary>
        /// <param name=”schema”>自定义方式</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootDN”>根对象DN,null表示全部域。</param>
        /// <returns>假使不设有,再次回到null。</returns>
        internal static DirectoryEntry Get(string schema, string objectClass, string objectCategory, string rootDN)
        {
            return Get(schema, objectClass, objectCategory, rootDN, null, null);
        }

        /// <summary>
        /// 查找DirectoryEntry
        /// </summary>
        /// <param name=”schema”>自定义方式</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootPath”>根对象ADsPath</param>
        /// <param name=”scope”>SearchScope</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗许用户地方标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>若是不设有,重返空集合。</returns>
        internal static List<DirectoryEntry> Search(string schema, string objectClass, string objectCategory,
            string rootPath, SearchScope scope, string userName, string password)
        {
            DirectoryEntry de = null;

            if (!String.IsNullOrEmpty(rootPath))
            {
                de = GetByPath(rootPath, userName, password);
            }
            if (de == null)
                de = GetByPath(ParaMgr.ADFullPath, userName, password);

            DirectorySearcher deSearch = new DirectorySearcher();
            if (de != null)
                deSearch.SearchRoot = de;
            if (!String.IsNullOrEmpty(objectClass) ||
                !String.IsNullOrEmpty(objectCategory) ||
                !String.IsNullOrEmpty(schema))
            {
                deSearch.Filter = String.Format(“(&{0}{1}{2})”,
                    ((!String.IsNullOrEmpty(objectClass)) ? String.Format(“(objectClass={0})”, objectClass) : “”),
                    ((!String.IsNullOrEmpty(objectCategory)) ? String.Format(“(objectCategory={0})”, objectCategory) : “”),
                    ((!String.IsNullOrEmpty(schema)) ? String.Format(“({0})”, schema) : “”)
                    );
            }
            deSearch.SearchScope = scope;
            SearchResultCollection results = deSearch.FindAll();

            List<DirectoryEntry> entries = new List<DirectoryEntry>();
            if (results != null)
            {
                foreach (SearchResult se in results)
                {
                    //entries.Add(GetByPath(se.Path));
                    entries.Add(se.GetDirectoryEntry());
                }
            }

            de.Close();
            de.Dispose();

            return entries;

        }

        /// <summary>
        /// 查找DirectoryEntry,使用暗中认可用户地点标识。
        /// </summary>
        /// <param name=”schema”>自定义形式</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootPath”>根对象ADsPath</param>
        /// <param name=”scope”>SearchScope</param>
        /// <returns>假设不存在,再次来到空集合。</returns>
        internal static List<DirectoryEntry> Search(string schema, string objectClass, string objectCategory, 
            string rootPath, SearchScope scope)
        {
            return Search(schema, objectClass, objectCategory, rootPath, scope, null, null);
        }

        /// <summary>
        /// 查找DirectoryEntry,结果为字符串格局
        /// </summary>
        /// <param name=”schema”>自定义方式</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootPath”>根对象ADsPath</param>
        /// <param name=”scope”>SearchScope</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗许用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>借使不设有,重临空集合。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass。
        /// 最后添加了sAMAccountName。</remarks>
        internal static List<string[]> Search2(string schema, string objectClass, string objectCategory,
            string rootPath, SearchScope scope, string userName, string password)
        {
            DirectoryEntry de = null;

            if (!String.IsNullOrEmpty(rootPath))
            {
                de = GetByPath(rootPath, userName, password);
            }
            if (de == null)
                de = GetByPath(ParaMgr.ADFullPath, userName, password);

            DirectorySearcher deSearch = new DirectorySearcher();
            if (de != null)
                deSearch.SearchRoot = de;
            if (!String.IsNullOrEmpty(objectClass) ||
                !String.IsNullOrEmpty(objectCategory) ||
                !String.IsNullOrEmpty(schema))
            {
                deSearch.Filter = String.Format(“(&{0}{1}{2})”,
                    ((!String.IsNullOrEmpty(objectClass)) ? String.Format(“(objectClass={0})”, objectClass) : “”),
                    ((!String.IsNullOrEmpty(objectCategory)) ? String.Format(“(objectCategory={0})”, objectCategory) : “”),
                    ((!String.IsNullOrEmpty(schema)) ? String.Format(“({0})”, schema) : “”)
                    );
            }
            deSearch.SearchScope = scope;
            SearchResultCollection results = deSearch.FindAll();

            List<string[]> entriesProperty = new List<string[]>();
            if (results != null)
            {
                foreach (SearchResult se in results)
                {
                    string nativeGuid = “”;
                    foreach(byte g in (byte[])se.Properties[“objectguid”][0])
                    {
                        nativeGuid += g.ToString(“x2”);
                    }
                    string oc = “”;
                    foreach (object c in se.Properties[“objectclass”])
                    {
                        oc = oc + “,” + c.ToString();
                    }

                    string sAMAccountName = null;
                    if (se.Properties.Contains(“sAMAccountName”))
                        sAMAccountName = se.Properties[“sAMAccountName”][0].ToString();

                    entriesProperty.Add(new string[] {
                        se.Properties[“distinguishedname”][0].ToString(),
                        Utils.ConvertNativeGuidToGuid(nativeGuid).ToString(),
                        se.Properties[“name”][0].ToString(),
                        ((se.Properties[“description”].Count > 0) ? se.Properties[“description”][0].ToString() : null),
                        se.Properties[“adspath”][0].ToString(),
                        se.Properties[“objectcategory”][0].ToString(),
                        oc.Substring(1),
                        sAMAccountName
                    });
                }
            }

            de.Close();
            de.Dispose();

            return entriesProperty;

        }

        /// <summary>
        /// 查找DirectoryEntry,使用暗中认可用户地点标识。结果为字符串格局
        /// </summary>
        /// <param name=”schema”>自定义情势</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootPath”>根对象ADsPath</param>
        /// <param name=”scope”>SearchScope</param>
        /// <returns>要是不存在,重临空集合。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass</remarks>
        internal static List<string[]> Search2(string schema, string objectClass, string objectCategory,
            string rootPath, SearchScope scope)
        {
            return Search2(schema, objectClass, objectCategory, rootPath, scope, null, null);
        }

        /// <summary>
        /// 查找DirectoryEntry
        /// </summary>
        /// <param name=”schema”>自定义格局</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootPath”>根对象ADsPath</param>
        /// <param name=”scope”>SearchScope</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗许用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>假使不设有,重返空集合。</returns>
        internal static SearchResultCollection Search3(string schema, string objectClass, string objectCategory,
            string rootPath, SearchScope scope, string userName, string password)
        {
            DirectoryEntry de = null;

            if (!String.IsNullOrEmpty(rootPath))
            {
                de = GetByPath(rootPath, userName, password);
            }
            if (de == null)
                de = GetByPath(ParaMgr.ADFullPath, userName, password);

            DirectorySearcher deSearch = new DirectorySearcher();
            if (de != null)
                deSearch.SearchRoot = de;
            if (!String.IsNullOrEmpty(objectClass) ||
                !String.IsNullOrEmpty(objectCategory) ||
                !String.IsNullOrEmpty(schema))
            {
                deSearch.Filter = String.Format(“(&{0}{1}{2})”,
                    ((!String.IsNullOrEmpty(objectClass)) ? String.Format(“(objectClass={0})”, objectClass) : “”),
                    ((!String.IsNullOrEmpty(objectCategory)) ? String.Format(“(objectCategory={0})”, objectCategory) : “”),
                    ((!String.IsNullOrEmpty(schema)) ? String.Format(“({0})”, schema) : “”)
                    );
            }
            deSearch.SearchScope = scope;
            
            SearchResultCollection results = deSearch.FindAll();

            de.Close();
            de.Dispose();

            return results;
        }

        /// <summary>
        /// 查找DirectoryEntry,使用私下认可用户地点标识。
        /// </summary>
        /// <param name=”schema”>自定义情势</param>
        /// <param name=”objectClass”>类型</param>
        /// <param name=”objectCategory”>类别</param>
        /// <param name=”rootPath”>根对象ADsPath</param>
        /// <param name=”scope”>SearchScope</param>
        /// <returns>借使不存在,再次回到空集合。</returns>
        internal static SearchResultCollection Search3(string schema, string objectClass, string objectCategory,
            string rootPath, SearchScope scope)
        {
            return Search3(schema, objectClass, objectCategory, rootPath, scope, null, null);
        }

        /// <summary>
        /// 根据DirectoryEntry的Guid得到DirectoryEntry对象。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中认可用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>要是不设有,再次回到null。</returns>
        internal static DirectoryEntry GetByGuid(Guid guid, string userName, string password)
        {
            return GetByPath(Utils.GenerateADsPath(guid), userName, password);
        }

        /// <summary>
        /// 依照DirectoryEntry的Guid获得DirectoryEntry对象,使用暗中同意用户身份标识。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <returns>假诺不存在,重返null。</returns>
        internal static DirectoryEntry GetByGuid(Guid guid)
        {
            return GetByGuid(guid, null,null );
        }

        /// <summary>
        /// 根据DirectoryEntry的SID得到DirectoryEntry对象。
        /// </summary>
        /// <param name=”sid”>objectSID</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中认可用户地点标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>要是不设有,重回null。</returns>
        internal static DirectoryEntry GetBySid(string sid, string userName, string password)
        {
            return Get(“objectSID=” + sid, null, null, null, userName, password);
        }

        /// <summary>
        /// 依据DirectoryEntry的SID获得DirectoryEntry对象,使用暗许用户身份标识。
        /// </summary>
        /// <param name=”sid”>objectSID</param>
        /// <returns>就算不存在,再次回到null。</returns>
        internal static DirectoryEntry GetBySid(string sid)
        {
            return GetBySid(sid, null, null);
        }

        /// <summary>
        /// 根据DirectoryEntry的DN得到DirectoryEntry对象。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地点标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>若是不设有,重返null。</returns>
        internal static DirectoryEntry GetByDN(string dn, string userName, string password)
        {
            return GetByPath(ParaMgr.LDAP_IDENTITY + dn, userName, password);
        }

        /// <summary>
        /// 依照DirectoryEntry的DN获得DirectoryEntry对象,使用暗中同意用户地点标识。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <returns>假设不设有,重回null。</returns>
        internal static DirectoryEntry GetByDN(string dn)
        {
            return GetByDN(dn, null, null);
        }

        /// <summary>
        /// 根据DirectoryEntry的ADsPath得到DirectoryEntry对象。
        /// </summary>
        /// <param name=”path”>完整的ADsPath,自动添加LDAP_IDENTITY。完全转义过的。</param>
        /// <param name=”userName”>用户位置标识–用户名。为空时使用默许用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>假使不存在,重回null。</returns>
        /// <returns></returns>
        internal static DirectoryEntry GetByPath(string path, string userName, string password)
        {
            if (Exists(path))
            {
                if (UseDefaultIdentity(userName, password))
                    return new DirectoryEntry((path.StartsWith(ParaMgr.LDAP_IDENTITY)) ? path : (ParaMgr.LDAP_IDENTITY + path));
                else
                    return new DirectoryEntry(
                        (path.StartsWith(ParaMgr.LDAP_IDENTITY)) ? path : (ParaMgr.LDAP_IDENTITY + path),
                        userName,
                        password,
                        AuthenticationTypes.Secure);

            }
            else
                return null;
        }
        
        /// <summary>
        /// 依据DirectoryEntry的ADsPath获得DirectoryEntry对象,使用私下认可用户地方标识。
        /// </summary>
        /// <param name=”path”>完整的ADsPath。完全转义过的。</param>
        /// <returns>要是不存在,再次回到null。</returns>
        /// <returns></returns>
        internal static DirectoryEntry GetByPath(string path)
        {
            return GetByPath(path, null, null);
        }

        #endregion

        #region User

        #region Search

        /// <summary>
        /// 获取钦点全体用户。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示整个域。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用私下认可用户身份标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>假设不存在,重临null。</returns>
        public static List<User> GetUserAll(string rootPath, string userName, string password)
        {
            List<DirectoryEntry> entries = Search(null, “user”, “person”, rootPath, SearchScope.Subtree, userName, password);
            List<User> users = new List<User>();
            foreach (DirectoryEntry de in entries)
            {
                users.Add(new User(de));

                de.Close();
                de.Dispose();
            }

            return users;
        }

        /// <summary>
        /// 获取钦定全体用户,使用默许用户身份标识。
        /// </summary>
        /// <param name=”rootPath”>根对象ADs帕特h,null表示一切域。</param>
        /// <returns>假若不存在,重回null。</returns>
        public static List<User> GetUserAll(string rootPath)
        {
            return GetUserAll(rootPath, null, null);
        }

        /// <summary>
        /// 获取内定全体用户。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示一切域。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中同意用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>倘诺不存在,再次回到null。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass。
        /// 最终添加了sAMAccountName。</remarks>
        public static List<string[]> GetUserAllSimple(string rootPath, string userName, string password)
        {
            return Search2(null, “user”, “person”, rootPath, SearchScope.Subtree, userName, password);
        }

        /// <summary>
        /// 获取钦定全数用户,使用私下认可用户地点标识。
        /// </summary>
        /// <param name=”root帕特h”>根对象ADsPath,null表示一切域。</param>
        /// <returns>如果不存在,重返null。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass</remarks>
        public static List<string[]> GetUserAllSimple(string rootPath)
        {
            return GetUserAllSimple(rootPath, null, null);
        }

        /// <summary>
        /// 获取钦命全数用户。直接解析查询结果,速度较GetUserAll快。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示整个域。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中同意用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>假设不设有,重回null。</returns>
        public static List<User> GetUserAllQuick(string rootPath, string userName, string password)
        {
            SearchResultCollection results = Search3(null, “user”, “person”, rootPath, SearchScope.Subtree, userName, password);

            List<User> users = new List<User>();
            foreach (SearchResult se in results)
            {
                users.Add(new User(se));
            }

            return users;
        }

        /// <summary>
        /// 获取内定全体用户,使用暗中认可用户身份标识。直接解析查询结果,速度较GetUserAll快。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示全体域。</param>
        /// <returns>如若不设有,重回null。</returns>
        public static List<User> GetUserAllQuick(string rootPath)
        {
            return GetUserAllQuick(rootPath, null, null);
        }

        /// <summary>
        /// 根据userPrincipalName获取Group。
        /// </summary>
        /// <param name=”userPrincipalName”>userPrincipalName。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>如若不存在,再次回到null。</returns>
        public static User GetUserByPrincipalName(string userPrincipalName, string userName, string password)
        {
            List<DirectoryEntry> entries = Search(“userPrincipalName=” + Utils.Escape4Query(userPrincipalName), 
                “user”, “person”, null, SearchScope.Subtree, userName, password);
            if (entries.Count == 1)
            {
                DirectoryEntry de = entries[0];

                User user = new User(de);

                de.Close();
                de.Dispose();

                return user;
            }

            return null;
        }

        /// <summary>
        /// 根据sAMAccountName获取User。
        /// </summary>
        /// <param name=”sAMAccountName”>sAMAccountName。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗许用户身份标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>如若不存在,重回null。</returns>
        public static User GetUserBySAMAccountName(string sAMAccountName, string userName, string password)
        {
            List<DirectoryEntry> entries = Search(“sAMAccountName=” + Utils.Escape4Query(sAMAccountName), 
                “user”, “person”, null, SearchScope.Subtree, userName, password);
            if (entries.Count == 1)
            {
                DirectoryEntry de = entries[0];

                User user = new User(de);

                de.Close();
                de.Dispose();

                return user;
            }

            return null;
        }
        #endregion

        #region Get

        /// <summary>
        /// 依据用户的Guid获得用户对象。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗许用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>如若不存在,重回null。</returns>
        public static User GetUserByGuid(Guid guid, string userName, string password)
        {
            return GetUserByPath(Utils.GenerateADsPath(guid), userName, password);
        }

        /// <summary>
        /// 依据用户的Guid获得用户对象,使用默许用户身份标识。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <returns>假若不存在,再次来到null。</returns>
        public static User GetUserByGuid(Guid guid)
        {
            return GetUserByGuid(guid, null, null);
        }

        /// <summary>
        /// 依照用户的DN得到用户对象。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗许用户身份标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>假若不存在,重临null。</returns>
        public static User GetUserByDN(string dn, string userName, string password)
        {
            return GetUserByPath(dn, userName, password);    
        }

        /// <summary>
        /// 依据用户的DN获得用户对象,使用暗许用户地方标识。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <returns>要是不存在,重回null。</returns>
        public static User GetUserByDN(string dn)
        {
            return GetUserByDN(dn, null, null);
        }

        /// <summary>
        /// 依据用户的ADsPath拿到用户对象。
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗许用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>假使不设有,再次回到null。</returns>
        public static User GetUserByPath(string path, string userName, string password)
        {
            DirectoryEntry entry = GetByPath(path, userName, password);
            if (entry != null)
            {
                User user = new User(entry);
                entry.Close();
                entry.Dispose();

                return user;
            }
            else
                return null;
        }

        /// <summary>
        /// 依据用户的ADsPath得到用户对象,使用暗许用户身份标识。
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <returns>假使不设有,重临null。</returns>
        public static User GetUserByPath(string path)
        {
            return GetUserByPath(path, null, null);
        }

        #endregion

        #region Password

        /// <summary>
        /// 设置用户密码。
        /// </summary>
        /// <param name=”guid”>用户DirectoryEntry的Guid。</param>
        /// <param name=”newPassword”>新密码。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地点标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        public static void SetUserPassword(Guid guid, string newPassword, string userName, string password)
        {
            DirectoryEntry de = null;
            try
            {
                de = GetByGuid(guid, userName, password);

                if (de == null)
                    throw new EntryNotExistException(“用户对象不设有。”);

                if (de.SchemaClassName != SchemaClass.user.ToString(“F”))
                    throw new SchemaClassException(“对象类型不是” + SchemaClass.user.ToString(“F”) + “。”);

                de.Invoke(“SetPassword”, new object[] { newPassword });

                de.CommitChanges();
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 设置用户密码,使用暗许用户身份标识。
        /// </summary>
        /// <param name=”guid”>用户DirectoryEntry的Guid。</param>
        /// <param name=”newPassword”>新密码。</param>
        public static void SetUserPassword(Guid guid, string newPassword)
        {
            SetUserPassword(guid, newPassword, null, null);
        }

        #endregion

        #region Move

        /// <summary>
        /// 移动用户DirectoryEntry到内定地方。
        /// </summary>
        /// <param name=”userPath”>要运动的用户DirectoryEntry的ADsPath。必须是DN方式。完全转义过的。</param>
        /// <param name=”newLocationPath”>移动到的岗位的ADsPath。必须是DN情势。完全转义过的。</param>
        /// <param name=”mustOU”>移动到的职责对应的DirectoryEntry是或不是必须是团队单位。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        public static void MoveUser(string userPath, string newLocationPath, bool mustOU, string userName, string password)
        {
            if (!Exists(userPath))
                throw new EntryNotExistException(“须要被移位的对象不存在。”);

            DirectoryEntry de = null;
            try
            {
                de = GetByPath(userPath, userName, password);

                MoveUser(de, newLocationPath, mustOU, userName, password);
            }
            catch
            {
                throw;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 移动用户DirectoryEntry到钦定地方,使用默许用户身份标识。
        /// </summary>
        /// <param name=”userPath”>要活动的用户DirectoryEntry的ADsPath。必须是DN格局。完全转义过的。</param>
        /// <param name=”newLocationPath”>移动到的职位的ADsPath。必须是DN方式。完全转义过的。</param>
        /// <param name=”mustOU”>移动到的地方对应的DirectoryEntry是或不是必须是团组织单位。</param>
        public static void MoveUser(string userPath, string newLocationPath, bool mustOU)
        {
            MoveUser(userPath, newLocationPath, mustOU, null, null);
        }

        /// <summary>
        /// 移动用户DirectoryEntry到钦点地方。
        /// </summary>
        /// <param name=”user”>要活动的用户DirectoryEntry的Guid</param>
        /// <param name=”newLocation”>移动到的职责的Guid</param>
        /// <param name=”mustOU”>移动到的职分对应的DirectoryEntry是还是不是必须是团组织单位。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中同意用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        public static void MoveUser(Guid user, Guid newLocation, bool mustOU, string userName, string password)
        {
            MoveUser(GetUserByGuid(user).Dn, GetOUByGuid(newLocation).Dn, mustOU, userName, password);
        }

        /// <summary>
        /// 移动用户DirectoryEntry到钦赐地点,使用暗中认可用户地方标识。
        /// </summary>
        /// <param name=”user”>要活动的用户DirectoryEntry的Guid</param>
        /// <param name=”newLocation”>移动到的职务的Guid</param>
        /// <param name=”mustOU”>移动到的岗位对应的DirectoryEntry是或不是必须是组织单位。</param>
        public static void MoveUser(Guid user, Guid newLocation, bool mustOU)
        {
            MoveUser(GetUserByGuid(user).Dn, GetOUByGuid(newLocation).Dn, mustOU, null, null);
        }

        /// <summary>
        /// 移动用户DirectoryEntry到钦命地点。
        /// </summary>
        /// <param name=”de”>要活动的用户DirectoryEntry对象。必须是透过DN情势路径获得的对象。</param>
        /// <param name=”newLocationPath”>移动到的义务的ADsPath。必须是DN格局。完全转义过的。</param>
        /// <param name=”mustOU”>移动到的职位对应的DirectoryEntry是不是必须是集团单位。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        internal static void MoveUser(DirectoryEntry de, string newLocationPath, bool mustOU, string userName, string password)
        {
            if (!Exists(newLocationPath))
                throw new EntryNotExistException(“移动到的地方对象不设有。”);

            DirectoryEntry newLocation = null;
            try
            {
                newLocation = GetByPath(newLocationPath, userName, password);

                if (de.SchemaClassName != SchemaClass.user.ToString(“F”))
                    throw new SchemaClassException(“必要被活动的靶子类型不是” + SchemaClass.user.ToString(“F”) + “。”);

                if (mustOU && newLocation.SchemaClassName != SchemaClass.organizationalUnit.ToString(“F”))
                    throw new SchemaClassException(“移动到的岗位对象类型不是” + SchemaClass.organizationalUnit.ToString(“F”) + “。”);

                if (Exists(Utils.GetRDNValue(de.Properties[BaseObject.PROPERTY_DN].Value.ToString()) + “,” +
                    newLocation.Properties[BaseObject.PROPERTY_DN].Value.ToString()))
                    throw new Same大切诺基DNException(“移动到的岗位下存在同名对象。”);

                de.MoveTo(newLocation);
                de.CommitChanges();
            }
            catch (InvalidOperationException ioe)   // 内定的 DirectoryEntry 不是容器。
            {
                throw new NotContainerException(ioe.Message, ioe);
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (newLocation != null)
                {
                    newLocation.Close();
                    newLocation.Dispose();
                }
            }
        }

        #endregion

        #region MemberOf

        /// <summary>
        /// 获取用户DirectoryEntry对象的PrimaryGroup DirectoryEntry对象。
        /// </summary>
        /// <param name=”userPath”>用户DirectoryEntry的ADsPath。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用默许用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>不存在重临null。</returns>
        public static DirectoryEntry GetUserPrimaryGroup(string userPath, string userName, string password)
        {
            DirectoryEntry de = GetByPath(userPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“用户对象不设有。”);

            if (de.SchemaClassName != SchemaClass.user.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.user.ToString(“F”) + “。”);

            return GetUserPrimaryGroup(de, userName, password);
        }

        /// <summary>
        /// 获取用户DirectoryEntry对象的PrimaryGroup DirectoryEntry对象,使用私下认可用户身份标识。
        /// </summary>
        /// <param name=”userPath”>用户DirectoryEntry的ADsPath。</param>
        /// <returns>不存在重回null。</returns>
        public static DirectoryEntry GetUserPrimaryGroup(string userPath)
        {
            return GetUserPrimaryGroup(userPath, null, null);
        }

        /// <summary>
        /// 获取用户DirectoryEntry对象的PrimaryGroup DirectoryEntry对象。
        /// </summary>
        /// <param name=”user”>用户DirectoryEntry对象。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用默许用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>不存在再次回到null。</returns>
        internal static DirectoryEntry GetUserPrimaryGroup(DirectoryEntry user, string userName, string password)
        {
            string primaryGroupSID = User.GeneratePrimaryGroupSID((byte[])(user.Properties[BaseObject.PROPERTY_OBJECTSID].Value),
                Convert.ToInt32(user.Properties[User.PROPERTY_MEMBEROF_PRIMARY].Value));

            return GetBySid(primaryGroupSID, userName, password);
        }

        /// <summary>
        /// 获取用户DirectoryEntry对象的专属组的DN。
        /// </summary>
        /// <param name=”userPath”>用户DirectoryEntry的ADsPath。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗中同意用户身份标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <param name=”includePrimaryGroup”>是不是包涵PrimaryGroup</param>
        /// <returns>不设有重返空集合。</returns>
        public static List<string> GetUserMemberOfDN(string userPath, string userName, string password, bool includePrimaryGroup)
        {
            DirectoryEntry de = GetByPath(userPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“用户对象不存在。”);

            if (de.SchemaClassName != SchemaClass.user.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.user.ToString(“F”) + “。”);

            List<string> dn = new List<string>();

            if (includePrimaryGroup)
            {
                DirectoryEntry primary = GetUserPrimaryGroup(de, userName, password);
                if (primary != null)
                {
                    dn.Add(Utils.EscapeDNBackslashedChar(primary.Properties[BaseObject.PROPERTY_DN].Value.ToString()));

                    primary.Close();
                    primary.Dispose();
                }
            }
            if (de.Properties.Contains(User.PROPERTY_MEMBEROF_ALL))
            {
                foreach (object m in de.Properties[User.PROPERTY_MEMBEROF_ALL])
                {
                    dn.Add(Utils.EscapeDNBackslashedChar(m.ToString()));        // 转义/
                }
            }

            de.Close();
            de.Dispose();

            return dn;
        }

        /// <summary>
        /// 获取用户DirectoryEntry对象的依附组的DN,使用默许用户地方标识。
        /// </summary>
        /// <param name=”userPath”>用户DirectoryEntry的ADsPath。</param>
        /// <param name=”includePrimaryGroup”>是不是包罗PrimaryGroup</param>
        /// <returns>不存在重回空集合。</returns>
        public static List<string> GetUserMemberOfDN(string userPath, bool includePrimaryGroup)
        {
            return GetUserMemberOfDN(userPath, null, null, includePrimaryGroup);
        }

        #endregion

        #endregion

        #region Group

        #region Search

        /// <summary>
        /// 获取钦定全部组。
        /// </summary>
        /// <param name=”cn”>组CN。</param>
        /// <param name=”description”>组描述。</param>
        /// <param name=”rootPath”>根对象ADsPath,null表示全体域。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>假设不设有,再次来到null。</returns>
        public static List<Group> SearchGroup(string cn, string description, string rootPath, string userName, string password)
        {
            string schema = null;
            if (!String.IsNullOrEmpty(cn) || !String.IsNullOrEmpty(description))
                schema = String.Format(“(&{0}{1})”, 
                    (!String.IsNullOrEmpty(cn) ? String.Format(“(cn=*{0}*)”, Utils.Escape4Query(cn)) : “” ),
                    (!String.IsNullOrEmpty(description) ? String.Format(“(description=*{0}*)”, Utils.Escape4Query(description)) : “”));

            List<DirectoryEntry> entries = Search(schema, “group”, null, rootPath, SearchScope.Subtree, userName, password);
            List<Group> groups = new List<Group>();
            foreach (DirectoryEntry de in entries)
            {
                groups.Add(new Group(de));

                de.Close();
                de.Dispose();
            }

            return groups;
        }

        /// <summary>
        /// 获取钦命全体组,使用默许用户地点标识。
        /// </summary>
        /// <param name=”cn”>组CN。</param>
        /// <param name=”description”>组描述。</param>
        /// <param name=”rootPath”>根对象ADsPath,null表示全体域。</param>
        /// <returns>若是不设有,重回null。</returns>
        public static List<Group> SearchGroup(string cn, string description, string rootPath)
        {
            return SearchGroup(cn, description, rootPath, null, null);
        }

        /// <summary>
        /// 获取内定全数组。
        /// </summary>
        /// <param name=”cn”>组CN。</param>
        /// <param name=”description”>组描述。</param>
        /// <param name=”rootPath”>根对象ADsPath,null表示全数域。</param>
        /// <param name=”userName”>用户位置标识–用户名。为空时使用暗中同意用户身份标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>若是不存在,重返null。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass。
        /// 最终添加了sAMAccountName。</remarks>
        public static List<String[]> SearchGroupSimple(string cn, string description, string rootPath, string userName, string password)
        {
            string schema = null;
            if (!String.IsNullOrEmpty(cn) || !String.IsNullOrEmpty(description))
                schema = String.Format(“&{0}{1}”,
                    (!String.IsNullOrEmpty(cn) ? String.Format(“(cn=*{0}*)”, Utils.Escape4Query(cn)) : “”),
                    (!String.IsNullOrEmpty(description) ? String.Format(“(cn=*{0}*)”, Utils.Escape4Query(description)) : “”));

            return Search2(schema, “group”, null, rootPath, SearchScope.Subtree, userName, password);
        }

        /// <summary>
        /// 获取钦命全数组,使用默许用户地点标识。
        /// </summary>
        /// <param name=”cn”>组CN。</param>
        /// <param name=”description”>组描述。</param>
        /// <param name=”rootPath”>根对象ADsPath,null表示一切域。</param>
        /// <returns>倘若不设有,再次来到null。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass</remarks>
        public static List<String[]> SearchGroupSimple(string cn, string description, string rootPath)
        {
            return SearchGroupSimple(cn, description, rootPath, null, null);
        }

        /// <summary>
        /// 获取钦定全部组。直接解析查询结果,速度较SearchGroup快。
        /// </summary>
        /// <param name=”cn”>组CN。</param>
        /// <param name=”description”>组描述。</param>
        /// <param name=”rootPath”>根对象ADsPath,null表示整个域。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗中认可用户身份标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>假若不存在,重回null。</returns>
        public static List<Group> SearchGroupQuick(string cn, string description, string rootPath, string userName, string password)
        {
            string schema = null;
            if (!String.IsNullOrEmpty(cn) || !String.IsNullOrEmpty(description))
                schema = String.Format(“&{0}{1}”,
                    (!String.IsNullOrEmpty(cn) ? String.Format(“(cn=*{0}*)”, Utils.Escape4Query(cn)) : “”),
                    (!String.IsNullOrEmpty(description) ? String.Format(“(cn=*{0}*)”, Utils.Escape4Query(description)) : “”));

            SearchResultCollection results = Search3(schema, “group”, null, rootPath, SearchScope.Subtree, userName, password);

            List<Group> groups = new List<Group>();
            foreach (SearchResult se in results)
            {
                groups.Add(new Group(se));
            }

            return groups;
        }

        /// <summary>
        /// 获取钦定全部组,使用暗中同意用户地点标识。直接解析查询结果,速度较SearchGroup快。
        /// </summary>
        /// <param name=”cn”>组CN。</param>
        /// <param name=”description”>组描述。</param>
        /// <param name=”rootPath”>根对象ADsPath,null表示全体域。</param>
        /// <returns>假诺不存在,重临null。</returns>
        public static List<Group> SearchGroupQuick(string cn, string description, string rootPath)
        {
            return SearchGroupQuick(null,null, rootPath, null, null);
        }

        /// <summary>
        /// 根据sAMAccountName获取Group。
        /// </summary>
        /// <param name=”sAMAccountName”>sAMAccountName。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗许用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>如若不设有,重临null。</returns>
        public static Group GetGroupBySAMAccountName(string sAMAccountName, string userName, string password)
        {
            List<DirectoryEntry> entries = Search(“sAMAccountName=” + Utils.Escape4Query(sAMAccountName), 
                “group”, null, null, SearchScope.Subtree, userName, password);
            if (entries.Count == 1)
            {
                DirectoryEntry de = entries[0];

                Group group = new Group(de);

                de.Close();
                de.Dispose();

                return group;
            }

            return null;
        }

        #endregion

        #region Get

        /// <summary>
        /// 依据用户的Guid获得组对象。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>假若不设有,重返null。</returns>
        public static Group GetGroupByGuid(Guid guid, string userName, string password)
        {
            return GetGroupByPath(Utils.GenerateADsPath(guid), userName, password);

        }

        /// <summary>
        /// 依照用户的Guid获得组对象,使用暗中认可用户身份标识。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <returns>假设不设有,再次来到null。</returns>
        public static Group GetGroupByGuid(Guid guid)
        {
            return GetGroupByGuid(guid, null,null);
        }

        /// <summary>
        /// 根据用户的DN获得用户组。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用默许用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>倘诺不设有,再次来到null。</returns>
        public static Group GetGroupByDN(string dn, string userName, string password)
        {
            return GetGroupByPath(dn, userName, password);
        }

        /// <summary>
        /// 依据用户的DN获得组对象,使用暗许用户身份标识。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <returns>假若不设有,重回null。</returns>
        public static Group GetGroupByDN(string dn)
        {
            return GetGroupByDN(dn, null, null);
        }

        /// <summary>
        /// 根据用户的ADsPath得到组对象。
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用私下认可用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>借使不存在,重回null。</returns>
        public static Group GetGroupByPath(string path, string userName, string password)
        {
            DirectoryEntry entry = GetByPath(path, userName, password);
            if (entry != null)
            {
                Group group = new Group(entry);
                entry.Close();
                entry.Dispose();

                return group;
            }
            else
                return null;

            
        }

        /// <summary>
        /// 根据用户的ADsPath获得组对象,使用暗中认可用户地点标识。
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <returns>借使不存在,再次回到null。</returns>
        public static Group GetGroupByPath(string path)
        {
            return GetGroupByPath(path, null, null);
        }

        #endregion

        #region Rename

        /// <summary>
        /// 更改组DirectoryEntry对象的名目。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath</param>
        /// <param name=”newName”>该项的新名称。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗中同意用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        public static void RenameGroup(string groupPath, string newName, string userName, string password)
        {
            DirectoryEntry de = GetByPath(groupPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“组对象不存在。”);

            if (de.SchemaClassName != SchemaClass.group.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.group.ToString(“F”) + “。”);

            string dn = Utils.EscapeDNBackslashedChar(de.Properties[BaseObject.PROPERTY_DN].Value.ToString());
            string rdn = Utils.GenerateRDNCN(newName);
            if(Exists(Utils.GenerateDN(rdn, Utils.GetParentDN(dn))))
                throw new 萨姆e途观DNException(“已存在同名对象。”);
            try
            {
                de.Rename(rdn);

                de.CommitChanges();
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 更改组DirectoryEntry对象的名号,使用暗中同意用户身份标识。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath</param>
        /// <param name=”newName”>该项的新名称。</param>
        public static void RenameGroup(string groupPath, string newName)
        {
            RenameGroup(groupPath, newName);
        }

        #endregion

        #region Member Change

        /// <summary>
        /// 将用户拉长到组。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <param name=”userDN”>需求丰硕的用户的DN。完全转义的。</param>
        public static void AddUserToGroup(string groupPath, string userName, string password, params string[] userDN)
        {
            DirectoryEntry de = GetByPath(groupPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“组对象不存在。”);

            if (de.SchemaClassName != SchemaClass.group.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.group.ToString(“F”) + “。”);

            // 获得已有个别Member
            List<string> ms = new List<string>();
            foreach (object m in de.Properties[Group.PROPERTY_MEMBER])
            {
                ms.Add(Utils.EscapeDNBackslashedChar(m.ToString()));
            }
            ms.Sort();          // 已排序 — 以便内部使用

            List<string> toAdd = new List<string>();
            foreach (string udn in userDN)
            {
                if (!(ms.BinarySearch(udn) >= 0))
                {
                    if (!toAdd.Exists(delegate(string a ) {return a == udn;}))
                        toAdd.Add(udn);
                }
            }

            try
            {
                foreach (string udn in toAdd)
                {
                    de.Invoke(“Add”, new object[] { ParaMgr.LDAP_IDENTITY + udn });         // 需要ADsPath
                }

                de.CommitChanges();
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 将用户增进到组,使用默许用户身份标识。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userDN”>须要丰硕的用户的DN。</param>
        public static void AddUserToGroup(string groupPath, params string[] userDN)
        {
            AddUserToGroup(groupPath, null,null,userDN);
        }

        /// <summary>
        /// 将用户拉长到组。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <param name=”userGuid”>须要添加的用户的Guid。</param>
        public static void AddUserToGroup(string groupPath, string userName, string password, params Guid[] userGuid)
        {
            List<string> userDN = new List<string>();
            User user = null;
            foreach(Guid guid in userGuid)
            {
                user = GetUserByGuid(guid);
                if (user != null)
                {
                    userDN.Add(user.Dn);
                }
            }

            AddUserToGroup(groupPath, userName, password, userDN.ToArray());
        }

        /// <summary>
        /// 将用户增长到组,使用私下认可用户身份标识。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userGuid”>要求加上的用户的Guid。</param>
        public static void AddUserToGroup(string groupPath, params Guid[] userGuid)
        {
            AddUserToGroup(groupPath, null, null, userGuid);
        }

        /// <summary>
        /// 将用户从组中移除。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用默认用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <param name=”userDN”>须要移除的用户的DN。完全转义的。</param>
        public static void RemoveUserFromGroup(string groupPath, string userName, string password, params string[] userDN)
        {
            DirectoryEntry de = GetByPath(groupPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“组对象不存在。”);

            if (de.SchemaClassName != SchemaClass.group.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.group.ToString(“F”) + “。”);

            // 获得已部分Group
            List<string> ms = new List<string>();
            foreach (object m in de.Properties[Group.PROPERTY_MEMBER])
            {
                ms.Add(Utils.EscapeDNBackslashedChar(m.ToString()));
            }
            ms.Sort();          // 已排序 — 以便内部使用

            List<string> toRemove = new List<string>();
            foreach (string udn in userDN)
            {
                if (ms.BinarySearch(udn) >= 0)
                {
                    if (!toRemove.Exists(delegate(string a) { return a == udn; }))
                        toRemove.Add(udn);
                }
            }

            try
            {
                foreach (string udn in toRemove)
                {
                    de.Invoke(“Remove”, new object[] { ParaMgr.LDAP_IDENTITY + udn });         // 需要ADsPath
                }

                //de.Invoke(“Remove”, userDN);        // TODO:是或不是需求保留转义的/,是或不是要求ADsPath,like AddUserToGroup

                de.CommitChanges();
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 将用户从组中移除,使用默许用户地方标识。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userDN”>需求移除的用户的DN。</param>        
        public static void RemoveUserFromGroup(string groupPath, params string[] userDN)
        {
            RemoveUserFromGroup(groupPath, null,null,userDN);
        }

        /// <summary>
        /// 将用户从组中移除。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <param name=”userGuid”>必要移除的用户的Guid。</param>
        public static void RemoveUserFromGroup(string groupPath, string userName, string password, params Guid[] userGuid)
        {
            List<string> userDN = new List<string>();
            User user = null;
            foreach(Guid guid in userGuid)
            {
                user = GetUserByGuid(guid);
                if (user != null)
                {
                    userDN.Add(user.Dn);
                }
            }

            RemoveUserFromGroup(groupPath, userName, password, userDN.ToArray());
        }

        /// <summary>
        /// 将用户从组中移除,使用私下认可用户地方标识。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userGuid”>必要移除的用户的Guid。</param>
        public static void RemoveUserFromGroup(string groupPath, params Guid[] userGuid)
        {
            RemoveUserFromGroup(groupPath, null, null, userGuid);
        }

        #endregion

        #region MemberOf & Member

        /// <summary>
        /// 获取组的专属组的DN
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns></returns>
        public static List<string> GetGroupMemberOfDN(string groupPath, string userName, string password)
        {
            DirectoryEntry de = GetByPath(groupPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“组对象不设有。”);

            if (de.SchemaClassName != SchemaClass.group.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.group.ToString(“F”) + “。”);

            List<string> dn = new List<string>();
            if (de.Properties.Contains(Group.PROPERTY_MEMBEROF))
            {
                foreach (object m in de.Properties[Group.PROPERTY_MEMBEROF])
                {
                    dn.Add(Utils.EscapeDNBackslashedChar(m.ToString()));
                }
            }

            de.Close();
            de.Dispose();

            return dn;
        }

        /// <summary>
        /// 获取组的直属组的DN,使用私下认可用户地点标识。
        /// </summary>
        /// <param name=”group帕特h”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <returns></returns>
        public static List<string> GetGroupMemberOfDN(string groupPath)
        {
            return GetGroupMemberOfDN(groupPath, null, null);
        }

        /// <summary>
        /// 获取组的成员(仅用户)
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中认可用户身份标识。</param>
        /// <param name=”password”>用户位置标识–密码。</param>
        /// <returns></returns>
        public static List<User> GetGroupUserMember(string groupPath, string userName, string password)
        {
            DirectoryEntry de = GetByPath(groupPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“组对象不存在。”);

            if (de.SchemaClassName != SchemaClass.group.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.group.ToString(“F”) + “。”);

            List<User> users = new List<User>();
            string userSchemaClassName = SchemaClass.user.ToString(“F”);

            if (de.Properties.Contains(Group.PROPERTY_MEMBER))
            {
                foreach (object memberDN in de.Properties[Group.PROPERTY_MEMBER])
                {
                    de = GetByDN(Utils.EscapeDNBackslashedChar(memberDN.ToString()), userName, password);

                    if (de != null)
                    {
                        if (de.SchemaClassName == userSchemaClassName)
                        {
                            users.Add(new User(de));
                        }

                        de.Close();
                        de.Dispose();
                    }
                }
            }

            return users;
        }

        /// <summary>
        /// 获取组的分子(仅用户),使用暗许用户地点标识。
        /// </summary>
        /// <param name=”groupPath”>组DirectoryEntry的ADsPath。完全转义的。</param>
        /// <returns></returns>
        public static List<User> GetGroupUserMember(string groupPath)
        {
            return GetGroupUserMember(groupPath, null, null);
        }

        #endregion

        #endregion

        #region OU

        #region Search

        /// <summary>
        /// 获取内定全部组织单位。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示整个域。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗许用户地点标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        /// <returns>借使不设有,重临null。</returns>
        public static List<OU> GetOUAll(string rootPath, string userName, string password)
        {
            List<DirectoryEntry> entries = Search(null, “organizationalUnit”, null, rootPath, SearchScope.Subtree, userName, password);
            List<OU> ous = new List<OU>();
            foreach (DirectoryEntry de in entries)
            {
                ous.Add(new OU(de));

                de.Close();
                de.Dispose();
            }

            return ous;
        }

        /// <summary>
        /// 获取钦点所有组织单位,使用暗中认可用户身份标识。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示一切域。</param>
        /// <returns>即使不设有,重临null。</returns>
        public static List<OU> GetOUAll(string rootPath)
        {
            return GetOUAll(rootPath, null, null);
        }

        /// <summary>
        /// 获取钦定全体组织单位。
        /// </summary>
        /// <param name=”root帕特h”>根对象ADsPath,null表示全部域。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用私下认可用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>倘若不设有,再次来到null。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass</remarks>
        public static List<String[]> GetOUAllSimple(string rootPath, string userName, string password)
        {
            return Search2(null, “organizationalUnit”, null, rootPath, SearchScope.Subtree, userName, password);
        }

        /// <summary>
        /// 获取钦赐全部组织单位,使用暗中同意用户身份标识。
        /// </summary>
        /// <param name=”rootPath”>根对象ADs帕特h,null表示全部域。</param>
        /// <returns>如若不设有,再次来到null。</returns>
        /// <remarks>包括distinguishedname,objectguid,name,description,adspath,objectcategory,objectclass</remarks>
        public static List<String[]> GetOUAllSimple(string rootPath)
        {
            return GetOUAllSimple(rootPath, null, null);
        }

        /// <summary>
        /// 获取钦赐全体协会单位。直接解析查询结果,速度较GetUserAll快。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示一切域。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用默许用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>假诺不设有,重回null。</returns>
        public static List<OU> GetOUAllQuick(string rootPath, string userName, string password)
        {
            SearchResultCollection results = Search3(null, “organizationalUnit”, null, rootPath, SearchScope.Subtree, userName, password);

            List<OU> ous = new List<OU>();
            foreach (SearchResult se in results)
            {
                ous.Add(new OU(se));
            }

            return ous;
        }

        /// <summary>
        /// 获取钦点全部组织单位,使用私下认可用户身份标识。直接解析查询结果,速度较GetUserAll快。
        /// </summary>
        /// <param name=”rootPath”>根对象ADsPath,null表示整个域。</param>
        /// <returns>假使不设有,重返null。</returns>
        public static List<OU> GetOUAllQuick(string rootPath)
        {
            return GetOUAllQuick(rootPath, null, null);
        }

        #endregion

        #region Get

        /// <summary>
        /// 依照公司单位的Guid得到组织单位指标。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>借使不设有,重临null。</returns>
        public static OU GetOUByGuid(Guid guid, string userName, string password)
        {
            return GetOUByPath(Utils.GenerateADsPath(guid), userName, password);
        }

        /// <summary>
        /// 依据集团单位的Guid得到组织单位目的,使用暗中同意用户身份标识。
        /// </summary>
        /// <param name=”guid”>Guid</param>
        /// <returns>假诺不存在,再次回到null。</returns>
        public static OU GetOUByGuid(Guid guid)
        {
            return GetOUByGuid(guid, null, null);
        }

        /// <summary>
        /// 依照公司单位的DN获得组织单位指标。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中同意用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>如果不设有,重临null。</returns>
        public static OU GetOUByDN(string dn, string userName, string password)
        {
            return GetOUByPath(dn, userName, password);
        }

        /// <summary>
        /// 依据集团单位的DN获得组织单位目的,使用私下认可用户地点标识。
        /// </summary>
        /// <param name=”dn”>DN。完全转义过的。</param>
        /// <returns>如若不存在,再次来到null。</returns>
        public static OU GetOUByDN(string dn)
        {
            return GetOUByDN(dn, null, null);
        }

        /// <summary>
        /// 遵照公司单位的ADsPath得到组织单位指标。
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <param name=”userName”>用户地方标识–用户名。为空时使用暗许用户身份标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns>假如不存在,再次回到null。</returns>
        public static OU GetOUByPath(string path, string userName, string password)
        {
            DirectoryEntry entry = GetByPath(path, userName, password);
            if (entry != null)
            {
                OU ou = new OU(entry);
                entry.Close();
                entry.Dispose();

                return ou;
            }
            else
                return null;
        }

        /// <summary>
        /// 遵照公司单位的ADs帕特h获得组织单位目的,使用暗中同意用户地方标识。
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <returns>假使不存在,重临null。</returns>
        public static OU GetOUByPath(string path)
        {
            return GetOUByPath(path, null, null);
        }

        #endregion

        #region Rename

        /// <summary>
        /// 更改协会单位DirectoryEntry对象的称谓。
        /// </summary>
        /// <param name=”ouPath”>协会单位DirectoryEntry的ADsPath。必须是DN方式,且完全转义。</param>
        /// <param name=”newName”>该项的新名称。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中认可用户地点标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        public static void RenameOU(string ouPath, string newName, string userName, string password)
        {
            DirectoryEntry de = GetByPath(ouPath, userName, password);

            if (de == null)
                throw new EntryNotExistException(“组织单位指标不存在。”);

            if (de.SchemaClassName != SchemaClass.organizationalUnit.ToString(“F”))
                throw new SchemaClassException(“对象类型不是” + SchemaClass.organizationalUnit.ToString(“F”) + “。”);

            string dn = Utils.EscapeDNBackslashedChar(de.Properties[BaseObject.PROPERTY_DN].Value.ToString());
            string rdn = Utils.GenerateRDNOU(newName);
            if (Exists(Utils.GenerateDN(rdn, Utils.GetParentDN(dn))))
                throw new 萨姆e大切诺基DNException(“已存在同名对象。”);
            try
            {
                de.Rename(rdn);

                de.CommitChanges();
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 更改组DirectoryEntry对象的名目,使用暗中同意用户身份标识。
        /// </summary>
        /// <param name=”ouPath”>组织单位DirectoryEntry的ADsPath。必须是DN情势,且完全转义。</param>
        /// <param name=”newName”>该项的新名称。</param>
        public static void RenameOU(string ouPath, string newName)
        {
            RenameOU(ouPath, newName, null, null);
        }

        /// <summary>
        /// 更改组织单位DirectoryEntry对象的名目。
        /// </summary>
        /// <param name=”ouGuid”>组织单位DirectoryEntry的Guid</param>
        /// <param name=”newName”>该项的新名称。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用私下认可用户地方标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        public static void RenameOU(Guid ouGuid, string newName, string userName, string password)
        {
            RenameOU(TB.ADBlock.ADManager.GetOUByGuid(ouGuid).Dn, newName, userName, password);
        }

        /// <summary>
        /// 更改协会单位DirectoryEntry对象的名目,使用暗中认可用户地点标识。
        /// </summary>
        /// <param name=”ouGuid”>协会单位DirectoryEntry的ADsPath</param>
        /// <param name=”newName”>该项的新名称。</param>
        public static void RenameOU(Guid ouGuid, string newName)
        {
            RenameOU(Utils.GenerateADsPath(ouGuid), newName, null, null);
        }

        #endregion

        #region Move

        /// <summary>
        /// 移动集团单位DirectoryEntry到钦赐地点。
        /// </summary>
        /// <param name=”ouPath”>要活动的团体单位DirectoryEntry的ADsPath。必须是DN情势,且完全转义。</param>
        /// <param name=”newLocationPath”>移动到的职位的ADsPath。必须是DN方式,且完全转义。</param>
        /// <param name=”mustOU”>移动到的地点对应的DirectoryEntry是不是必须是团伙单位。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户地点标识–密码。</param>
        public static void MoveOU(string ouPath, string newLocationPath, bool mustOU, string userName, string password)
        {
            if (!Exists(ouPath))
                throw new EntryNotExistException(“要求被活动的靶子不存在。”);

            DirectoryEntry de = null;
            try
            {
                de = GetByPath(ouPath, userName, password);

                MoveOU(de, newLocationPath, mustOU, userName, password);
            }
            catch
            {
                throw;
            }
            finally
            {
                if (de != null)
                {
                    de.Close();
                    de.Dispose();
                }
            }
        }

        /// <summary>
        /// 移动公司单位DirectoryEntry到钦点地点,使用私下认可用户地方标识。
        /// </summary>
        /// <param name=”ouPath”>要活动的团伙单位DirectoryEntry的ADsPath</param>
        /// <param name=”newLocationPath”>移动到的任务的ADsPath</param>
        /// <param name=”mustOU”>移动到的任务对应的DirectoryEntry是还是不是必须是公司单位。</param>
        public static void MoveOU(string ouPath, string newLocationPath, bool mustOU)
        {
            MoveUser(ouPath, newLocationPath, mustOU, null, null);
        }

        /// <summary>
        /// 移动集团单位DirectoryEntry到钦点地方。
        /// </summary>
        /// <param name=”ou”>要运动的公司单位DirectoryEntry的Guid</param>
        /// <param name=”newLocation”>移动到的岗位的Guid</param>
        /// <param name=”mustOU”>移动到的地点对应的DirectoryEntry是不是必须是团组织单位。</param>
        /// <param name=”userName”>用户地点标识–用户名。为空时使用私下认可用户身份标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        public static void MoveOU(Guid ou, Guid newLocation, bool mustOU, string userName, string password)
        {
            MoveUser(TB.ADBlock.ADManager.GetOUByGuid(ou).Dn,
               TB.ADBlock.ADManager.GetOUByGuid(newLocation).Dn, mustOU, userName, password);
        }

        /// <summary>
        /// 移动公司单位DirectoryEntry到内定地点,使用暗中认可用户地点标识。
        /// </summary>
        /// <param name=”ou”>要运动的组织单位DirectoryEntry的Guid</param>
        /// <param name=”newLocationPath”>移动到的地方的Guid</param>
        /// <param name=”mustOU”>移动到的地点对应的DirectoryEntry是或不是必须是集体单位。</param>
        public static void MoveOU(Guid ou, Guid newLocationPath, bool mustOU)
        {
            MoveUser(ou, newLocationPath, mustOU, null, null);
        }

        /// <summary>
        /// 移动公司单位DirectoryEntry到钦命地点。
        /// </summary>
        /// <param name=”de”>要运动的集体单位DirectoryEntry对象</param>
        /// <param name=”newLocationPath”>移动到的职位的ADsPath</param>
        /// <param name=”mustOU”>移动到的职位对应的DirectoryEntry是还是不是必须是团队单位。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗许用户地点标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        internal static void MoveOU(DirectoryEntry de, string newLocationPath, bool mustOU, string userName, string password)
        {
            if (!Exists(newLocationPath))
                throw new EntryNotExistException(“移动到的地方对象不设有。”);

            DirectoryEntry newLocation = null;
            try
            {
                newLocation = GetByPath(newLocationPath, userName, password);

                if (de.SchemaClassName != SchemaClass.organizationalUnit.ToString(“F”))
                    throw new SchemaClassException(“必要被活动的靶子类型不是” + SchemaClass.organizationalUnit.ToString(“F”) + “。”);

                if (mustOU && newLocation.SchemaClassName != SchemaClass.organizationalUnit.ToString(“F”))
                    throw new SchemaClassException(“移动到的岗位对象类型不是” + SchemaClass.organizationalUnit.ToString(“F”) + “。”);

                if (Exists(Utils.GetRDNValue(de.Properties[BaseObject.PROPERTY_DN].Value.ToString()) + “,” +
                    newLocation.Properties[BaseObject.PROPERTY_DN].Value.ToString()))
                    throw new Same卡宴DNException(“移动到的岗位下存在同名对象。”);

                de.MoveTo(newLocation);
                de.CommitChanges();
            }
            catch (InvalidOperationException ioe)   // 内定的 DirectoryEntry 不是容器。
            {
                throw new NotContainerException(ioe.Message, ioe);
            }
            catch (DirectoryServicesCOMException dsce)
            {
                throw dsce;
            }
            finally
            {
                if (newLocation != null)
                {
                    newLocation.Close();
                    newLocation.Dispose();
                }
            }
        }

        #endregion

        #region Structure

        /// <summary>
        /// 获取组织单位子树。
        /// </summary>
        /// <param name=”ouGuid”>组织单位DirectoryEntry的Guid</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用默许用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns></returns>
        public OU GetOUSubTree(Guid ouGuid, string userName, string password)
        {
            OU ou = GetOUByGuid(ouGuid);

            if (ou == null)
                throw new EntryNotExistException(“协会单位目的不设有。”);

            return ou.GetSubTree(userName, password);
        }

        /// <summary>
        /// 获取组织单位子树,使用私下认可用户地方标识。
        /// </summary>
        /// <param name=”ouGuid”>组织单位DirectoryEntry的Guid</param>
        /// <returns></returns>
        public OU GetOUSubTree(Guid ouGuid)
        {
            return GetOUSubTree(ouGuid, null, null);
        }

        /// <summary>
        /// 获取组织单位子协会单位。
        /// </summary>
        /// <param name=”ouGuid”>组织单位DirectoryEntry的Guid</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地点标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns></returns>
        public List<OU> GetOUChildren(Guid ouGuid, string userName, string password)
        {
            OU ou = GetOUByGuid(ouGuid);

            if (ou == null)
                throw new EntryNotExistException(“组织单位目的不设有。”);

            return ou.GetChildren(userName, password);
        }

        /// <summary>
        /// 获取组织单位子组织单位,使用暗中认可用户地点标识。
        /// </summary>
        /// <param name=”ouGuid”>组织单位DirectoryEntry的Guid</param>
        /// <returns></returns>
        public List<OU> GetOUChildren(Guid ouGuid)
        {
            return GetOUChildren(ouGuid, null, null);
        }

        /// <summary>
        /// 获取组织单位父组织单位。
        /// </summary>
        /// <param name=”ouGuid”>组织单位DirectoryEntry的Guid</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用默许用户地方标识。</param>
        /// <param name=”password”>用户身份标识–密码。</param>
        /// <returns></returns>
        public OU GetOUParent(Guid ouGuid, string userName, string password)
        {
            OU ou = GetOUByGuid(ouGuid);

            if (ou == null)
                throw new EntryNotExistException(“组织单位目的不设有。”);

            return ou.GetParent(userName, password);
        }

        /// <summary>
        /// 获取协会单位父协会单位,使用私下认可用户地方标识。
        /// </summary>
        /// <param name=”ouGuid”>协会单位DirectoryEntry的Guid</param>
        /// <returns></returns>
        public OU GetOUParent(Guid ouGuid)
        {
            return GetOUParent(ouGuid, null, null);
        }

        #endregion

        #endregion

        /// <summary>
        /// 通过ADsPath获取对象。如今仅限User,OU和Group
        /// </summary>
        /// <param name=”path”>ADsPath。完全转义过的。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中认可用户地点标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>若是不设有,再次来到null。</returns>
        public static BaseObject GetObjectByPath(string path, string userName, string password)
        {
            BaseObject baseObject = null;
            DirectoryEntry entry = GetByPath(path, userName, password);
            if (entry != null)
            {
                SchemaClass schema = SchemaClass.none;
                try
                {
                    schema = (SchemaClass)(Enum.Parse(typeof(SchemaClass), entry.SchemaClassName));
                    switch (schema)
                    {
                        case SchemaClass.user:
                            baseObject = new User(entry);
                            break;
                        case SchemaClass.group:
                            baseObject = new Group(entry);
                            break;
                        case SchemaClass.organizationalUnit:
                            baseObject = new OU(entry);
                            break;
                    }
                }
                catch
                { }
                
                entry.Close();
                entry.Dispose();

                return baseObject;
            }
            else
                return null;
        }

        /// <summary>
        /// 钦命的SAMAccountName用户或组是还是不是存在。
        /// </summary>
        /// <param name=”sAMAccountName”>sAMAccountName</param>
        /// <param name=”an”>如若存在,对应的sAMAccountName。</param>
        /// <param name=”dn”>假设存在,对应的DN。</param>
        /// <param name=”precision”>true表示完全合作,false表示前向匹配。</param>
        /// <param name=”userName”>用户身份标识–用户名。为空时使用暗中同意用户地方标识。</param>
        /// <param name=”password”>用户地方标识–密码。</param>
        /// <returns>如若不设有,重回false。</returns>
        public static bool SAMAccountNameExists(string sAMAccountName, out string an, out string dn, bool precision,
            string userName, string password)
        {
            an = null;
            dn = null;
            List<DirectoryEntry> entries = Search(“sAMAccountName=” + Utils.Escape4Query(sAMAccountName) + “*”, null, null, null, SearchScope.Subtree, userName, password);
            if (entries.Count >= 1)
            {
                string schemaClassName = entries[0].SchemaClassName;
                bool valid = ((schemaClassName == SchemaClass.group.ToString(“F”)) || (schemaClassName == SchemaClass.user.ToString(“F”)));

                if (valid)
                {
                    an = entries[0].Properties[“sAMAccountName”].Value.ToString();
                    if ((precision && (an == sAMAccountName)) || (!precision))
                    {
                        dn = Utils.EscapeDNBackslashedChar(entries[0].Properties[BaseObject.PROPERTY_DN].Value.ToString());
                    }
                    else
                    {
                        an = null;
                        valid = false;
                    }
                    
                }

                entries[0].Close();
                entries[0].Dispose();

                return valid;
            }

            return false;
        }

    }
}

相关文章

Your Comments

近期评论

    功能


    网站地图xml地图