Package Classe

Définition

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
Package
Dérivé
Implémente

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 cadre du document. (Cela est similaire au cas où un fichier HTML a une <IMG> balise 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 la partie document en tant qu’élément racine du package. Une deuxième relation, « au niveau du composant », définit l’association entre la partie de document (la « source » de la relation au niveau de la partie) et son utilisation de la partie de l’image (« cible » de la relation au niveau de la partie). Pour obtenir l’exemple complet, consultez écriture d’un exemple de package.

//  -------------------------- 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 seule entité d’un format physique défini pour la portabilité et un accès efficace.

Un fichier ZIP est le format physique principal de Package . PackageD’autres 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 organisation hiérarchique de dossiers et de fichiers.

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

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

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

  • Une relation au niveau du package (créée par la Package.CreateRelationship méthode) associe un Package à l’un ou l’autre :

    • Composant cible dans le package.

    • Ressource cible en dehors du package.

  • Une relation au niveau du composant (créée par la PackagePart.CreateRelationship méthode) lie une source PackagePart à l’un ou l’autre des éléments suivants :

    • Une autre partie cible dans le package.

    • Ressource cible en dehors du package.

La source ou la source de la relation Package PackagePart est considérée comme le « propriétaire » de la relation. Lorsque l’objet source est supprimé, toutes les relations détenues par l’objet source sont également supprimées. Le processus de création ou de suppression d’une relation ne change 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’expéditeur et valide que les parties et les relations signées contenues dans le n' Package ont pas été modifiées.

Les packages prennent également en charge la Rights Management numérique (DRM) qui permet le chiffrement des éléments de contenu dans un Package à l’aide de droits d’accès spécifiques accordés aux utilisateurs autorisés.

En fonction de l' Package architecture, un XpsDocument est un type de package conçu pour stocker des documents basés sur le XPS (Open XML Paper Specification).

le .NET Framework utilise des packages pour stocker le contenu, les ressources et les relations des pages et des documents à l’aide d’un fichier ZIP standard par défaut. Comme avec tout fichier ZIP, votre application peut utiliser les System.IO.Packaging classes pour stocker et éventuellement protéger tout 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://go.microsoft.com/fwlink/?LinkID=71255 .

Constructeurs

Package(FileAccess)

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

Package(FileAccess, Boolean)

Initialise une nouvelle instance de la classe Package qui utilise un FileAccess et une option de diffusion donnés.

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 avec un composant avec un URI donné, le mode cible, le type de relation et l’identificateur (ID).

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é à être utilisé par l’application. Utilisez plutôt la méthode de type sécurisé Dispose(Boolean).

S’applique à

Voir aussi