IsolatedStorageContainment Énumération

Définition

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

Object

ValueType

Enum

IsolatedStorageContainment

Attributs

ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Champs

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

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

• IsolatedStoragePermission
• IsolatedStoragePermissionAttribute
• IsolatedStorageFilePermission
• IsolatedStorageFilePermissionAttribute