Gestion de processus

**Stormy31** · 30/03/2009, 16h00

Bonjour !
Je souhaiterais effacer un fichier pour lequel j'effectue un traitement préalable. J'ai survolé le forum et le net mais n'ai pas trouvé de réponses adéquate à mes attentes...
Voici le code de mon application:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    private void btnOK_Click(object sender, EventArgs e)
        {
            picnumber = 0;
            string nom = ConfigurationManager.AppSettings[0]; //récupération du répertoire dépot des fichiers scannés
            DirectoryInfo dir = new DirectoryInfo(nom);
            FileInfo[] file = dir.GetFiles();
            int cpt = 0;
            foreach (FileInfo fi in file)
            {
                if (cpt == 0)
                {
                    doMultipageTiffSave(nom + "\\Num_GAP.tiff");//création d'un tiff multipage "hote"
                }
                else
                {
                    if (fi.Name != "Num_GAP.tiff")
                    {
                        doExistingFileSave(nom + "\\Num_GAP.tiff");//insertion des autres images dans le tiff généré en premier
                        cpt++;
 
                    }
                }
 
            }
 
   // Envoi du fichier tiff multipage
 
            //Vidage du répertoire de stockage des fichiers scannés
 
             foreach (string f in Directory.GetFiles(nom))
                {
                    try
                    {   
                        File.Delete(f);
                    }
                    catch (Exception ere)
                    {
                        MessageBox.Show(ere.ToString());
                    }
                }
}

Pour commentaires, j'ai un répertoire contenant des fichiers image. Je le parcours dans un premier temps pour générer un fichier TIFF multipage et je voudrais ensuite supprimer ces fichiers une fois que ce tiff multipage a été envoyé là où je le souhaite.
Mais lors de la tentative de suppression, j'ai un message d'erreur disant que le fichier image est toujours en cours d'utilisation par un autre processus...

Quelqu'un aurait-il une solution pour m'aider ??

Merci

**alavoler** · 30/03/2009, 16h08

tu oublis de faire un close de ton fichier quelque part...

Le best practice dans ton cas est d'utiliser un using{ }, le close se fera automatiquement apres la fermeture de l'accolade.

**Lyche** · 30/03/2009, 16h09

tu as pensé à fermer ton fichier avant de le supprimer?

edit : grilled

**Stormy31** · 30/03/2009, 16h18

J'avoue que je suis débutant en C# ... après mon parcours de fichier un fi.Close() ne marchait pas ...

Quelqu'un pourrait-il m'éclairer sur l'utilisation de ce using svp ??

**alavoler** · 30/03/2009, 16h23

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
            using (StreamReader sr = new StreamReader("TestFile.txt")) 
            {
                string line;
                // Read and display lines from the file until the end of 
                // the file is reached.
                while ((line = sr.ReadLine()) != null) 
                {
                    Console.WriteLine(line);
                }
            }

**Stormy31** · 30/03/2009, 16h26

Merci j'avais trouvé cet extrait de code là... mais un StreamReader est-il valable pour des fichiers images ?
Ce sont des TIFF que je traite ...

**alavoler** · 30/03/2009, 16h42

Ba j'en sais rien...

ca depend de l'objet que t 'utilises en ce moment ?

le using est valable pour d'autre chose que les StreamReader...

**Stormy31** · 30/03/2009, 17h16

A priori sur le peu de docs que j'ai vu StreamReader ne s'applique sur des fichiers textes....
QUelqu'un a-t-il autre chose à me proposer ??

**Lyche** · 30/03/2009, 17h40

regarde du côté de la bibliothèque FileStream, je m'en sers pour mon stream de PDF et ça marche très bien. Je crois que c'est du générique pour la lecture de fichier tout type.

**Stormy31** · 30/03/2009, 17h46

Merci pour toutes vos remarques...

J'ai remplacé la première phase de parcours des fichiers ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
            for (int i = 0; i < file.Length; i++)
            {
                FileStream fr;
                fr = file[i].OpenRead();
                if (cpt == 0)
                {
                    doMultipageTiffSave(nom + "\\Num_GAP.tiff");//création d'un tiff multipage "hote"
                }
                else
                {
                    if (file[i].Name != "Num_GAP.tiff")
                    {
                        doExistingFileSave(nom + "\\Num_GAP.tiff");//insertion des autres images dans le tiff généré en premier
                        cpt++;
 
                    }
                }
                fr.Close();
            }

J'ai malheureusement toujours la même erreur concernant les processus ...

**Lyche** · 30/03/2009, 18h10

je vois que tu n'ouvres pas ton fileStream

Il te faudrait faire quelque chose comme ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
fr = new FileStream(File[i]);

dans ton tableau File[], est-ce que c'est le nom du fichier qui est stocké, ou le chemin d'accès complet?

**Stormy31** · 30/03/2009, 18h36

Il s'agit juste du nom de fichier

**Stormy31** · 31/03/2009, 11h56

Bon en fait j'ai continué à réfléchir sur mon problème... et visiblement ce n'est pas ici qu'est le soucis...

Pour recadrer le contexte, j'ai une IHM. Je clique sur un bouton de traitement qui effectue donc une opération. Je clique ensuite un bouton de validation qui doit me permettre de supprimer mes fichiers.

Comment puis-je "purger" et libérer les ressources de manière automatique à la fin de mon traitement pour pouvoir supprimer mes fichiers automatiquement...
Il s'agit de fichier .tiff que je veux supprimer...

Donc voilà si quelqu'un pouvait éventuellement m'aider ... ça serait sympa

**Lyche** · 31/03/2009, 11h57

dans ces cas là il te faut changer ta déclaration d'ouverture de FileStream par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
  for (int i = 0; i < file.Length; i++)
            {
                //Lorsque tu déclares un nouvel objet, tu dois l'instancier avec la commande new, cela l'ouvre et le charge en mémoire.
                FileStream fr = new FileStream("monAdresseFichier" + File[i]);
                //n'oublie pas l'adressage du dossier d'où provient ton fichier. ex : "c:\\monFichier".
                if (cpt == 0)
                {
                    doMultipageTiffSave(nom + "\\Num_GAP.tiff");//création d'un tiff multipage "hote"
                }
                else
                {
                    if (file[i].Name != "Num_GAP.tiff")
                    {
                        doExistingFileSave(nom + "\\Num_GAP.tiff");//insertion des autres images dans le tiff généré en premier
                        cpt++;
 
                    }
                }
                fr.Close();
            }

Cordialement.

**Stormy31** · 31/03/2009, 12h12

Merci de ta réponse ... mais je crois que le soucis ne vient pas de ce coin là ...
Enfin je vais regarder déjà avec ce que tu m'as mis

Si quelqu'un a une idée sur là où je pense que se situe le problème

**ppphil** · 31/03/2009, 14h35

Je ne sais pas ce que vous bricolez, mais il me semble que cela ne sert à rien d'ouvrir des stream et autre choses.....
Dans le code que l'on voit, on utilise que le nom du fichier mais en aucun cas on n'ouvre ce fichier...
Donc pas besoin de le fermer (ben voyon...)
Il serait beaucoup plus intéressant de savoir ce que fait doMultipageTiffSave().
Et c'est probablement là que le fichier n'est pas fermé correctement.....

**Lyche** · 31/03/2009, 15h10

Il n'est carrément pas ouvert le fichier, ni même exploité, c'est là le hic. Tu demandes à créer un fichier tiff, mais nul part tu ne précises quel fichier est exploité.

pphil à raison, il faudrait que tu nous transmettes les codes de tes 2 fonctions, celles qui ajoute et celle qui crée le fichier de base.

**Stormy31** · 31/03/2009, 15h55

Je vois ce que vous voulez dire ...
Le but de mon programme est de numériser des docs et de les stocker, puis de les envoyer sur un serveur.
L'IHM me permet de numériser à partir d'un bouton et envoyer avec un autre.
Mais en fait en bidouillant un peu, je me rends compte que les fichiers sont bien numérisés et bien stockés là où je veux, mais lorsque la numérisation est finie, les fichiers ne sont pas supprimables à la main car on me dit qu'ils sont déjà utilisés par un processus ... Donc je pense que le problème vient de là...

voici le code des différentes méthodes utilisées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
   private void btnNumeriser_Click(object sender, EventArgs e)
        {
            if (!msgfilter)
            {
                this.Enabled = false;
                msgfilter = true;
                Application.AddMessageFilter(this);
            }
            tw.FastAcquire();
        }
 
        public void FastAcquire()
        {
            InternatAcquire(0);
        }
 
       public void InternatAcquire(int mode)
        {
            TwRC rc;
            CloseSrc();
            if (appid.Id == IntPtr.Zero)
            {
                Init(hwnd);
                if (appid.Id == IntPtr.Zero)
                    return;
            }
            rc = DSMident(appid, IntPtr.Zero, TwDG.Control, TwDAT.Identity, TwMSG.OpenDS, srcds);
            if (rc != TwRC.Success)
                return;
 
            TwCapability cap = new TwCapability(TwCap.XferCount, 1);
            rc = DScap(appid, srcds, TwDG.Control, TwDAT.Capability, TwMSG.Set, cap);
            if (rc != TwRC.Success)
            {
                CloseSrc();
                return;
            }
 
            TwUserInterface guif = new TwUserInterface();
            guif.ShowUI = (short)mode;
            guif.ModalUI = 1;
            guif.ParentHand = hwnd;
            rc = DSuserif(appid, srcds, TwDG.Control, TwDAT.UserInterface, TwMSG.EnableDS, guif);
            if (rc != TwRC.Success)
            {
                CloseSrc();
                return;
            }
        }
 
 
        bool IMessageFilter.PreFilterMessage(ref Message m)
        {
            TwainCommand cmd = tw.PassMessage(ref m);
            if (cmd == TwainCommand.Not)
                return false;
 
            switch (cmd)
            {
                case TwainCommand.CloseRequest:
                    {
                        EndingScan();
                        tw.CloseSrc();
                        break;
                    }
                case TwainCommand.CloseOk:
                    {
                        EndingScan();
                        tw.CloseSrc();
                        break;
                    }
                case TwainCommand.DeviceEvent:
                    {
                        break;
                    }
                case TwainCommand.TransferReady:
                    {
                        ArrayList pics = tw.TransferPictures();
                        EndingScan();
                        tw.CloseSrc();
                        picnumber++;
                        for (int i = 0; i < pics.Count; i++)
                        {
                            IntPtr img = (IntPtr)pics[i];
                            PicForm newpic = new PicForm(img);
                            string nom = ConfigurationManager.AppSettings[0];
                            String name = nom+"\\Scan_"+picnumber.ToString()+".tiff";
 
                            Gdip.SaveDIBAs(name, newpic.bmpptr, newpic.pixptr);  
                            createPanel(name);                           
                        }
                        break;                      
                    }
            }           
            return true;
        }
 
 
 
        public static bool SaveDIBAs(string picname, IntPtr bminfo, IntPtr pixdat)
        {           
            Guid clsid;
            GetCodecClsid(picname, out clsid);
            IntPtr img = IntPtr.Zero;
            int st = GdipCreateBitmapFromGdiDib(bminfo, pixdat, ref img);
            if ((st != 0) || (img == IntPtr.Zero))
                return false;
 
            st = GdipSaveImageToFile(img, picname, ref clsid, IntPtr.Zero);
            GdipDisposeImage(img);
            return st == 0;
        }
 
        [DllImport("gdiplus.dll", ExactSpelling = true)]
        internal static extern int GdipDisposeImage(IntPtr image);

C'est assez brutal ... j'avoue

C'est une partie de code que j'ai récupéré d'un pilote twain codé en C# qui fonctionne "classiquement". Scan, puis affichage temporaire puis save As.

Voilà ... je suis pas sûr que ça vous aide mais bon ...

**Stormy31** · 31/03/2009, 16h36

Bon après avoir pourri le forum de mon blocage, j'ai fini par trouver la solution au problème...

C'était en fait ma méthode createpanel qui posait problème et qui ne libérait pas les ressources !!!

Merci à tous ceux qui se sont dérangés à me répondre

**Lyche** · 31/03/2009, 16h37

edit : avait pas vu le tag..

Gestion de processus

C#

Discussions similaires

Partager

Partager