Bonjour, j'essaie de supprimer un élément de la liste filesPath mais impossible, un message d'erreur s'affiche et je comprend pas pourquoi

Je résume ce que mon programme doit faire. Lire à partir d'un fichier texte: les chemins d'accès au fichier, puis les mettres dans filesPath.

Vérifier que le chemin existe donc que l'image existe bien, et s'il existe pas, supprimer la ligne du fichier en question.

Mais arriver à la 1ère boucle foreach, le programme plante en m'affichant cette erreur.

Voici mon code:

public string[] LoadDenialImageList()
        {
            if (Directory.Exists(PATH_DENIALIMAGES))
            {
                string filePathDenialList = PATH_DENIALIMAGES + "denial-list.txt";
                if (File.Exists(filePathDenialList))
                {
                    var stream = new FileStream(@filePathDenialList, FileMode.Open, FileAccess.Read);
                    List<string> filesPath;
                    using (var reader = new StreamReader(stream))
                    {
                        filesPath = new List<string>(reader.ReadToEnd().Split("\r".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)); 
                    }

                    int i = 0;
                    foreach (string line in filesPath)
                    {
                        if (!File.Exists(PATH_DENIALIMAGES + line))
                            filesPath.RemoveAt(i);
                        i++;
                    }
                    foreach (string s in filesPath)
                        System.Windows.Forms.MessageBox.Show(s);
                    return filesPath.ToArray();

                }
            }
            return null;
        }

Merci d'avance de votre aide!

Normal, vu que tu modifies la liste en la parcourant, c'est problématique. Dans ces cas, là on fait plutôt une boucle for en partant du dernier indice de la liste

for (i=filesPath.Count-1;i>=0;i--)
{
    if (!File.Exists(PATH_DENIALIMAGES + filesPath[i]))
        filesPath.RemoveAt(i);
}

umfred a écrit:

Normal, vu que tu modifies la liste en la parcourant, c'est problématique. Dans ces cas, là on fait plutôt une boucle for en partant du dernier indice de la liste

for (i=filesPath.Count-1;i>=0;i--)
{
    if (!File.Exists(PATH_DENIALIMAGES + filesPath[i]))
        filesPath.RemoveAt(i);
}

Merci @umfred c'est nickel

Malheureusement pour moi, il me reste une erreur à corriger qui me semble plus complexe que ce que je pense.

En faite, je prend une image du web je la télécharge et s'il elle est identique à celle qui est dans mon dossier d'image alors la supprimer.

Sauf que le temps que sa télécharge et que le bitmap se charge et tout.. Bah le File.Delete vient tout gacher car l'image n'est pas encore telechargé à fond, du coup y aurait-il quelque chose à faire à ce niveau là ?

if (DownloadImage(imageNameURL, imagePath))
                        Extension.SaveOptions(STARTNBR, CheckBoxBack.Checked);
                    if (Fichier.ImageIsBlackList(imagePath))
                        File.Delete(imagePath);

private static byte[] RGBValues(Bitmap bmp1)
        {
            BitmapData curBitmapData = bmp1.LockBits(new Rectangle(0, 0, bmp1.Width, bmp1.Height),
                            ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

            Int32 stride = curBitmapData.Stride;
            Byte[] data = new Byte[stride * bmp1.Height];
            Marshal.Copy(curBitmapData.Scan0, data, 0, data.Length);
            bmp1.UnlockBits(curBitmapData);

            return data;
        }

        private Bitmap BitmapImage2Bitmap(BitmapImage bitmapImage)
        {
            using (MemoryStream outStream = new MemoryStream())
            {
                BitmapEncoder enc = new BmpBitmapEncoder();
                enc.Frames.Add(BitmapFrame.Create(bitmapImage));
                enc.Save(outStream);
                Bitmap bitmap = new Bitmap(outStream);

                return new Bitmap(bitmap);
            }
        }

        public Bitmap NewBitmapWithFileName(string filename)
        {
            BitmapImage image = new BitmapImage();
            using (var stream = File.OpenRead(filename))
            {
                image.BeginInit();
                image.CacheOption = BitmapCacheOption.OnLoad;
                image.StreamSource = stream;
                image.EndInit();
            }
            if (image != null)
                return BitmapImage2Bitmap(image);
            return null;
        }

        public bool ImageIsBlackList(string filename)
        {
            int length = RGBIMAGES.Length;
            int i, tmp = 0;
            for (i = 0; i < length; i++)
            {
                byte[] rgbValue = RGBValues(NewBitmapWithFileName(filename));

                for (int j = 0; j != RGBIMAGES[i].Length; j++)
                {
                    if (RGBIMAGES[i][j] != rgbValue[j])
                    {
                        tmp++;
                        break;
                    }
                }
            }
            if (tmp == length)
                return false;
            return true;
        }

Merci de ton aide en tout cas

ce n'est pas ta fonction isblacklist qui serait mal fichue ? vérifie qu'elle fait bien ce que tu penses qu'elle fait. teste la sur 2 images qui ont des similarités. (pas tout à fait identiques mais presque)