Class DataStreamSupporter

Class DataStreamSupporter

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

Kontejner datového proudu.

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

Dědění

objectDisposableObjectDataStreamSupporter

Odvozené

Image

Implementuje

IDisposable

Děděné členy

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

Konstruktor

DataStreamSupporter()

Inicializuje novou instanci třídy Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Pole

timeout

Časový limit pro čekání na synchronizaci.

[JsonProperty]
protected int timeout

Hodnota pole

int

Vlastnosti

DataStreamContainer

Získá datový proud objektu.

public StreamContainer DataStreamContainer { get; }

Hodnota vlastnosti

StreamContainer

IsCached

Získá hodnotu, která indikuje, zda jsou data objektu aktuálně uložená v cache a není potřeba číst žádná data.

public abstract bool IsCached { get; }

Hodnota vlastnosti

bool

Metody

CacheData()

Uloží data do cache a zajistí, že nebudou prováděna žádná další načítání dat z podkladového Aspose.Imaging.DataStreamSupporter.DataStreamContainer.

public abstract void CacheData()

Příklady

Následující příklad ukazuje, jak caching obrázků ovlivňuje výkon. V obecném případě je čtení uložených dat rychlejší než čtení neuložených dat.```csharp [C#]

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

                                                                                                                                                                // Načtení obrázku z PNG souboru.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Uloží všechny pixelové údaje do cache, aby nebylo potřeba provádět žádné další načítání dat z podkladového datového proudu
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // Čtení všech pixelů je docela rychlé.
                                                                                                                                                                    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("Čtení všech uložených pixelů trvalo {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Načtení obrázku z PNG souboru
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Čtení všech pixelů není tak rychlé jako při cachování
                                                                                                                                                                    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("Čtení všech pixelů bez předchozího cachování trvalo {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Výstup může vypadat takto:
                                                                                                                                                                // Čtení všech uložených pixelů trvalo 1500 ms.
                                                                                                                                                                // Čtení všech pixelů bez předchozího cachování trvalo 150000 ms.

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

Volá se, když se mění kontejner datového proudu.

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

Parametry

streamContainer StreamContainer

Kontejner proudu.

ReleaseManagedResources()

Uvolňuje spravované zdroje. Ujistěte se, že zde nejsou uvolněny žádné nespravované zdroje, protože ty mohly být již uvolněny.

protected override void ReleaseManagedResources()

Save()

Uloží data objektu do aktuálního Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Uloží data objektu do zadaného proudu.

public void Save(Stream stream)

Parametry

stream Stream

Proud, do kterého se mají uložit data objektu.

Save(string)

Uloží data objektu na zadané umístění souboru.

public virtual void Save(string filePath)

Parametry

filePath string

Cesta k souboru, kam se mají uložit data objektu.

Save(string, bool)

Uloží data objektu na zadané umístění souboru.

public virtual void Save(string filePath, bool overWrite)

Parametry

filePath string

Cesta k souboru, kam se mají uložit data objektu.

overWrite bool

pokud je nastaveno na ```cstrue, přepíše obsah souboru, jinak dojde k přidání.

SaveData(Stream)

Uloží data.

protected abstract void SaveData(Stream stream)

Parametry

stream Stream

Proud, do kterého se mají uložit data.

 Čeština