Class DataStreamSupporter

Class DataStreamSupporter

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

El contenedor de flujo de datos.

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

Herencia

objectDisposableObjectDataStreamSupporter

Derivados

Image

Implementa

IDisposable

Miembros heredados

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

Constructores

DataStreamSupporter()

Inicializa una nueva instancia de la clase Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Campos

timeout

El tiempo de espera para esperar la sincronización.

[JsonProperty]
protected int timeout

Valor del campo

int

Propiedades

DataStreamContainer

Obtiene el flujo de datos del objeto.

public StreamContainer DataStreamContainer { get; }

Valor de la propiedad

StreamContainer

IsCached

Obtiene un valor que indica si los datos del objeto están actualmente en caché y no se requiere lectura de datos.

public abstract bool IsCached { get; }

Valor de la propiedad

bool

Métodos

CacheData()

Cachea los datos y asegura que no se realice ninguna carga adicional de datos desde el Aspose.Imaging.DataStreamSupporter.DataStreamContainer subyacente.

public abstract void CacheData()

Ejemplos

El siguiente ejemplo muestra cómo el almacenamiento en caché de imágenes afecta el rendimiento. En general, la lectura de datos en caché se realiza más rápido que la lectura de datos no en caché.```csharp [C#]

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

                                                                                                                                                                // Cargar una imagen desde un archivo PNG.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Cachear todos los datos de píxeles para que no se realice ninguna carga adicional de datos desde el flujo de datos subyacente
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // Leer todos los píxeles es bastante rápido.
                                                                                                                                                                    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("Leer todos los píxeles en caché tomó {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Cargar una imagen desde un archivo PNG
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Leer todos los píxeles no es tan rápido como cuando se utiliza caché
                                                                                                                                                                    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("Leer todos los píxeles sin caché preliminar tomó {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // La salida puede verse así:
                                                                                                                                                                // Leer todos los píxeles en caché tomó 1500 ms.
                                                                                                                                                                // Leer todos los píxeles sin caché preliminar tomó 150000 ms.

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

Se llama cuando el contenedor de flujo de datos está cambiando.

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

Parámetros

streamContainer StreamContainer

El contenedor de flujo.

ReleaseManagedResources()

Libera los recursos administrados. Asegúrate de que no se liberen recursos no administrados aquí, ya que pueden haber sido liberados ya.

protected override void ReleaseManagedResources()

Save()

Guarda los datos del objeto en el actual Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Guarda los datos del objeto en el flujo especificado.

public void Save(Stream stream)

Parámetros

stream Stream

El flujo para guardar los datos del objeto.

Save(string)

Guarda los datos del objeto en la ubicación de archivo especificada.

public virtual void Save(string filePath)

Parámetros

filePath string

La ruta del archivo para guardar los datos del objeto.

Save(string, bool)

Guarda los datos del objeto en la ubicación de archivo especificada.

public virtual void Save(string filePath, bool overWrite)

Parámetros

filePath string

La ruta del archivo para guardar los datos del objeto.

overWrite bool

si se establece en ```cstrue se sobrescribirá el contenido del archivo, de lo contrario se añadirá.

SaveData(Stream)

Guarda los datos.

protected abstract void SaveData(Stream stream)

Parámetros

stream Stream

El flujo para guardar datos.

 Español