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:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Diagnostics;
using System.Threading;

namespace DLL_Kopieren_Neu
{
    public partial class Form1 : Form
    {
        //Dialog um Datei auszwählen wird initialisiert
        FolderBrowserDialog dlgFileOpen = new FolderBrowserDialog();

        //Zum Speichern der Datein in den ListViews
        List<FileInfo> leftViewFiles = new List<FileInfo>();
        List<FileInfo> rightViewFiles = new List<FileInfo>();

        ListView view = null;
        ListViewItem liste = null;

        //Zustandanzeiger(Membervariablen)
        bool m_bStatusShowing = false;
        bool m_bFirstOpened = true;
        bool m_bOpenHandler = false;
        bool m_bCopyHandler = false;
        bool m_bFirstCopy = true;

        string m_strCurrentFile = string.Empty;
        string m_strCurrentVersion;
        string m_strTemp = Path.GetTempPath();

        List<string> vonDatei = new List<string>();
        List<string> nachDatei = new List<string>();

        DateTime m_dtDate;

        public Form1()
        {
            InitializeComponent();

            //Es wird für Ordner 1 & Ordner 2 auf eine Methode zugegriffen
            öffnenOrdner2ToolStripMenuItem.Click += new EventHandler(öffnenOrdner1ToolStripMenuItem_Click);

            //Meldet der Progressbar einen Fortschritt(dies passiert mit backgroundworker1.ReportProgress(percent))
            backgroundWorker1.WorkerReportsProgress = true;
        }

        private void öffnenOrdner1ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //Backgroundworker wird die Kopierfunktion entfernt
            if(m_bCopyHandler)
            {
                backgroundWorker1.DoWork -= this.KopierenHandler;
                m_bCopyHandler = false;
                m_bFirstOpened = true;
            }

            //Backgroundworker wird die Öffnenmethode mitgegeben
            if(m_bFirstOpened)
            {
                backgroundWorker1.DoWork += this.OpenHandler;
                m_bOpenHandler = true;
                m_bFirstOpened = false;
            }

            //Hier wird entschieden in welcher ListView was angezeigt wird
            if(sender == öffnenOrdner1ToolStripMenuItem)
            {
                listView1.Items.Clear();
                view = listView1;
                leftViewFiles = new List<FileInfo>();
            }
            else
            {
                listView2.Items.Clear();
                view = listView2;
                rightViewFiles = new List<FileInfo>();
            }

            //Wenn im Dialog auf Ok geklickt wird beginnt der Backgroundworker
            if(dlgFileOpen.ShowDialog() == DialogResult.OK)
            {
                view.BeginUpdate();

                //Prüft ob Backgroundworker schon was ausführt
                if(!backgroundWorker1.IsBusy)
                {
                    //Worker starten
                    backgroundWorker1.RunWorkerAsync(dlgFileOpen.SelectedPath);

                    //Progressbar-Status auf True setzen
                    m_bStatusShowing = true;
                }

                view.EndUpdate();
            }     
        }

        //Hauptfunktion zum Datei auslesen
        private void OpenHandler(object sPath, DoWorkEventArgs e)
        {
            string strPath = (string)e.Argument;
            string[] strDateien = Directory.GetFileSystemEntries(strPath);

            foreach (string strDatei in strDateien)
            {
                if (Path.GetExtension(strDatei) == ".dll")
                {
                    if (view == listView1)
                    {
                        leftViewFiles.Add(new FileInfo(strDatei));
                        File.Copy(strDatei, m_strTemp ,true);
                    }
                    else
                    {
                        rightViewFiles.Add(new FileInfo(strDatei));
                    }
                }
            }

            int counter = 0;
            if (view == listView1)
            {
                foreach (FileInfo _info in leftViewFiles)
                {
                    //Prozent für Progressbar errechen
                    int max = leftViewFiles.Count;
                    int percent = (counter * 100) / max;

                    //Meldet den Fortschritt
                    backgroundWorker1.ReportProgress(percent);
                    BuildList(_info);
                    counter++;
                }
            }
            else
            {
                foreach (FileInfo _info in rightViewFiles)
                {
                    int max = rightViewFiles.Count;
                    int percent = (counter * 100) / max;
                    backgroundWorker1.ReportProgress(percent);
                    BuildList(_info);
                    counter++;
                }
            }
        }

        void BuildList(FileInfo _info)
        {
            try
            {
                FileVersionInfo VersionsInfo = FileVersionInfo.GetVersionInfo(_info.FullName);
                m_strCurrentFile = _info.Name;
                m_strCurrentVersion = VersionsInfo.ProductVersion.ToString();
                m_dtDate = File.GetLastWriteTimeUtc(_info.FullName);

                //Das ListView in einem anderen Thread läuft fügen wir die Items per Invoke ein
                MethodInvoker mi = new MethodInvoker(AddItems);
                view.Invoke(mi);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        //Invokemethode zum hinzufügen
        private void AddItems()
        {
            liste = view.Items.Add(m_strCurrentFile);
            liste.SubItems.Add(m_strCurrentVersion);
            liste.SubItems.Add(m_dtDate.ToString());
        }

        private void kopierenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            //Die Funktion Öffnen aus dem Backgroundworker entfernen
            if (m_bOpenHandler)
            {
                backgroundWorker1.DoWork -= this.OpenHandler;
                m_bOpenHandler = false;
                m_bFirstCopy = true;
            }

            if (m_bFirstCopy)
            {
                backgroundWorker1.DoWork += this.KopierenHandler;
                m_bCopyHandler = true;
            }

            if (m_bFirstCopy)
            {
                backgroundWorker1.RunWorkerAsync();
            }
        }

        private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            //Progressbar wird aktualisiert
            if (m_bStatusShowing)
            {
                toolStripStatusLabel1.Text = m_strCurrentFile;
                toolStripProgressBar1.Value = e.ProgressPercentage;
            }
        }

        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (m_bOpenHandler)
            {
                if (m_bStatusShowing)
                {
                    toolStripProgressBar1.Value = toolStripProgressBar1.Maximum;
                    m_bStatusShowing = false;
                }
            }

            if (m_bCopyHandler)
            {
                MessageBox.Show("Ersetzen Abgeschloßen");
            }
        }

        private void KopierenHandler(object sender, DoWorkEventArgs e)
        {
            //Hier holen wir uns für jede Datei die Version
            FileVersionInfo fvi1, fvi2;
            Version v1, v2;

            foreach (FileInfo finfo1 in leftViewFiles)
            {
                try
                {
                    fvi1 = FileVersionInfo.GetVersionInfo(finfo1.FullName);
                    v1 = new Version(fvi1.FileVersion.ToString());

                    foreach (FileInfo finfo2 in rightViewFiles)
                    {
                        fvi2 = FileVersionInfo.GetVersionInfo(finfo2.FullName);
                        v2 = new Version(fvi2.FileVersion);

                        //Wird geschaut ob beide Dateien gleich sind
                        if (finfo1.Name == finfo2.Name)
                        {
                            //Wenn im linken Fenster die Version kleiner ist als im Rechten
                            if (v1 < v2)
                            {
                                vonDatei.Add(finfo2.FullName);
                                nachDatei.Add(finfo1.FullName);
                            }
                        }

                        int percent = 0;
                        for (int i = 0; i < vonDatei.Count; ++i)
                        {
                            //Wird die Datei ersetzt
                            File.Delete(nachDatei[i]);
                            File.Copy(vonDatei[i], nachDatei[i]);
                            m_strCurrentVersion = nachDatei[i];
                            percent = (i * 100) / vonDatei.Count;
                            backgroundWorker1.ReportProgress(percent);
                        }
                    }
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show(ex.Message + "\r\nStacktrace: " + ex.StackTrace);
                }
            }
        }

        private void rückgängigToolStripMenuItem_Click(object sender, EventArgs e)
        {

        }
    }
}