(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

HostProtectionAttribute-Klasse

Ermöglicht das Bestimmen von Hostsicherheitsanforderungen mithilfe von Deklarationssicherheitsaktionen. Die Klasse erlaubt keine Vererbung.

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

[SerializableAttribute]
[AttributeUsageAttribute(AttributeTargets.Assembly|AttributeTargets.Class|AttributeTargets.Struct|AttributeTargets.Constructor|AttributeTargets.Method|AttributeTargets.Delegate, AllowMultiple = true, 
	Inherited = false)]
[ComVisibleAttribute(true)]
public sealed class HostProtectionAttribute : CodeAccessSecurityAttribute

Der HostProtectionAttribute-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeHostProtectionAttribute()Initialisiert eine neue Instanz der HostProtectionAttribute-Klasse mit Standardwerten.
Öffentliche MethodeHostProtectionAttribute(SecurityAction)Initialisiert eine neue Instanz der HostProtectionAttribute-Klasse mit dem angegebenen SecurityAction-Wert.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftActionRuft eine Sicherheitsaktion ab oder legt diese fest. (Von SecurityAttribute geerbt.)
Öffentliche EigenschaftExternalProcessMgmtRuft einen Wert ab, der angibt, ob eine externe Prozessverwaltung verfügbar gemacht wird, oder legt diesen fest.
Öffentliche EigenschaftExternalThreadingRuft einen Wert ab, der angibt, ob externes Threading verfügbar gemacht wird, oder legt diesen fest.
Öffentliche EigenschaftMayLeakOnAbortRuft einen Wert ab, der angibt, ob Ressourcen möglicherweise zu Speicherverlusten beim Beenden der Operation führen, oder legt diesen Wert fest.
Öffentliche EigenschaftResourcesRuft Flags ab, die Kategorien von Funktionen angeben, die potenziell schädlich für den Host sind, oder legt diese Flags fest.
Öffentliche EigenschaftSecurityInfrastructureRuft einen Wert ab, der angibt, ob die Sicherheitsinfrastruktur verfügbar gemacht wird, oder legt diesen fest.
Öffentliche EigenschaftSelfAffectingProcessMgmtRuft einen Wert ab, der angibt, ob eine sich selbst beeinflussende Prozessverwaltung verfügbar gemacht wird, oder legt diesen fest.
Öffentliche EigenschaftSelfAffectingThreadingRuft einen Wert ab, der angibt, ob ein sich selbst beeinflussendes Threading verfügbar gemacht wird, oder legt diesen Wert fest.
Öffentliche EigenschaftSharedStateRuft einen Wert ab, der angibt, ob der Freigabezustand verfügbar gemacht wird, oder legt diesen Wert fest.
Öffentliche EigenschaftSynchronizationRuft einen Wert ab, der angibt, ob eine Synchronisierung verfügbar gemacht wird, oder legt diesen fest.
Öffentliche EigenschaftTypeIdBei Implementierung in einer abgeleiteten Klasse wird ein eindeutiger Bezeichner für dieses Attribute abgerufen. (Von Attribute geerbt.)
Öffentliche EigenschaftUIRuft einen Wert ab, der angibt, ob die Benutzeroberfläche verfügbar gemacht wird, oder legt diesen fest.
Öffentliche EigenschaftUnrestrictedRuft einen Wert ab, der angibt, ob eine vollständige (uneingeschränkte) Berechtigung für die durch das Attribut geschützte Ressource deklariert ist, oder legt diesen fest. (Von SecurityAttribute geerbt.)
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeCreatePermissionErstellt eine neue Hostsicherheitsberechtigung und gibt diese zurück. (Überschreibt SecurityAttribute.CreatePermission().)
Öffentliche MethodeEqualsInfrastruktur. Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. (Von Attribute geerbt.)
Öffentliche MethodeGetHashCodeGibt den Hashcode für diese Instanz zurück. (Von Attribute geerbt.)
Öffentliche MethodeGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeIsDefaultAttributeBeim Überschreiben in einer abgeleiteten Klasse wird angegeben, ob der Wert dieser Instanz der Standardwert für die abgeleitete Klasse ist. (Von Attribute geerbt.)
Öffentliche MethodeMatchBeim Überschreiben in einer abgeleiteten Klasse wird ein Wert zurückgegeben, der angibt, ob diese Instanz einem bestimmten Objekt entspricht. (Von Attribute geerbt.)
Öffentliche MethodeToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang

  NameBeschreibung
Explizite SchnittstellenimplementierungPrivate Methode_Attribute.GetIDsOfNamesOrdnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu. (Von Attribute geerbt.)
Explizite SchnittstellenimplementierungPrivate Methode_Attribute.GetTypeInfoRuft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können. (Von Attribute geerbt.)
Explizite SchnittstellenimplementierungPrivate Methode_Attribute.GetTypeInfoCountRuft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1). (Von Attribute geerbt.)
Explizite SchnittstellenimplementierungPrivate Methode_Attribute.InvokeStellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit. (Von Attribute geerbt.)
Zum Seitenanfang

Dieses Attribut wirkt sich nur auf nicht verwaltete Anwendungen aus, die die Common Language Runtime hosten und Hostsicherheit implementieren, z. B. SQL Server. Wenn der Code in einer Clientanwendung oder auf einem Server ausgeführt wird, der über keinen Hostschutz verfügt, "verpufft" das Attribut. Es wird nicht erkannt und folglich nicht angewendet. Wenn dieses angewendet wird, führt die Sicherheitsaktion zum Erstellen eines Linkaufrufs auf Grundlage der von der Klasse oder Methode offen gelegten Hostressourcen.

Wichtiger HinweisWichtig

Der Zweck dieses Attributs ist, hostspezifische Programmiermodellrichtlinien durchzusetzen, jedoch nicht das Sicherheitsverhalten. Obwohl ein Linkaufruf zum Überprüfen auf Konformität mit den Programmiermodellanforderungen verwendet wird, stellt das HostProtectionAttribute keine Sicherheitsberechtigung dar.

Wenn der Host nicht über Programmiermodellanforderungen verfügt, treten keine Linkaufrufe auf.

Dieses Attribut bezeichnet Folgendes:

  • Methoden oder Klassen, die nicht mit dem Hostprogrammiermodell übereinstimmen, aber keine anderen Auswirkungen haben.

  • Methoden oder Klassen, die nicht mit dem Hostprogrammiermodell übereinstimmen, und möglicherweise zur Destabilisierung des vom Server verwalteten Benutzercodes führen.

  • Methoden oder Klassen, die nicht mit dem Hostprogrammiermodell übereinstimmen, und möglicherweise zur Destabilisierung des Serverprozesses selbst führen.

HinweisHinweis

Wenn Sie eine Klassenbibliothek erstellen, die von Anwendungen aufgerufen wird, die möglicherweise in einer Umgebung mit Hostsicherheit ausgeführt werden, muss dieses Attribut auf die Member angewendet werden, die HostProtectionResource-Ressourcenkategorien verfügbar machen. Bei .NET Framework-Klassenbibliotheksmembern mit diesem Attribut wird nur der unmittelbare Aufrufer überprüft. Der Bibliotheksmember muss auf die gleiche Weise auch eine Prüfung seines unmittelbaren Aufrufers verursachen.

HinweisHinweis

Verwenden Sie Ngen.exe (Native Image Generator) nicht, um ein systemeigenes Abbild von Assemblys zu erstellen, die mit dem HostProtectionAttribute geschützt sind. In einer voll vertrauenswürdigen Umgebung wird das Abbild immer und unabhängig vom HostProtectionAttribute geladen, und in einer teilweise vertrauenswürdigen Umgebung wird das Abbild nicht geladen.

Im folgenden Codebeispiel wird die Verwendung des HostProtectionAttribute-Attributs mit einer Vielzahl von HostProtectionResource-Werten veranschaulicht.


using System;
using System.IO;
using System.Threading;
using System.Security;
using System.Security.Policy;
using System.Security.Principal;
using System.Security.Permissions;
using System.Diagnostics;
using System.ComponentModel;
using System.Windows.Forms;

// If this application is run on a server that implements host protection, the 
// HostProtectionAttribute attribute is applied. If the application is run on   
// a server that is not host-protected, the attribute evaporates; it is not  
// detected and therefore not applied. Host protection can be configured with  
// members of the HostProtectionResource enumeration to customize the  
// protection offered.
// The primary intent of this sample is to show situations in which the 
// HostProtectionAttribute attribute might be meaningfully used. The  
// environment required to demonstrate a particular behavior is
// too complex to invoke within the scope of this sample.

class HostProtectionExample
{
    public static int Success = 100;

    // Use the enumeration flags to indicate that this method exposes 
    // shared state and self-affecting process management.
    // Either of the following attribute statements can be used to set the
    // resource flags.
    [HostProtectionAttribute(SharedState = true, 
        SelfAffectingProcessMgmt = true)]
    [HostProtectionAttribute(Resources = HostProtectionResource.SharedState |
         HostProtectionResource.SelfAffectingProcessMgmt)]
    private static void Exit(string Message, int Code)
    {
        // Exit the sample when an exception is thrown.
        Console.WriteLine("\nFAILED: " + Message + " " + Code.ToString());
        Environment.ExitCode = Code;
        Environment.Exit(Code);
    }

    // Use the enumeration flags to indicate that this method exposes shared 
    // state, self-affecting process management, and self-affecting threading.
    [HostProtectionAttribute(SharedState=true, SelfAffectingProcessMgmt=true,
         SelfAffectingThreading=true, UI=true)]
    // This method allows the user to quit the sample.
    private static void ExecuteBreak()
    {
        Console.WriteLine("Executing Debugger.Break.");
        Debugger.Break();
        Debugger.Log(1,"info","test message");
    }

    // Use the enumeration flags to indicate that this method exposes shared 
    // state, self-affecting threading, and the security infrastructure.
    [HostProtectionAttribute(SharedState=true, SelfAffectingThreading=true,
         SecurityInfrastructure=true)]
    // ApplyIdentity sets the current identity.
    private static int ApplyIdentity()
    {
        string[] roles = {"User"};
        try
        {
            AppDomain mAD = AppDomain.CurrentDomain;
            GenericPrincipal mGenPr = 
                new GenericPrincipal(WindowsIdentity.GetCurrent(), roles);
            mAD.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
            mAD.SetThreadPrincipal(mGenPr);
            return Success;
        }
        catch (Exception e)
        {
            Exit(e.ToString(), 5);
        }
        return 0;
    }

    // The following method is started on a separate thread.
    public static void WatchFileEvents()
    {
        try
        {
            Console.WriteLine("In the child thread.");
            FileSystemWatcher watcher = new FileSystemWatcher();
            watcher.Path = "C:\\Temp";

            // Watch for changes in LastAccess and LastWrite times, and
            // name changes to files or directories.
            watcher.NotifyFilter = NotifyFilters.LastAccess 
                | NotifyFilters.LastWrite
                | NotifyFilters.FileName | NotifyFilters.DirectoryName;

            // Watch only text files.
            watcher.Filter = "*.txt";

            // Add event handlers.
            watcher.Changed += new FileSystemEventHandler(OnChanged);
            watcher.Created += new FileSystemEventHandler(OnChanged);
            watcher.Deleted += new FileSystemEventHandler(OnChanged);

            // Begin watching.
            watcher.EnableRaisingEvents = true;

            // Wait for the user to quit the program.
            Console.WriteLine("Event handlers have been enabled.");
            while(Console.Read()!='q');
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }

    // Use the enumeration flags to indicate that this method exposes 
    // synchronization and external threading.
    [HostProtectionAttribute(Synchronization=true, ExternalThreading=true)]
    private static void StartThread()
    {
        Thread t = new Thread(new ThreadStart(WatchFileEvents));

        // Start the new thread. On a uniprocessor, the thread is not given
        // any processor time until the main thread yields the processor.
        t.Start();

        // Give the new thread a chance to execute.
        Thread.Sleep(1000);
    }

    // Call methods that show the use of the HostProtectionResource enumeration.
    [HostProtectionAttribute(Resources=HostProtectionResource.All)]
    static int Main(string [] args)
    {
        try
        {
            // Show use of the HostProtectionResource.SharedState,
            // HostProtectionResource.SelfAffectingThreading, and
            // HostProtectionResource.Security enumeration values.
            ApplyIdentity();
            Directory.CreateDirectory("C:\\Temp");

            // Show use of the HostProtectionResource.Synchronization and
            // HostProtectionResource.ExternalThreading enumeration values.
            StartThread();
            Console.WriteLine("In the main thread.");
            Console.WriteLine("Deleting and creating 'MyTestFile.txt'.");
            if (File.Exists("C:\\Temp\\MyTestFile.txt"))
            {
                File.Delete("C:\\Temp\\MyTestFile.txt");
            }

            StreamWriter sr = File.CreateText("C:\\Temp\\MyTestFile.txt");
            sr.WriteLine ("This is my file.");
            sr.Close();
            Thread.Sleep(1000);

            // Show use of the HostProtectionResource.SharedState,
            // HostProtectionResource.SelfProcessMgmt,
            // HostProtectionResource.SelfAffectingThreading, and
            // HostProtectionResource.UI enumeration values.
            ExecuteBreak();

            // Show the use of the 
            // HostProtectionResource.ExternalProcessManagement 
            // enumeration value.
            MyControl myControl = new MyControl ();
            Console.WriteLine ("Enter 'q' to quit the sample.");
            return 100;
        }
        catch (Exception e)
        {
            Exit(e.ToString(), 0);
            return 0;
        }
    }

    // Define the event handlers.
    private static void OnChanged(object source, FileSystemEventArgs e)
    {
        // Specify whether a file is changed, created, or deleted.
        Console.WriteLine("In the OnChanged event handler.");
        Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
    }
}

// The following class is an example of code that exposes 
// external process management.
// Add the LicenseProviderAttribute to the control.
[LicenseProvider (typeof(LicFileLicenseProvider))]
public class MyControl : System.Windows.Forms.Control
{
    // Create a new, null license.
    private License license = null;

    [HostProtection (ExternalProcessMgmt = true)]
    public MyControl ()
    {
        // Determine if a valid license can be granted.
        bool isValid = LicenseManager.IsValid (typeof(MyControl));
        Console.WriteLine ("The result of the IsValid method call is " + 
            isValid.ToString ());
    }

    protected override void Dispose (bool disposing)
    {
        if (disposing)
        {
            if (license != null)
            {
                license.Dispose ();
                license = null;
            }
        }
    }
}


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

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

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft