IsolatedStorageContainment Énumération

Référence

Définition

Espace de noms:: System.Security.Permissions

Assembly:: System.Security.Permissions.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Attention

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

Spécifie l'utilisation autorisée du stockage isolé.

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

Héritage: Object

ValueType

Enum
IsolatedStorageContainment

Attributs: ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Champs

AdministerIsolatedStorageByUser	112	Possibilités d'administration illimitées pour le magasin de données de l'utilisateur. Permet la consultation et la suppression de l'ensemble du magasin de données de l'utilisateur, mais pas l'accès en lecture autre que l'identité de domaine/assembly propre à cet utilisateur.
ApplicationIsolationByMachine	69	Le stockage est isolé d'abord par l'ordinateur puis par l'application. Propose un magasin de données pour l'application qui est accessible dans n'importe quel contexte de domaine. Le compartimentage de données par application nécessite une confiance supplémentaire car cela fournit potentiellement un « tunnel » entre applications qui pourrait compromettre l'isolation des données d'applications, en particulier les sites Web.
ApplicationIsolationByRoamingUser	101	Le stockage est isolé d'abord par l'utilisateur puis par les preuves d'applications. Le Stockage est itinérant si un profil d'utilisateur itinérant Windows est activé. Propose un magasin de données pour l'application qui est accessible dans n'importe quel contexte de domaine. Le compartimentage de données par application nécessite une confiance supplémentaire car cela fournit potentiellement un « tunnel » entre applications qui pourrait compromettre l'isolation des données d'applications, en particulier les sites Web.
ApplicationIsolationByUser	21	Le stockage est isolé d'abord par l'utilisateur puis par l'application. Le stockage est également isolé par ordinateur. Propose un magasin de données pour l'application qui est accessible dans n'importe quel contexte de domaine. Le compartimentage de données par application nécessite une confiance supplémentaire car cela fournit potentiellement un « tunnel » entre applications qui pourrait compromettre l'isolation des données d'applications, en particulier les sites Web.
AssemblyIsolationByMachine	64	Le stockage est isolé d'abord par l'ordinateur puis par l'assembly de code. Propose un magasin de données pour l'assembly qui est accessible dans n'importe quel contexte de domaine. Le compartimentage de données par assembly nécessite une confiance supplémentaire car cela fournit potentiellement un « tunnel » entre applications qui pourrait compromettre l'isolation des données d'applications, en particulier les sites Web.
AssemblyIsolationByRoamingUser	96	Le stockage est isolé d'abord par l'utilisateur puis par les preuves d'assemblys. Le Stockage est itinérant si un profil d'utilisateur itinérant Windows est activé. Propose un magasin de données pour l'assembly qui est accessible dans n'importe quel contexte de domaine. Le compartimentage de données par assembly nécessite une confiance supplémentaire car cela fournit potentiellement un « tunnel » entre applications qui pourrait compromettre l'isolation des données d'applications, en particulier les sites Web.
AssemblyIsolationByUser	32	Le stockage est isolé d'abord par l'utilisateur puis par l'assembly de code. Le stockage est également isolé par ordinateur. Propose un magasin de données pour l'assembly qui est accessible dans n'importe quel contexte de domaine. Le compartimentage de données par assembly nécessite une confiance supplémentaire car cela fournit potentiellement un « tunnel » entre applications qui pourrait compromettre l'isolation des données d'applications, en particulier les sites Web.
DomainIsolationByMachine	48	Le stockage est isolé d'abord par ordinateur, puis par domaine et par assembly. Les données peuvent faire l'objet d'un accès uniquement dans le contexte d'une même application et lorsqu'elles sont exécutées sur le même ordinateur. Ce mécanisme est utile lorsqu'un assembly tiers souhaite conserver un magasin de données privé.
DomainIsolationByRoamingUser	80	Le stockage est isolé d'abord par utilisateur, puis par domaine et par assembly. Le Stockage est itinérant si un profil d'utilisateur itinérant Windows est activé. Les données peuvent faire l'objet d'un accès uniquement dans le contexte d'une même application et lorsqu'elles sont exécutées par le même utilisateur. Ce mécanisme est utile lorsqu'un assembly tiers souhaite conserver un magasin de données privé.
DomainIsolationByUser	16	Le stockage est isolé d'abord par utilisateur, puis par domaine et par assembly. Le stockage est également isolé par ordinateur. Les données peuvent faire l'objet d'un accès uniquement dans le contexte d'une même application et lorsqu'elles sont exécutées par le même utilisateur. Ce mécanisme est utile lorsqu'un assembly tiers souhaite conserver un magasin de données privé.
None	0	L'utilisation du stockage isolé n'est pas autorisée.
UnrestrictedIsolatedStorage	240	L'utilisation du stockage isolé est autorisée sans restriction. Le code dispose d'un accès complet à toute partie du magasin utilisateur, quelle que soit l'identité du domaine ou de l'assembly. Cette utilisation du stockage isolé comprend la possibilité d'énumérer le contenu du magasin de données en stockage isolé.

Exemples

Cet exemple montre comment indiquer au CLR que le code de cet assembly nécessite et IsolatedStoragePermission montre également comment écrire et lire à partir d’un stockage isolé.

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.

Remarques

Le stockage isolé utilise des preuves pour déterminer une zone de stockage unique à utiliser par une application ou un composant. L’identité d’un assembly détermine de manière unique la racine d’un système de fichiers virtuel à utiliser par cet assembly. Par conséquent, plutôt que de nombreuses applications et composants partageant une ressource commune telle que le système de fichiers ou le registre, chacun a sa propre zone de fichier affectée par nature.

Quatre étendues d’isolation de base sont utilisées lors de l’attribution d’un stockage isolé :

User - Le code est toujours limité en fonction de l’utilisateur actuel. Le même assembly reçoit des magasins différents lors de l’exécution par différents utilisateurs.
Machine - Le code est toujours limité en fonction de l’ordinateur. Le même assembly reçoit les mêmes magasins lors de l’exécution par différents utilisateurs sur le même ordinateur.
Assembly- Le code est identifié par chiffrement par nom fort (par exemple, Microsoft.Office.* ou Microsoft.Office. Word), par éditeur (basé sur une clé publique), par URL (par exemple, http://www.fourthcoffee.com/process/grind.htm), par site ou par zone.
Domain - Le code est identifié en fonction des preuves associées au domaine d’application. L’identité de l’application web est dérivée de l’URL du site ou de l’URL, du site ou de la zone de la page Web. L’identité de code local est basée sur le chemin d’accès au répertoire de l’application.

Pour connaître les définitions d’URL, de site et de zone, consultez UrlIdentityPermission, SiteIdentityPermissionet ZoneIdentityPermission.

Ces identités sont regroupées, auquel cas les identités sont appliquées les unes après les autres jusqu’à ce que le stockage isolé souhaité soit créé. Les regroupements valides sont User+Assembly et User+Assembly+Domain. Ce regroupement d’identités est utile dans de nombreuses applications différentes.

Si les données sont stockées par domaine, utilisateur et assembly, les données sont privées dans ce seul code de cet assembly peuvent accéder aux données. Le magasin de données est également isolé par l’application dans laquelle il s’exécute, de sorte que l’assembly ne représente pas une fuite potentielle en exposant des données à d’autres applications.

L’isolation par assembly et utilisateur peut être utilisée pour les données utilisateur qui s’appliquent à plusieurs applications ; par exemple, les informations de licence ou les informations personnelles d’un utilisateur (nom, informations d’identification d’authentification, et ainsi de suite) indépendantes d’une application.

IsolatedStorageContainment expose des indicateurs qui déterminent si une application est autorisée à utiliser un stockage isolé et, le cas échéant, quelles combinaisons d’identités sont autorisées à l’utiliser. Il détermine également si une application est autorisée à stocker des informations dans un emplacement qui peut se déplacer avec un utilisateur (Windows profils utilisateur itinérants ou redirection de dossiers doit être configurée).

S’applique à