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 einer Grafik enthält, die 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 Beziehung auf Paketebene, definiert den Dokumentteil als Stammelement des Pakets. Eine zweite Beziehung auf "Teilebene" definiert die Zuordnung zwischen dem Dokumentteil (der "Quelle" der Beziehung auf Teilebene) und seiner Verwendung des Bildteils (dem "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 einzelnen Entität eines definierten physischen Formats zu organisieren, um Portabilität und effizienten Zugriff zu ermöglichen.

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

Wie bei einem Dateisystem wird auf in einem Package enthaltenen Elemente in einer hierarchischen organization von Ordnern und Dateien verwiesen.

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

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

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

• Eine Beziehung auf Paketebene (erstellt von der Package.CreateRelationship -Methode) bezieht sich auf einen Package der folgenden:

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

• Eine Beziehung auf Teilebene (erstellt von der PackagePart.CreateRelationship -Methode) bezieht sich auf eine Quelle PackagePart auf eine der folgenden:

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

Die Quelle oder Quelle PackagePackagePart der Beziehung wird als "Besitzer" der Beziehung betrachtet. Wenn das Quellobjekt gelöscht wird, werden alle Beziehungen, die dem Quellobjekt gehören, ebenfalls gelöscht. Der Prozess zum Erstellen oder Löschen einer Beziehung ändert weder die Quell- noch die Zielobjekte physisch.

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

Pakete unterstützen auch Digital Rights Management (DRM), mit dem Inhaltselemente in einem Package mit bestimmten Zugriffsrechten verschlüsselt werden können, die autorisierten Benutzern gewährt werden.

Basierend auf der Package Architektur ist ein XpsDocument Pakettyp, der zum Speichern von Dokumenten entwickelt wurde, die auf der Open XML Paper Specification (XPS) basieren.

.NET Framework verwendet Pakete, um Inhalte, Ressourcen und Beziehungen für Seiten und Dokumente standardmäßig mithilfe einer ZIP-Standarddatei zu speichern. Wie bei jeder ZIP-Datei kann Ihre Anwendung die System.IO.Packaging Klassen verwenden, um jeden Typ oder eine Beliebige Anzahl von Datendateien in einem einzigen container mit effizientem Zugriff zu speichern und optional zu schützen.

Weitere Informationen finden Sie in der OPC-Spezifikation (Open Packaging Conventions), die unter heruntergeladen werden https://www.ecma-international.org/publications-and-standards/standards/ecma-376/kann.

Konstruktoren

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Gilt für:

Weitere Informationen

• PackagePart
• XpsDocument
• OPC-Spezifikation (Open Packaging Conventions)