Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe HostProtectionAttribute

Consente l'utilizzo di azioni di sicurezza dichiarativa per determinare i requisiti di sicurezza host. Questa classe non può essere ereditata.

Spazio dei nomi:  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

Il tipo HostProtectionAttribute espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoHostProtectionAttribute()Inizializza una nuova istanza della classe HostProtectionAttribute con valori predefiniti.
Metodo pubblicoHostProtectionAttribute(SecurityAction)Inizializza una nuova istanza della classe HostProtectionAttribute con il valore SecurityAction specificato.
In alto

  NomeDescrizione
Proprietà pubblicaActionOttiene o imposta un'azione di sicurezza. (Ereditato da SecurityAttribute)
Proprietà pubblicaExternalProcessMgmtOttiene o imposta un valore che indica se viene esposta la gestione esterna del processo.
Proprietà pubblicaExternalThreadingOttiene o imposta un valore che indica se viene esposto il threading esterno.
Proprietà pubblicaMayLeakOnAbortOttiene o imposta un valore che indica se viene prodotta una perdita di memoria delle risorse al termine dell'operazione.
Proprietà pubblicaResourcesOttiene o imposta i flag che specificano categorie di funzionalità potenzialmente dannose per l'host.
Proprietà pubblicaSecurityInfrastructureOttiene o imposta un valore che indica se viene esposta l'infrastruttura di sicurezza.
Proprietà pubblicaSelfAffectingProcessMgmtOttiene o imposta un valore che indica se viene esposta la gestione dei processi con effetti diretti.
Proprietà pubblicaSelfAffectingThreadingOttiene o imposta un valore che indica se viene esposto il threading con effetti diretti.
Proprietà pubblicaSharedStateOttiene o imposta un valore che indica se viene esposto lo stato condiviso.
Proprietà pubblicaSynchronizationOttiene o imposta un valore che indica se viene esposta la sincronizzazione.
Proprietà pubblicaTypeId Quando implementato in una classe derivata, ottiene un identificatore univoco per questo Attribute. (Ereditato da Attribute)
Proprietà pubblicaUIOttiene o imposta un valore che indica se viene esposta l'interfaccia utente.
Proprietà pubblicaUnrestrictedOttiene o imposta un valore che indica se esiste una dichiarazione di autorizzazione completa, ovvero senza restrizioni, alla risorsa protetta dall’attributo. (Ereditato da SecurityAttribute)
In alto

  NomeDescrizione
Metodo pubblicoCreatePermissionCrea e restituisce una nuova autorizzazione di sicurezza host. (Esegue l'override di SecurityAttribute.CreatePermission()).
Metodo pubblicoEqualsInfrastruttura. Restituisce un valore che indica se l'istanza è uguale ad un oggetto specificato. (Ereditato da Attribute)
Metodo pubblicoGetHashCode Restituisce il codice hash per l'istanza corrente. (Ereditato da Attribute)
Metodo pubblicoGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoIsDefaultAttribute Quando viene eseguito l'override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata. (Ereditato da Attribute)
Metodo pubblicoMatch Quando viene eseguito l'override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato. (Ereditato da Attribute)
Metodo pubblicoToString Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.GetIDsOfNames Esegue il mapping di un set di nomi a un corrispondente set di identificatori di dispatch. (Ereditato da Attribute)
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.GetTypeInfo Recupera le informazioni sui tipi per un oggetto, che possono essere utilizzate per ottenere informazioni sul tipo per un'interfaccia. (Ereditato da Attribute)
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.GetTypeInfoCount Recupera il numero di interfacce di informazioni sui tipi che un oggetto fornisce (0 o 1). (Ereditato da Attribute)
Implementazione esplicita dell'interfacciaMetodo privato_Attribute.Invoke Fornisce l'accesso alle proprietà ed ai metodi esposti da un oggetto. (Ereditato da Attribute)
In alto

Questo attributo influisce solo sulle applicazioni non gestite che contengono il Common Language Runtime e implementano la sicurezza host, come ad esempio SQL Server. Se il codice viene eseguito in un'applicazione client o su un server privo di protezione host, l'attributo non ha alcun effetto. Non viene rilevato e quindi nemmeno applicato. Quando applicata, l'azione di protezione ha per effetto la creazione di una richiesta di collegamento in base alle risorse host esposte dalla classe o dal metodo.

Nota importanteImportante

Lo scopo di questo attributo è di imporre le regole del modello di programmazione specifico per l'host, non il comportamento di sicurezza. Anche se per la verifica della conformità ai requisiti del modello di programmazione viene utilizzata una richiesta di collegamento, la classe HostProtectionAttribute non è un'autorizzazione di sicurezza.

Se l'host non dispone di requisiti del modello di programmazione, non verranno effettuate richieste di collegamento.

Questo attributo consente di identificare:

  • Metodi o classi non idonei per il modello di programmazione dell'host, tuttavia benigni.

  • Metodi o classi che non sono idonei per il modello di programmazione dell'host e che potrebbero portare alla destabilizzazione del codice utente gestito dal server.

  • Metodi o classi che non sono idonei per il modello di programmazione dell'host e che potrebbero portare alla destabilizzazione del processo server stesso.

NotaNota

Se si crea una libreria di classi che verrà chiamata da applicazioni eseguibili in un ambiente host protetto, è necessario applicare questo attributo ai membri che espongono categorie di risorse dell'enumerazione HostProtectionResource. I membri della libreria di classi .NET Framework con questo attributo provocano solo la verifica del chiamante immediato. Analogamente, anche i membri della propria libreria devono determinare il controllo del rispettivo chiamante immediato.

NotaNota

Non utilizzare Ngen.exe (generatore di immagini native) per creare un'immagine nativa di assembly protetti dalla classe HostProtectionAttribute. In un ambiente ad attendibilità totale l'immagine viene sempre caricata, senza tener conto della classe HostProtectionAttribute, mentre in un ambiente ad attendibilità parziale l'immagine non viene caricata.

Nell'esempio di codice riportato di seguito viene illustrato l'utilizzo dell'attributo HostProtectionAttribute con diversi valori di 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

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato 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 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft