◆ GetRules()

AuthorizationRuleCollection System.Security.AccessControl.DirectoryObjectSecurity.GetRules	(	bool	access,
		bool	includeExplicit,
		bool	includeInherited,
		Type	targetType )
inlineprivate
Definition at line 34 of file DirectoryObjectSecurity.cs.
    {
        ReadLock();
        try
        {
            AuthorizationRuleCollection authorizationRuleCollection = new AuthorizationRuleCollection();
            if (!IsValidTargetTypeStatic(targetType))
            {
                throw new ArgumentException(System.SR.Arg_MustBeIdentityReferenceType, "targetType");
            }
            CommonAcl commonAcl = null;
            if (access)
            {
                if ((base.SecurityDescriptor.ControlFlags & ControlFlags.DiscretionaryAclPresent) != 0)
                {
                    commonAcl = base.SecurityDescriptor.DiscretionaryAcl;
                }
            }
            else if ((base.SecurityDescriptor.ControlFlags & ControlFlags.SystemAclPresent) != 0)
            {
                commonAcl = base.SecurityDescriptor.SystemAcl;
            }
            if (commonAcl == null)
            {
                return authorizationRuleCollection;
            }
            IdentityReferenceCollection identityReferenceCollection = null;
            if (targetType != typeof(SecurityIdentifier))
            {
                IdentityReferenceCollection identityReferenceCollection2 = new IdentityReferenceCollection(commonAcl.Count);
                for (int i = 0; i < commonAcl.Count; i++)
                {
                    QualifiedAce qualifiedAce = commonAcl[i] as QualifiedAce;
                    if (qualifiedAce == null || qualifiedAce.IsCallback)
                    {
                        continue;
                    }
                    if (access)
                    {
                        if (qualifiedAce.AceQualifier != 0 && qualifiedAce.AceQualifier != AceQualifier.AccessDenied)
                        {
                            continue;
                        }
                    }
                    else if (qualifiedAce.AceQualifier != AceQualifier.SystemAudit)
                    {
                        continue;
                    }
                    identityReferenceCollection2.Add(qualifiedAce.SecurityIdentifier);
                }
                identityReferenceCollection = identityReferenceCollection2.Translate(targetType);
            }
            for (int j = 0; j < commonAcl.Count; j++)
            {
                QualifiedAce qualifiedAce2 = commonAcl[j] as CommonAce;
                if (qualifiedAce2 == null)
                {
                    qualifiedAce2 = commonAcl[j] as ObjectAce;
                    if (qualifiedAce2 == null)
                    {
                        continue;
                    }
                }
                if (qualifiedAce2.IsCallback)
                {
                    continue;
                }
                if (access)
                {
                    if (qualifiedAce2.AceQualifier != 0 && qualifiedAce2.AceQualifier != AceQualifier.AccessDenied)
                    {
                        continue;
                    }
                }
                else if (qualifiedAce2.AceQualifier != AceQualifier.SystemAudit)
                {
                    continue;
                }
                if ((!includeExplicit || (qualifiedAce2.AceFlags & AceFlags.Inherited) != 0) && (!includeInherited || (qualifiedAce2.AceFlags & AceFlags.Inherited) == 0))
                {
                    continue;
                }
                IdentityReference identityReference = ((targetType == typeof(SecurityIdentifier)) ? qualifiedAce2.SecurityIdentifier : identityReferenceCollection[j]);
                if (access)
                {
                    AccessControlType type = ((qualifiedAce2.AceQualifier != 0) ? AccessControlType.Deny : AccessControlType.Allow);
                    if (qualifiedAce2 is ObjectAce objectAce)
                    {
                        authorizationRuleCollection.AddRule(AccessRuleFactory(identityReference, objectAce.AccessMask, objectAce.IsInherited, objectAce.InheritanceFlags, objectAce.PropagationFlags, type, objectAce.ObjectAceType, objectAce.InheritedObjectAceType));
                        continue;
                    }
                    CommonAce commonAce = qualifiedAce2 as CommonAce;
                    if (!(commonAce == null))
                    {
                        authorizationRuleCollection.AddRule(AccessRuleFactory(identityReference, commonAce.AccessMask, commonAce.IsInherited, commonAce.InheritanceFlags, commonAce.PropagationFlags, type));
                    }
                }
                else if (qualifiedAce2 is ObjectAce objectAce2)
                {
                    authorizationRuleCollection.AddRule(AuditRuleFactory(identityReference, objectAce2.AccessMask, objectAce2.IsInherited, objectAce2.InheritanceFlags, objectAce2.PropagationFlags, objectAce2.AuditFlags, objectAce2.ObjectAceType, objectAce2.InheritedObjectAceType));
                }
                else
                {
                    CommonAce commonAce2 = qualifiedAce2 as CommonAce;
                    if (!(commonAce2 == null))
                    {
                        authorizationRuleCollection.AddRule(AuditRuleFactory(identityReference, commonAce2.AccessMask, commonAce2.IsInherited, commonAce2.InheritanceFlags, commonAce2.PropagationFlags, commonAce2.AuditFlags));
                    }
                }
            }
            return authorizationRuleCollection;
        }
        finally
        {
            ReadUnlock();
        }
    }
Referenced by System.Security.AccessControl.DirectoryObjectSecurity.GetAccessRules(), and System.Security.AccessControl.DirectoryObjectSecurity.GetAuditRules().