IsolatedStorageContainment Enumeração

Definição

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

Herança

Object

ValueType

Enum

IsolatedStorageContainment

Atributos

ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Campos

Exemplos

Este exemplo mostra como informar ao CLR que o código neste assembly requer o IsolatedStoragePermission e também demonstra como gravar e ler do armazenamento isolado.

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.

Comentários

O armazenamento isolado usa evidências para determinar uma área de armazenamento exclusiva para uso por um aplicativo ou componente. A identidade de um assembly determina exclusivamente a raiz de um sistema de arquivos virtual para uso por esse assembly. Portanto, em vez de muitos aplicativos e componentes compartilharem um recurso comum, como o sistema de arquivos ou o registro, cada um tem sua própria área de arquivo inerentemente atribuída a ele.

Quatro escopos de isolamento básicos são usados ao atribuir armazenamento isolado:

• User – O código sempre tem escopo de acordo com o usuário atual. O mesmo assembly receberá repositórios diferentes ao ser executado por usuários diferentes.

• Machine – O código sempre tem o escopo definido de acordo com o computador. O mesmo assembly receberá os mesmos repositórios ao ser executado por usuários diferentes no mesmo computador.

• Assembly– O código é identificado criptograficamente por nome forte (por exemplo, Microsoft.Office.* ou Microsoft.Office.Word), por publicador (com base em chave pública), por URL (por exemplo, http://www.fourthcoffee.com/process/grind.htm), por site ou por zona.

• Domain – O código é identificado com base em evidências associadas ao domínio do aplicativo. A identidade do aplicativo Web é derivada da URL do site ou da URL, do site ou da zona da página da Web. A identidade do código local é baseada no caminho do diretório do aplicativo.

Para obter definições de URL, site e zona, consulte UrlIdentityPermission, SiteIdentityPermissione ZoneIdentityPermission.

Essas identidades são agrupadas, caso em que as identidades são aplicadas uma após a outra até que o armazenamento isolado desejado seja criado. Os agrupamentos válidos são User+Assembly e User+Assembly+Domain. Esse agrupamento de identidades é útil em muitos aplicativos diferentes.

Se os dados forem armazenados por domínio, usuário e assembly, os dados serão privados nesse único código nesse assembly poderá acessar os dados. O armazenamento de dados também é isolado pelo aplicativo no qual ele é executado, para que o assembly não represente um possível vazamento expondo dados a outros aplicativos.

O isolamento por assembly e usuário pode ser usado para dados de usuário que se aplicam a vários aplicativos; por exemplo, informações de licença ou informações pessoais de um usuário (nome, credenciais de autenticação e assim por diante) que são independentes de um aplicativo.

IsolatedStorageContainment expõe sinalizadores que determinam se um aplicativo tem permissão para usar o armazenamento isolado e, em caso afirmativo, quais combinações de identidade têm permissão para usá-lo. Ele também determina se um aplicativo tem permissão para armazenar informações em um local que pode fazer roaming com um usuário (Perfis de Usuário Móvel do Windows ou Redirecionamento de Pastas devem ser configurados).

Aplica-se a

Confira também

• IsolatedStoragePermission
• IsolatedStoragePermissionAttribute
• IsolatedStorageFilePermission
• IsolatedStorageFilePermissionAttribute