Package Klasse

Definition

Namespace:

System.IO.Packaging

Assembly:

System.IO.Packaging.dll

Paket:

System.IO.Packaging v9.0.0-rc.1.24431.7

Quelle:

Package.cs

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

Object

Package

Abgeleitet

System.IO.Packaging.ZipPackage

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

Package(FileAccess)

Initialisiert eine neue Instanz der Package-Klasse, die einen angegebenen FileAccess 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 Beziehung auf Paketebene zu einem Teil mit einem bestimmten URI, Zielmodus, Beziehungstyp und Bezeichner (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()

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

Weitere Informationen

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