IsolatedStorageContainment Enumerazione

Riferimento

Definizione

Spazio dei nomi:: System.Security.Permissions

Assembly:: System.Security.Permissions.dll

Assembly:: mscorlib.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Attenzione

Code Access Security is not supported or honored by the runtime.

Specifica l'utilizzo consentito dello spazio di memorizzazione isolato.

public enum class IsolatedStorageContainment

public enum IsolatedStorageContainment

[System.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public enum IsolatedStorageContainment

[System.Serializable]
public enum IsolatedStorageContainment

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum IsolatedStorageContainment

type IsolatedStorageContainment =

[<System.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
type IsolatedStorageContainment =

[<System.Serializable>]
type IsolatedStorageContainment =

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type IsolatedStorageContainment =

Public Enum IsolatedStorageContainment

Ereditarietà: Object

ValueType

Enum
IsolatedStorageContainment

Attributi: ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Campi

AdministerIsolatedStorageByUser	112	Capacità amministrative illimitate per l’archivio utente. Consente di sfogliare ed eliminare tutto l'archivio utente, ma concede l’accesso in lettura solo all'identità dominio/assembly dell'utente.
ApplicationIsolationByMachine	69	L'archiviazione è isolata innanzitutto in base al computer, quindi all'applicazione. In questo modo è disponibile un archivio dati per l'applicazione accessibile in qualsiasi contesto di dominio. Il contesto dati per applicazione richiede ulteriore attendibilità in quanto fornisce un potenziale tunnel tra le applicazioni che può compromettere l'isolamento dei dati in particolari siti Web.
ApplicationIsolationByRoamingUser	101	L'archiviazione è isolata innanzitutto in base all'utente, quindi all'evidenza dell'applicazione. e diventa comune se è abilitato il profilo comune dei dati utente Windows. In questo modo è disponibile un archivio dati per l'applicazione accessibile in qualsiasi contesto di dominio. Il contesto dati per applicazione richiede ulteriore attendibilità in quanto fornisce un potenziale tunnel tra le applicazioni che può compromettere l'isolamento dei dati in particolari siti Web.
ApplicationIsolationByUser	21	L'archiviazione è isolata innanzitutto in base all'utente, quindi all'applicazione. nonché al computer. In questo modo è disponibile un archivio dati per l'applicazione accessibile in qualsiasi contesto di dominio. Il contesto dati per applicazione richiede ulteriore attendibilità in quanto fornisce un potenziale tunnel tra le applicazioni che può compromettere l'isolamento dei dati in particolari siti Web.
AssemblyIsolationByMachine	64	L'archiviazione è isolata innanzitutto in base al computer, quindi all’assembly di codice. In questo modo è disponibile un archivio dati per l'assembly accessibile in qualsiasi contesto di dominio. Il contesto dati per assembly richiede ulteriore attendibilità in quanto fornisce un potenziale tunnel tra le applicazioni che può compromettere l'isolamento dei dati in particolari siti Web.
AssemblyIsolationByRoamingUser	96	L'archiviazione è isolata innanzitutto in base all'utente, quindi all'evidenza dell'assembly e diventa comune se è abilitato il profilo comune dei dati utente Windows. In questo modo è disponibile un archivio dati per l'assembly accessibile in qualsiasi contesto di dominio. Il contesto dati per assembly richiede ulteriore attendibilità in quanto fornisce un potenziale tunnel tra le applicazioni che può compromettere l'isolamento dei dati in particolari siti Web.
AssemblyIsolationByUser	32	L'archiviazione è isolata in base all’utente e all’assembly, nonché al computer. In questo modo è disponibile un archivio dati per l'assembly accessibile in qualsiasi contesto di dominio. Il contesto dati per assembly richiede ulteriore attendibilità in quanto fornisce un potenziale tunnel tra le applicazioni che può compromettere l'isolamento dei dati in particolari siti Web.
DomainIsolationByMachine	48	L'archiviazione è isolata innanzitutto in base al computer, quindi al dominio e all’assembly. È possibile accedere ai dati solo nel contesto della stessa applicazione e solo se questa viene eseguita sullo stesso computer. Questa possibilità risulta utile quando è richiesta la gestione di un archivio dati privato per un assembly di terze parti.
DomainIsolationByRoamingUser	80	L'archiviazione è isolata in base all’utente, al dominio e all’assembly, e diventa comune se è abilitato il profilo comune dei dati utente Windows. È possibile accedere ai dati solo nel contesto della stessa applicazione e solo se eseguita dallo stesso utente. Questa possibilità risulta utile quando è richiesta la gestione di un archivio dati privato per un assembly di terze parti.
DomainIsolationByUser	16	L'archiviazione è isolata in base all’utente, al dominio e all’assembly, nonché al computer. È possibile accedere ai dati solo nel contesto della stessa applicazione e solo se eseguita dallo stesso utente. Questa possibilità risulta utile quando è richiesta la gestione di un archivio dati privato per un assembly di terze parti.
None	0	Non è consentito l'utilizzo dello spazio di memorizzazione isolato.
UnrestrictedIsolatedStorage	240	L'utilizzo dello spazio di memorizzazione isolato è consentito senza restrizioni. Con il codice si dispone di accesso completo a qualsiasi parte dell'archivio utente, indipendentemente dall'identità del dominio o dell'assembly. Questo utilizzo dello spazio di memorizzazione isolato include la capacità di enumerare i contenuti dell'archivio dati dello spazio di memorizzazione isolato.

Esempio

In questo esempio viene illustrato come indicare a CLR che il codice in questo assembly richiede IsolatedStoragePermission e illustra anche come scrivere e leggere dall'archiviazione isolata.

using namespace System;
using namespace System::Security;
using namespace System::Security::Permissions;
using namespace System::IO::IsolatedStorage;
using namespace System::IO;


static void WriteIsolatedStorage()
{
    try
    {
        // Attempt to create a storage file that is isolated by
        // user and assembly. IsolatedStorageFilePermission
        // granted to the attribute at the top of this file
        // allows CLR to load this assembly and execution of this
        // statement.
        Stream^ fileCreateStream = gcnew
            IsolatedStorageFileStream(
            "AssemblyData",
            FileMode::Create,
            IsolatedStorageFile::GetUserStoreForAssembly());

        StreamWriter^ streamWriter = gcnew StreamWriter(
            fileCreateStream);
        try
        {
            // Write some data out to the isolated file.

            streamWriter->Write("This is some test data.");
            streamWriter->Close();	
        }
        finally
        {
            delete fileCreateStream;
            delete streamWriter;
        } 
    }
    catch (IOException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    try
    {
        Stream^ fileOpenStream =
            gcnew IsolatedStorageFileStream(
            "AssemblyData",
            FileMode::Open,
            IsolatedStorageFile::GetUserStoreForAssembly());
        // Attempt to open the file that was previously created.

        StreamReader^ streamReader = gcnew StreamReader(
            fileOpenStream);
        try
        { 
            // Read the data from the file and display it.

            Console::WriteLine(streamReader->ReadLine());
            streamReader->Close();
        }
        finally
        {
            delete fileOpenStream;
            delete streamReader;
        }
    }
    catch (FileNotFoundException^ ex)
    {
        Console::WriteLine(ex->Message);
    }
    catch (IOException^ ex)
    {
        Console::WriteLine(ex->Message);
    }
}
// Notify the CLR to only grant IsolatedStorageFilePermission to called methods. 
// This restricts the called methods to working only with storage files that are isolated 
// by user and assembly.
[IsolatedStorageFilePermission(SecurityAction::PermitOnly, UsageAllowed = IsolatedStorageContainment::AssemblyIsolationByUser)]
int main()
{
    WriteIsolatedStorage();
}

// This code produces the following output.
//
//  This is some test data.

using System;
using System.Security.Permissions;
using System.IO.IsolatedStorage;
using System.IO;

// Notify the CLR to only grant IsolatedStorageFilePermission to called methods.
// This restricts the called methods to working only with storage files that are isolated
// by user and assembly.
[IsolatedStorageFilePermission(SecurityAction.PermitOnly, UsageAllowed = IsolatedStorageContainment.AssemblyIsolationByUser)]
public sealed class App
{
    static void Main()
    {
        WriteIsolatedStorage();
    }
    private static void WriteIsolatedStorage()
    {
        // Attempt to create a storage file that is isolated by user and assembly.
        // IsolatedStorageFilePermission granted to the attribute at the top of this file
        // allows CLR to load this assembly and execution of this statement.
        using (Stream s = new IsolatedStorageFileStream("AssemblyData", FileMode.Create, IsolatedStorageFile.GetUserStoreForAssembly()))
        {

            // Write some data out to the isolated file.
            using (StreamWriter sw = new StreamWriter(s))
            {
                sw.Write("This is some test data.");
            }
        }

        // Attempt to open the file that was previously created.
        using (Stream s = new IsolatedStorageFileStream("AssemblyData", FileMode.Open, IsolatedStorageFile.GetUserStoreForAssembly()))
        {
            // Read the data from the file and display it.
            using (StreamReader sr = new StreamReader(s))
            {
                Console.WriteLine(sr.ReadLine());
            }
        }
    }
}

// This code produces the following output.
//
//  Some test data.

Option Strict On
Imports System.Security.Permissions
Imports System.IO.IsolatedStorage
Imports System.IO


' Notify the CLR to only grant IsolatedStorageFilePermission to called methods. 
' This restricts the called methods to working only with storage files that are isolated 
' by user and assembly.
<IsolatedStorageFilePermission(SecurityAction.PermitOnly, UsageAllowed:=IsolatedStorageContainment.AssemblyIsolationByUser)> _
Public NotInheritable Class App

    Shared Sub Main()
        WriteIsolatedStorage()
    End Sub
    Shared Sub WriteIsolatedStorage()
        ' Attempt to create a storage file that is isolated by user and assembly.
        ' IsolatedStorageFilePermission granted to the attribute at the top of this file 
        ' allows CLR to load this assembly and execution of this statement.
        Dim s As New IsolatedStorageFileStream("AssemblyData", FileMode.Create, IsolatedStorageFile.GetUserStoreForAssembly())
        Try

            ' Write some data out to the isolated file.
            Dim sw As New StreamWriter(s)
            Try
                sw.Write("This is some test data.")
            Finally
                sw.Dispose()
            End Try
        Finally
            s.Dispose()
        End Try

        ' Attempt to open the file that was previously created.
        Dim t As New IsolatedStorageFileStream("AssemblyData", FileMode.Open, IsolatedStorageFile.GetUserStoreForAssembly())
        Try
            ' Read the data from the file and display it.
            Dim sr As New StreamReader(t)
            Try
                Console.WriteLine(sr.ReadLine())
            Finally
                sr.Dispose()
            End Try
        Finally
            t.Dispose()
        End Try

    End Sub
End Class

' This code produces the following output.
'
'  Some test data.

Commenti

Attenzione

La sicurezza dall'accesso al codice è stata deprecata in tutte le versioni di .NET Framework e .NET. Le versioni recenti di .NET non rispettano le annotazioni CAS e generano errori se vengono usate API correlate a CAS. Gli sviluppatori devono cercare metodi alternativi per eseguire attività di sicurezza.

L'archiviazione isolata usa l'evidenza per determinare un'area di archiviazione univoca per l'uso da parte di un'applicazione o di un componente. L'identità di un assembly determina in modo univoco la radice di un file system virtuale da utilizzare da tale assembly. Pertanto, anziché molte applicazioni e componenti che condividono una risorsa comune, ad esempio il file system o il Registro di sistema, ognuno ha una propria area file intrinsecamente assegnata.

Durante l'assegnazione dello spazio di memorizzazione isolato vengono usati quattro ambiti di isolamento di base:

User - Il codice è sempre con ambito in base all'utente corrente. Lo stesso assembly riceverà archivi diversi quando vengono eseguiti da utenti diversi.
Machine - Il codice è sempre con ambito in base al computer. Lo stesso assembly riceverà gli stessi archivi quando vengono eseguiti da utenti diversi nello stesso computer.
Assembly- Il codice viene identificato crittograficamente in base al nome sicuro (ad esempio, Microsoft. Office.* o Microsoft. Office.Word), per autore (basato sulla chiave pubblica), per URL (ad esempio, http://www.fourthcoffee.com/process/grind.htm), per sito o per zona.
Domain - Il codice viene identificato in base all'evidenza associata al dominio dell'applicazione. L'identità dell'applicazione Web è derivata dall'URL del sito o dall'URL, dal sito o dall'area della pagina Web. L'identità del codice locale si basa sul percorso della directory dell'applicazione.

Per le definizioni di URL, sito e zona, vedere UrlIdentityPermission, SiteIdentityPermissione ZoneIdentityPermission.

Queste identità vengono raggruppate, nel qual caso le identità vengono applicate una dopo l'altra fino alla creazione dell'archiviazione isolata desiderata. I raggruppamenti validi sono User+Assembly e User+Assembly+Domain. Questo raggruppamento di identità è utile in molte applicazioni diverse.

Se i dati vengono archiviati da dominio, utente e assembly, i dati sono privati in tale solo codice in tale assembly può accedere ai dati. L'archivio dati è isolato anche dall'applicazione in cui viene eseguita, in modo che l'assembly non rappresenti una potenziale perdita esponendo i dati ad altre applicazioni.

L'isolamento in base all'assembly e all'utente può essere usato per i dati utente che si applicano a più applicazioni; Ad esempio, le informazioni sulla licenza o le informazioni personali di un utente (nome, credenziali di autenticazione e così via) indipendenti da un'applicazione.

IsolatedStorageContainment espone i flag che determinano se un'applicazione può usare lo spazio di memorizzazione isolato e, in tal caso, quali combinazioni di identità sono autorizzate a usarlo. Determina anche se un'applicazione può archiviare le informazioni in un percorso in cui è possibile eseguire il roaming con un utente (è necessario configurare profili utente mobili di Windows o reindirizzamento cartelle).

Si applica a