Class DataStreamSupporter

Class DataStreamSupporter

De naam: Aspose.Imaging Verzameling: Aspose.Imaging.dll (25.4.0)

De data stream container.

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

Inheritance

object DisposableObject DataStreamSupporter

Derived

Image

Implements

IDisposable

Geëerbiede leden

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

Initialiseert een nieuwe instantie van de Aspose.Imaging.DataStreamSupporter-klasse.

[JsonConstructor]
protected DataStreamSupporter()

Fields

Tijdduur

De tijd om te wachten op synchronisatie

[JsonProperty]
protected int timeout

veldwaarde

int

Properties

DataStreamContainer

Geeft de gegevensstroom van het object.

public StreamContainer DataStreamContainer { get; }

Eigendomswaarde

StreamContainer

IsCached

Geeft een waarde die aangeeft of de gegevens van het object momenteel verborgen zijn en dat geen gegevenslezen vereist is.

public abstract bool IsCached { get; }

Eigendomswaarde

bool

Methods

CacheData()

Het verbergt de gegevens en zorgt ervoor dat geen aanvullende gegevensloading zal worden uitgevoerd vanaf de onderliggende Aspose.Imaging.DataStreamSupporter.

public abstract void CacheData()

Examples

Het volgende voorbeeld laat zien hoe beeldcaching de prestaties beïnvloedt. in het algemeen wordt het lezen van cached data sneller uitgevoerd dan het leren van niet-cached gegevens.

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)

Het wordt genoemd wanneer de data stream container verandert.

protected virtual void OnDataStreamContainerChanging(StreamContainer streamContainer)

Parameters

streamContainer StreamContainer

De stroom container.

ReleaseManagedResources()

Verwijder de beheerde middelen. zorg ervoor dat geen beheerde middelen hier worden vrijgegeven, omdat ze misschien al zijn vrijgegeven.

protected override void ReleaseManagedResources()

Save()

Bewaar de gegevens van het object naar de huidige Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Speelt de gegevens van het object naar de aangegeven stroom.

public void Save(Stream stream)

Parameters

stream Stream

De stroom om de gegevens van het object op te slaan.

Save(String)

Speelt de gegevens van het object naar de aangegeven bestandlocatie.

public virtual void Save(string filePath)

Parameters

filePath string

De bestandpad om de gegevens van het object op te slaan.

Save(String en Bool)

Speelt de gegevens van het object naar de aangegeven bestandlocatie.

public virtual void Save(string filePath, bool overWrite)

Parameters

filePath string

De bestandpad om de gegevens van het object op te slaan.

overWrite bool

als je ’true’ hebt ingesteld over het schrijven van de bestandinhoud, anders zal een aanvulling plaatsvinden.

SaveData(Stream)

Bespaar de gegevens.

protected abstract void SaveData(Stream stream)

Parameters

stream Stream

De stroom om gegevens op te slaan.

 Nederlands