Package Classe

Définition

Espace de noms:

System.IO.Packaging

Assembly:

System.IO.Packaging.dll

Paquet:

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

Source:

Package.cs

Représente un conteneur qui peut stocker plusieurs objets de données.

public ref class Package abstract : IDisposable

public abstract class Package : IDisposable

type Package = class
    interface IDisposable

Public MustInherit Class Package
Implements IDisposable

Héritage

Object

Package

Dérivé

System.IO.Packaging.ZipPackage

Exemples

L’exemple suivant montre les étapes de base pour créer un Package. Dans cet exemple, un package est créé pour contenir un document avec une image graphique qui s’affiche dans le document. (Ceci est similaire au cas dans lequel un fichier HTML a un <Balise IMG> qui fait référence à un fichier image externe.) Deux PackageRelationship éléments sont également inclus dans le package. La première, une relation au niveau du package, définit le composant de document comme élément racine du package. Une deuxième relation, « de niveau partie » définit l’association entre le composant de document (la « source » de la relation de niveau partie) et son utilisation de la partie image (la « cible » de la relation de niveau partie).

//  -------------------------- 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

Remarques

Package est une classe abstraite qui peut être utilisée pour organiser des objets en une entité unique d’un format physique défini pour la portabilité et l’accès efficace.

Un fichier ZIP est le format physique principal pour .Package D’autres Package implémentations peuvent utiliser d’autres formats physiques tels qu’un document XML, une base de données ou un service Web.

Comme un système de fichiers, les éléments contenus dans un Package sont référencés dans une organization hiérarchique de dossiers et de fichiers.

Bien qu’elle-même soit Package une classe abstraite, la ZipPackage classe dérivée est utilisée par défaut par la Open méthode .

Un PackagePart (« part ») est la classe abstraite qui représente un objet stocké dans un Package.

Une PackageRelationship (« relation ») définit une association entre une source Package ou un PackagePart objet cible. Un PackageRelationship peut être l’un des deux types, chacun d’entre eux peut être l’une des deux formes suivantes :

• Une relation au niveau du package (créée par la Package.CreateRelationship méthode) est liée à :Package

  • Partie cible dans le package.
  • Ressource cible en dehors du package.

• Une relation de niveau partie (créée par la PackagePart.CreateRelationship méthode) lie une source PackagePart à :

  • Une autre partie cible dans le package.
  • Ressource cible en dehors du package.

La source Package ou la source PackagePart de la relation est considérée comme le « propriétaire » de la relation. Lorsque l’objet source est supprimé, toutes les relations appartenant à l’objet source sont également supprimées. Le processus de création ou de suppression d’une relation ne modifie pas physiquement les objets source ou cible de quelque manière que ce soit.

Une PackageDigitalSignature (« signature numérique ») est une composition de parties et de relations représentant une signature numérique incluse avec un Package. La signature numérique identifie l’initiateur et valide que les parties et relations signées contenues dans n’ont Package pas été modifiées.

Les packages prennent également en charge la gestion des droits numériques (DRM), qui permet de chiffrer les éléments de contenu d’un avec des droits d’accès Package spécifiques accordés aux utilisateurs autorisés.

En fonction de l’architecturePackage, un est un type de XpsDocument package conçu pour stocker des documents basés sur la spécification de papier XML ouverte (XPS).

.NET Framework utilise des packages pour stocker du contenu, des ressources et des relations pour les pages et les documents à l’aide d’un fichier ZIP standard par défaut. Comme avec n’importe quel fichier ZIP, votre application peut utiliser les System.IO.Packaging classes pour stocker et éventuellement protéger n’importe quel type ou nombre de fichiers de données dans un seul conteneur d’accès efficace.

Pour plus d’informations, consultez la spécification Open Packaging Conventions (OPC) disponible en téléchargement à l’adresse https://www.ecma-international.org/publications-and-standards/standards/ecma-376/.

Constructeurs

Package(FileAccess)

Initialise une nouvelle instance de la classe Package qui utilise un FileAccess donné.

Propriétés

FileOpenAccess	Obtient le paramètre d'accès au fichier pour le package.
PackageProperties	Obtient les propriétés principales du package.

Méthodes

Close()	Enregistre et ferme le package ainsi que tout flux sous-jacent des composants.
CreatePart(Uri, String)	Crée un nouveau composant non compressé avec un URI et un type de contenu donnés.
CreatePart(Uri, String, CompressionOption)	Crée un nouveau composant avec un URI, un type de contenu et une option de compression donnés.
CreatePartCore(Uri, String, CompressionOption)	En cas de substitution dans une classe dérivée, crée un nouveau composant dans le package.
CreateRelationship(Uri, TargetMode, String)	Crée une relation au niveau du package avec un composant avec URI, mode cible et type de relation donnés.
CreateRelationship(Uri, TargetMode, String, String)	Crée une relation au niveau du package à une partie avec un URI, un mode cible, un type de relation et un identificateur (ID) donnés.
DeletePart(Uri)	Supprime du package un composant avec un URI donné.
DeletePartCore(Uri)	En cas de substitution dans une classe dérivée, supprime un composant avec un URI donné.
DeleteRelationship(String)	Supprime une relation au niveau du package.
Dispose(Boolean)	Vide et enregistre le contenu de tous les composants et relations, ferme le package et libère toutes les ressources.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Flush()	Enregistre le contenu de tous les composants et relations contenus dans le package.
FlushCore()	En cas de substitution dans une classe dérivée, enregistre le contenu de tous les composants et relations dans le magasin de classes dérivées.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetPart(Uri)	Retourne le composant avec un URI donné.
GetPartCore(Uri)	En cas de substitution dans une classe dérivée, retourne le composant adressé par un URI donné.
GetParts()	Retourne une collection de tous les composants dans le package.
GetPartsCore()	Lors d'une substitution dans une classe dérivée, retourne un tableau contenant tous les composants dans le package.
GetRelationship(String)	Retourne la relation au niveau du package avec un identificateur donné.
GetRelationships()	Retourne une collection de toutes les relations au niveau du package.
GetRelationshipsByType(String)	Retourne une collection de toutes les relations au niveau du package correspondant à un RelationshipType donné.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Open(Stream)	Ouvre un package sur un flux de données E/S donné.
Open(Stream, FileMode)	Ouvre un package avec un flux de données E/S et un mode de fichier donnés.
Open(Stream, FileMode, FileAccess)	Ouvre un package avec un flux de données E/S, un mode de fichier et un paramètre d'accès au fichier donnés.
Open(String)	Ouvre un package à un chemin d'accès et nom de fichier donnés.
Open(String, FileMode)	Ouvre un package à un chemin d'accès donné au moyen d'un mode de fichier donné.
Open(String, FileMode, FileAccess)	Ouvre un package à un chemin d'accès donné à l'aide d'un mode de fichier et d'un paramètre d'accès au fichier donnés.
Open(String, FileMode, FileAccess, FileShare)	Ouvre un package à un chemin d'accès donné à l'aide d'un mode de fichier, d'un chemin d'accès et d'un paramètre de partage de fichier donnés.
PartExists(Uri)	Indique si un composant avec un URI donné est dans le package.
RelationshipExists(String)	Indique si une relation au niveau du package avec un ID donné est contenue dans le package.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Ce membre prend en charge l’infrastructure Windows Presentation Foundation (WPF) et n’est pas destiné à l’utilisation de l’application. Utilisez plutôt la méthode de type sécurisé Dispose(Boolean).

Voir aussi

• PackagePart
• XpsDocument
• Spécification OPC (Open Packaging Conventions)