操作Active Directory C#
.Net平台操作活动目录Active Directory，使用System.DirectoryServices.ActiveDirectory，主要是User OU 和Group的操作。
代码运行了一年多，还没有出现问题，应该算是经过了验证。
更新的代码在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; namespace TB.ADBlock
{
/// <summary>
/// 用于进行AD管理里的对象，提供操作AD的静态方法。
/// </summary>
/// <remarks>
/// 这里ADsPath可以是LDAP://DN和LDAP://<GUID>两种形式，但不限于这种形式。
/// 一般方法均提供2种形式，一种是用参数提供的用户身份标识，一种是用默认的用户身份标识。
/// 默认用户身份标识取决于当前进程的用户身份标识。
/// </remarks>
public class ADManager
{
#region 域信息 /// <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;
} /// <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);
} /// <summary>
/// 获取当前用户上下文的 Forest 对象中的所有域名称。
/// </summary>
/// <returns></returns>
public static List<string> EnumerateDomains()
{
List<string> alDomains = new List<string>();
Forest currentForest = Forest.GetCurrentForest();
DomainCollection myDomains = currentForest.Domains; foreach (System.DirectoryServices.ActiveDirectory.Domain objDomain in myDomains)
{
alDomains.Add(objDomain.Name);
}
return alDomains;
} /// <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>
/// 获取当前用户身份标识的 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;
} #endregion #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 SameRDNException("移动到的位置下存在同名对象。"); 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">根对象ADsPath，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="rootPath">根对象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 SameRDNException("移动到的位置下存在同名对象。"); 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 SameRDNException("已存在同名对象。");
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="groupPath">组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="rootPath">根对象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">根对象ADsPath，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>
/// 根据组织单位的ADsPath得到组织单位对象，使用默认用户身份标识。
/// </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 SameRDNException("已存在同名对象。");
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 SameRDNException("移动到的位置下存在同名对象。"); 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;
} }
}
操作Active Directory C#的更多相关文章
- C#操作Active Directory(AD)详解
1. LDAP简介 LDAP(轻量级目录访问协议,Lightweight Directory Access Protocol)是实现提供被称为目录服务的信息服务.目录服务是一种特殊的数据库系统,其专门 ...
- Active Directory组织单位(Organizational Unit)操作汇总
前言 本章聊Active Directory的组织单位(OU)的新增.修改.移动等操作,使用.NET Framework 为我们提供的System.DirectoryServices程序集. 不积跬步 ...
- PHP 通过LDAP协议，操作Windows Active Directory
原文地址:http://hi.baidu.com/lllangxx/item/3ccb7cdfa13b56eb3dc2cb39 一.学习如何管理Active Directory Active Dire ...
- Windows Azure Active Directory (3) China Azure AD增加新用户
<Windows Azure Platform 系列文章目录> 本文介绍的是国内由世纪互联运维的China Azure. 本文是对笔者之前的文档:Windows Azure Active ...
- DNS笔记 DNS区域集成到 Active Directory
可以将 DNS 区域集成到 Active Directory 中以提供增强的容错功能和安全性.OpenDNS Google Public DNS往返时间 (RTT) 远程访问服务 (RAS)域名与 ...
- install Active Directory域控制器
设置Active Directory域控制器 正如我们在网络与系统配置专题文章中所提到的那样,我们已将两部服务器设置为对应于内部域“intdomain.com”的Active Directory域控制 ...
- 移动服务和 Azure Active Directory 中基于角色的访问控制
编辑人员注释:本文章由 Matthew Henderson撰写 去年 11月,我们发布了 Azure Active Directory (AAD) 预览版作为移动服务身份提供程序.此举旨在为企业开 ...
- 宣布正式发布 Biz Talk Services、Azure Active Directory 和 Traffic Manager, 同时发布 Azure Active Directory 高级版预览
除经济优势之外,云计算还在可转化为竞争优势的应用程序开发方面提供了更大的灵活性.我们很高兴看到每天创建的新 Windows Azure 订阅超过 1000 个,更令人兴奋的是,有一半客户使用价值更高的 ...
- PowerShell 批量导入/导出Active Directory
PowerShell 批量导入/导出Active Directory 近期由于公司要求,须要导入20个供应商.20个客户到AD域中,刚開始手动添�了2个供应商,2个客户.可是感觉费时费 ...
随机推荐
- Luogu P1801 黑匣子_NOI导刊2010提高（06）
P1801 黑匣子_NOI导刊2010提高(06) 题目描述 Black Box是一种原始的数据库.它可以储存一个整数数组,还有一个特别的变量i.最开始的时候Black Box是空的．而i等于0.这个 ...
- POJ_1456 Supermarket 【并查集/贪心】
一.题面 POJ1456 二.分析 1.贪心策略:先保证从利润最大的开始判断,然后开一个标记时间是否能访问的数组,时间尽量从最大的时间开始选择,这样能够保证后面时间小的还能够卖. 2.并查集:并查集直 ...
- 2019.3.13 final与static
final 当使用final修饰类的时候,表示类不能被继承(就是extends后面不能再加它了) final 注意事项: 当使用final修饰时,该方法不能被子类重写 当一个方法被标记为private ...
- 完全原生javascript简约日历插件，js、html
效果图: 效果如图所示,尽管看上去并不是很美观,但是,基本上的功能还是已经完成了,码了一天多的时间,权当做复习一下js吧. 整个做下来差不多码了500多行代码~其实只是很多的样式也包括了在其中了,虽然 ...
- TOJ 3488 Game Dice
描述 In the game of Dungeons & Dragons, players often roll multi-sided dice to generate random num ...
- mysql中字段类型是datetime时比较大小问题
select sum(studychj) as tofflinejz from afterline where studybegin >= '2010-01-01 00:00:00' and s ...
- 生成ks.cfg文件
RHEL 7下生成ks.cfg文件 环境 + RHEL 7 + 字符界面, 没有安装图形界面 软件包安装 + `yum install system-config-kickstart -y` + `y ...
- HDU 1800——Flying to the Mars——————【字符串哈希】
Flying to the Mars Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Other ...
- Linux Tomcat 80端口 Port 80 required by Tomcat v8.5 Server at localhost is already in use.
Port 80 required by Tomcat v8.5 Server at localhost is already in use. The server may already be run ...
- 修改ThinkPHP的验证码类
今天用ThinkPHP重新开发一个系统,用到了ThinkPHP的验证码类,由于我希望验证码别太复杂,希望验证码里边只有数字,却发现该Verify类并未提供设置验证码中使用的字符的配置的方法,于是查看源 ...