Package Klasse

Definition

Stellt einen Container dar, der mehrere Datenobjekte speichern kann.

public ref class Package abstract : IDisposable
public abstract class Package : IDisposable
type Package = class
    interface IDisposable
Public MustInherit Class Package
Implements IDisposable
Vererbung
Package
Abgeleitet
Implementiert

Beispiele

Im folgenden Beispiel werden die grundlegenden Schritte zum Erstellen einer Package. In diesem Beispiel wird ein Paket erstellt, um ein Dokument zusammen mit einem Grafikbild zu enthalten, das als Teil des Dokuments angezeigt wird. (Dies ähnelt dem Fall, in dem eine HTML-Datei über ein <IMG> Tag verfügt, das auf eine externe Bilddatei verweist.) Zwei PackageRelationship Elemente sind auch im Paket enthalten. Die erste, eine "Paketebene"-Beziehung definiert den Dokumentteil als Stammelement des Pakets. Eine zweite, "part-level"-Beziehung definiert die Zuordnung zwischen dem Dokumentteil (der Quelle" der Beziehung auf Teilebene) und deren Verwendung des Bildteils (das Ziel der Part-Level-Beziehung). Das vollständige Beispiel finden Sie unter Schreiben eines Paketbeispiels.

//  -------------------------- CreatePackage --------------------------
/// <summary>
///   Creates a package zip file containing specified
///   content and resource files.</summary>
private static void CreatePackage()
{
    // Convert system path and file names to Part URIs. In this example
    // Uri partUriDocument /* /Content/Document.xml */ =
    //     PackUriHelper.CreatePartUri(
    //         new Uri("Content\Document.xml", UriKind.Relative));
    // Uri partUriResource /* /Resources/Image1.jpg */ =
    //     PackUriHelper.CreatePartUri(
    //         new Uri("Resources\Image1.jpg", UriKind.Relative));
    Uri partUriDocument = PackUriHelper.CreatePartUri(
                              new Uri(documentPath, UriKind.Relative));
    Uri partUriResource = PackUriHelper.CreatePartUri(
                              new Uri(resourcePath, UriKind.Relative));

    // Create the Package
    // (If the package file already exists, FileMode.Create will
    //  automatically delete it first before creating a new one.
    //  The 'using' statement insures that 'package' is
    //  closed and disposed when it goes out of scope.)
    using (Package package =
        Package.Open(packagePath, FileMode.Create))
    {
        // Add the Document part to the Package
        PackagePart packagePartDocument =
            package.CreatePart(partUriDocument,
                           System.Net.Mime.MediaTypeNames.Text.Xml);

        // Copy the data to the Document Part
        using (FileStream fileStream = new FileStream(
               documentPath, FileMode.Open, FileAccess.Read))
        {
            CopyStream(fileStream, packagePartDocument.GetStream());
        }// end:using(fileStream) - Close and dispose fileStream.

        // Add a Package Relationship to the Document Part
        package.CreateRelationship(packagePartDocument.Uri,
                                   TargetMode.Internal,
                                   PackageRelationshipType);

        // Add a Resource Part to the Package
        PackagePart packagePartResource =
            package.CreatePart(partUriResource,
                           System.Net.Mime.MediaTypeNames.Image.Jpeg);

        // Copy the data to the Resource Part
        using (FileStream fileStream = new FileStream(
               resourcePath, FileMode.Open, FileAccess.Read))
        {
            CopyStream(fileStream, packagePartResource.GetStream());
        }// end:using(fileStream) - Close and dispose fileStream.

        // Add Relationship from the Document part to the Resource part
        packagePartDocument.CreateRelationship(
                                new Uri(@"../resources/image1.jpg",
                                UriKind.Relative),
                                TargetMode.Internal,
                                ResourceRelationshipType);
    }// end:using (Package package) - Close and dispose package.
}// end:CreatePackage()

//  --------------------------- CopyStream ---------------------------
/// <summary>
///   Copies data from a source stream to a target stream.</summary>
/// <param name="source">
///   The source stream to copy from.</param>
/// <param name="target">
///   The destination stream to copy to.</param>
private static void CopyStream(Stream source, Stream target)
{
    const int bufSize = 0x1000;
    byte[] buf = new byte[bufSize];
    int bytesRead = 0;
    while ((bytesRead = source.Read(buf, 0, bufSize)) > 0)
        target.Write(buf, 0, bytesRead);
}// end:CopyStream()
'  -------------------------- CreatePackage --------------------------
''' <summary>
'''   Creates a package zip file containing specified
'''   content and resource files.</summary>
Private Shared Sub CreatePackage()
    ' Convert system path and file names to Part URIs. In this example
    ' Dim partUriDocument as Uri /* /Content/Document.xml */ =
    '     PackUriHelper.CreatePartUri(
    '         New Uri("Content\Document.xml", UriKind.Relative))
    ' Dim partUriResource as Uri /* /Resources/Image1.jpg */ =
    '     PackUriHelper.CreatePartUri(
    '         New Uri("Resources\Image1.jpg", UriKind.Relative))
    Dim partUriDocument As Uri = PackUriHelper.CreatePartUri(New Uri(documentPath, UriKind.Relative))
    Dim partUriResource As Uri = PackUriHelper.CreatePartUri(New Uri(resourcePath, UriKind.Relative))

    ' Create the Package
    ' (If the package file already exists, FileMode.Create will
    '  automatically delete it first before creating a new one.
    '  The 'using' statement insures that 'package' is
    '  closed and disposed when it goes out of scope.)
    Using package As Package = Package.Open(packagePath, FileMode.Create)
        ' Add the Document part to the Package
        Dim packagePartDocument As PackagePart = package.CreatePart(partUriDocument, System.Net.Mime.MediaTypeNames.Text.Xml)

        ' Copy the data to the Document Part
        Using fileStream As New FileStream(documentPath, FileMode.Open, FileAccess.Read)
            CopyStream(fileStream, packagePartDocument.GetStream())
        End Using ' end:using(fileStream) - Close and dispose fileStream.

        ' Add a Package Relationship to the Document Part
        package.CreateRelationship(packagePartDocument.Uri, TargetMode.Internal, PackageRelationshipType)

        ' Add a Resource Part to the Package
        Dim packagePartResource As PackagePart = package.CreatePart(partUriResource, System.Net.Mime.MediaTypeNames.Image.Jpeg)

        ' Copy the data to the Resource Part
        Using fileStream As New FileStream(resourcePath, FileMode.Open, FileAccess.Read)
            CopyStream(fileStream, packagePartResource.GetStream())
        End Using ' end:using(fileStream) - Close and dispose fileStream.

        ' Add Relationship from the Document part to the Resource part
        packagePartDocument.CreateRelationship(New Uri("../resources/image1.jpg", UriKind.Relative), TargetMode.Internal, ResourceRelationshipType)

    End Using ' end:using (Package package) - Close and dispose package.

End Sub


'  --------------------------- CopyStream ---------------------------
''' <summary>
'''   Copies data from a source stream to a target stream.</summary>
''' <param name="source">
'''   The source stream to copy from.</param>
''' <param name="target">
'''   The destination stream to copy to.</param>
Private Shared Sub CopyStream(ByVal source As Stream, ByVal target As Stream)
    Const bufSize As Integer = &H1000
    Dim buf(bufSize - 1) As Byte
    Dim bytesRead As Integer = 0
    bytesRead = source.Read(buf, 0, bufSize)
    Do While bytesRead > 0
        target.Write(buf, 0, bytesRead)
        bytesRead = source.Read(buf, 0, bufSize)
    Loop
End Sub

Hinweise

Package ist eine abstrakte Klasse, die verwendet werden kann, um Objekte in eine einzelne Entität eines definierten physischen Formats für portierbare und effizienten Zugriff zu organisieren.

Eine ZIP-Datei ist das primäre physische Format für das Package. Andere Package Implementierungen können andere physische Formate wie ein XML-Dokument, eine Datenbank oder einen Webdienst verwenden.

Wie ein Dateisystem werden Elemente, die in einer Package hierarchischen Organisation von Ordnern und Dateien enthalten sind, verwiesen.

Obwohl Package selbst eine abstrakte Klasse ist, wird die ZipPackage abgeleitete Klasse standardmäßig von der Open Methode verwendet.

Ein PackagePart ("Teil") ist die abstrakte Klasse, die ein Objekt darstellt, das in einem Packagegespeichert wird.

Ein PackageRelationship ("Beziehung") definiert eine Zuordnung zwischen einer Quelle Package oder PackagePart einem Zielobjekt. Eine PackageRelationship der beiden Typen kann eine von zwei Arten sein, die jeweils eine von zwei Formen sein können:

  • Eine von der Package.CreateRelationship Methode erstellte Paketebenenbeziehung bezieht Package sich auf eine der folgenden:

    • Ein Zielteil im Paket.

    • Eine Zielressource außerhalb des Pakets.

  • Eine Teilebenenbeziehung (die von der PackagePart.CreateRelationship Methode erstellt wurde) bezieht sich auf eine Quelle PackagePart :

    • Ein weiterer Zielteil im Paket.

    • Eine Zielressource außerhalb des Pakets.

Die Quelle Package oder Quelle PackagePart der Beziehung gilt als "Besitzer" der Beziehung. Wenn das Quellobjekt gelöscht wird, werden auch alle Beziehungen, die dem Quellobjekt gehören, gelöscht. Der Prozess, eine Beziehung zu erstellen oder zu löschen, ändert entweder die Quell- oder Zielobjekte in irgendeiner Weise.

Eine PackageDigitalSignature ("digitale Signatur") ist eine Zusammensetzung von Teilen und Beziehungen, die eine digitale Signatur darstellen, die mit einer Package. Die digitale Signatur identifiziert den Absender und überprüft, dass die signierten Teile und Beziehungen, die in der Package Datei enthalten sind, nicht geändert wurden.

Pakete unterstützen außerdem das Digital Rights Management (DRM), mit dem Inhaltselemente in einer Package verschlüsselten Datei mit bestimmten Zugriffsrechten verschlüsselt werden können, die autorisierten Benutzern gewährt werden.

Basierend auf der Architektur ist ein XpsDocument Pakettyp, der für das Package Speichern von Dokumenten basierend auf der open XML-Papierspezifikation (XPS) konzipiert ist.

.NET Framework verwendet Pakete zum Speichern von Inhalten, Ressourcen und Beziehungen für Seiten und Dokumente mithilfe einer standardmäßigen ZIP-Datei. Wie bei jeder ZIP-Datei kann Ihre Anwendung die System.IO.Packaging Klassen verwenden, um beliebige Datentypen oder Datendateien in einem einzigen effizienten Zugriffscontainer zu speichern und optional zu schützen.

Weitere Informationen finden Sie in der Spezifikation open Packaging Conventions (OPC) zum Download unter https://www.ecma-international.org/publications-and-standards/standards/ecma-376/.

Konstruktoren

Package(FileAccess)

Initialisiert eine neue Instanz der Package-Klasse, die einen angegebenen FileAccess verwendet.

Package(FileAccess, Boolean)

Initialisiert eine neue Instanz der Package-Klasse, die einen angegebenen FileAccess und eine angegebene Streamingoption verwendet.

Eigenschaften

FileOpenAccess

Ruft die Dateizugriffseinstellung für das Paket ab.

PackageProperties

Ruft die Haupteigenschaften des Pakets ab.

Methoden

Close()

Speichert und schließt das Paket sowie alle zugrunde liegenden Partstreams.

CreatePart(Uri, String)

Erstellt ein neues unkomprimiertes Part mit einem angegebenen URI und Inhaltstyp.

CreatePart(Uri, String, CompressionOption)

Erstellt ein neues Part mit einem angegebenen URI, einem angegebenen Inhaltstyp und einer angegebenen Komprimierungsoption.

CreatePartCore(Uri, String, CompressionOption)

Erstellt beim Überschreiben in einer abgeleiteten Klasse ein neues Part im Paket.

CreateRelationship(Uri, TargetMode, String)

Erstellt eine Beziehung auf Paketebene zu einem Part mit einem angegebenen URI, einem angegebenen Zielmodus und einem angegebenen Beziehungstyp.

CreateRelationship(Uri, TargetMode, String, String)

Erstellt eine Paketebenenbeziehung zu einem Teil mit einem bestimmten URI, Zielmodus, Beziehungstyp und Id (ID).

DeletePart(Uri)

Löscht ein Part mit einem angegebenen URI aus dem Paket.

DeletePartCore(Uri)

Löscht beim Überschreiben in einer abgeleiteten Klasse ein Part mit einem angegebenen URI.

DeleteRelationship(String)

Löscht eine Beziehung auf Paketebene.

Dispose(Boolean)

Leert und speichert den Inhalt von allen Parts und Beziehungen, schließt das Paket und gibt alle Ressourcen frei.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Flush()

Speichert die Inhalte von allen Parts und Beziehungen, die im Paket enthalten sind.

FlushCore()

Speichert beim Überschreiben in einer abgeleiteten Klasse die Inhalte aller Parts und Beziehungen im Speicher der abgeleiteten Klasse.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetPart(Uri)

Gibt das Part mit einem angegebenen URI zurück.

GetPartCore(Uri)

Gibt beim Überschreiben in einer abgeleiteten Klasse das von einem angegebenen URI adressierte Part zurück.

GetParts()

Gibt eine Auflistung aller Parts im Paket zurück.

GetPartsCore()

Gibt beim Überschreiben in einer abgeleiteten Klasse ein Array aller Parts im Paket zurück.

GetRelationship(String)

Gibt die Beziehung auf Paketebene zu einem angegebenen Bezeichner zurück.

GetRelationships()

Gibt eine Auflistung aller Beziehungen auf Paketebene zurück.

GetRelationshipsByType(String)

Gibt eine Auflistung aller Beziehungen auf Paketebene zurück, die mit einem angegebenen RelationshipType übereinstimmen.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
Open(Stream)

Öffnet ein Paket in einem angegebenen E/A-Stream.

Open(Stream, FileMode)

Öffnet ein Paket mit einem angegebenen E/A-Stream und Dateimodus.

Open(Stream, FileMode, FileAccess)

Öffnet ein Paket mit einem angegebenen E/A-Stream, einem angegebenen Dateimodus und einer angegebenen Dateizugriffseinstellung.

Open(String)

Öffnet ein Paket mit einem angegebenen Pfad und Dateinamen.

Open(String, FileMode)

Öffnet mithilfe einer angegebenen Dateimethode ein Paket in einem angegebenen Pfad.

Open(String, FileMode, FileAccess)

Öffnet mit einem angegebenen Dateimodus und einer angegebenen Dateizugriffseinstellung ein Paket in einem angegebenen Pfad.

Open(String, FileMode, FileAccess, FileShare)

Öffnet mit einem angegebenen Dateimodus, einer angegebenen Dateizugriffseinstellung und einer angegebenen Dateifreigabeeinstellung ein Paket in einem angegebenen Pfad.

PartExists(Uri)

Gibt an, ob ein Part mit einem angegebenen URI im Paket vorhanden ist.

RelationshipExists(String)

Gibt an, ob eine Beziehung auf Paketebene mit einer angegebenen ID im Paket enthalten ist.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Dieses Mitglied unterstützt die Windows Presentation Foundation (WPF)-Infrastruktur und ist nicht für die Anwendungsverwendung vorgesehen. Verwenden Sie stattdessen die typsichere Dispose(Boolean)-Methode.

Gilt für

Siehe auch