Image.Save (..) lève une exception GDI + car le flux de mémoire est fermé

J'ai des données binaires que je veux enregistrer sous forme d'image. Lorsque j'essaie d'enregistrer l'image, cela lève une exception si le flux de mémoire utilisé pour créer l'image a été fermé avant l'enregistrement. La raison pour laquelle je fais cela est parce que je crée dynamiquement des images et en tant que tel .. j'ai besoin d'utiliser un flux de mémoire.

c'est le code:

[TestMethod]
public void TestMethod1()
{
    // Grab the binary data.
    byte[] data = File.ReadAllBytes("Chick.jpg");

    // Read in the data but do not close, before using the stream.
    Stream originalBinaryDataStream = new MemoryStream(data);
    Bitmap image = new Bitmap(originalBinaryDataStream);
    image.Save(@"c:\test.jpg");
    originalBinaryDataStream.Dispose();

    // Now lets use a nice dispose, etc...
    Bitmap2 image2;
    using (Stream originalBinaryDataStream2 = new MemoryStream(data))
    {
        image2 = new Bitmap(originalBinaryDataStream2);
    }

    image2.Save(@"C:\temp\pewpew.jpg"); // This throws the GDI+ exception.
}

Quelqu'un a-t-il des suggestions sur la façon dont je pourrais enregistrer une image avec le flux fermé? Je ne peux pas compter sur les développeurs pour se souvenir de fermer le flux une fois l'image enregistrée. En fait, le développeur n'aurait AUCUNE IDÉE que l'image a été générée en utilisant un flux mémoire (car cela se produit dans un autre code, ailleurs).

Je suis vraiment confus :(

Comme il s'agit d'un MemoryStream, vous n'avez vraiment pas besoin de fermer le flux - il ne se passera rien de grave si vous ne le faites pas, bien que de toute façon, il soit bon de disposer de tout ce qui est jetable. (Voir cette question pour en savoir plus.)

Cependant, vous devriez supprimer le Bitmap - et cela fermera le flux pour vous. En gros, une fois que vous donnez un flux au constructeur Bitmap, il "possède" le flux et vous ne devriez pas le fermer. Comme le disent les documents de ce constructeur :

Vous devez garder le flux ouvert pendant toute la durée de vie du Bitmap.

Je ne trouve aucun document promettant de fermer le flux lorsque vous supprimez le bitmap, mais vous devriez pouvoir le vérifier assez facilement.

Une erreur générique s'est produite dans GDI +. Peut également résulter d' un chemin de sauvegarde incorrect ! Il m'a fallu une demi-journée pour le remarquer. Assurez-vous donc que vous avez également vérifié le chemin pour enregistrer l'image.

Peut-être vaut-il la peine de mentionner que si le répertoire C: \ Temp n'existe pas, il lèvera également cette exception même si votre flux existe toujours.

J'ai eu le même problème mais en fait la cause était que l'application n'avait pas l'autorisation d'enregistrer des fichiers sur C. Lorsque j'ai changé en "D: \ .." l'image a été enregistrée.

Copiez le Bitmap. Vous devez garder le flux ouvert pendant toute la durée de vie du bitmap.

Lors du dessin d'une image: System.Runtime.InteropServices.ExternalException: une erreur générique s'est produite dans GDI

    public static Image ToImage(this byte[] bytes)
    {
        using (var stream = new MemoryStream(bytes))
        using (var image = Image.FromStream(stream, false, true))
        {
            return new Bitmap(image);
        }
    }

    [Test]
    public void ShouldCreateImageThatCanBeSavedWithoutOpenStream()
    {
        var imageBytes = File.ReadAllBytes("bitmap.bmp");

        var image = imageBytes.ToImage();

        image.Save("output.bmp");
    }

Vous pouvez essayer de créer une autre copie du bitmap:

using (var memoryStream = new MemoryStream())
{
    // write to memory stream here

    memoryStream.Position = 0;
    using (var bitmap = new Bitmap(memoryStream))
    {
        var bitmap2 = new Bitmap(bitmap);
        return bitmap2;
    }
}

Cette erreur m'est apparue lorsque j'essayais de Citrix. Le dossier image a été défini sur C: \ sur le serveur, pour lequel je n'ai pas de privilège. Une fois le dossier d'image déplacé vers un lecteur partagé, l'erreur a disparu.

Une erreur générique s'est produite dans GDI +. Cela peut se produire en raison de problèmes de chemins de stockage d'images, j'ai eu cette erreur parce que mon chemin de stockage est trop long, j'ai résolu ce problème en stockant d'abord l'image dans un chemin le plus court et en la déplaçant vers l'emplacement correct avec des techniques de gestion des longs chemins.

J'obtenais cette erreur, car le test automatisé que j'exécutais essayait de stocker des instantanés dans un dossier qui n'existait pas. Après avoir créé le dossier, l'erreur a été résolue

Une solution étrange qui a fait fonctionner mon code. Ouvrez l'image dans Paint et enregistrez-la en tant que nouveau fichier au même format (.jpg). Maintenant, essayez avec ce nouveau fichier et cela fonctionne. Cela vous explique clairement que le fichier peut être corrompu d'une manière ou d'une autre. Cela ne peut aider que si votre code a tous les autres bogues corrigés

Il est également apparu avec moi lorsque j'essayais de sauvegarder une image dans le chemin

C:\Program Files (x86)\some_directory

et le .exen'a pas été exécuté pour fonctionner en tant qu'administrateur, j'espère que cela peut également aider quelqu'un qui a le même problème.

Pour moi, le code ci-dessous s'est écrasé A generic error occurred in GDI+sur la ligne qui enregistre dans un fichier MemoryStream. Le code s'exécutait sur un serveur Web et je l'ai résolu en arrêtant et en démarrant le pool d'applications qui exécutait le site.

Il doit y avoir une erreur interne dans GDI +

    private static string GetThumbnailImageAsBase64String(string path)
    {
        if (path == null || !File.Exists(path))
        {
            var log = ContainerResolver.Container.GetInstance<ILog>();
            log.Info($"No file was found at path: {path}");
            return null;
        }

        var width = LibraryItemFileSettings.Instance.ThumbnailImageWidth;

        using (var image = Image.FromFile(path))
        {
            using (var thumbnail = image.GetThumbnailImage(width, width * image.Height / image.Width, null, IntPtr.Zero))
            {
                using (var memoryStream = new MemoryStream())
                {
                    thumbnail.Save(memoryStream, ImageFormat.Png); // <= crash here 
                    var bytes = new byte[memoryStream.Length];
                    memoryStream.Position = 0;
                    memoryStream.Read(bytes, 0, bytes.Length);
                    return Convert.ToBase64String(bytes, 0, bytes.Length);
                }
            }
        }
    }

Je suis tombé sur cette erreur lorsque j'essayais une simple retouche d'image dans une application WPF.

La définition de la source d'un élément Image sur le bitmap empêche l'enregistrement du fichier. Même la définition de Source = null ne semble pas libérer le fichier.

Maintenant, je n'utilise jamais l'image comme élément Source de l'image, je peux donc l'écraser après l'édition!

ÉDITER

Après avoir entendu parler de la propriété CacheOption (grâce à @Nyerguds), j'ai trouvé la solution: donc au lieu d'utiliser le constructeur Bitmap, je dois définir l'URI après le réglage CacheOption BitmapCacheOption.OnLoad( Image1ci-dessous, l' Imageélément Wpf )

Au lieu de

Image1.Source = new BitmapImage(new Uri(filepath));

Utilisation:

var image = new BitmapImage();
image.BeginInit();
image.CreateOptions = BitmapCreateOptions.IgnoreImageCache;
image.CacheOption = BitmapCacheOption.OnLoad;
image.UriSource = new Uri(filepath);
image.EndInit();
Image1.Source = image;

Voir ceci: Mise en cache d'image WPF

Essayez ce code:

static void Main(string[] args)
{
    byte[] data = null;
    string fullPath = @"c:\testimage.jpg";

    using (MemoryStream ms = new MemoryStream())
    using (Bitmap tmp = (Bitmap)Bitmap.FromFile(fullPath))
    using (Bitmap bm = new Bitmap(tmp))
    {
        bm.SetResolution(96, 96);
        using (EncoderParameters eps = new EncoderParameters(1))
        {   
            eps.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 100L);
            bm.Save(ms, GetEncoderInfo("image/jpeg"), eps);
        }

        data = ms.ToArray();
    }

    File.WriteAllBytes(fullPath, data);
}

private static ImageCodecInfo GetEncoderInfo(string mimeType)
{
        ImageCodecInfo[] encoders = ImageCodecInfo.GetImageEncoders();

        for (int j = 0; j < encoders.Length; ++j)
        {
            if (String.Equals(encoders[j].MimeType, mimeType, StringComparison.InvariantCultureIgnoreCase))
                return encoders[j];
        }
    return null;
}

J'ai utilisé le processeur d'image pour redimensionner les images et un jour j'ai eu l'exception "Une erreur générique s'est produite dans GDI +".

Après avoir regardé un moment, j'ai essayé de recycler le pool d'applications et de bingo, cela fonctionne. Alors je le note ici, j'espère que ça aidera;)

À votre santé