Class DataStreamSupporter

Class DataStreamSupporter

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

O contêiner de fluxo de dados.

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

Herança

objectDisposableObjectDataStreamSupporter

Derivados

Image

Implementa

IDisposable

Membros Herdados

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

Construtores

DataStreamSupporter()

Inicializa uma nova instância da classe Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Campos

timeout

O tempo limite para aguardar a sincronização.

[JsonProperty]
protected int timeout

Valor do Campo

int

Propriedades

DataStreamContainer

Obtém o fluxo de dados do objeto.

public StreamContainer DataStreamContainer { get; }

Valor da Propriedade

StreamContainer

IsCached

Obtém um valor indicando se os dados do objeto estão atualmente em cache e não é necessário ler dados.

public abstract bool IsCached { get; }

Valor da Propriedade

bool

Métodos

CacheData()

Armazena em cache os dados e garante que nenhum carregamento adicional de dados seja realizado a partir do Aspose.Imaging.DataStreamSupporter.DataStreamContainer subjacente.

public abstract void CacheData()

Exemplos

O exemplo a seguir mostra como o cache de imagens afeta o desempenho. Em geral, a leitura de dados em cache é realizada mais rapidamente do que a leitura de dados não em cache.```csharp [C#]

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

                                                                                                                                                                // Carrega uma imagem de um arquivo PNG.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Armazena em cache todos os dados de pixel para que nenhum carregamento adicional de dados seja realizado a partir do fluxo de dados subjacente
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // Ler todos os pixels é 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("Ler todos os pixels em cache levou {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Carrega uma imagem de um arquivo PNG
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // Ler todos os pixels não é tão rápido quanto quando em 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("Ler todos os pixels sem cache preliminar levou {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // A saída pode parecer assim:
                                                                                                                                                                // Ler todos os pixels em cache levou 1500 ms.
                                                                                                                                                                // Ler todos os pixels sem cache preliminar levou 150000 ms.

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

Chamado quando o contêiner de fluxo de dados está mudando.

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

Parâmetros

streamContainer StreamContainer

O contêiner de fluxo.

ReleaseManagedResources()

Libera os recursos gerenciados. Certifique-se de que nenhum recurso não gerenciado seja liberado aqui, pois eles podem já ter sido liberados.

protected override void ReleaseManagedResources()

Save()

Salva os dados do objeto no atual Aspose.Imaging.DataStreamSupporter.

public virtual void Save()

Save(Stream)

Salva os dados do objeto no fluxo especificado.

public void Save(Stream stream)

Parâmetros

stream Stream

O fluxo para salvar os dados do objeto.

Save(string)

Salva os dados do objeto na localização de arquivo especificada.

public virtual void Save(string filePath)

Parâmetros

filePath string

O caminho do arquivo para salvar os dados do objeto.

Save(string, bool)

Salva os dados do objeto na localização de arquivo especificada.

public virtual void Save(string filePath, bool overWrite)

Parâmetros

filePath string

O caminho do arquivo para salvar os dados do objeto.

overWrite bool

se definido como ```cstrue substituirá o conteúdo do arquivo, caso contrário, ocorrerá a adição.

SaveData(Stream)

Salva os dados.

protected abstract void SaveData(Stream stream)

Parâmetros

stream Stream

O fluxo para salvar os dados.

 Português