IsolatedStorageContainment Enumerazione

Definizione

public enum class 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

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}")>]
type IsolatedStorageContainment = 

[<System.Serializable>]
type IsolatedStorageContainment = 

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

type IsolatedStorageContainment = 

Public Enum IsolatedStorageContainment

Ereditarietà

Object

ValueType

Enum

IsolatedStorageContainment

Attributi

ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Campi

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

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), dal server di pubblicazione (basato sulla chiave pubblica), dall'URL (ad esempio, http://www.fourthcoffee.com/process/grind.htm), dal sito o dalla 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 possono 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

Vedi anche

• IsolatedStoragePermission
• IsolatedStoragePermissionAttribute
• IsolatedStorageFilePermission
• IsolatedStorageFilePermissionAttribute