Class DataStreamSupporter

Class DataStreamSupporter

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

Le conteneur de flux de données.

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

Héritage

objectDisposableObjectDataStreamSupporter

Dérivé

Image

Implemente

IDisposable

Membres hérités

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

Constructeurs

DataStreamSupporter()

Initialise une nouvelle instance de la classe Aspose.Imaging.DataStreamSupporter.

[JsonConstructor]
protected DataStreamSupporter()

Champs

timeout

Le délai d’attente pour attendre la synchronisation.

[JsonProperty]
protected int timeout

Valeur du champ

int

Propriétés

DataStreamContainer

Obtient le flux de données de l’objet.

public StreamContainer DataStreamContainer { get; }

Valeur de la propriété

StreamContainer

IsCached

Obtient une valeur indiquant si les données de l’objet sont actuellement mises en cache et qu’aucune lecture de données n’est requise.

public abstract bool IsCached { get; }

Valeur de la propriété

bool

Méthodes

CacheData()

Met en cache les données et s’assure qu’aucun chargement de données supplémentaire ne sera effectué à partir du conteneur de flux de données sous-jacent Aspose.Imaging.DataStreamSupporter.DataStreamContainer.

public abstract void CacheData()

Exemples

L’exemple suivant montre comment la mise en cache d’image affecte les performances. En général, la lecture des données mises en cache est effectuée plus rapidement que la lecture des données non mises en cache.```csharp [C#]

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

                                                                                                                                                                // Charger une image à partir d'un fichier PNG.
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    // Mettre en cache toutes les données de pixels afin qu'aucun chargement de données supplémentaire ne soit effectué à partir du flux de données sous-jacent
                                                                                                                                                                    image.CacheData();

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

                                                                                                                                                                    // La lecture de tous les pixels est assez rapide.
                                                                                                                                                                    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 lecture de tous les pixels mis en cache a pris {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // Charger une image à partir d'un fichier PNG
                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
                                                                                                                                                                {
                                                                                                                                                                    System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
                                                                                                                                                                    stopwatch.Start();

                                                                                                                                                                    // La lecture de tous les pixels n'est pas aussi rapide que lors de la mise en 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 lecture de tous les pixels sans mise en cache préalable a pris {0} ms.", stopwatch.ElapsedMilliseconds);
                                                                                                                                                                }

                                                                                                                                                                // La sortie peut ressembler à ceci :
                                                                                                                                                                // La lecture de tous les pixels mis en cache a pris 1500 ms.
                                                                                                                                                                // La lecture de tous les pixels sans mise en cache préalable a pris 150000 ms.

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

Appelée lorsque le conteneur de flux de données est en train de changer.

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

Paramètres

streamContainer StreamContainer

Le conteneur de flux.

ReleaseManagedResources()

Libère les ressources gérées. Assurez-vous qu’aucune ressource non gérée n’est libérée ici, car elles ont peut-être déjà été libérées.

protected override void ReleaseManagedResources()

Save()

Sauvegarde les données de l’objet dans l’Aspose.Imaging.DataStreamSupporter actuel.

public virtual void Save()

Save(Stream)

Sauvegarde les données de l’objet dans le flux spécifié.

public void Save(Stream stream)

Paramètres

stream Stream

Le flux dans lequel sauvegarder les données de l’objet.

Save(string)

Sauvegarde les données de l’objet à l’emplacement de fichier spécifié.

public virtual void Save(string filePath)

Paramètres

filePath string

Le chemin du fichier pour sauvegarder les données de l’objet.

Save(string, bool)

Sauvegarde les données de l’objet à l’emplacement de fichier spécifié.

public virtual void Save(string filePath, bool overWrite)

Paramètres

filePath string

Le chemin du fichier pour sauvegarder les données de l’objet.

overWrite bool

si défini sur ```cstrue, écrase le contenu du fichier, sinon un ajout sera effectué.

SaveData(Stream)

Sauvegarde les données.

protected abstract void SaveData(Stream stream)

Paramètres

stream Stream

Le flux dans lequel sauvegarder les données.

 Français