IsolatedStorageContainment Enumeration

Definition

Namespace:

System.Security.Permissions

Assembly:

System.Security.Permissions.dll

Paket:

System.Security.Permissions v9.0.0-rc.2.24473.5

Quelle:

IsolatedStorageContainment.cs

Achtung

Code Access Security is not supported or honored by the runtime.

Gibt die zulässige Verwendung der isolierten Speicherung an.

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.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
type IsolatedStorageContainment = 

Public Enum IsolatedStorageContainment

Vererbung

Object

ValueType

Enum

IsolatedStorageContainment

Attribute

ObsoleteAttribute

Felder

AdministerIsolatedStorageByUser	112	Uneingeschränkte Verwaltungsmöglichkeiten für den Benutzerspeicher. Ermöglicht das Durchsuchen und Löschen für den gesamten Speicher des Benutzer, gewährt jedoch lediglich den Lesezugriff für die eigene Domänen-/Assemblyidentität des Benutzers.
ApplicationIsolationByMachine	69	Der Speicher wird zuerst nach Computer und dann nach Anwendung isoliert. Dadurch wird der Anwendung ein Datenspeicher bereitgestellt, der vom Kontext einer beliebigen Domäne aus zugänglich ist. Bei einer Einteilung nach Anwendung sind zusätzliche Vertrauensstellungen erforderlich, da hierbei möglicherweise ein "Tunnel" zwischen Anwendungen entsteht, der die Datenisolation von Anwendungen in bestimmten Websites gefährden kann.
ApplicationIsolationByRoamingUser	101	Der Speicher wird erst nach Benutzer und anschließend nach Anwendungsbeweis isoliert. Das Roaming des Speichers wird ausgeführt, wenn servergespeicherte Benutzerdaten unter Windows aktiviert sind. Dadurch wird der Anwendung ein Datenspeicher bereitgestellt, der vom Kontext einer beliebigen Domäne aus zugänglich ist. Bei einer Einteilung nach Anwendung sind zusätzliche Vertrauensstellungen erforderlich, da hierbei möglicherweise ein "Tunnel" zwischen Anwendungen entsteht, der die Datenisolation von Anwendungen in bestimmten Websites gefährden kann.
ApplicationIsolationByUser	21	Der Speicher wird zuerst nach Benutzer und dann nach Anwendung isoliert. Der Speicher wird auch nach Computer isoliert. Dadurch wird der Anwendung ein Datenspeicher bereitgestellt, der vom Kontext einer beliebigen Domäne aus zugänglich ist. Bei einer Einteilung nach Anwendung sind zusätzliche Vertrauensstellungen erforderlich, da hierbei möglicherweise ein "Tunnel" zwischen Anwendungen entsteht, der die Datenisolation von Anwendungen in bestimmten Websites gefährden kann.
AssemblyIsolationByMachine	64	Der Speicher wird erst nach Computer und anschließend nach Codeassembly isoliert. Dadurch wird ein Datenspeicher für die Assembly bereitgestellt, der vom Kontext einer beliebigen Domäne aus zugänglich ist. Bei Datendepots pro Assembly sind zusätzliche Vertrauensstellungen erforderlich, da hierbei möglicherweise ein "Tunnel" zwischen Anwendungen entsteht, der die Datenisolation von Anwendungen in bestimmten Websites gefährden kann.
AssemblyIsolationByRoamingUser	96	Der Speicher wird erst nach Benutzer und anschließend nach Assemblybeweis isoliert. Das Roaming des Speichers wird ausgeführt, wenn servergespeicherte Benutzerdaten unter Windows aktiviert sind. Dadurch wird ein Datenspeicher für die Assembly bereitgestellt, der vom Kontext einer beliebigen Domäne aus zugänglich ist. Bei Datendepots pro Assembly sind zusätzliche Vertrauensstellungen erforderlich, da hierbei möglicherweise ein "Tunnel" zwischen Anwendungen entsteht, der die Datenisolation von Anwendungen in bestimmten Websites gefährden kann.
AssemblyIsolationByUser	32	Der Speicher wird erst nach Benutzer und anschließend nach Codeassembly isoliert. Der Speicher wird auch nach Computer isoliert. Dadurch wird ein Datenspeicher für die Assembly bereitgestellt, der vom Kontext einer beliebigen Domäne aus zugänglich ist. Bei Datendepots pro Assembly sind zusätzliche Vertrauensstellungen erforderlich, da hierbei möglicherweise ein "Tunnel" zwischen Anwendungen entsteht, der die Datenisolation von Anwendungen in bestimmten Websites gefährden kann.
DomainIsolationByMachine	48	Der Speicher wird erst nach Computer und anschließend nach Domäne und Assembly isoliert. Der Zugriff auf Daten ist nur im Kontext derselben Anwendung und nur bei der Ausführung auf dem gleichen Computer möglich. Dies bietet sich an, wenn für eine Assembly von Drittparteien ein privater Datenspeicher unterhalten werden soll.
DomainIsolationByRoamingUser	80	Der Speicher wird erst nach Benutzer und anschließend nach Domäne und Assembly isoliert. Das Roaming des Speichers wird ausgeführt, wenn servergespeicherte Benutzerdaten unter Windows aktiviert sind. Der Zugriff auf Daten ist nur im Kontext derselben Anwendung und nur bei der Ausführung durch denselben Benutzer möglich. Dies bietet sich an, wenn für eine Assembly von Drittparteien ein privater Datenspeicher unterhalten werden soll.
DomainIsolationByUser	16	Der Speicher wird erst nach Benutzer und anschließend nach Domäne und Assembly isoliert. Der Speicher wird auch nach Computer isoliert. Der Zugriff auf Daten ist nur im Kontext derselben Anwendung und nur bei der Ausführung durch denselben Benutzer möglich. Dies bietet sich an, wenn für eine Assembly von Drittparteien ein privater Datenspeicher unterhalten werden soll.
None	0	Verwendung der isolierten Speicherung ist nicht zulässig.
UnrestrictedIsolatedStorage	240	Verwendung der isolierten Speicherung ist ohne Beschränkung zulässig. Der Code verfügt über Vollzugriff auf alle Teile des Benutzerspeichers, unabhängig von der Identität der Domäne oder der Assembly. Diese Verwendung der isolierten Speicherung schließt die Fähigkeit ein, den Inhalt des Datenspeichers der isolierten Speicherung aufzulisten.

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

Achtung

Die Codezugriffssicherheit (CAS, Code Access Security) ist in allen Versionen von .NET Framework und .NET veraltet. Aktuelle Versionen von .NET berücksichtigen keine CAS-Anmerkungen und erzeugen Fehler, wenn CAS-bezogene APIs verwendet werden. Entwickler*innen sollten alternative Mittel zum Ausführen von Sicherheitsaufgaben suchen.

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).

Weitere Informationen

• IsolatedStoragePermission
• IsolatedStoragePermissionAttribute
• IsolatedStorageFilePermission
• IsolatedStorageFilePermissionAttribute