IsolatedStorageContainment Enumeration

Definition

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

Vererbung

Object

ValueType

Enum

IsolatedStorageContainment

Attribute

ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Felder

Beispiele

In diesem Beispiel wird gezeigt, wie sie der CLR mitteilen, dass code in dieser Assembly die IsolatedStoragePermission benötigt, und zeigt auch, wie geschrieben und aus isoliertem Speicher gelesen werden kann.

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.

Hinweise

Der isolierte Speicher verwendet Beweise, um einen eindeutigen Speicherbereich für die Verwendung durch eine Anwendung oder Komponente zu bestimmen. Die Identität einer Assembly bestimmt eindeutig den Stamm eines virtuellen Dateisystems für die Verwendung durch diese Assembly. Daher verfügt jede Anwendung anstelle vieler Anwendungen und Komponenten, die eine gemeinsame Ressource wie das Dateisystem oder die Registrierung gemeinsam nutzen, über einen eigenen Dateibereich, der ihr von Natur aus zugewiesen ist.

Beim Zuweisen von isoliertem Speicher werden vier grundlegende Isolationsbereiche verwendet:

• User - Code wird immer entsprechend dem aktuellen Benutzer erfasst. Dieselbe Assembly erhält unterschiedliche Speicher, wenn sie von verschiedenen Benutzern ausgeführt wird.

• Machine - Code wird immer entsprechend dem Computer erfasst. Dieselbe Assembly erhält dieselben Speicher, wenn sie von verschiedenen Benutzern auf demselben Computer ausgeführt wird.

• Assembly– Code wird kryptografisch durch einen starken Namen (z. B. Microsoft.Office.* oder Microsoft.Office.Word), durch Herausgeber (basierend auf öffentlichem Schlüssel), durch URL (z. B. http://www.fourthcoffee.com/process/grind.htm), nach Website oder nach Zone identifiziert.

• Domain – Code wird anhand von Beweisen identifiziert, die der Anwendungsdomäne zugeordnet sind. Die Webanwendungsidentität wird von der URL der Website oder von der URL, Website oder Zone der Webseite abgeleitet. Die lokale Codeidentität basiert auf dem Anwendungsverzeichnispfad.

Definitionen für URL, Website und Zone finden Sie unter UrlIdentityPermission, SiteIdentityPermissionund ZoneIdentityPermission.

Diese Identitäten werden gruppiert. In diesem Fall werden die Identitäten nacheinander angewendet, bis der gewünschte isolierte Speicher erstellt wird. Die gültigen Gruppierungen sind Benutzer+Assembly und Benutzer+Assembly+Domäne. Diese Gruppierung von Identitäten ist in vielen verschiedenen Anwendungen nützlich.

Wenn Daten nach Domäne, Benutzer und Assembly gespeichert werden, sind die Daten privat, da nur Code in dieser Assembly auf die Daten zugreifen kann. Der Datenspeicher wird auch von der Anwendung isoliert, in der er ausgeführt wird, sodass die Assembly kein potenzielles Leck darstellt, indem Daten für andere Anwendungen verfügbar sind.

Die Isolation nach Assembly und Benutzer kann für Benutzerdaten verwendet werden, die für mehrere Anwendungen gelten. z. B. Lizenzinformationen oder die persönlichen Informationen eines Benutzers (Name, Authentifizierungsanmeldeinformationen usw.), die unabhängig von einer Anwendung sind.

IsolatedStorageContainment macht Flags verfügbar, die bestimmen, ob eine Anwendung isolierten Speicher verwenden darf und wenn ja, welche Identitätskombinationen ihn verwenden dürfen. Außerdem wird bestimmt, ob eine Anwendung Informationen an einem Speicherort speichern darf, der mit einem Benutzer verschoben werden kann (Windows-Roamingbenutzerprofile oder Ordnerumleitung müssen konfiguriert werden).

Gilt für:

Weitere Informationen

• IsolatedStoragePermission
• IsolatedStoragePermissionAttribute
• IsolatedStorageFilePermission
• IsolatedStorageFilePermissionAttribute