Class DataStreamSupporter

Class DataStreamSupporter

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

Datastreambehållaren.

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

Arv

objectDisposableObjectDataStreamSupporter

Härledd

Image

Implementerar

IDisposable

Arvade medlemmar

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

Konstruktörer

DataStreamSupporter()

Initialiserar en ny instans av klassen Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Fält

timeout

Timeout för att vänta på synkronisering

[JsonProperty]
protected int timeout

Fältvärde

int

Egenskaper

DataStreamContainer

Hämtar objektets datastream.

public StreamContainer DataStreamContainer { get; }

Egenskapsvärde

StreamContainer

IsCached

Hämtar ett värde som indikerar om objektets data för närvarande är cachad och ingen dataläsning krävs.

public abstract bool IsCached { get; }

Egenskapsvärde

bool

Metoder

CacheData()

Cachar datan och säkerställer att ingen ytterligare dataladdning kommer att utföras från den underliggande Aspose.Imaging.DataStreamSupporter.DataStreamContainer.

public abstract void CacheData()

Exempel

Följande exempel visar hur bildcaching påverkar prestanda. I allmänhet är läsning av cachad data snabbare än läsning av icke-cachad data.```csharp [C#]

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

                                                                                                                                                                // Ladda en bild från en PNG-fil.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Cache alla pixeldata så att ingen ytterligare dataladdning kommer att utföras från den underliggande datastreamen
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // Att läsa alla pixlar är ganska snabbt.
                                                                                                                                                                    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("Att läsa alla cachade pixlar tog {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Ladda en bild från en PNG-fil
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Att läsa alla pixlar är inte lika snabbt som när 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("Att läsa alla pixlar utan preliminär caching tog {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Utdata kan se ut så här:
                                                                                                                                                                // Att läsa alla cachade pixlar tog 1500 ms.
                                                                                                                                                                // Att läsa alla pixlar utan preliminär caching tog 150000 ms.

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

Anropas när datastreambehållaren ändras.

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

Parametrar

streamContainer StreamContainer

Datastreambehållaren.

ReleaseManagedResources()

Frigör de hanterade resurserna. Se till att inga icke-hanterade resurser frigörs här, eftersom de kan ha frigjorts redan.

protected override void ReleaseManagedResources()

Save()

Sparar objektets data till den aktuella Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Sparar objektets data till den angivna streamen.

public void Save(Stream stream)

Parametrar

stream Stream

Streamen för att spara objektets data till.

Save(string)

Sparar objektets data till den angivna filplatsen.

public virtual void Save(string filePath)

Parametrar

filePath string

Filvägen för att spara objektets data till.

Save(string, bool)

Sparar objektets data till den angivna filplatsen.

public virtual void Save(string filePath, bool overWrite)

Parametrar

filePath string

Filvägen för att spara objektets data till.

overWrite bool

om inställt på ```cstrue skriv över filinnehållet, annars kommer det att läggas till.

SaveData(Stream)

Sparar datan.

protected abstract void SaveData(Stream stream)

Parametrar

stream Stream

Streamen för att spara data till.

 Svenska