Package Klasse

Definition

public ref class Package abstract : IDisposable

public abstract class Package : IDisposable

type Package = class
    interface IDisposable

Public MustInherit Class Package
Implements IDisposable

Vererbung

Object

Package

Abgeleitet

System.IO.Packaging.ZipPackage

Implementiert

IDisposable

Beispiele

Das folgende Beispiel zeigt die grundlegenden Schritte zum Erstellen eines Package. In diesem Beispiel wird ein Paket erstellt, das ein Dokument zusammen mit einem Grafikbild enthält, das als Teil des Dokuments angezeigt wird. (Dies ähnelt dem Fall, in dem eine HTML-Datei eine <IMG-Tag> , das auf eine externe Bilddatei verweist.) Zwei PackageRelationship Elemente sind auch im Paket enthalten. Die erste, eine "package-level"-Beziehung, definiert den Dokumentteil als Stammelement des Pakets. Eine zweite , "part-level"-Beziehung definiert die Zuordnung zwischen dem Dokumentteil (der "Quelle" der Part-Level-Beziehung) und dessen Verwendung des Bildteils (das "Ziel" der Beziehung auf Teilebene).

//  -------------------------- 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 einer einzigen Entität eines definierten physischen Formats zur Portabilität 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 in einer Package hierarchischen Organisation von Ordnern und Dateien referenziert.

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

A PackagePart ("part") ist die abstrakte Klasse, die ein Objekt darstellt, das in einem Package.

Eine PackageRelationship ("Beziehung") definiert eine Zuordnung zwischen einer Quelle Package oder PackagePart einem Zielobjekt. A PackageRelationship kann eine von zwei Typen sein, von denen jede eine von zwei Formen sein kann:

• Eine Von der Package.CreateRelationship Methode erstellte Beziehung auf Paketebene bezieht sich auf eine Package der folgenden:

  • Ein Zielteil im Paket.
  • Eine Zielressource außerhalb des Pakets.

• Eine Part-Level-Beziehung (erstellt durch die PackagePart.CreateRelationship Methode) bezieht sich auf eine der folgenden Quellen PackagePart :

  • Ein weiterer Zielteil im Paket.
  • Eine Zielressource außerhalb des Pakets.

Die Quelle Package oder Quelle PackagePart der Beziehung wird als "Besitzer" der Beziehung betrachtet. Wenn das Quellobjekt gelöscht wird, werden alle Beziehungen im Besitz des Quellobjekts ebenfalls gelöscht. Beim Erstellen oder Löschen einer Beziehung werden die Quell- oder Zielobjekte in keiner Weise physisch geändert.

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

Pakete unterstützen auch die Verwaltung digitaler Rechte (Digital Rights Management, DRM), sodass Inhaltselemente in einer Datei Package mit bestimmten Zugriffsrechten verschlüsselt werden können, die autorisierten Benutzern gewährt werden.

Basierend auf der Package Architektur ist ein XpsDocument Pakettyp zum Speichern von Dokumenten basierend auf der Open XML Paper Specification (XPS).

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

Weitere Informationen finden Sie in der Open Packaging Conventions (OPC)-Spezifikation, die zum Download verfügbar https://www.ecma-international.org/publications-and-standards/standards/ecma-376/ist.

Weitere Informationen

• PackagePart
• XpsDocument
• Open Packaging Conventions (OPC) Specification