Class DataStreamSupporter

Class DataStreamSupporter

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

Il contenitore del flusso di dati.

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

Ereditarietà

objectDisposableObjectDataStreamSupporter

Derivato

Image

Implementa

IDisposable

Membri Ereditati

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

Costruttori

DataStreamSupporter()

Inizializza una nuova istanza della classe Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Campi

timeout

Il timeout da attendere per la sincronizzazione

[JsonProperty]
protected int timeout

Valore del Campo

int

Proprietà

DataStreamContainer

Ottiene il flusso di dati dell’oggetto.

public StreamContainer DataStreamContainer { get; }

Valore della Proprietà

StreamContainer

IsCached

Ottiene un valore che indica se i dati dell’oggetto sono attualmente memorizzati nella cache e non è necessaria alcuna lettura dei dati.

public abstract bool IsCached { get; }

Valore della Proprietà

bool

Metodi

CacheData()

Memorizza nella cache i dati e assicura che non venga eseguita alcuna ulteriore operazione di caricamento dei dati dal sottostante Aspose.Imaging.DataStreamSupporter.DataStreamContainer.

public abstract void CacheData()

Esempi

Il seguente esempio mostra come la memorizzazione nella cache delle immagini influisce sulle prestazioni. In generale, la lettura dei dati memorizzati nella cache è più veloce rispetto alla lettura dei dati non memorizzati nella cache.```csharp [C#]

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

                                                                                                                                                                // Carica un'immagine da un file PNG.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Memorizza nella cache tutti i dati dei pixel in modo che non venga eseguito alcun ulteriore caricamento dei dati dal flusso di dati sottostante
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // La lettura di tutti i pixel è piuttosto veloce.
                                                                                                                                                                    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("La lettura di tutti i pixel memorizzati nella cache ha impiegato {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Carica un'immagine da un file PNG
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // La lettura di tutti i pixel non è veloce come quando si memorizza nella cache
                                                                                                                                                                    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("La lettura di tutti i pixel senza memorizzazione preliminare nella cache ha impiegato {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // L'output potrebbe apparire così:
                                                                                                                                                                // La lettura di tutti i pixel memorizzati nella cache ha impiegato 1500 ms.
                                                                                                                                                                // La lettura di tutti i pixel senza memorizzazione preliminare nella cache ha impiegato 150000 ms.

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

Chiamato quando il contenitore del flusso di dati sta cambiando.

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

Parametri

streamContainer StreamContainer

Il contenitore del flusso.

ReleaseManagedResources()

Rilascia le risorse gestite. Assicurati che non vengano rilasciate risorse non gestite qui, poiché potrebbero essere già state rilasciate.

protected override void ReleaseManagedResources()

Save()

Salva i dati dell’oggetto nell’attuale Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Salva i dati dell’oggetto nel flusso specificato.

public void Save(Stream stream)

Parametri

stream Stream

Il flusso in cui salvare i dati dell’oggetto.

Save(string)

Salva i dati dell’oggetto nella posizione di file specificata.

public virtual void Save(string filePath)

Parametri

filePath string

Il percorso del file in cui salvare i dati dell’oggetto.

Save(string, bool)

Salva i dati dell’oggetto nella posizione di file specificata.

public virtual void Save(string filePath, bool overWrite)

Parametri

filePath string

Il percorso del file in cui salvare i dati dell’oggetto.

overWrite bool

se impostato su ```cstrue sovrascrive il contenuto del file, altrimenti si verificherà un’aggiunta.

SaveData(Stream)

Salva i dati.

protected abstract void SaveData(Stream stream)

Parametri

stream Stream

Il flusso in cui salvare i dati.

 Italiano