Class DataStreamSupporter

Class DataStreamSupporter

Namespace: Aspose.Imaging
Assembly: Aspose.Imaging.dll (25.2.0)

Der Datenstromcontainer.

[JsonObject(MemberSerialization.OptIn)]
public abstract class DataStreamSupporter : DisposableObject, IDisposable

Vererbung

objectDisposableObjectDataStreamSupporter

Abgeleitet

Image

Implementiert

IDisposable

Vererbte Mitglieder

DisposableObject.Dispose(), DisposableObject.ReleaseManagedResources(), DisposableObject.ReleaseUnmanagedResources(), DisposableObject.VerifyNotDisposed(), DisposableObject.Disposed, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Konstruktoren

DataStreamSupporter()

Initialisiert eine neue Instanz der Klasse Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Felder

timeout

Die Zeitüberschreitung, um auf die Synchronisierung zu warten.

[JsonProperty]
protected int timeout

Feldwert

int

Eigenschaften

DataStreamContainer

Erhält den Datenstrom des Objekts.

public StreamContainer DataStreamContainer { get; }

Eigenschaftswert

StreamContainer

IsCached

Erhält einen Wert, der angibt, ob die Daten des Objekts derzeit zwischengespeichert sind und kein Datenlesen erforderlich ist.

public abstract bool IsCached { get; }

Eigenschaftswert

bool

Methoden

CacheData()

Speichert die Daten im Cache und stellt sicher, dass keine zusätzlichen Daten aus dem zugrunde liegenden Aspose.Imaging.DataStreamSupporter.DataStreamContainer geladen werden.

public abstract void CacheData()

Beispiele

Das folgende Beispiel zeigt, wie sich das Caching von Bildern auf die Leistung auswirkt. Im Allgemeinen erfolgt das Lesen von zwischengespeicherten Daten schneller als das Lesen von nicht zwischengespeicherten Daten.```csharp [C#]

                                                                                                                                                                string dir = "c:\\temp\\";

                                                                                                                                                                // Laden Sie ein Bild aus einer PNG-Datei.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Alle Pixel-Daten zwischenspeichern, damit keine zusätzlichen Daten aus dem zugrunde liegenden Datenstrom geladen werden
                                                                                                                                                                    image.CacheData();

                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Das Lesen aller Pixel ist ziemlich schnell.
                                                                                                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
                                                                                                                                                                    for (int y = 0; y < image.Height; y++)
                                                                                                                                                                    {
                                                                                                                                                                        for (int x = 0; x < image.Width; x++)
                                                                                                                                                                        {
                                                                                                                                                                            int color = rasterImage.GetArgb32Pixel(x, y);
                                                                                                                                                                        }
                                                                                                                                                                    }

                                                                                                                                                                    stopwatch.Stop();
                                                                                                                                                                    System.Console.WriteLine("Das Lesen aller zwischengespeicherten Pixel dauerte {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Laden Sie ein Bild aus einer PNG-Datei
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Das Lesen aller Pixel ist nicht so schnell wie beim Caching
                                                                                                                                                                    Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
                                                                                                                                                                    for (int y = 0; y < image.Height; y++)
                                                                                                                                                                    {
                                                                                                                                                                        for (int x = 0; x < image.Width; x++)
                                                                                                                                                                        {
                                                                                                                                                                            int color = rasterImage.GetArgb32Pixel(x, y);
                                                                                                                                                                        }
                                                                                                                                                                    }

                                                                                                                                                                    stopwatch.Stop();
                                                                                                                                                                    System.Console.WriteLine("Das Lesen aller Pixel ohne vorheriges Caching dauerte {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Die Ausgabe könnte so aussehen:
                                                                                                                                                                // Das Lesen aller zwischengespeicherten Pixel dauerte 1500 ms.
                                                                                                                                                                // Das Lesen aller Pixel ohne vorheriges Caching dauerte 150000 ms.

### <a id="Aspose_Imaging_DataStreamSupporter_OnDataStreamContainerChanging_Aspose_Imaging_StreamContainer_"></a> OnDataStreamContainerChanging\(StreamContainer\)

Wird aufgerufen, wenn sich der Datenstromcontainer ändert.

```csharp
protected virtual void OnDataStreamContainerChanging(StreamContainer streamContainer)

Parameter

streamContainer StreamContainer

Der Stream-Container.

ReleaseManagedResources()

Gibt die verwalteten Ressourcen frei. Stellen Sie sicher, dass hier keine nicht verwalteten Ressourcen freigegeben werden, da diese möglicherweise bereits freigegeben wurden.

protected override void ReleaseManagedResources()

Save()

Speichert die Daten des Objekts im aktuellen Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Speichert die Daten des Objekts im angegebenen Stream.

public void Save(Stream stream)

Parameter

stream Stream

Der Stream, in den die Daten des Objekts gespeichert werden.

Save(string)

Speichert die Daten des Objekts am angegebenen Speicherort.

public virtual void Save(string filePath)

Parameter

filePath string

Der Dateipfad, an dem die Daten des Objekts gespeichert werden.

Save(string, bool)

Speichert die Daten des Objekts am angegebenen Speicherort.

public virtual void Save(string filePath, bool overWrite)

Parameter

filePath string

Der Dateipfad, an dem die Daten des Objekts gespeichert werden.

overWrite bool

Wenn auf ```cstrue gesetzt, werden die Dateiinhalte überschrieben, andernfalls erfolgt eine Anhängung.

SaveData(Stream)

Speichert die Daten.

protected abstract void SaveData(Stream stream)

Parameter

stream Stream

Der Stream, in den die Daten gespeichert werden.

 Deutsch