C# Principal.GetUnderlyingObject方法代码示例

        public static DirectoryEntry GetDirectoryEntry(Principal principal)
        {
            if (principal == null)
            {
                throw new ArgumentNullException("principal", "Value cannot be null!");
            }

            return principal.GetUnderlyingObject() as DirectoryEntry;
        }

 private static string GetProperty(Principal principal, String property)
 {
     //using (WindowsImpersonationContextFacade impersonationContext
     //    = new WindowsImpersonationContextFacade(
     //        nc))
     //{
         var result = string.Empty;
         var directoryEntry = principal.GetUnderlyingObject() as DirectoryEntry;
         if (directoryEntry != null)
         {
             if (directoryEntry.Properties.Contains(property))
                 result = directoryEntry.Properties[property].Value.ToString();
             else
                 result = string.Empty;
         }
         return result;
     //}
 }

 private static DomainGroup ToDomainGroup(Principal principal)
 {
     try
     {
         var directoryEntry = principal.GetUnderlyingObject() as DirectoryEntry;
         return new DomainGroup
         {
             Name = principal.Name,
             Guid = principal.Guid.ToString(),
             DivisionId = directoryEntry.GetDivisionId(),
             Description = principal.Description
         };
     }
     catch (System.Exception)
     {
         return new DomainGroup();
     }
 }

        internal override bool AccessCheck(Principal p, PrincipalAccessMask targetPermission)
        {
            GlobalDebug.WriteLineIf(GlobalDebug.Info, "SAMStoreCtx", "AccessCheck " + targetPermission.ToString());

            switch (targetPermission)
            {
                case PrincipalAccessMask.ChangePassword:

                    PropertyValueCollection values = ((DirectoryEntry)p.GetUnderlyingObject()).Properties["UserFlags"];

                    if (values.Count != 0)
                    {
                        Debug.Assert(values.Count == 1);
                        Debug.Assert(values[0] is int);

                        return (SDSUtils.StatusFromAccountControl((int)values[0], PropertyNames.PwdInfoCannotChangePassword));
                    }

                    Debug.Fail("SAMStoreCtx.AccessCheck:  user entry has an empty UserFlags value");

                    GlobalDebug.WriteLineIf(GlobalDebug.Info, "SAMStoreCtx", "AccessCheck Unable to read userAccountControl");

                    break;

                default:

                    Debug.Fail("SAMStoreCtx.AccessCheck: Fell off end looking for " + targetPermission.ToString());

                    break;
            }

            return false;
        }

 public static string GetProperty(Principal principal, String property)
 {
     DirectoryEntry directoryEntry = principal.GetUnderlyingObject() as DirectoryEntry;
     if (directoryEntry.Properties.Contains(property))
     {
         return directoryEntry.Properties[property].Value.ToString();
     }
     else
     {
         return String.Empty;
     }
 }

 /// <summary>
 /// Sets the value of a directory entry property for a given AD Principal object
 /// </summary>
 /// <param name="principal"></param>
 /// <param name="property"></param>
 /// <param name="value"></param>
 private static void setProperty(Principal principal, string property, string value)
 {
     try
     {
         DirectoryEntry dirEntry = principal.GetUnderlyingObject() as DirectoryEntry;
         if (dirEntry.Properties.Contains(property))
         {
             dirEntry.Properties[property].Value = value;
         }
     }
     catch (System.DirectoryServices.DirectoryServicesCOMException ex)
     {
         throw ex;
     }
 }

 /// <summary>
 /// Gets the value of a directory entry property for a given AD Principal object
 /// </summary>
 /// <param name="principal"></param>
 /// <param name="property"></param>
 /// <returns></returns>
 private static String getProperty(Principal principal, string property)
 {
     try
     {
     string value;
     DirectoryEntry dirEntry = principal.GetUnderlyingObject() as DirectoryEntry;
     if (dirEntry.Properties.Contains(property))
         value = dirEntry.Properties[property].Value.ToString();
     else
         value = String.Empty;
     return value;
     }
     catch (System.DirectoryServices.DirectoryServicesCOMException ex)
     {
         throw ex;
     }
 }

		internal override bool AccessCheck(Principal p, PrincipalAccessMask targetPermission)
		{
			PrincipalAccessMask principalAccessMask = targetPermission;
			if (principalAccessMask == PrincipalAccessMask.ChangePassword)
			{
				PropertyValueCollection item = ((DirectoryEntry)p.GetUnderlyingObject()).Properties["UserFlags"];
				if (item.Count != 0)
				{
					return SDSUtils.StatusFromAccountControl((int)item[0], "AuthenticablePrincipal.PasswordInfo.UserCannotChangePassword");
				}
			}
			return false;
		}

        /// <summary>
        /// Sets the specified property to the specified value on the specified Principal.
        /// </summary>
        /// <param name="principal">The Principal object.</param>
        /// <param name="property">The name of the property.</param>
        /// <param name="value">The value to assign to the property.</param>
        /// <returns>True if success, false otherwise.</returns>
        public static Boolean SetProperty(Principal principal, string property, string value)
        {
            DirectoryEntry de = principal.GetUnderlyingObject() as DirectoryEntry;
            // Use PropertyLookup to get the property name in the correct format.
            string targetProperty = PropertyLookup.Instance.get(property);

            // if the property is Manager the value should be a distinguishedName but those
            // are hard to pass around in URLs if they have errant commas and escaping backslashes.
            // Instead get the dn from the value which should be a samaccountname.
            if (targetProperty == PropertyLookup.Instance.get("manager"))
            {
                value = GetDistinguishedName(value);
            }
            if (de.Properties.Contains(targetProperty))
            {
                try
                {
                    de.Properties[targetProperty][0] = value;
                    de.CommitChanges();
                }
                catch
                {
                    return false;
                }
            }
            else
            {
                try
                {
                    de.Properties[targetProperty].Add(value);
                    de.CommitChanges();
                }
                catch
                {
                    return false;
                }
            }
            return true;
        }

 /// <summary>
 /// This method will return the value of the specified property if it exists in the specified Principal's
 /// underlying DirectoryEntry object.
 /// </summary>
 /// <param name="principal">The unique identifier of a Principal.</param>
 /// <param name="property">The name of the Property whose value should be returned.</param>
 /// <returns></returns>
 public static String GetProperty(Principal principal, string property)
 {
     DirectoryEntry de = principal.GetUnderlyingObject() as DirectoryEntry;
     // property is case senstive, use PropertyLookup
     string targetProperty = PropertyLookup.Instance.get(property);
     if (de.Properties.Contains(targetProperty))
         return de.Properties[targetProperty].Value.ToString();
     else
         return String.Empty;
 }