Partager via


IsolatedStorageContainment Énumération

Définition

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
[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
Héritage
IsolatedStorageContainment
Attributs

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 le IsolatedStoragePermission et 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

Attention

La sécurité d’accès du code (CAS) a été déconseillée dans toutes les versions du .NET Framework et de .NET. Les versions récentes de .NET ne respectent pas les annotations CAS et produisent des erreurs si les API liées à CAS sont utilisées. Les développeurs doivent chercher d’autres moyens pour accomplir les tâches liées à la sécurité.

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. Ainsi, 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 fichiers intrinsèquement affectée.

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

  • User - Le code est toujours délimité en fonction de l’utilisateur actuel. Le même assembly reçoit des magasins différents lorsqu’il est exécuté par différents utilisateurs.

  • Machine - Le code est toujours délimité en fonction de la machine. Le même assembly recevra les mêmes magasins lorsqu’il est exécuté 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 (en fonction de la 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é du code local est basée sur le chemin du répertoire de l’application.

Pour obtenir des 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, car seul le code de cet assembly peut 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 par 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, etc.) 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, les combinaisons d’identités autorisées à l’utiliser. Il détermine également si une application est autorisée à stocker des informations dans un emplacement qui peut être itinérant avec un utilisateur (les profils utilisateur itinérants Windows ou la redirection de dossiers doivent être configurés).

S’applique à

Voir aussi