IsolatedStorageContainment-Enumeration

Gibt die zulässige Verwendung der isolierten Speicherung an.

Namespace: System.Security.Permissions
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Enumeration IsolatedStorageContainment
'Usage
Dim instance As IsolatedStorageContainment

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public enum IsolatedStorageContainment

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public enum class IsolatedStorageContainment

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public enum IsolatedStorageContainment

SerializableAttribute 
ComVisibleAttribute(true) 
public enum IsolatedStorageContainment

Member

	Membername	Beschreibung
	AdministerIsolatedStorageByUser	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	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	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	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	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 einer Einteilung, die pro Assembly erfolgt, 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	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	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	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	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	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	Verwendung der isolierten Speicherung ist nicht zulässig.
	UnrestrictedIsolatedStorage	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.

Hinweise

Die isolierte Speicherung bestimmt mithilfe von Beweisen einen eindeutigen Speicherbereich, der durch eine Anwendung bzw. Komponente verwendet wird. Die Identität einer Assembly bestimmt in eindeutiger Weise das Stammverzeichnis eines virtuellen Dateisystems, das durch diese Assembly verwendet wird. Somit wird nicht eine gemeinsame Ressource, z. B. das Dateisystem oder die Registrierung, von einer Vielzahl von Anwendungen und Komponenten geteilt, sondern jede verfügt über einen Dateibereich, der ausschließlich ihr zugewiesen ist.

Beim Zuweisen der isolierten Speicherung werden vier grundlegende Gültigkeitsbereiche für die Isolation verwendet:

• User – Der Gültigkeitsbereich von Code richtet sich stets nach dem aktuellen Benutzer. Derselben Assembly wird beim Ausführen durch verschiedene Benutzer unterschiedlicher Speicher zugewiesen.

• Machine – Der Gültigkeitsbereich von Code richtet sich stets nach dem Computer. Die gleiche Assembly erhält den gleichen Speicher, wenn sie von unterschiedlichen Benutzern auf dem gleichen Computer ausgeführt wird.

• Assembly – Code wird kryptographisch nach dem starken Namen (z. B. Microsoft.Office.* oder Microsoft.Office.Word), nach dem Herausgeber (auf der Grundlage des öffentlichen Schlüssels), nach dem URL (z. B. https://www.fourthcoffee.com/process/grind.htm), nach der Site oder nach der Zone angegeben.

• Domain – Code wird auf der Grundlage der Beweise angegeben, die der Anwendungsdomäne zugewiesen sind. Die Identität der Webanwendung wird vom URL der Site bzw. vom URL, von der Site oder der Zone der Webseite abgeleitet. Die Identität von lokalem Code basiert auf dem Verzeichnispfad der Anwendung.

Definitionen für URL, Site und Zone finden Sie unter UrlIdentityPermission, SiteIdentityPermission und ZoneIdentityPermission.

Diese Identitäten werden gruppiert. Deshalb werden die Identitäten nacheinander angewendet, bis die gewünschte isolierte Speicherung erstellt wurde. Gültige Gruppierungen sind User+Assembly und User+Assembly+Domain. Diese Gruppierung von Identitäten bietet sich bei vielen verschiedenen Anwendungen an.

Wenn Daten nach Domäne, Benutzer und Assembly gespeichert werden, sind die Daten insofern privat, als dass nur in dieser Assembly enthaltener Code Zugriff auf die Daten hat. Der Datenspeicher wird darüber hinaus durch die Anwendung isoliert, in der sie ausgeführt wird, sodass die Assembly keine Schwachstelle dadurch darstellt, durch die Daten möglicherweise anderen Anwendungen verfügbar gemacht werden.

Die Isolation nach Assembly und Benutzer empfiehlt sich für Benutzerdaten, die für mehrere Anwendungen gültig sind, z. B. Lizenzinformationen oder die persönlichen Informationen von Benutzern (Name, Anmeldeinformationen für die Authentifizierung usw.), die unabhängig von einer bestimmten Anwendung sind.

IsolatedStorageContainment macht Flags verfügbar, mit denen bestimmt wird, ob die Verwendung der isolierten Speicherung für eine Anwendung zulässig ist und, wenn dies der Fall ist, von welchen Identitätskombinationen diese verwendet werden darf. Darüber hinaus wird bestimmt, ob eine Anwendung Informationen an einem Ort speichern darf, der den Benutzern von überall aus zugänglich ist (Servergespeicherte Benutzerprofile oder Ordnerumleitung müssen in Windows konfiguriert sein).

Beispiel

In diesem Beispiel wird veranschaulicht, wie der CLR mitgeteilt wird, dass IsolatedStoragePermission für Code in dieser Assembly erforderlich ist, und wie der isolierte Speicher geschrieben und gelesen wird.

using System;
using System.Security.Permissions;
using System.IO.IsolatedStorage;
using System.IO;

// Notify the CLR to grant this assembly the IsolatedStorageFilePermission. 
// This allows the assembly to work with storage files that are isolated 
// by user and assembly.
[assembly: IsolatedStorageFilePermission(SecurityAction.RequestMinimum, UsageAllowed = IsolatedStorageContainment.AssemblyIsolationByUser)]

public sealed class App
{
    static void Main()
    {
        // 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.

using namespace System;
using namespace System::Security;
using namespace System::Security::Permissions;
using namespace System::IO::IsolatedStorage;
using namespace System::IO;

// Notify the CLR to grant this assembly the IsolatedStorage-
// FilePermission. This allows the assembly to work with storage
// files that are isolated by user and assembly.
[assembly: IsolatedStorageFilePermission(
    SecurityAction::RequestMinimum, UsageAllowed =
    IsolatedStorageContainment::AssemblyIsolationByUser)];
int main()
{
    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);
    }
}

// This code produces the following output.
//
//  This is some test data.

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

System.Security.Permissions-Namespace
IsolatedStoragePermission
IsolatedStoragePermissionAttribute
IsolatedStorageFilePermission
IsolatedStorageFilePermissionAttribute

Weitere Ressourcen

Isolierte Speicherung