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:

private void BW_CopyAllFiles_DoWork(object sender, DoWorkEventArgs e)
        {
            var bw = sender as BackgroundWorker;

            bw.ReportProgress(0);

            S7VariablenResult s7VariablenResult = ReadResult();

            //Ordner erstellen
            string createTargetPath = Path.Combine(DEFAULTTARGETPATH, s7VariablenResult.FolderName);
            Directory.CreateDirectory(createTargetPath);

            bw.ReportProgress(25);


            for (int i = 0; i < cbActivateLocalApps.Length; i++)
            {
                if (cbActivateLocalApps[i].Checked == true)
                {
                    string praegeCodeNrFolderName = s7VariablenResult.FolderName;
                    string praegeCodeNrFileName = s7VariablenResult.PraegeCodeNr;
                    string sourceFilePath = uivalues.SourceFilePathLocalApps[i];
                    string targetPath = DEFAULTTARGETPATH;

                    MoveFilesfromLocal(praegeCodeNrFolderName, praegeCodeNrFileName, sourceFilePath, targetPath);
                }
            }

            bw.ReportProgress(50);

            for (int j = 0; j < cbActivateLocalApps.Length; j++)
            {
                if (cbActivateLocalApps[j].Checked == true)
                {
                    string praegeCodeNrFolderName = s7VariablenResult.FolderName;
                    string praegeCode2NrFileName = s7VariablenResult.PraegeCode2Nr;
                    string sourceFilePath = uivalues.SourceFilePathLocalApps[j];
                    string targetPath = DEFAULTTARGETPATH;

                    MoveFilesCode2fromLocal(praegeCodeNrFolderName, praegeCode2NrFileName, sourceFilePath, targetPath);
                }
            }

            bw.ReportProgress(75);

            for (int k = 0; k < cbActivateNetApps.Length; k++)
            {
                if (cbActivateNetApps[k].Checked == true)
                {
                    string praegeCodeNrFolderName = s7VariablenResult.FolderName;
                    string praegeCodeNrFileName = s7VariablenResult.PraegeCodeNr;
                    string sourceFilePath = uivalues.SourceFilePathNetApps[k];
                    string targetPath = DEFAULTTARGETPATH;

                    CopyFilesfromNetwork(praegeCodeNrFolderName, praegeCodeNrFileName, sourceFilePath, targetPath);
                }
            }

            //Report 100% completion on operation completed
            bw.ReportProgress(100);
        }					

1:

 s7VariablenResult.PraegeCodeNr = S7.GetStringAt(dbbuffer, uivalues.PraegeCodeDBPos);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

private ComponentResult LeakResult()

{    ComponentResult Result = new ComponentResult();

    byte[] Buffer = new byte[26];

    // Reads the buffer.

    Client.DBRead(100, 0, 26, Buffer);

    // Extracts the fields and inserts them into the struct

    Result.SerialNumber = S7.GetCharsAt(Buffer, 0, 12);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

bw.ReportProgress(75);

            for (int k = 0; k < cbActivateNetApps.Length; k++)
            {
                if (cbActivateNetApps[k].Checked == true)
                {
                    string praegeCodeNrFolderName = s7VariablenResult.FolderName;
                    string praegeCodeNrFileName = s7VariablenResult.PraegeCodeNr;
                    string sourceFilePath = uivalues.SourceFilePathNetApps[k];
                    string targetPath = DEFAULTTARGETPATH;

                    CopyFilesfromNetwork(praegeCodeNrFolderName, praegeCodeNrFileName, sourceFilePath, targetPath);
                }
            }					

1:

using Microsoft.VisualBasic.FileIO;					

1:
2:

'Windows Dateioperationen zur Verfügung stellen
Set oFSO = CreateObject("Scripting.FileSystemObject") '					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

        private void ChooseSourcePathLocalApp_Click(object sender, EventArgs e)
        {
            if (sender is TextBox textBox)
            {
                if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
                {
                    textBox.Text = folderBrowserDialog1.SelectedPath;
                }
            }
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

 
        private void ChooseSourcePathNetApp_Click(object sender, EventArgs e)
        {
            if (sender is TextBox textBox)
            {
                textBox.Text = GetNetworkFolders(new FolderBrowserDialog());
            }
        }

        private string GetNetworkFolders(FolderBrowserDialog oFolderBrowserDialog)
        {
            Type type = oFolderBrowserDialog.GetType();
            FieldInfo fieldInfo = type.GetField("rootFolder", BindingFlags.NonPublic | BindingFlags.Instance);
            fieldInfo.SetValue(oFolderBrowserDialog, 18);
            if (oFolderBrowserDialog.ShowDialog() == DialogResult.OK)
            {
                return oFolderBrowserDialog.SelectedPath.ToString();
            }
            else
            {
                return "";
            }
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

public static void CopyDirectoryfromNetwork(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> dirs = Directory.EnumerateDirectories(sourceFilePath, "*", System.IO.SearchOption.AllDirectories).Where(x => x.Contains(praegeCodeNrFileName));

            foreach (string dir in dirs)
            {
                TryAction(() => FileSystem.CopyDirectory(dir, dir.Replace(sourceFilePath, Path.Combine(targetPath, praegeCodeNrFolderName)), true));
                TryAction(() => FileSystem.DeleteDirectory(dir, DeleteDirectoryOption.DeleteAllContents));
            }
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

private void ChooseSourcePathNetApp_Click(object sender, EventArgs e)
        {
            if (sender is TextBox textBox)
            {
                textBox.Text = GetNetworkFolders(new FolderBrowserDialog());
            }
        }

        private string GetNetworkFolders(FolderBrowserDialog oFolderBrowserDialog)
        {
            Type type = oFolderBrowserDialog.GetType();
            FieldInfo fieldInfo = type.GetField("rootFolder", BindingFlags.NonPublic | BindingFlags.Instance);
            fieldInfo.SetValue(oFolderBrowserDialog, 18);
            if (oFolderBrowserDialog.ShowDialog() == DialogResult.OK)
            {
                return oFolderBrowserDialog.SelectedPath.ToString();
            }
            else
            {
                return "";
            }
        }					

1:

Directory.EnumerateDirectories(sourceFilePath, "*", System.IO.SearchOption.AllDirectories)					

1:

"*" + praegeCodeNrFileName + "*"					

1:
2:
3:

//Ordner erstellen
string createTargetPath = Path.Combine(DEFAULTTARGETPATH, s7VariablenResult.FolderName);
Directory.CreateDirectory(createTargetPath);					

1:

x.Contains(praegeCodeNrFileName)					

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:

namespace PDE
{
    internal static class IOFileOperations
    {
        public static void TryAction(Action action)
        {
            try
            {
                action();
            }
            catch (DirectoryNotFoundException ex)
            {
                ex.SaveErrorMessage();
            }
        }

        public static void MoveDirectoryfromLocal(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {            
            IEnumerable<string> dirs = Directory.EnumerateDirectories(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string dir in dirs)
            {
                TryAction(() => FileSystem.MoveDirectory(dir, dir.Replace(sourceFilePath, Path.Combine(targetPath, praegeCodeNrFolderName)), true));
            }
        }

        public static void MoveFilesfromLocal(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string file in files)
            {
                FileInfo fi = new FileInfo(file);
                string filename = fi.FullName;
                
                TryAction(() => File.Move(filename, $"{Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(file))}"));
            }
        }

        public static void MoveFilesCode2fromLocal(string praegeCodeNrFolderName, string praegeCode2NrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCode2NrFileName + "*");

            foreach (string file in files)
            {
                FileInfo fi = new FileInfo(file);
                string filename = fi.FullName;
                
                TryAction(() => File.Move(filename, $"{Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(file))}"));
            }
        }

        public static void CopyDirectoryfromNetwork(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> dirs = Directory.EnumerateDirectories(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string dir in dirs)
            {
                TryAction(() => FileSystem.CopyDirectory(dir, dir.Replace(sourceFilePath, Path.Combine(targetPath, praegeCodeNrFolderName)), true));
                TryAction(() => FileSystem.DeleteDirectory(dir, DeleteDirectoryOption.DeleteAllContents));
            }
        }

        public static void CopyFilesfromNetwork(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string file in files)
            {
                FileInfo fi = new FileInfo(file);
                string filename = fi.FullName;
                
                TryAction(() => File.Copy(filename, $"{Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(file))}"));
                TryAction(() => File.Delete(file));
            }
        }
    }
}					

1:
2:
3:
4:
5:
6:

foreach (string file in files)
{
    FileInfo fi = new FileInfo(file);
    string filename = fi.FullName;
    // ...
}					

1:
2:
3:
4:
5:

string ReplacePath(string path, string sourcePath, string destPath)
{
  // evtl. vorher noch mittels if (path.StartsWith(sourcePath)) überprüfen, sonst String.Empty oder Exception
   return destPath + path.Substring(sourcePath.Length);
}					

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:

namespace PDE
{
    internal static class IOFileOperations
    {
        public static void TryAction(Action action)
        {
            try
            {
                action();
            }
            catch (DirectoryNotFoundException ex)
            {
                ex.SaveErrorMessage();
            }
        }

        public static void MoveDirectoryfromLocal(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> dirs = Directory.EnumerateDirectories(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string dir in dirs)
            {
                TryAction(() => FileSystem.MoveDirectory(dir, dir.Replace(sourceFilePath, Path.Combine(targetPath, praegeCodeNrFolderName)), true));
            }
        }

        public static void MoveFilesfromLocal(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string filename in files)
            {                
                TryAction(() => File.Move(filename, Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(filename))));
            }
        }

        public static void MoveFilesCode2fromLocal(string praegeCodeNrFolderName, string praegeCode2NrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCode2NrFileName + "*");

            foreach (string filename in files)
            {               
                TryAction(() => File.Move(filename, Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(filename))));
            }
        }

        public static void CopyDirectoryfromNetwork(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> dirs = Directory.EnumerateDirectories(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string dir in dirs)
            {
                TryAction(() => FileSystem.CopyDirectory(dir, dir.Replace(sourceFilePath, Path.Combine(targetPath, praegeCodeNrFolderName)), true));
                TryAction(() => FileSystem.DeleteDirectory(dir, DeleteDirectoryOption.DeleteAllContents));
            }
        }

        public static void CopyFilesfromNetwork(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string filename in files)
            {                
                TryAction(() => File.Copy(filename, Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(filename))));
                TryAction(() => File.Delete(filename));
            }
        }
    }
}					

1:
2:
3:
4:
5:

TryAction(() => 
          {
             File/-System.Copy...(...);
             File/-System.Delete...(...);
          });					

1:
2:
3:
4:
5:
6:
7:
8:
9:

 public static void MoveFilesfromLocal(string praegeCodeNrFolderName, string praegeCodeNrFileName, string sourceFilePath, string targetPath)
        {
            IEnumerable<string> files = Directory.EnumerateFiles(sourceFilePath, "*" + praegeCodeNrFileName + "*");

            foreach (string filename in files)
            {
                TryAction(() => File.Move(filename, Path.Combine(targetPath, praegeCodeNrFolderName, Path.GetFileName(filename))));
            }
        }					

1:

[IO.Directory]::EnumerateFiles("C:\MyLovelyPath", "*MyLovelyFilter*")