Classe Package

Package è una classe astratta che può essere utilizzata per organizzare oggetti in una sola entità di un formato fisico definito per portabilità ed accesso efficiente.

Un file zip è il formato fisico primario per Package. Altre implementazioni di Package possono utilizzare altri formati fisici come un documento XML, un database, o un servizio Web.

Come un file system, gli elementi contenuti in un Package sono organizzati in una gerarchica di cartelle e file.

Sebbene Package sia una classe astratta, la classe derivata ZipPackage viene utilizzata come impostazione predefinita dal metodo Open.

PackagePart (la "parte") è la classe astratta che rappresenta un oggetto archiviato in Package.

PackageRelationship (la "relazione") definisce un'associazione tra Package di origine o PackagePart e un oggetto di destinazione. Una PackageRelationship può essere di due tipi, ognuno dei quali può essere di uno di due formati:

• Una relazione (creata dal metodo Package.CreateRelationship ) a livello di pacchetto mette in correlazione Package con:

  • Una parte di destinazione nel pacchetto.

  • Una risorsa di destinazione fuori del pacchetto.

• Una relazione (creata dal metodo PackagePart.CreateRelationship ) a livello di parte mette in correlazione PackagePart con:

  • Un'altra parte di destinazione nel pacchetto.

  • Una risorsa di destinazione fuori del pacchetto.

La sorgente della relazione Package o PackagePart è considerata “proprietaria" della relazione stessa. Quando l'oggetto di origine viene eliminato, anche tutte le altre relazioni delle quali esso è proprietario vengono eliminate. Il processo di creazione o di eliminazione di una relazione non modifica fisicamente in alcun modo nè la sorgente nè gli oggetti di destinazione.

PackageDigitalSignature (la "firma digitale") è una composizione di parti e relazioni che rappresentano una firma digitale inclusa in Package. La firma digitale identifica il creatore e conferma che le parti e le relazioni contenute nel Package non sono state modificate.

I Package supportano inoltre Gestione dei diritti digitali (DRM) la quale consente agli elementi contenuti in un oggetto Package di essere crittografati con specifici diritti di accesso consentiti agli utenti autorizzati.

In base all'architettura di Package, XpsDocument è un tipo di pacchetto progettato per archiviare documenti secondo la specifica XML Paper Specification (XPS)

Microsoft .NET Framework utilizza pacchetti per archiviare contenuti, risorse e relazioni per pagine e documenti tramite un file ZIP standard per impostazione predefinita. Come con qualsiasi file ZIP, la vostra applicazione può utilizzare le classi di System.IO.Packaging per archiviare e opzionalmente proteggere qualsiasi tipo o numero di file di dati in un unico contenitore ad accesso efficiente.

Per ulteriori informazioni, vedere la specifica Open Packaging Conventions (OPC) disponibile per il download all'indirizzo http://go.microsoft.com/fwlink/?LinkID=71255.

Nell'esempio seguente vengono illustrati i passaggi di base per la creazione di Package. In questo esempio, un pacchetto viene creato per contenere un documento insieme a un'immagine grafica che viene visualizzata come parte del documento. (Si tratta del caso simile nel quale un file HTML ha un tag < IMG > che fa riferimento a un file di immagine esterno.) Nel pacchetto sono inclusi anche due elementi PackageRelationship. Il primo, una relazione a livello" di "pacchetto, definisce la parte del documento come l'elemento radice del pacchetto. Il secondo, la relazione a "livello di "parte, definisce l'associazione tra la parte del documento (l' "origine" della relazione a livello di parte) e l'utilizzo della parte dell'immagine (la "destinazione" della relazione a livello di parte). Per l'esempio completo, vedere Esempio di scrittura di 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()

.NET Framework

.NET Framework Client Profile

Windows 7, Windows Vista SP1 o versione successiva, Windows Server 2008 (componenti di base del server non supportati), Windows Server 2008 R2 (componenti di base del server supportati con SP1 o versione successiva)

Riferimenti

Altre risorse