IsolatedStorageContainment Enumeración

Definición

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

Herencia

Object

ValueType

Enum

IsolatedStorageContainment

Atributos

ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Campos

Ejemplos

En este ejemplo se muestra cómo indicar al CLR que el código de este ensamblado requiere IsolatedStoragePermission y también muestra cómo escribir y leer desde el almacenamiento aislado.

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.

Comentarios

El almacenamiento aislado usa evidencias para determinar un área de almacenamiento única para su uso por parte de una aplicación o componente. La identidad de un ensamblado determina de forma única la raíz de un sistema de archivos virtual para su uso por ese ensamblado. Por lo tanto, en lugar de muchas aplicaciones y componentes que comparten un recurso común, como el sistema de archivos o el registro, cada uno tiene su propio área de archivo asignada de forma inherente.

Se usan cuatro ámbitos de aislamiento básicos al asignar almacenamiento aislado:

• User - El código siempre se limita según el usuario actual. El mismo ensamblado recibirá diferentes almacenes cuando los distintos usuarios los ejecuten.

• Machine - El código siempre se limita según la máquina. El mismo ensamblado recibirá los mismos almacenes cuando los distintos usuarios ejecuten en el mismo equipo.

• Assembly- El código se identifica criptográficamente por nombre seguro (por ejemplo, Microsoft.Office.* o Microsoft.Office.Word), por publicador (basado en clave pública), por dirección URL (por ejemplo, http://www.fourthcoffee.com/process/grind.htm), por sitio o por zona.

• Domain - El código se identifica en función de la evidencia asociada al dominio de aplicación. La identidad de la aplicación web se deriva de la dirección URL del sitio o de la dirección URL, el sitio o la zona de la página web. La identidad del código local se basa en la ruta de acceso del directorio de la aplicación.

Para obtener definiciones de dirección URL, sitio y zona, vea UrlIdentityPermission, SiteIdentityPermissiony ZoneIdentityPermission.

Estas identidades se agrupan, en cuyo caso las identidades se aplican una después de otra hasta que se crea el almacenamiento aislado deseado. Las agrupaciones válidas son User+Assembly y User+Assembly+Domain. Esta agrupación de identidades es útil en muchas aplicaciones diferentes.

Si los datos se almacenan por dominio, usuario y ensamblado, los datos son privados en ese solo código de ese ensamblado puede acceder a los datos. El almacén de datos también está aislado por la aplicación en la que se ejecuta, de modo que el ensamblado no represente una posible pérdida exponiendo datos a otras aplicaciones.

El aislamiento por ensamblado y usuario podría usarse para los datos de usuario que se aplican en varias aplicaciones; por ejemplo, la información de licencia o la información personal de un usuario (nombre, credenciales de autenticación, etc.) que es independiente de una aplicación.

IsolatedStorageContainment expone marcas que determinan si una aplicación puede usar el almacenamiento aislado y, si es así, qué combinaciones de identidades pueden usarla. También determina si una aplicación puede almacenar información en una ubicación que pueda desplazarse con un usuario (los perfiles de usuario móviles de Windows o el redireccionamiento de carpetas deben estar configurados).

Se aplica a

Consulte también

• IsolatedStoragePermission
• IsolatedStoragePermissionAttribute
• IsolatedStorageFilePermission
• IsolatedStorageFilePermissionAttribute