Class DataStreamSupporter

Class DataStreamSupporter

Název místa: Aspose.Imaging Shromáždění: Aspose.Imaging.dll (25.4.0)

Data stream kontejner.

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

Inheritance

object DisposableObject DataStreamSupporter

Derived

Image

Implements

IDisposable

Dědiční členové

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

Začíná nový příklad třídy Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Fields

Časový

Čas čekání na synchronizaci

[JsonProperty]
protected int timeout

Polní hodnota

int

Properties

DataStreamContainer

Obsahuje tok dat objektu.

public StreamContainer DataStreamContainer { get; }

Hodnota nemovitosti

StreamContainer

IsCached

Obdrží hodnotu, která naznačuje, zda jsou data objektu v současné době krytá a není nutné číst údaje.

public abstract bool IsCached { get; }

Hodnota nemovitosti

bool

Methods

CacheData()

Ukládá údaje a zajišťuje, že žádné dodatečné datové nabíjení nebude provedeno z podkladového Aspose.Imaging.DataStreamSupporter.DataStreamContainer.

public abstract void CacheData()

Examples

Následující příklad ukazuje, jak image caching ovlivňuje výkonnost.V obecném případě se čtení cache dat provádí rychleji než čtení non-cache dat.

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)

Volá se, když se data stream kontejner se měn.

protected virtual void OnDataStreamContainerChanging(StreamContainer streamContainer)

Parameters

streamContainer StreamContainer

Přechodový kontejner.

ReleaseManagedResources()

Ujistěte se, že zde nejsou zveřejněny žádné nezveřejněné zdroje, protože mohou být již zveřejně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 určeného toku.

public void Save(Stream stream)

Parameters

stream Stream

Průtok zachraňuje data objektu.

Save(Stringová)

Uloží data objektu na specifikovanou polohu souboru.

public virtual void Save(string filePath)

Parameters

filePath string

Souborový průvodce pro ukládání údajů o objektu.

Save(Stringová, boolová)

Uloží data objektu na specifikovanou polohu souboru.

public virtual void Save(string filePath, bool overWrite)

Parameters

filePath string

Souborový průvodce pro ukládání údajů o objektu.

overWrite bool

Pokud je nastaven na “pravdivý” přes psaní obsahu souboru, jinak se přidání objev.

SaveData(Stream)

Ušetříme data.

protected abstract void SaveData(Stream stream)

Parameters

stream Stream

Příliv pro ukládání dat.

 Čeština