SecurityPermission.Intersect-Methode

Erstellt eine Berechtigung als Schnittmenge der aktuellen und der angegebenen Berechtigung und gibt diese zurück.

Namespace: System.Security.Permissions
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Overrides Function Intersect ( _
    target As IPermission _
) As IPermission
'Usage
Dim instance As SecurityPermission
Dim target As IPermission
Dim returnValue As IPermission

returnValue = instance.Intersect(target)

public override IPermission Intersect (
    IPermission target
)

public:
virtual IPermission^ Intersect (
    IPermission^ target
) override

public IPermission Intersect (
    IPermission target
)

public override function Intersect (
    target : IPermission
) : IPermission

Parameter

• target
  Eine Berechtigung, deren Schnittmenge mit der aktuellen Berechtigung gebildet wird. Diese muss von demselben Typ wie die aktuelle Berechtigung sein.

Rückgabewert

Ein neues Berechtigungsobjekt, das die Schnittmenge der aktuellen und der angegebenen Berechtigung darstellt. Diese neue Berechtigung ist NULL (Nothing in Visual Basic), wenn die Schnittmenge leer ist.

Ausnahmen

Ausnahmetyp	Bedingung
ArgumentException	Der target-Parameter ist nicht NULL (Nothing in Visual Basic) und gehört nicht zum gleichen Typ wie die aktuelle Berechtigung.

Hinweise

Die Schnittmenge zweier Berechtigungen ist eine Berechtigung, die den von beiden Berechtigungen gemeinsam beschriebenen Zustand wiedergibt. Eine Anforderung über die Schnittmenge ist nur erfolgreich, wenn sie beide ursprünglichen Berechtigungen erfolgreich durchläuft.

Beispiel

Im folgenden Codebeispiel soll das Verhalten der Intersect-Methode veranschaulicht werden, auf ihre Verwendung wird jedoch nicht eingegangen. Im Allgemeinen werden die Methoden von Berechtigungsklassen durch die Sicherheitsinfrastruktur verwendet und sind nicht für die Verwendung in Anwendungen bestimmt. Im folgenden Codebeispiel wird jedoch veranschaulicht, wie sich die Methode verhält, wenn sie vom Code aus ausgeführt wird. Den vollständigen Beispielcode finden Sie in der SecurityPermission-Klasse.

    Private Function IntersectDemo() As Boolean
        Dim returnValue As Boolean = True
        Dim Security1, Security2 As SecurityPermissionFlag
        Dim SecurityPerm1, SecurityPerm2, SecurityPerm3 As SecurityPermission
        Dim SecurityGen1 As New SecurityGenerator()
        Dim SecurityGen2 As New SecurityGenerator()
        SecurityGen1.ResetIndex()
        While SecurityGen1.GetSecurityFlag(Security1)
            SecurityPerm1 = New SecurityPermission(Security1)
            Console.WriteLine("**********************************************************" & ControlChars.Lf)
            SecurityGen2.ResetIndex()

            While SecurityGen2.GetSecurityFlag(Security2)
                SecurityPerm2 = New SecurityPermission(Security2)
                SecurityPerm3 = CType(SecurityPerm1.Intersect(SecurityPerm2), SecurityPermission)
                If Not (SecurityPerm3 Is Nothing) Then
                    Console.WriteLine(("The intersection of " & Security1.ToString() & " and " _
                    & Security2.ToString() & " = " _
                    & CType(SecurityPerm3, SecurityPermission).Flags.ToString().ToString()))
                Else
                    Console.WriteLine(("The intersection of " & Security1.ToString() & " and " _
                    & Security2.ToString() & " is null."))
                End If
ContinueWhile2:
            End While
ContinueWhile1:
        End While

        Return returnValue
    End Function 'IntersectDemo

private bool IntersectDemo()
{
    bool returnValue = true;
    SecurityPermissionFlag security1,security2;
    SecurityPermission securityPerm1,securityPerm2,SecurityPerm3;
    SecurityGenerator SecurityGen1 = new SecurityGenerator();
    SecurityGenerator SecurityGen2 = new SecurityGenerator();
    SecurityGen1.ResetIndex();
    while(SecurityGen1.GetSecurityFlag( out security1 ))
    {
        securityPerm1 = new SecurityPermission(security1);
        Console.WriteLine("**********************************************************\n");
        SecurityGen2.ResetIndex();

        while(SecurityGen2.GetSecurityFlag( out security2 ))
        {
            securityPerm2 = new SecurityPermission(security2);

            SecurityPerm3 = (SecurityPermission)securityPerm1.Intersect(securityPerm2);
            if (SecurityPerm3 != null)
            {
                Console.WriteLine("The intersection of " + security1 + " and " + security2 + " = " +
                    ((SecurityPermission)SecurityPerm3).Flags.ToString());
            }
            else
            {
                Console.WriteLine("The intersection of " + security1 + " and " + security2 + " is null." );
            }
        }
    }

    return returnValue;
}

bool IntersectDemo()
{
   bool returnValue = true;
   SecurityPermissionFlag security1;
   SecurityPermissionFlag security2;
   SecurityPermission^ securityPerm1;
   SecurityPermission^ securityPerm2;
   SecurityPermission^ SecurityPerm3;
   SecurityGenerator^ SecurityGen1 = gcnew SecurityGenerator;
   SecurityGenerator^ SecurityGen2 = gcnew SecurityGenerator;
   SecurityGen1->ResetIndex();
   while ( SecurityGen1->GetSecurityFlag(  &security1 ) )
   {
      securityPerm1 = gcnew SecurityPermission(security1);

      Console::WriteLine( "**********************************************************\n" );
      SecurityGen2->ResetIndex();
      while ( SecurityGen2->GetSecurityFlag(  &security2 ) )
      {
         securityPerm2 = gcnew SecurityPermission(security2);
         SecurityPerm3 = dynamic_cast<SecurityPermission^>(securityPerm1->Intersect( securityPerm2 ));
         if ( SecurityPerm3 != nullptr )
         {
            Console::WriteLine( "The intersection of {0} and {1} = {2}", security1, security2, (dynamic_cast<SecurityPermission^>(SecurityPerm3))->Flags );
         }
         else
         {
            Console::WriteLine( "The intersection of {0} and {1} is null.", security1, security2 );
         }
      }
   }

   return returnValue;
}

private boolean IntersectDemo() 
{
    boolean returnValue = true;
    SecurityPermissionFlag security1[] = new SecurityPermissionFlag[1];
    SecurityPermissionFlag security2[] = new SecurityPermissionFlag[1];
    SecurityPermission securityPerm1[] = new SecurityPermission[1];
    SecurityPermission securityPerm2[] = new SecurityPermission[1];
    SecurityPermission securityPerm3;
    SecurityGenerator securityGen1 =  new SecurityGenerator();
    SecurityGenerator securityGen2 =  new SecurityGenerator();
    securityGen1.ResetIndex();
    while (securityGen1.CreateSecurity(securityPerm1, security1)) {
        if (securityPerm1[0] == null) {
            continue ;
        }
        Console.WriteLine("********************************" 
            + "**************************\n");
        securityGen2.ResetIndex();
        
        while (securityGen2.CreateSecurity(securityPerm2, security2)) {
            if (securityPerm2[0] == null) {
                continue ;
            }
            
            securityPerm3 =((SecurityPermission)(
            securityPerm1[0].Intersect(securityPerm2[0])));
            if (securityPerm3 != null) {
                Console.WriteLine(("The intersection of " 
                    + security1[0] + " and " + security2[0] + " = " 
                    + ((SecurityPermission)(securityPerm3)).
                    get_Flags().ToString()));
            }
            else {
                Console.WriteLine(("The intersection of " 
                    + security1[0] + " and " + security2[0] + " is null."));
            }
        }
    }      
    return returnValue ;
} //IntersectDemo

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

SecurityPermission-Klasse
SecurityPermission-Member
System.Security.Permissions-Namespace