Class DataStreamSupporter

Class DataStreamSupporter

Nazwa przestrzeń: Aspose.Imaging Zgromadzenie: Aspose.Imaging.dll (25.4.0)

Przepływ danych w kontenerze.

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

Inheritance

object DisposableObject DataStreamSupporter

Derived

Image

Implements

IDisposable

Dziedziczeni członkowie

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()

Constructors

DataStreamSupporter()

Inicjalizuje nową instancję klasy Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Fields

Czas wyjścia

Czas oczekiwania na synchronizację

[JsonProperty]
protected int timeout

Wartość pola

int

Properties

DataStreamContainer

Dostępuje strumień danych obiektu.

public StreamContainer DataStreamContainer { get; }

Wartość nieruchomości

StreamContainer

IsCached

Otrzymuje wartość wskazującą, czy dane obiektu są obecnie przechowywane, a nie wymagane jest czytanie danych.

public abstract bool IsCached { get; }

Wartość nieruchomości

bool

Methods

CacheData()

Kryje dane i gwarantuje, że żadne dodatkowe ładowanie danych nie zostanie wykonane z podłoża Aspose.Imaging.DataStreamSupporter.

public abstract void CacheData()

Examples

Poniższy przykład pokazuje, jak caching obrazu wpływa na wydajność.W ogóle, czytanie danych cache jest wykonywane szybciej niż odczytywanie nie-cache danych.

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

                                                                                                                                                                    // Load an image from a PNG file.
                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                    {
                                                                                                                                                                        // Cache all pixel data so that no additional data loading will be performed from the underlying data stream
                                                                                                                                                                        image.CacheData();

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

                                                                                                                                                                        // Reading all pixels is pretty fast.
                                                                                                                                                                        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("Reading all cached pixels took {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                    }

                                                                                                                                                                    // Load an image from a PNG file
                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                    {
                                                                                                                                                                        System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                        stopwatch.Start();

                                                                                                                                                                        // Reading all pixels is not as fast as when 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("Reading all pixels without preliminary caching took {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                    }

                                                                                                                                                                    // The output may look like this:
                                                                                                                                                                    // Reading all cached pixels took 1500 ms.
                                                                                                                                                                    // Reading all pixels without preliminary caching took 150000 ms.

OnDataStreamContainerChanging(StreamContainer)

Nazywa się, kiedy zmienia się pojemnik przepływu danych.

protected virtual void OnDataStreamContainerChanging(StreamContainer streamContainer)

Parameters

streamContainer StreamContainer

Przepływ kontenerów.

ReleaseManagedResources()

Upewnij się, że nie zarządzane zasoby nie są tutaj uwalniane, ponieważ mogą być już uwalniane.

protected override void ReleaseManagedResources()

Save()

Przechowuje dane obiektu do bieżącego Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Przechowuje dane obiektu do określonego strumienia.

public void Save(Stream stream)

Parameters

stream Stream

Przepływ do przechowywania danych obiektu do.

Save(strumień)

Przechowuje dane przedmiotu do określonego miejsca pliku.

public virtual void Save(string filePath)

Parameters

filePath string

Droga pliku do przechowywania danych obiektu do.

Save(Złoty, Bool)

Przechowuje dane przedmiotu do określonego miejsca pliku.

public virtual void Save(string filePath, bool overWrite)

Parameters

filePath string

Droga pliku do przechowywania danych obiektu do.

overWrite bool

Jeśli ustawiono na “prawdziwy” po napisaniu treści pliku, w przeciwnym razie pojawi się dodatek.

SaveData(Stream)

Oszczędzaj dane.

protected abstract void SaveData(Stream stream)

Parameters

stream Stream

Przepływ do przechowywania danych do.

 Polski