Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

HostProtectionAttribute, classe

Autorise l'utilisation d'actions de sécurité déclarative pour déterminer les exigences de protection de l'hôte. Cette classe ne peut pas être héritée.

Espace de noms :  System.Security.Permissions
Assembly :  mscorlib (dans 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

Le type HostProtectionAttribute expose les membres suivants.

  NomDescription
Méthode publiqueHostProtectionAttribute()Initialise une nouvelle instance de la classe HostProtectionAttribute avec les valeurs par défaut.
Méthode publiqueHostProtectionAttribute(SecurityAction)Initialise une nouvelle instance de la classe HostProtectionAttribute avec la valeur SecurityAction spécifiée.
Début

  NomDescription
Propriété publiqueActionObtient ou définit une action de sécurité. (Hérité de SecurityAttribute.)
Propriété publiqueExternalProcessMgmtObtient ou définit une valeur qui indique si la gestion du processus externe est exposée.
Propriété publiqueExternalThreadingObtient ou définit une valeur qui indique si les threads externes sont exposés.
Propriété publiqueMayLeakOnAbortObtient ou définit une valeur qui indique si les ressources peuvent avoir une fuite de mémoire si l'opération est arrêtée.
Propriété publiqueResourcesObtient ou définit des indicateurs qui spécifient des catégories de fonctionnalités potentiellement dangereuses pour l'hôte.
Propriété publiqueSecurityInfrastructureObtient ou définit une valeur qui indique si l'infrastructure de sécurité est exposée.
Propriété publiqueSelfAffectingProcessMgmtObtient ou définit une valeur qui indique si la gestion du processus à affectation automatique est exposée.
Propriété publiqueSelfAffectingThreadingObtient ou définit une valeur qui indique si les threads à affectation automatique sont exposés.
Propriété publiqueSharedStateObtient ou définit une valeur qui indique si l'état partagé est exposé.
Propriété publiqueSynchronizationObtient ou définit une valeur qui indique si la synchronisation est exposée.
Propriété publiqueTypeIdLors de son implémentation dans une classe dérivée, obtient un identificateur unique pour Attribute. (Hérité de Attribute.)
Propriété publiqueUIObtient ou définit une valeur qui indique si l'interface utilisateur est exposée.
Propriété publiqueUnrestrictedObtient ou définit une valeur indiquant si l'autorisation complète (sans restriction) d'accès à la ressource protégée par l'attribut est déclarée. (Hérité de SecurityAttribute.)
Début

  NomDescription
Méthode publiqueCreatePermissionCrée et retourne une nouvelle autorisation de protection hôte. (Substitue SecurityAttribute.CreatePermission().)
Méthode publiqueEqualsInfrastructure. Retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute.)
Méthode publiqueGetHashCodeRetourne le code de hachage de cette instance. (Hérité de Attribute.)
Méthode publiqueGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueIsDefaultAttributeEn cas de substitution dans une classe dérivée, indique si la valeur de cette instance est la valeur par défaut pour la classe dérivée. (Hérité de Attribute.)
Méthode publiqueMatchEn cas de substitution dans une classe dérivée, retourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de Attribute.)
Méthode publiqueToStringRetourne une chaîne qui représente l'objet actif. (Hérité de Object.)
Début

  NomDescription
Implémentation d'interface expliciteMéthode privée_Attribute.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de Attribute.)
Implémentation d'interface expliciteMéthode privée_Attribute.GetTypeInfoRécupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface. (Hérité de Attribute.)
Implémentation d'interface expliciteMéthode privée_Attribute.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de Attribute.)
Implémentation d'interface expliciteMéthode privée_Attribute.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de Attribute.)
Début

Cet attribut n'affecte que les applications non managées, telles que SQL Server, qui hébergent le Common Language Runtime et implémentent la protection de l'hôte. Si le code est exécuté dans une application cliente ou sur un serveur sans protection de l'hôte, l'attribut « s'évapore » ; non détecté, il ne peut pas s'appliquer. Lorsque qu'elle s'applique, l'action de sécurité crée une demande de liaison sur la base des ressources hôte que la classe ou la méthode expose.

Remarque importanteImportant

Cet attribut a pour but de permettre de suivre un modèle de programmation spécifique de l'hôte et non d'adopter un comportement de sécurité. Bien qu'une demande de liaison vérifie la conformité aux exigences en matière de modèle de programmation, HostProtectionAttribute n'est pas une autorisation de sécurité.

Si l'hôte n'a pas d'exigences en modèle de programmation, il n'y a pas de demande de liaison.

Cet attribut identifie les éléments suivants :

  • Méthodes ou classes qui ne correspondent pas au modèle de programmation hôte, mais sans gravité par ailleurs.

  • Méthodes ou classes qui ne correspondent pas au modèle de programmation hôte et pourraient déstabiliser le code utilisateur géré par le serveur.

  • Méthodes ou classes qui ne correspondent pas au modèle de programmation hôte et pourraient mener à une déstabilisation du processus serveur lui-même.

RemarqueRemarque

Si vous créez une bibliothèque de classes destinée à être appelée par des applications exécutables dans un environnement protégé par un hôte, vous devez appliquer cet attribut aux membres qui exposent des catégories de ressources HostProtectionResource. Lorsque des membres de la bibliothèque de classes du .NET Framework ont cet attribut, seul l'appelant immédiat est vérifié. Votre membre de bibliothèque doit également demander une vérification de son appelant immédiat de la même manière.

RemarqueRemarque

N'utilisez pas l'Ngen.exe (Native Image Generator) pour créer une image native des assemblys qui sont protégés par HostProtectionAttribute. Dans un environnement de confiance totale, l'image est systématiquement chargée, indépendamment de HostProtectionAttribute alors que dans un environnement de confiance partielle, l'image n'est pas chargée.

L'exemple de code suivant illustre l'utilisation de l'attribut HostProtectionAttribute avec différentes valeurs HostProtectionResource.


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

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 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 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2015 Microsoft