IsolatedStorageContainment Enumeration

Referenz

Definition

Namespace:: System.Security.Permissions

Assembly:: System.Security.Permissions.dll

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

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

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}")]
public enum IsolatedStorageContainment

[System.Serializable]
public enum IsolatedStorageContainment

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum IsolatedStorageContainment

type 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 =

Public Enum IsolatedStorageContainment

Vererbung: Object

ValueType

Enum
IsolatedStorageContainment

Attribute: ObsoleteAttribute SerializableAttribute ComVisibleAttribute

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 dem CLR mitteilen, dass Code in dieser Assembly erforderlich IsolatedStoragePermission ist und zeigt auch, wie Sie aus isoliertem Speicher schreiben und lesen können.

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

Isolierter Speicher verwendet Nachweise, 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. Anstatt viele Anwendungen und Komponenten, die eine gemeinsame Ressource wie das Dateisystem oder die Registrierung freigeben, verfügt jede über einen eigenen Dateibereich, der ihm inhärent zugewiesen ist.

Vier grundlegende Isolationsbereiche werden beim Zuweisen isolierter Speicher verwendet:

User - Code wird immer nach dem aktuellen Benutzer ausgerichtet. Die gleiche Assembly erhält unterschiedliche Speicher, wenn sie von verschiedenen Benutzern ausgeführt werden.
Machine - Code wird immer nach dem Computer ausgerichtet. Die gleiche Assembly erhält die gleichen Speicher, wenn sie von verschiedenen Benutzern auf demselben Computer ausgeführt werden.
Assembly- Code wird kryptografisch durch starken Namen identifiziert (z. B. Microsoft.Office.* oder Microsoft.Office. Word), nach Publisher (basierend auf öffentlichen Schlüsseln), nach URL (zhttp://www.fourthcoffee.com/process/grind.htm. B. nach Website oder nach Zone).
Domain - Code wird basierend auf Nachweisen identifiziert, die der Anwendungsdomäne zugeordnet sind. Die Webanwendungsidentität wird von der URL der Website oder von der URL der Webseite, Website oder Zone abgeleitet. Die lokale Codeidentität basiert auf dem Anwendungsverzeichnispfad.

Informationen zu Definitionen von 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 User+Assembly und User+Assembly+Domain. Diese Gruppierung von Identitäten ist in vielen verschiedenen Anwendungen nützlich.

Wenn Daten von Domäne, Benutzer und Assembly gespeichert werden, ist die Daten in diesem einzigen Code in dieser Assembly auf die Daten zugreifen können. Der Datenspeicher wird auch durch die Anwendung isoliert, in der sie ausgeführt wird, sodass die Assembly kein potenzielles Leck darstellt, indem Daten in anderen Anwendungen angezeigt werden.

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

IsolatedStorageContainment stellt Flags bereit, die bestimmen, ob eine Anwendung isolierten Speicher verwenden darf und falls ja, welche Identitätskombinationen sie verwenden dürfen. Außerdem wird ermittelt, ob eine Anwendung Informationen an einem Speicherort speichern kann, der mit einem Benutzer roamen kann (Windows Roamingbenutzerprofile oder Ordnerumleitung muss konfiguriert werden).

Gilt für