Package Klas

Definitie

public ref class Package abstract : IDisposable

public abstract class Package : IDisposable

type Package = class
    interface IDisposable

Public MustInherit Class Package
Implements IDisposable

Overname

Object

Package

Afgeleid

System.IO.Packaging.ZipPackage

Implementeringen

IDisposable

Voorbeelden

In het volgende voorbeeld ziet u de basisstappen voor het maken van een Package. In dit voorbeeld wordt een pakket gemaakt dat een document bevat, samen met een afbeelding die wordt weergegeven als onderdeel van het document. (Dit is vergelijkbaar met het geval waarin een HTML-bestand een <IMG-tag> die verwijst naar een extern afbeeldingsbestand.) Er zijn ook twee PackageRelationship elementen opgenomen in het pakket. De eerste, een relatie op pakketniveau, definieert het documentonderdeel als het hoofdelement van het pakket. Een tweede relatie op onderdeelniveau definieert de koppeling tussen het documentonderdeel (de 'bron' van de relatie op onderdeelniveau) en het gebruik van het afbeeldingsonderdeel (het doel van de relatie op onderdeelniveau).

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

Opmerkingen

Package is een abstracte klasse die kan worden gebruikt om objecten te ordenen in één entiteit van een gedefinieerde fysieke indeling voor draagbaarheid en efficiënte toegang.

Een ZIP-bestand is de primaire fysieke indeling voor de Package. Andere Package implementaties kunnen andere fysieke indelingen gebruiken, zoals een XML-document, een database of webservice.

Net als een bestandssysteem worden items in een bestand Package waarnaar wordt verwezen in een hiërarchische organisatie van mappen en bestanden.

Hoewel Package zichzelf een abstracte klasse is, wordt de ZipPackage afgeleide klasse standaard gebruikt door de Open methode.

Een PackagePart ("onderdeel") is de abstracte klasse die een object vertegenwoordigt dat is opgeslagen in een Package.

Een PackageRelationship ("relatie") definieert een koppeling tussen een bron Package of PackagePart een doelobject. Een PackageRelationship kan een van twee typen zijn, die elk een van twee vormen kunnen zijn:

• Een relatie op pakketniveau (gemaakt door de Package.CreateRelationship methode) heeft betrekking Package op een van de volgende:

  • Een doelonderdeel in het pakket.
  • Een doelresource buiten het pakket.

• Een relatie op onderdeelniveau (gemaakt door de methode) heeft betrekking op een van PackagePart de PackagePart.CreateRelationship volgende bronnen:

  • Een ander doelonderdeel in het pakket.
  • Een doelresource buiten het pakket.

De bron Package of bron PackagePart van de relatie wordt beschouwd als de 'eigenaar' van de relatie. Wanneer het bronobject wordt verwijderd, worden alle relaties die eigendom zijn van het bronobject ook verwijderd. Het proces voor het maken of verwijderen van een relatie verandert niet fysiek de bron- of doelobjecten op welke manier dan ook.

Een PackageDigitalSignature ("digitale handtekening") is een samenstelling van onderdelen en relaties die een digitale handtekening vertegenwoordigen die deel uitmaakt van een Package. De digitale handtekening identificeert de originator en valideert dat de ondertekende onderdelen en relaties in de Package handtekening niet zijn gewijzigd.

Pakketten bieden ook ondersteuning voor Digital Rights Management (DRM), waarmee inhoudselementen in een Package worden versleuteld met specifieke toegangsrechten die zijn verleend aan geautoriseerde gebruikers.

Op basis van de Package architectuur is een XpsDocument pakkettype ontworpen voor het opslaan van documenten op basis van de open XML Paper Specification (XPS).

.NET Framework maakt gebruik van pakketten voor het opslaan van inhoud, resources en relaties voor pagina's en documenten met behulp van een standaard ZIP-bestand. Net als bij elk ZIP-bestand kan uw toepassing de System.IO.Packaging klassen gebruiken om elk type of aantal gegevensbestanden op te slaan en optioneel te beveiligen in één container voor efficiënte toegang.

Zie de OPC-specificatie (Open Packaging Conventions) die u kunt downloaden voor https://www.ecma-international.org/publications-and-standards/standards/ecma-376/meer informatie.

Zie ook

• PackagePart
• XpsDocument
• OpC-specificatie (Open Packaging Conventions)