Package Klasa

Definicja

Przestrzeń nazw:

System.IO.Packaging

Zestaw:

System.IO.Packaging.dll

Pakiet:

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

Źródło:

Package.cs

Reprezentuje kontener, który może przechowywać wiele obiektów danych.

public ref class Package abstract : IDisposable

public abstract class Package : IDisposable

type Package = class
    interface IDisposable

Public MustInherit Class Package
Implements IDisposable

Dziedziczenie

Object

Package

Pochodne

System.IO.Packaging.ZipPackage

Przykłady

W poniższym przykładzie przedstawiono podstawowe kroki tworzenia elementu Package. W tym przykładzie tworzony jest pakiet zawierający dokument wraz z obrazem graficznym wyświetlanym w ramach dokumentu. (Jest to podobne do przypadku, w którym plik HTML ma <Tag IMG> , który odwołuje się do pliku obrazu zewnętrznego). W pakiecie znajdują się również dwa PackageRelationship elementy. Pierwsza relacja "na poziomie pakietu" definiuje część dokumentu jako element główny pakietu. Druga relacja "na poziomie części" definiuje skojarzenie między częścią dokumentu ("źródłem" relacji na poziomie części) i jego użyciem części obrazu ("element docelowy" relacji na poziomie części).

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

Uwagi

Package to abstrakcyjna klasa, która może służyć do organizowania obiektów w jedną jednostkę zdefiniowanego formatu fizycznego w celu przenoszenia i wydajnego dostępu.

Plik ZIP jest podstawowym formatem fizycznym dla pliku Package. Inne Package implementacje mogą używać innych formatów fizycznych, takich jak dokument XML, baza danych lub usługa sieci Web.

Podobnie jak system plików, elementy zawarte w obiekcie Package są przywoływania w hierarchicznej organizacji folderów i plików.

Chociaż Package sama jest klasą abstrakcyjną, ZipPackage klasa pochodna jest używana domyślnie przez metodę Open .

A PackagePart ("część") to klasa abstrakcyjna, która reprezentuje obiekt przechowywany w obiekcie Package.

Obiekt PackageRelationship ("relacja") definiuje skojarzenie między źródłem Package lub PackagePart obiektem docelowym. Może PackageRelationship to być jeden z dwóch typów, z których każdy może być jednym z dwóch formularzy:

• Relacja na poziomie pakietu (utworzona przez Package.CreateRelationship metodę) odnosi się do jednego z Package następujących elementów:

  • Część docelowa w pakiecie.
  • Zasób docelowy poza pakietem.

• Relacja na poziomie części (utworzona przez PackagePart.CreateRelationship metodę) wiąże źródło PackagePart z jednym z następujących elementów:

  • Inna część docelowa w pakiecie.
  • Zasób docelowy poza pakietem.

Źródło lub źródło PackagePart relacji Package jest uważane za "właściciela" relacji. Po usunięciu obiektu źródłowego wszystkie relacje należące do obiektu źródłowego również zostaną usunięte. Proces tworzenia lub usuwania relacji nie zmienia fizycznie obiektów źródłowych ani docelowych w żaden sposób.

A PackageDigitalSignature ("podpis cyfrowy") to kompozycja części i relacji reprezentujących podpis cyfrowy dołączony do elementu Package. Podpis cyfrowy identyfikuje inicjatora i sprawdza, czy podpisane części i relacje zawarte w Package obiekcie nie zostały zmodyfikowane.

Pakiety obsługują również usługę Digital Rights Management (DRM), która umożliwia szyfrowanie elementów zawartości przy Package użyciu określonych praw dostępu przyznanych autoryzowanym użytkownikom.

Oparty na architekturze Package jest XpsDocument typem pakietu przeznaczonym do przechowywania dokumentów na podstawie otwartej specyfikacji papieru XML (XPS).

.NET Framework domyślnie używa pakietów do przechowywania zawartości, zasobów i relacji dla stron i dokumentów przy użyciu standardowego pliku ZIP. Podobnie jak w przypadku dowolnego pliku ZIP, aplikacja może używać System.IO.Packaging klas do przechowywania i opcjonalnie ochrony dowolnego typu lub liczby plików danych w jednym wydajnym kontenerze dostępu.

Aby uzyskać więcej informacji, zobacz specyfikację Open Packaging Conventions (OPC) dostępną do pobrania pod adresem https://www.ecma-international.org/publications-and-standards/standards/ecma-376/.

Konstruktory

Package(FileAccess)

Inicjuje Package nowe wystąpienie klasy, która używa danego FileAccesselementu .

Właściwości

FileOpenAccess	Pobiera ustawienie dostępu do pliku dla pakietu.
PackageProperties	Pobiera podstawowe właściwości pakietu.

Metody

Close()	Zapisuje i zamyka pakiet oraz wszystkie bazowe strumienie części.
CreatePart(Uri, String)	Tworzy nową nieskompresowaną część z danym identyfikatorem URI i typem zawartości.
CreatePart(Uri, String, CompressionOption)	Tworzy nową część z danym identyfikatorem URI, typem zawartości i opcją kompresji.
CreatePartCore(Uri, String, CompressionOption)	Po przesłonięciu w klasie pochodnej tworzy nową część pakietu.
CreateRelationship(Uri, TargetMode, String)	Tworzy relację na poziomie pakietu ze częścią z danym identyfikatorem URI, trybem docelowym i typem relacji.
CreateRelationship(Uri, TargetMode, String, String)	Tworzy relację na poziomie pakietu z częścią z danym identyfikatorem URI, trybem docelowym, typem relacji i identyfikatorem (ID).
DeletePart(Uri)	Usuwa część z danego identyfikatora URI z pakietu.
DeletePartCore(Uri)	Gdy zastąpisz klasę pochodną, usuwa część z danym identyfikatorem URI.
DeleteRelationship(String)	Usuwa relację na poziomie pakietu.
Dispose(Boolean)	Opróżnia i zapisuje zawartość wszystkich części i relacji, zamyka pakiet i zwalnia wszystkie zasoby.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
Flush()	Zapisuje zawartość wszystkich części i relacji zawartych w pakiecie.
FlushCore()	Po zastąpieniu klasy pochodnej zapisuje zawartość wszystkich części i relacji w magazynie klas pochodnych.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetPart(Uri)	Zwraca część z danym identyfikatorem URI.
GetPartCore(Uri)	Po przesłonięciu w klasie pochodnej zwraca część adresowaną przez dany identyfikator URI.
GetParts()	Zwraca kolekcję wszystkich części pakietu.
GetPartsCore()	Po zastąpieniu klasy pochodnej zwraca tablicę wszystkich części pakietu.
GetRelationship(String)	Zwraca relację na poziomie pakietu z danym identyfikatorem.
GetRelationships()	Zwraca kolekcję wszystkich relacji na poziomie pakietu.
GetRelationshipsByType(String)	Zwraca kolekcję wszystkich relacji na poziomie pakietu, które pasują do danego RelationshipTypeelementu .
GetType()	Type Pobiera bieżące wystąpienie. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Open(Stream)	Otwiera pakiet w danym strumieniu we/wy.
Open(Stream, FileMode)	Otwiera pakiet z danym strumieniem we/wy i trybem pliku.
Open(Stream, FileMode, FileAccess)	Otwiera pakiet z danym strumieniem we/wy, trybem plików i ustawieniem dostępu do plików.
Open(String)	Otwiera pakiet pod daną ścieżką i nazwą pliku.
Open(String, FileMode)	Otwiera pakiet w danej ścieżce przy użyciu danego trybu pliku.
Open(String, FileMode, FileAccess)	Otwiera pakiet w danej ścieżce przy użyciu danego trybu pliku i ustawienia dostępu do plików.
Open(String, FileMode, FileAccess, FileShare)	Otwiera pakiet w danej ścieżce przy użyciu danego trybu plików, dostępu do plików i ustawienia udziału plików.
PartExists(Uri)	Wskazuje, czy część z danym identyfikatorem URI znajduje się w pakiecie.
RelationshipExists(String)	Wskazuje, czy relacja na poziomie pakietu z danym identyfikatorem jest zawarta w pakiecie.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Jawne implementacje interfejsu

IDisposable.Dispose()

Ten element członkowski obsługuje infrastrukturę Windows Presentation Foundation (WPF) i nie jest przeznaczony do użycia aplikacji. Zamiast tego należy użyć metody bezpiecznej Dispose(Boolean) typu.

Zobacz też

• PackagePart
• XpsDocument
• Specyfikacja open packaging conventions (OPC)