Autor Beitrag
c-f-user
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Fr 12.01.18 16:46 
Hallo zusammen,

bin hier neu im Forum und eventuell könnte mir vielleicht jemand helfen:
Ich hab eine WinForms Anwendung die mittels FileSystemWatcher einen Netzwerkordner überwacht.

Grundsätzlich funktioniert es auch soweit.
Nur würde ich gerne die Einträge in der ListBox umdrehen so dass der neueste Eintrag in der Liste immer oben erscheint und der nächste Eintrag dann wieder darüber usw.

Hab schon versucht das mittels listBox.TopIndex hinzubekommen, bin aber wegen meiner unzureichender Programmierkenntnisse daran gescheitert...
Vielleicht hätte da jemand einen Tipp für mich?

Der button2 bereitet mir auch Kopfzerbrechen, wenn ich den anklicke um die Überwachung zu stoppen und dann wieder starte sind die neuen Einträge in der listBox dann doppelt vorhanden, wenn ich nochmal stoppe und starte dann dreifach usw. :nixweiss:
Ich vermute dass eventuell durch FileSystemWatcher fsWatcher = new FileSystemWatcher() jedesmal beim starten eine neue Instanz erstellt wird und das zu den Mehrfacheinträgen führt?

Ich hab schon versucht die Instanz ausserhalb von button2 zu setzen, hab ich aber auch nicht hinbekommen, könnt ja auch sein dass ich da überhaupt am Holzweg bin? :?!?:

Falls da jemand Anregungen hätte, wäre das echt spitze!
ausblenden volle Höhe C#-Quelltext
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:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Threading;

namespace FolderMonitor2
{
    public partial class Form1 : Form
    {
        public ListBox listBox;
        public const String startMonitoring = "Start Monitoring…";
        public const String stopMonitoring = "Stop Monitoring…";
        
        public Form1()
        {

            InitializeComponent();
            //listBox für FileSystemWatcher
            listBox = new ListBox();  
            listBox.FormattingEnabled = false;
            listBox.Location = new System.Drawing.Point(55);
            listBox.Name = "listBox";
            listBox.Size = new System.Drawing.Size(50050);
            listBox.TabIndex = 2;
            listBox.ScrollAlwaysVisible = true;
            this.Controls.Add(listBox);
            listBox.Items.Add("List2");
        }



        private void button1_Click(object sender, EventArgs e)
        
            {
                //  FolderBrowserDialog object erstellen
                FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
                folderBrowserDialog.ShowNewFolderButton = true;
                DialogResult dialogResult = folderBrowserDialog.ShowDialog();
              
                if (dialogResult == DialogResult.OK)
                {
                    textBox1.Text = folderBrowserDialog.SelectedPath;
                    Environment.SpecialFolder root = folderBrowserDialog.RootFolder;
                }
                
            }

       

        private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
         
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {
                        //new FileSystemWatcher object erstellen
            FileSystemWatcher fsWatcher = new FileSystemWatcher();
            
            {
                
            }
            switch (button2.Text)
            {
                // Start Monitoring…
                case startMonitoring:
                    if (!textBox1.Text.Equals(String.Empty))
                    {
            listBox1.Items.Add("Started FolderMonitor2 Service…");
            listBox1.SelectedIndex = listBox1.Items.Count - 1;
            listBox1.SelectedIndex = -1;
        //falls Verzeichnis nicht vorhanden:
            string folder_check = textBox1.Text;
            if (Directory.Exists(folder_check) == false)
            {
                MessageBox.Show("Folder doesn't exist");
                break;

            }

  fsWatcher.Path = textBox1.Text;
                        
  fsWatcher.Filter = (textBox2.Text.Equals(String.Empty)) ? "*.*" : textBox2.Text;

  fsWatcher.IncludeSubdirectories = true;


  fsWatcher.NotifyFilter = NotifyFilters.Attributes |
                           NotifyFilters.CreationTime |
                           NotifyFilters.DirectoryName |
                           NotifyFilters.FileName |
                           NotifyFilters.LastAccess |
                           NotifyFilters.LastWrite |
                           NotifyFilters.Security |
                           NotifyFilters.Size;
  
  fsWatcher.EnableRaisingEvents = true;

  fsWatcher.Changed += new FileSystemEventHandler(OnChanged);
  fsWatcher.Created += new FileSystemEventHandler(OnCreated);
  fsWatcher.Deleted += new FileSystemEventHandler(OnDeleted);
  fsWatcher.Renamed += new RenamedEventHandler(OnRenamed);
  fsWatcher.Error += new ErrorEventHandler(OnError);
  button2.Text = stopMonitoring;
  textBox1.Enabled = false;
  textBox2.Enabled = false;

        }
        else
        {
         listBox1.Items.Add("Please select folder to monitor….");
        }

         break;
       // Stop Monitoring…
                case stopMonitoring:
                default:
                    fsWatcher.EnableRaisingEvents = false;
                    fsWatcher = null;
                    button2.Text = startMonitoring;
                    textBox1.Enabled = true;
                    textBox2.Enabled = true;
                    listBox1.Items.Add("Stopped FolderMonitor2 Service…");
                    listBox1.SelectedIndex = listBox1.Items.Count - 1;
                    listBox1.SelectedIndex = -1;
                    break;
            }
        }
        

                // FileSystemWatcher – OnCreated Event Handler
        public void OnCreated(object sender, FileSystemEventArgs e)
        {
            //event details in listbox hinzufügen
            this.Invoke((MethodInvoker)delegate { listBox.Items.Add(String.Format(" {0} 

|| Date : {1}  || Action : {2}"
, e.Name, DateTime.Now, e.ChangeType)); });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = 

listBox.Items.Count - 1 ; });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = -1; });

        }
        // FileSystemWatcher – OnChanged Event Handler
        public void OnChanged(object sender, FileSystemEventArgs e)
        {
            //event details in listbox hinzufügen
            this.Invoke((MethodInvoker)delegate { listBox.Items.Add(String.Format(" {0} 

|| Date : {1}  || Action : {2}"
, e.Name, DateTime.Now, e.ChangeType)); });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = 

listBox.Items.Count - 1; });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = -1; });
        }
        // FileSystemWatcher – OnRenamed Event Handler
        public void OnRenamed(object sender, RenamedEventArgs e)
        {
            //event details in listbox hinzufügen
            this.Invoke((MethodInvoker)delegate { listBox.Items.Add(String.Format(" {0} 

|| Date : {1}  || Action : {2} to {3}"
, e.Name, DateTime.Now, e.ChangeType, e.Name)); 

});
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = 

listBox.Items.Count - 1; });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = -1; });
        }
        // FileSystemWatcher – OnDeleted Event Handler
        public void OnDeleted(object sender, FileSystemEventArgs e)
        {
            //event details in listbox hinzufügen
            this.Invoke((MethodInvoker)delegate { listBox.Items.Add(String.Format(" {0} 

|| Date : {1}  || Action : {2}"
, e.Name, DateTime.Now, e.ChangeType)); });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = 

listBox.Items.Count - 1; });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = -1; });
        }
        // FileSystemWatcher – OnError Event Handler
        public void OnError(object sender, ErrorEventArgs e)
        {
            //event details in listbox hinzufügen
            this.Invoke((MethodInvoker)delegate { listBox.Items.Add(String.Format

("Error : {0}", e.GetException().Message)); });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = 

listBox.Items.Count - 1; });
            this.Invoke((MethodInvoker)delegate { listBox.SelectedIndex = -1; });
        }


        private void textBox2_TextChanged(object sender, EventArgs e)
        {
        
        }

        
    }
}


Moderiert von user profile iconTh69: C#-Tags hinzugefügt
Moderiert von user profile iconTh69: Beitragsformatierung überarbeitet (überflüssige Zeilenumbrüche entfernt).
Symbroson
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 332
Erhaltene Danke: 47

Linux Raspbian, Win10
C, C++, Python, Java, JavaScript, Delphi7, Casio Basic
BeitragVerfasst: Fr 12.01.18 17:40 
Wenn ich die Reihenfolge einer Liste umkehre würde ich jeweils die i-ten Elemente vom Anfang und Ende der Liste miteinander tauschen, und das len div 2 mal, also bis zur hälfte

_________________
most good programmers do programming not because they expect to get paid or get adulation by the public, but because it's fun to program. (Linus Torvalds)
Th69
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Moderator
Beiträge: 3868
Erhaltene Danke: 787

Win7
C++, C# (VS 2015/17)
BeitragVerfasst: Fr 12.01.18 17:50 
Hallo und :welcome:

anstatt listBox.Items.Add kannst du einfach listBox.Items.Insert(0, ...) benutzen.

Und wegen den Mehrfacheinträgen:
Ja, du erzeugst jeweils im Button-Klick eine neue Instanz des FileSystemWatcher. Erzeuge daher diese als Membervariable der Klasse und initialisiere diese nur einmalig im Konstruktor der Klasse (bzw. lagere den Code in eine eigene private Methode aus und rufe diese dann dort auf).

PS: Deine OnCreated/OnChanged/...-Methoden sind aber noch suboptimal (dein Code sieht noch sehr nach C# bzw. .NET 2.0 aus, und nicht 4.x)...


Zuletzt bearbeitet von Th69 am Fr 12.01.18 18:02, insgesamt 1-mal bearbeitet
Ralf Jansen
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 4305
Erhaltene Danke: 865


VS2010 Pro, VS2012 Pro, VS2013 Pro, VS2015 Pro, Delphi 7 Pro
BeitragVerfasst: Fr 12.01.18 17:59 
Zitat:
Ich vermute dass eventuell durch FileSystemWatcher fsWatcher = new FileSystemWatcher() jedesmal beim starten eine neue Instanz erstellt wird und das zu den Mehrfacheinträgen führt?

Ja du erstellst zwar jedesmal eine neue Instanz aber beendest die alte nicht richtig. Du solltest aus der FileSystemWatcher Variablen eine Klassenvariablen machen damit du in button2_Click die alte sauber aufräumen kannst bevor du eine neue erstellst. Ohne genaue Details über den FileSystemWatcher zu kennen heißt aufräumen vermutlich zumindest die Events wieder abzuhängen und ich würde auch EnableRaisingEvents wieder zurücksetzen. Möglichrweise sollte man auch Dispose an dem Ding aufrufen.

Edit:

@TH69 weißt korrekterweise auf die Insert Methode hin. Du solltest aber besser noch gleich Databinding verwenden und z.B. eine BindingList<string> an die ListBox binden und an der dann Insert aufrufen. Dann fallen die ganzen Invoke Aufrufe zur Threadsynchronisierung weg.
c-f-user Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: Fr 12.01.18 19:44 
Wow,

schon 3 Antworten, ihr seid ja fix hier:-) :)

@ Th69 ja, da hast du gut erkannt, hab vor langer Zeit mit C++ angefangen,
aber leider nie lange durchgehalten und mich nie intensiver mit Programmierung beschäftigt...
Auch nur einfache kleine Progrämmchen und mich dann laaange Zeit
nicht mehr mit Programmierung beschäftigt, bin eigentlich nach wie vor blutiger Anfänger...

Na gut das ist ja schon mal reichlich input für mich, denke das wird ein beschäftigungsreiches Wochenende werden. :les:

Mit listBox.Items.Insert(0, ...) hatte ich auch schon erfolglos experimeniert,
aber gut dass ich jetzt weiß dass das der richtige Weg ist. :zustimm:

Werd dann Anfang nächster Woche mal berichten wie es vorangeht

Besten Dank an euch einstweilen und schönes Wochenende! :party:

Moderiert von user profile iconTh69: C#-Tags hinzugefügt
c-f-user Threadstarter
Hält's aus hier
Beiträge: 5



BeitragVerfasst: So 14.01.18 01:53 
Ja,
perfekt, mit listBox.Items.Insert(0,...)klappt das wunderbar, hab jetzt noch listBox.TopIndex=0 ergänzt und somit funktioniert das genau so wie geplant und scrollt dann bei jeder neu erstellten Datei wieder ganz nach oben.
:think::think::think:
Falls sich jemand fragt wofür die Anwendung gut sein soll: :lupe:

Es geht darum das 3 User Programme für eine Laserschneidanlage schreiben und die Dateien fortlaufende Nummern haben sollen, also P23001.lst, P23002.lst usw. Somit musste man bisher immer im Windows Explorer schauen welche Nummer zuletzt verwendet wurde damit man nicht die Programme eines anderen Users überschreibt. Da die Anwendung always on top läuft hat man die zuletzt verwendete Programmnummer jetzt immer im Blick und spart sich dann das relativ umständliche nachschauen im Explorer.

Die restlichen Tipps zur Codeverbesserung werd ich auch noch umsetzen, aber da muß ich vorher noch mein Grundlagenwissen ziemlich auffrischen und den Staub von meinen C# Büchern runterklopfen :zwinker:

Ihr habt mir sehr geholfen, war schon fast am verzweifeln, tausend Dank dafür! :beer: