Class DataStreamSupporter

Class DataStreamSupporter

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

Kontener strumienia danych.

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

Dziedziczenie

objectDisposableObjectDataStreamSupporter

Pochodne

Image

Implementuje

IDisposable

Członkowie dziedziczeni

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

Konstruktorzy

DataStreamSupporter()

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

[JsonConstructor]
protected DataStreamSupporter()

Pola

timeout

Czas oczekiwania na synchronizację.

[JsonProperty]
protected int timeout

Wartość pola

int

Właściwości

DataStreamContainer

Zwraca strumień danych obiektu.

public StreamContainer DataStreamContainer { get; }

Wartość właściwości

StreamContainer

IsCached

Zwraca wartość wskazującą, czy dane obiektu są aktualnie buforowane i nie jest wymagane odczytywanie danych.

public abstract bool IsCached { get; }

Wartość właściwości

bool

Metody

CacheData()

Buforuje dane i zapewnia, że nie będą wykonywane dodatkowe operacje ładowania danych z podstawowego Aspose.Imaging.DataStreamSupporter.DataStreamContainer.

public abstract void CacheData()

Przykłady

Poniższy przykład pokazuje, jak buforowanie obrazów wpływa na wydajność. W ogólnym przypadku odczyt danych buforowanych jest szybszy niż odczyt danych niebuforowanych.```csharp [C#]

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

                                                                                                                                                                // Załaduj obraz z pliku PNG.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Buforuj wszystkie dane pikseli, aby nie były wykonywane dodatkowe operacje ładowania danych z podstawowego strumienia danych
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // Odczyt wszystkich pikseli jest dość szybki.
                                                                                                                                                                    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("Odczyt wszystkich buforowanych pikseli zajął {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Załaduj obraz z pliku PNG
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Odczyt wszystkich pikseli nie jest tak szybki jak przy buforowaniu
                                                                                                                                                                    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("Odczyt wszystkich pikseli bez wstępnego buforowania zajął {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Wynik może wyglądać tak:
                                                                                                                                                                // Odczyt wszystkich buforowanych pikseli zajął 1500 ms.
                                                                                                                                                                // Odczyt wszystkich pikseli bez wstępnego buforowania zajął 150000 ms.

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

Wywoływane, gdy kontener strumienia danych się zmienia.

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

Parametry

streamContainer StreamContainer

Kontener strumienia.

ReleaseManagedResources()

Zwalnia zarządzane zasoby. Upewnij się, że żadne niezarządzane zasoby nie są zwalniane tutaj, ponieważ mogły zostać już zwolnione.

protected override void ReleaseManagedResources()

Save()

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

public virtual void Save()

Save(Stream)

Zapisuje dane obiektu do określonego strumienia.

public void Save(Stream stream)

Parametry

stream Stream

Strumień, do którego zostaną zapisane dane obiektu.

Save(string)

Zapisuje dane obiektu do określonej lokalizacji pliku.

public virtual void Save(string filePath)

Parametry

filePath string

Ścieżka pliku, do której zostaną zapisane dane obiektu.

Save(string, bool)

Zapisuje dane obiektu do określonej lokalizacji pliku.

public virtual void Save(string filePath, bool overWrite)

Parametry

filePath string

Ścieżka pliku, do której zostaną zapisane dane obiektu.

overWrite bool

jeśli ustawione na ```cstrue nadpisuje zawartość pliku, w przeciwnym razie nastąpi dodanie.

SaveData(Stream)

Zapisuje dane.

protected abstract void SaveData(Stream stream)

Parametry

stream Stream

Strumień, do którego zostaną zapisane dane.

 Polski