public void SimpleCommandLineParser_Parse_Arguments() { // Assign _parser.Parse(new[] { "--test1", "one", "--test2", "two", "--test3", "three" }); // Act string value1 = _parser.GetStringValue("test1"); string value2 = _parser.GetStringValue("test2"); string value3 = _parser.GetStringValue("test3"); // Assert Check.That(value1).IsEqualTo("one"); Check.That(value2).IsEqualTo("two"); Check.That(value3).IsEqualTo("three"); }
public static bool LoadConfig(string[] args) { try { var parser = new SimpleCommandLineParser(); parser.Parse(args); bool exists = File.Exists(GGMCFile); if (!exists) { GenerateConfig(); } else { GGMC = DeSerializeString <GGMConfig>(File.ReadAllText(GGMCFile)); } return(true); } catch (Exception ex) { Logger.Log(LogType.FatalError, "Error while loading config.", ex); return(false); } }
public void Run(string[] args) { RebooterProperties = new AppProperties(); // Parse the command line arguments var oParser = new SimpleCommandLineParser(); oParser.Parse(args); RebooterProperties.CurrentModem = GetModemClass(); // Show startup text ShowIntro(RebooterProperties); // Read the command line parameters RebooterProperties.ReadParameters(oParser, RebooterProperties); // One minute timer Timer oTimer = new Timer { Interval = 60000 }; oTimer.Elapsed += (sender, e) => { HandleTimerElapsed(RebooterProperties); }; oTimer.Enabled = !String.IsNullOrEmpty(RebooterProperties.ModemIP); if (oTimer.Enabled) { DoTimedEvents(RebooterProperties); } DoConsoleRead(); oTimer.Dispose(); }
static int Main(string[] args) { SimpleCommandLineParser parser = new SimpleCommandLineParser(args); parser.addOption("v", ARGUMENT_TYPE.MUST, "verb"); parser.addOption("a", ARGUMENT_TYPE.MUST, "arguments"); parser.addOption("type", ARGUMENT_TYPE.MUST, "type"); parser.addOption("name", ARGUMENT_TYPE.MUST, "name"); parser.Parse(); string verb = parser["v"].ToString(); // getString("v"); string arguments = parser["a"].ToString(); //.getString("a"); string folder = parser.getMainargs(0); if (string.IsNullOrEmpty(verb)) { MessageBox.Show("No Verb", Application.ProductName); return(-1); } if (string.IsNullOrEmpty(arguments)) { MessageBox.Show("No Arguments", Application.ProductName); return(-1); } if (string.IsNullOrEmpty(folder)) { MessageBox.Show("No Folder", Application.ProductName); return(-1); } if (!Directory.Exists(folder)) { MessageBox.Show(folder + " does not exist.", Application.ProductName); return(-1); } string type = parser["type"].ToString(); if (type != null) { if (type != "f" || type != "d") { MessageBox.Show("wrong type", Application.ProductName); return(-1); } } string name = parser["name"].ToString(); return(0); }
public void ParseTest() { var parser = new SimpleCommandLineParser(); String[] args = { "-help" }; parser.Parse(args); bool shouldContainHelp = false; if (parser.Arguments.ContainsKey("help")) { shouldContainHelp = true; } Assert.IsTrue(shouldContainHelp); String[] realArgs = new String[] { "C:\\temp\\Video_Sync_2\\MediaPlayer\\MyMediaPlayer\\bin\\Debug\\MyMediaPlayer.vshost.exe", "-file", "c:\\\\temp\\\\testcase objects\\\\0) Unreal 2004 patching instructions.PNG", "-time", "1" }; parser.Parse(realArgs); bool shouldContainFile = false; if (parser.Arguments.ContainsKey("file")) { shouldContainFile = true; } Assert.IsTrue(shouldContainFile); bool shouldContainTime = false; if (parser.Arguments.ContainsKey("time")) { shouldContainTime = true; } Assert.IsTrue(shouldContainTime); }
public VideoSyncServer(string[] args) { InitializeComponent(); cmdParser.Parse(args); ProcessCmdArgs(); textBoxIP.Text = m_Globals.m_library.GetLocalName(); // React to the command line arguments that perform automation. if (isAutoConnectCmd) { BeginListening(); } }
public static string[] Parse(string input) { if (string.IsNullOrWhiteSpace(input) || input.Length == 0) { throw new ArgumentException("Cannot parse an empty embedded command-line string"); } #if !SYS_SUB_CMDLINE var parser = new SimpleCommandLineParser(input); return(parser.Parse()); #endif #if SYS_SUB_CMDLINE var allowance = new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode); allowance.Assert(); IntPtr argv = IntPtr.Zero; try { int argc; argv = CommandLineToArgvW(input, out argc); if (argv == IntPtr.Zero) { throw new ArgumentException("Unable to parse arguments", input, new System.ComponentModel.Win32Exception()); } string[] args = new string[argc]; for (int k = 0; k < argc; ++k) { args[k] = System.Runtime.InteropServices.Marshal.PtrToStringUni ( System.Runtime.InteropServices.Marshal.ReadIntPtr(argv, k * IntPtr.Size) ); } return(args); } finally { LocalFree(argv); System.Security.CodeAccessPermission.RevertAssert(); } #endif }
public PlaylistGenerator(string[] args) { InitializeComponent(); cmdParser.Parse(args); ProcessCmdArgs(); m_Globals.m_communications.m_serverName = m_library.GetLocalName(); textBoxIP.Text = m_Globals.m_communications.m_serverName; // React to the command line arguments that perform automation. if (isAutoConnectCmd) { bool wasConnectionGood = m_Globals.m_communications.ConnectToServer(); UpdateControls(wasConnectionGood); if (wasConnectionGood) { SendPlaylist("publisher_connect", "publisher"); } if (IsFilePathGiven) { SendPlaylist("publisher_playlist", richText_Playlist.Text); if (isImmediateExitCmd) { try { System.Threading.Thread.Sleep(1000); System.Environment.Exit(0); } catch (SystemException se) { String se_string = se.ToString(); } } } } }
public VideoSyncClient(string[] args) { InitializeComponent(); cmdParser.Parse(args); ProcessCmdArgs(); m_Globals.m_library.SetStateFile(Library1.State.not_busy); m_Globals.m_communications.m_serverName = m_Globals.m_library.GetLocalName(); m_Globals.m_communications.m_portNumber = m_Globals.m_communications.GetPortNumber(); m_LastSettingsFile = m_Globals.m_ApplicationDirectory + @"\lastSettings.xml"; if (m_Globals.m_library.TestFilePathExistance(m_LastSettingsFile) == true) { m_Globals.AssignVariablesFromXML(m_LastSettingsFile); m_UsersChosenSettingsFile = m_LastSettingsFile; String tempPath = m_Globals.Get_tempPath(); if (m_Globals.m_library.TestFilePathExistance(tempPath)) { m_Globals.isTempPathSet = true; } } textBoxIP.Text = m_Globals.m_communications.m_serverName; // React to the command line arguments that perform automation. if (isAutoConnectCmd) { m_Globals.AssignVariablesFromXML(m_LastSettingsFile); bool wasConnectionGood = m_Globals.m_communications.ConnectToServer(); UpdateControls(wasConnectionGood); { First_WaitForData(); SendConnectMessageToServer(); } } }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Start Electron Desktop Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); string aspCoreProjectPath = ""; if (parser.Arguments.ContainsKey(_aspCoreProjectPath)) { string projectPath = parser.Arguments[_aspCoreProjectPath].First(); if (Directory.Exists(projectPath)) { aspCoreProjectPath = projectPath; } } else { aspCoreProjectPath = Directory.GetCurrentDirectory(); } string tempPath = Path.Combine(aspCoreProjectPath, "obj", "Host"); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty); string tempBinPath = Path.Combine(tempPath, "bin"); var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} --output \"{tempBinPath}\"", aspCoreProjectPath); if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); var nodeModulesDirPath = Path.Combine(tempPath, "node_modules"); Console.WriteLine("node_modules missing in: " + nodeModulesDirPath); Console.WriteLine("Start npm install..."); ProcessHelper.CmdExecute("npm install", tempPath); Console.WriteLine("ElectronHostHook handling started..."); string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook"); if (Directory.Exists(electronhosthookDir)) { string hosthookDir = Path.Combine(tempPath, "ElectronHostHook"); DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>() { "node_modules" }); Console.WriteLine("Start npm install for typescript & hosthooks..."); ProcessHelper.CmdExecute("npm install", hosthookDir); // ToDo: Not sure if this runs under linux/macos ProcessHelper.CmdExecute(@"npx tsc -p ../../ElectronHostHook", tempPath); } string arguments = ""; if (parser.Arguments.ContainsKey(_arguments)) { arguments = string.Join(' ', parser.Arguments[_arguments]); } if (parser.Arguments.ContainsKey(_manifest)) { arguments += " --manifest=" + parser.Arguments[_manifest].First(); } string path = Path.Combine(tempPath, "node_modules", ".bin"); bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows); if (isWindows) { Console.WriteLine("Invoke electron.cmd - in dir: " + path); ProcessHelper.CmdExecute(@"electron.cmd ""..\..\main.js"" " + arguments, path); } else { Console.WriteLine("Invoke electron - in dir: " + path); ProcessHelper.CmdExecute(@"./electron ""../../main.js"" " + arguments, path); } return true; })); }
public InitCommand(string[] args) { _parser.Parse(args); }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Build Electron Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); var desiredPlatform = parser.Arguments[_paramTarget][0]; string specifiedFromCustom = string.Empty; if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1) { specifiedFromCustom = parser.Arguments[_paramTarget][1]; } string configuration = "Release"; if (parser.Arguments.ContainsKey(_paramDotNetConfig)) { configuration = parser.Arguments[_paramDotNetConfig][0]; } var platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}..."); string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } Console.WriteLine("Executing dotnet publish in this directory: " + tempPath); string tempBinPath = Path.Combine(tempPath, "bin"); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration..."); var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c {configuration} --output \"{tempBinPath}\"", Directory.GetCurrentDirectory()); if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules"); if (Directory.Exists(checkForNodeModulesDirPath) == false) { Console.WriteLine("node_modules missing in: " + checkForNodeModulesDirPath); Console.WriteLine("Start npm install..."); ProcessHelper.CmdExecute("npm install", tempPath); Console.WriteLine("Start npm install electron-packager..."); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { // Works proper on Windows... ProcessHelper.CmdExecute("npm install electron-packager --global", tempPath); } else { // ToDo: find another solution or document it proper // GH Issue https://github.com/electron-userland/electron-prebuilt/issues/48 Console.WriteLine("Electron Packager - make sure you invoke 'sudo npm install electron-packager --global' at " + tempPath + " manually. Sry."); } } else { Console.WriteLine("Skip npm install, because node_modules directory exists in: " + checkForNodeModulesDirPath); } Console.WriteLine("Build Electron Desktop Application..."); string buildPath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "desktop"); Console.WriteLine("Executing electron magic in this directory: " + buildPath); // ToDo: Need a solution for --asar support string electronArch = "x64"; if (parser.Arguments.ContainsKey(_paramElectronArch)) { electronArch = parser.Arguments[_paramElectronArch][0]; } string electronParams = ""; if (parser.Arguments.ContainsKey(_paramElectronParams)) { electronParams = parser.Arguments[_paramElectronParams][0]; } Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}..."); ProcessHelper.CmdExecute($"electron-packager . --platform={platformInfo.ElectronPackerPlatform} --arch={electronArch} {electronParams} --out=\"{buildPath}\" --overwrite", tempPath); Console.WriteLine("... done"); return true; })); }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Build Electron Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); var desiredPlatform = parser.Arguments[_paramTarget][0]; string specifiedFromCustom = string.Empty; if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1) { specifiedFromCustom = parser.Arguments[_paramTarget][1]; } string configuration = "Release"; if (parser.Arguments.ContainsKey(_paramDotNetConfig)) { configuration = parser.Arguments[_paramDotNetConfig][0]; } var platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}..."); string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } Console.WriteLine("Executing dotnet publish in this directory: " + tempPath); string tempBinPath = Path.Combine(tempPath, "bin"); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration..."); var resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c {configuration} --output \"{tempBinPath}\"", Directory.GetCurrentDirectory()); if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); var nodeModulesDirPath = Path.Combine(tempPath, "node_modules"); if (parser.Arguments.ContainsKey(_paramPackageJson)) { Console.WriteLine("Copying custom package.json."); File.Copy(parser.Arguments[_paramPackageJson][0], Path.Combine(tempPath, "package.json"), true); } var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules"); if (Directory.Exists(checkForNodeModulesDirPath) == false || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson)) { Console.WriteLine("Start npm install..."); } ProcessHelper.CmdExecute("npm install --production", tempPath); Console.WriteLine("ElectronHostHook handling started..."); string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook"); if (Directory.Exists(electronhosthookDir)) { string hosthookDir = Path.Combine(tempPath, "ElectronHostHook"); DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>() { "node_modules" }); Console.WriteLine("Start npm install for hosthooks..."); ProcessHelper.CmdExecute("npm install", hosthookDir); // ToDo: Not sure if this runs under linux/macos ProcessHelper.CmdExecute(@"npx tsc -p . --sourceMap false", hosthookDir); } Console.WriteLine("Build Electron Desktop Application..."); // Specifying an absolute path supercedes a relative path string buildPath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "desktop"); if (parser.Arguments.ContainsKey(_paramAbsoluteOutput)) { buildPath = parser.Arguments[_paramAbsoluteOutput][0]; } else if (parser.Arguments.ContainsKey(_paramOutputDirectory)) { buildPath = Path.Combine(Directory.GetCurrentDirectory(), parser.Arguments[_paramOutputDirectory][0]); } Console.WriteLine("Executing electron magic in this directory: " + buildPath); string electronArch = "x64"; if (parser.Arguments.ContainsKey(_paramElectronArch)) { electronArch = parser.Arguments[_paramElectronArch][0]; } string electronParams = ""; if (parser.Arguments.ContainsKey(_paramElectronParams)) { electronParams = parser.Arguments[_paramElectronParams][0]; } // ToDo: Make the same thing easer with native c# - we can save a tmp file in production code :) Console.WriteLine("Create electron-builder configuration file..."); ProcessHelper.CmdExecute($"node build-helper.js", tempPath); Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}..."); ProcessHelper.CmdExecute($"npx electron-builder . --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=5.0.8 {electronParams}", tempPath); Console.WriteLine("... done"); return true; })); }
static int Main(string[] args) { SimpleCommandLineParser parser = new SimpleCommandLineParser(args); parser.addOption("rf", ARGUMENT_TYPE.MUST); parser.addOption("rt", ARGUMENT_TYPE.MUST); parser.addOption("ie", ARGUMENT_TYPE.MUSTNOT); parser.addOption("ic", ARGUMENT_TYPE.MUSTNOT); parser.addOption("cf", ARGUMENT_TYPE.MUSTNOT); parser.addOption("ca", ARGUMENT_TYPE.MUSTNOT); parser.addOption("blob", ARGUMENT_TYPE.MUSTNOT); parser.addOption("h", ARGUMENT_TYPE.MUSTNOT); parser.addOption("?", ARGUMENT_TYPE.MUSTNOT); parser.Parse(); if (parser["h"] != null || parser["?"] != null) { return(0); } if (parser["ca"] != null) { // check argument StringBuilder sb = new StringBuilder(); if (parser["rf"] != null) { sb.Append("rf:"); sb.AppendLine(parser["rf"].ToString()); } if (parser["rt"] != null) { sb.Append("rt:"); sb.AppendLine(parser["rt"].ToString()); } if (parser["ie"] != null) { sb.AppendLine("ie"); } if (parser["ic"] != null) { sb.AppendLine("ic"); } if (parser["ca"] != null) { sb.AppendLine("ca"); } if (parser["cf"] != null) { sb.AppendLine("cf"); } if (parser["blob"] != null) { sb.AppendLine("blob"); } if (parser["h"] != null) { sb.AppendLine("h"); } if (parser["?"] != null) { sb.AppendLine("?"); } sb.AppendLine("--------------"); for (int i = 0; i < parser.MainargLength; ++i) { sb.AppendLine(parser.getMainargs(i)); } CppUtils.CenteredMessageBox(sb.ToString()); } return(0); }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); string port = "8000"; if (parser.Arguments.ContainsKey(_paramPort)) { port = parser.Arguments[_paramPort][0]; } string staticPort = "false"; if (parser.Arguments.ContainsKey(_paramStaticPort)) { staticPort = parser.Arguments[_paramStaticPort][0]; } string aspCoreProjectPath = ""; if (parser.Arguments.ContainsKey(_paramPath)) { if (Directory.Exists(parser.Arguments[_paramPath][0])) { aspCoreProjectPath = parser.Arguments[_paramPath][0]; } else { Console.WriteLine("Supplied path doesn't exist. Creating in current working directory."); } } else { aspCoreProjectPath = Directory.GetCurrentDirectory(); } var currentDirectory = aspCoreProjectPath; Console.WriteLine("Adding our config file to your project..."); var targetFilePath = Path.Combine(currentDirectory, ConfigName); if (File.Exists(targetFilePath)) { Console.WriteLine("Config file already in your project."); return false; } // Deploy config file EmbeddedFileHelper.DeployEmbeddedFile(currentDirectory, ConfigName); // search .csproj Console.WriteLine($"Search your .csproj to add the needed {ConfigName}..."); var projectFile = Directory.EnumerateFiles(currentDirectory, "*.csproj", SearchOption.TopDirectoryOnly).FirstOrDefault(); string executable = GetAssemblyName(projectFile); string text = File.ReadAllText(targetFilePath); text = text.Replace("{{executable}}", executable); text = text.Replace("\"{{port}}\"", port); text = text.Replace("\"{{static}}\"", staticPort); File.WriteAllText(targetFilePath, text); Console.WriteLine($"Found your .csproj: {projectFile} - check for existing config or update it."); if (!EditCsProj(projectFile)) { return false; } // search launchSettings.json Console.WriteLine($"Search your .launchSettings to add our electron debug profile..."); EditLaunchSettings(currentDirectory); Console.WriteLine($"Everything done - happy electronizing!"); return true; })); }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Build Electron Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); //This version will be shared between the dotnet publish and electron-builder commands string version = null; if (parser.Arguments.ContainsKey(_paramVersion)) { version = parser.Arguments[_paramVersion][0]; } if (!parser.Arguments.ContainsKey(_paramTarget) || parser.Arguments[_paramTarget].Length == 0) { Console.WriteLine($"Error: missing '{_paramTarget}' argument."); Console.WriteLine(COMMAND_ARGUMENTS); return false; } var desiredPlatform = parser.Arguments[_paramTarget][0]; string specifiedFromCustom = string.Empty; if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1) { specifiedFromCustom = parser.Arguments[_paramTarget][1]; } string configuration = "Release"; if (parser.Arguments.ContainsKey(_paramDotNetConfig)) { configuration = parser.Arguments[_paramDotNetConfig][0]; } var platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}..."); string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } else { Directory.Delete(tempPath, true); Directory.CreateDirectory(tempPath); } Console.WriteLine("Executing dotnet publish in this directory: " + tempPath); string tempBinPath = Path.Combine(tempPath, "bin"); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration..."); var dotNetPublishFlags = GetDotNetPublishFlags(parser, "false", "false"); var project = string.Empty; if (parser.Arguments.ContainsKey(_paramDotNetProject)) { project = parser.Arguments[_paramDotNetProject][0]; } var command = $"dotnet publish {project} -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))}"; // add any additional dotnet flags var dotnetFlags = GetDotNetArgs(parser); if (dotnetFlags.Any()) { command += " " + string.Join(" ", dotnetFlags); } // output the command Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine(command); Console.ResetColor(); var resultCode = ProcessHelper.CmdExecute(command, Directory.GetCurrentDirectory()); if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); if (parser.Arguments.ContainsKey(_paramPackageJson)) { Console.WriteLine("Copying custom package.json."); File.Copy(parser.Arguments[_paramPackageJson][0], Path.Combine(tempPath, "package.json"), true); } var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules"); if (!Directory.Exists(checkForNodeModulesDirPath) || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson)) { Console.WriteLine("Start npm install..."); ProcessHelper.CmdExecute("npm install --production", tempPath); } Console.WriteLine("ElectronHostHook handling started..."); string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook"); if (Directory.Exists(electronhosthookDir)) { string hosthookDir = Path.Combine(tempPath, "ElectronHostHook"); DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>() { "node_modules" }); Console.WriteLine("Start npm install for hosthooks..."); ProcessHelper.CmdExecute("npm install", hosthookDir); // ToDo: Not sure if this runs under linux/macos ProcessHelper.CmdExecute(@"npx tsc -p . --sourceMap false", hosthookDir); } Console.WriteLine("Build Electron Desktop Application..."); // Specifying an absolute path supercedes a relative path string buildPath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "desktop"); if (parser.Arguments.ContainsKey(_paramAbsoluteOutput)) { buildPath = parser.Arguments[_paramAbsoluteOutput][0]; } else if (parser.Arguments.ContainsKey(_paramOutputDirectory)) { buildPath = Path.Combine(Directory.GetCurrentDirectory(), parser.Arguments[_paramOutputDirectory][0]); } Console.WriteLine("Executing electron magic in this directory: " + buildPath); string electronArch = "x64"; if (platformInfo.NetCorePublishRid == "osx-arm64") //Apple Silicon Mac { electronArch = "arm64"; } if (parser.Arguments.ContainsKey(_paramElectronArch)) { electronArch = parser.Arguments[_paramElectronArch][0]; } var electronVersion = ""; if (parser.Arguments.ContainsKey(_paramElectronVersion)) { electronVersion = parser.Arguments[_paramElectronVersion][0]; } else { //try getting version from project foreach (var projectFile in Directory.GetFiles(Directory.GetCurrentDirectory(), "*.csproj")) { var projectXML = File.ReadAllText(projectFile); var match = Regex.Match(projectXML, @"<PackageReference\s+Include=""h5\.ElectronNET\.API""\s+Version=""([0-9\.]+)""\s+\/>"); if (match.Success) { var candidate = match.Groups[1].Value; var majorMinorRevision = string.Join(".", candidate.Split(new char[] { '.' }).Take(3)); electronVersion = majorMinorRevision; Console.WriteLine($"Found electron version {majorMinorRevision} in project file {projectFile}"); break; } } } if (string.IsNullOrWhiteSpace(electronVersion)) { electronVersion = _defaultElectronVersion; } string electronParams = ""; if (parser.Arguments.ContainsKey(_paramElectronParams)) { electronParams = parser.Arguments[_paramElectronParams][0]; } // ToDo: Make the same thing easer with native c# - we can save a tmp file in production code :) Console.WriteLine("Create electron-builder configuration file..."); string manifestFileName = "electron.manifest.json"; if (parser.Arguments.ContainsKey(_manifest)) { manifestFileName = parser.Arguments[_manifest].First(); } ProcessHelper.CmdExecute( string.IsNullOrWhiteSpace(version) ? $"node build-helper.js {manifestFileName}" : $"node build-helper.js {manifestFileName} {version}", tempPath); Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}..."); ProcessHelper.CmdExecute($"npx electron-builder --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion={electronVersion} {electronParams}", tempPath); Console.WriteLine("... done"); return true; })); }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Build Electron Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); //This version will be shared between the dotnet publish and electron-builder commands string version = null; if (parser.Arguments.ContainsKey(_paramVersion)) { version = parser.Arguments[_paramVersion][0]; } if (!parser.Arguments.ContainsKey(_paramTarget) || parser.Arguments[_paramTarget].Length == 0) { Console.WriteLine($"Error: missing '{_paramTarget}' argument."); Console.WriteLine(COMMAND_ARGUMENTS); return false; } var desiredPlatform = parser.Arguments[_paramTarget][0]; string specifiedFromCustom = string.Empty; if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1) { specifiedFromCustom = parser.Arguments[_paramTarget][1]; } string configuration = "Release"; if (parser.Arguments.ContainsKey(_paramDotNetConfig)) { configuration = parser.Arguments[_paramDotNetConfig][0]; } var platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid}..."); string tempPath = Path.Combine(Directory.GetCurrentDirectory(), "obj", "desktop", desiredPlatform); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } else { Directory.Delete(tempPath, true); Directory.CreateDirectory(tempPath); } Console.WriteLine("Executing dotnet publish in this directory: " + tempPath); string tempBinPath = Path.Combine(tempPath, "bin"); Console.WriteLine($"Build ASP.NET Core App for {platformInfo.NetCorePublishRid} under {configuration}-Configuration..."); var dotNetPublishFlags = GetDotNetPublishFlags(parser); var command = $"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} --self-contained"; // output the command Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine(command); Console.ResetColor(); var resultCode = ProcessHelper.CmdExecute(command, Directory.GetCurrentDirectory()); if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); var nodeModulesDirPath = Path.Combine(tempPath, "node_modules"); if (parser.Arguments.ContainsKey(_paramPackageJson)) { Console.WriteLine("Copying custom package.json."); File.Copy(parser.Arguments[_paramPackageJson][0], Path.Combine(tempPath, "package.json"), true); } var checkForNodeModulesDirPath = Path.Combine(tempPath, "node_modules"); if (Directory.Exists(checkForNodeModulesDirPath) == false || parser.Contains(_paramForceNodeInstall) || parser.Contains(_paramPackageJson)) { Console.WriteLine("Start npm install..."); } ProcessHelper.CmdExecute("npm install --production", tempPath); Console.WriteLine("ElectronHostHook handling started..."); string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook"); if (Directory.Exists(electronhosthookDir)) { string hosthookDir = Path.Combine(tempPath, "ElectronHostHook"); DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>() { "node_modules" }); Console.WriteLine("Start npm install for hosthooks..."); ProcessHelper.CmdExecute("npm install", hosthookDir); // ToDo: Not sure if this runs under linux/macos ProcessHelper.CmdExecute(@"npx tsc -p . --sourceMap false", hosthookDir); } Console.WriteLine("Build Electron Desktop Application..."); // Specifying an absolute path supercedes a relative path string buildPath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "desktop"); if (parser.Arguments.ContainsKey(_paramAbsoluteOutput)) { buildPath = parser.Arguments[_paramAbsoluteOutput][0]; } else if (parser.Arguments.ContainsKey(_paramOutputDirectory)) { buildPath = Path.Combine(Directory.GetCurrentDirectory(), parser.Arguments[_paramOutputDirectory][0]); } Console.WriteLine("Executing electron magic in this directory: " + buildPath); string electronArch = "x64"; if (parser.Arguments.ContainsKey(_paramElectronArch)) { electronArch = parser.Arguments[_paramElectronArch][0]; } string electronParams = ""; if (parser.Arguments.ContainsKey(_paramElectronParams)) { electronParams = parser.Arguments[_paramElectronParams][0]; } // ToDo: Make the same thing easer with native c# - we can save a tmp file in production code :) Console.WriteLine("Create electron-builder configuration file..."); string manifestFileName = "electron.manifest.json"; if (parser.Arguments.ContainsKey(_manifest)) { manifestFileName = parser.Arguments[_manifest].First(); } ProcessHelper.CmdExecute( string.IsNullOrWhiteSpace(version) ? $"node build-helper.js {manifestFileName}" : $"node build-helper.js {manifestFileName} {version}", tempPath); Console.WriteLine($"Package Electron App for Platform {platformInfo.ElectronPackerPlatform}..."); ProcessHelper.CmdExecute($"npx electron-builder --config=./bin/electron-builder.json --{platformInfo.ElectronPackerPlatform} --{electronArch} -c.electronVersion=13.1.5 {electronParams}", tempPath); Console.WriteLine("... done"); return true; })); }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Start Electron Desktop Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); string aspCoreProjectPath = ""; if (parser.Arguments.ContainsKey(_aspCoreProjectPath)) { string projectPath = parser.Arguments[_aspCoreProjectPath].First(); if (Directory.Exists(projectPath)) { aspCoreProjectPath = projectPath; } } else { aspCoreProjectPath = Directory.GetCurrentDirectory(); } string tempPath = Path.Combine(aspCoreProjectPath, "obj", "Host"); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } string tempBinPath = Path.GetFullPath(Path.Combine(tempPath, "bin")); var dotNetPublishFlags = BuildCommand.GetDotNetPublishFlags(parser, "false", "false"); var resultCode = 0; // If target is specified as a command line argument, use it. // Format is the same as the build command. // If target is not specified, autodetect it. var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty); if (parser.Arguments.ContainsKey(_paramTarget)) { var desiredPlatform = parser.Arguments[_paramTarget][0]; string specifiedFromCustom = string.Empty; if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1) { specifiedFromCustom = parser.Arguments[_paramTarget][1]; } platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom); } string configuration = "Debug"; if (parser.Arguments.ContainsKey(_paramDotNetConfig)) { configuration = parser.Arguments[_paramDotNetConfig][0]; } var project = string.Empty; if (parser.Arguments.ContainsKey(_paramDotNetProject)) { project = parser.Arguments[_paramDotNetProject][0]; } if (!parser.Arguments.ContainsKey("watch")) { resultCode = ProcessHelper.CmdExecute($"dotnet publish {project} -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {string.Join(' ', dotNetPublishFlags.Select(kvp => $"{kvp.Key}={kvp.Value}"))} /p:DisabledWarnings=true", aspCoreProjectPath); } if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); var nodeModulesDirPath = Path.Combine(tempPath, "node_modules"); bool runNpmInstall = false; Console.WriteLine("node_modules in: " + nodeModulesDirPath); if (!Directory.Exists(nodeModulesDirPath)) { runNpmInstall = true; } var packagesJson = Path.Combine(tempPath, "package.json"); var packagesPrevious = Path.Combine(tempPath, "package.json.previous"); if (!runNpmInstall) { if (File.Exists(packagesPrevious)) { if (File.ReadAllText(packagesPrevious) != File.ReadAllText(packagesJson)) { runNpmInstall = true; } } else { runNpmInstall = true; } } if (runNpmInstall) { Console.WriteLine("Start npm install..."); ProcessHelper.CmdExecute("npm install", tempPath); File.Copy(packagesJson, packagesPrevious, true); } Console.WriteLine("ElectronHostHook handling started..."); string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook"); if (Directory.Exists(electronhosthookDir)) { string hosthookDir = Path.Combine(tempPath, "ElectronHostHook"); DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>() { "node_modules" }); Console.WriteLine("Start npm install for typescript & hosthooks..."); ProcessHelper.CmdExecute("npm install", hosthookDir); // ToDo: Not sure if this runs under linux/macos ProcessHelper.CmdExecute(@"npx tsc -p ../../ElectronHostHook", tempPath); } string arguments = ""; if (parser.Arguments.ContainsKey(_arguments)) { arguments = string.Join(' ', parser.Arguments[_arguments]); } if (parser.Arguments.ContainsKey(_manifest)) { arguments += " --manifest=" + parser.Arguments[_manifest].First(); } if (parser.Arguments.ContainsKey(_clearCache)) { arguments += " --clear-cache=true"; } if (parser.Arguments.ContainsKey("watch")) { arguments += " --watch=true"; } string path = Path.Combine(tempPath, "node_modules", ".bin"); bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows); if (isWindows) { Console.WriteLine("Invoke electron.cmd - in dir: " + path); Console.WriteLine("\n\n---------------------------------------------------\n\n\n"); ProcessHelper.CmdExecute(@"electron.cmd ""..\..\main.js"" " + arguments, path); } else { Console.WriteLine("Invoke electron - in dir: " + path); Console.WriteLine("\n\n---------------------------------------------------\n\n\n"); ProcessHelper.CmdExecute(@"./electron ""../../main.js"" " + arguments, path); } return true; })); }
private static void Main(string[] args) { var parser = new SimpleCommandLineParser(); parser.Parse(args); if (parser.Arguments.ContainsKey("server")) { var server = new LoadTestServer { MessagesPerAck = parser.GetValue("MessagesPerAck", 0, 0) }; server.Start(parser.GetValue("server", 0, 8334)); Console.WriteLine("Server started"); if (parser.Arguments.ContainsKey("quit")) { Console.WriteLine("Waiting for completion"); server.WaitForExit(); Console.WriteLine("Exiting"); } else { Console.WriteLine("Press ENTER to quit"); Console.ReadLine(); } } else if (parser.Arguments.ContainsKey("client")) { Process serverProcess = null; if (parser.Arguments.ContainsKey("SpawnServer")) { var hostAndPort = parser.Arguments["client"][0]; var port = hostAndPort.Split(':')[1]; var psi = new ProcessStartInfo(Assembly.GetExecutingAssembly().Location); psi.Arguments = " -server " + port + " -quit"; serverProcess = Process.Start(psi); } var client = new LoadTestClient { MessageCount = parser.GetValue("MessageCount", 0, 10000), MessageSize = parser.GetValue("MessageSize", 0, 1000), MessagesPerAck = parser.GetValue("MessagesPerAck", 0, 0), RemoteHost = parser.Arguments["client"][0] }; var mbits = (client.MessageCount * client.MessageSize * 8) / 1000000; Console.WriteLine("Sending " + client.MessageCount + " messages of size " + client.MessageSize + " bytes. Total of " + mbits.ToString("N3") + "Mbits."); if (client.MessagesPerAck > 0) Console.WriteLine("Using ACKs every " + client.MessagesPerAck + " message."); client.Start(); Console.WriteLine("Waiting for exit"); client.WaitForExit(); if (serverProcess != null) { client.Close(); Console.WriteLine("Waiting for server exit"); serverProcess.WaitForExit(); } } else { Console.WriteLine("SharpMessaging.BenchmarkApp"); Console.WriteLine(); Console.WriteLine("SharpMessaging.BenchmarkApp -server [port]"); Console.WriteLine("SharpMessaging.BenchmarkApp -client [host:port]"); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("Options (for client and server)"); Console.WriteLine(" Name Default Description"); Console.WriteLine(" =============================================="); Console.WriteLine(" MessagesPerAck 0 0 = disable acks"); Console.WriteLine(); Console.WriteLine("Options (for client)"); Console.WriteLine(" Name Default Description"); Console.WriteLine(" =============================================="); Console.WriteLine(" MessageCount 10000 Number of messages to send"); Console.WriteLine(" MessageSize 1000 Message size"); Console.WriteLine(); Console.WriteLine("Example:"); Console.WriteLine("SharpMessaging.BenchmarkApp -client localhost:8334 -MessageCount 100000"); return; } }
public Task <bool> ExecuteAsync() { return(Task.Run(() => { Console.WriteLine("Start Electron Desktop Application..."); SimpleCommandLineParser parser = new SimpleCommandLineParser(); parser.Parse(_args); string aspCoreProjectPath = ""; if (parser.Arguments.ContainsKey(_aspCoreProjectPath)) { string projectPath = parser.Arguments[_aspCoreProjectPath].First(); if (Directory.Exists(projectPath)) { aspCoreProjectPath = projectPath; } } else { aspCoreProjectPath = Directory.GetCurrentDirectory(); } string tempPath = Path.Combine(aspCoreProjectPath, "obj", "Host"); if (Directory.Exists(tempPath) == false) { Directory.CreateDirectory(tempPath); } string tempBinPath = Path.Combine(tempPath, "bin"); var resultCode = 0; string publishReadyToRun = "/p:PublishReadyToRun="; if (parser.Arguments.ContainsKey(_paramPublishReadyToRun)) { publishReadyToRun += parser.Arguments[_paramPublishReadyToRun][0]; } else { publishReadyToRun += "true"; } string publishSingleFile = "/p:PublishSingleFile="; if (parser.Arguments.ContainsKey(_paramPublishSingleFile)) { publishSingleFile += parser.Arguments[_paramPublishSingleFile][0]; } else { publishSingleFile += "true"; } // If target is specified as a command line argument, use it. // Format is the same as the build command. // If target is not specified, autodetect it. var platformInfo = GetTargetPlatformInformation.Do(string.Empty, string.Empty); if (parser.Arguments.ContainsKey(_paramTarget)) { var desiredPlatform = parser.Arguments[_paramTarget][0]; string specifiedFromCustom = string.Empty; if (desiredPlatform == "custom" && parser.Arguments[_paramTarget].Length > 1) { specifiedFromCustom = parser.Arguments[_paramTarget][1]; } platformInfo = GetTargetPlatformInformation.Do(desiredPlatform, specifiedFromCustom); } string configuration = "Debug"; if (parser.Arguments.ContainsKey(_paramDotNetConfig)) { configuration = parser.Arguments[_paramDotNetConfig][0]; } if (parser != null && !parser.Arguments.ContainsKey("watch")) { resultCode = ProcessHelper.CmdExecute($"dotnet publish -r {platformInfo.NetCorePublishRid} -c \"{configuration}\" --output \"{tempBinPath}\" {publishReadyToRun} {publishSingleFile} --no-self-contained", aspCoreProjectPath); } if (resultCode != 0) { Console.WriteLine("Error occurred during dotnet publish: " + resultCode); return false; } DeployEmbeddedElectronFiles.Do(tempPath); var nodeModulesDirPath = Path.Combine(tempPath, "node_modules"); Console.WriteLine("node_modules missing in: " + nodeModulesDirPath); Console.WriteLine("Start npm install..."); ProcessHelper.CmdExecute("npm install", tempPath); Console.WriteLine("ElectronHostHook handling started..."); string electronhosthookDir = Path.Combine(Directory.GetCurrentDirectory(), "ElectronHostHook"); if (Directory.Exists(electronhosthookDir)) { string hosthookDir = Path.Combine(tempPath, "ElectronHostHook"); DirectoryCopy.Do(electronhosthookDir, hosthookDir, true, new List <string>() { "node_modules" }); Console.WriteLine("Start npm install for typescript & hosthooks..."); ProcessHelper.CmdExecute("npm install", hosthookDir); // ToDo: Not sure if this runs under linux/macos ProcessHelper.CmdExecute(@"npx tsc -p ../../ElectronHostHook", tempPath); } string arguments = ""; if (parser.Arguments.ContainsKey(_arguments)) { arguments = string.Join(' ', parser.Arguments[_arguments]); } if (parser.Arguments.ContainsKey(_manifest)) { arguments += " --manifest=" + parser.Arguments[_manifest].First(); } if (parser.Arguments.ContainsKey(_clearCache)) { arguments += " --clear-cache=true"; } if (parser.Arguments.ContainsKey("watch")) { arguments += " --watch=true"; } string path = Path.Combine(tempPath, "node_modules", ".bin"); bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows); if (isWindows) { Console.WriteLine("Invoke electron.cmd - in dir: " + path); ProcessHelper.CmdExecute(@"electron.cmd ""..\..\main.js"" " + arguments, path); } else { Console.WriteLine("Invoke electron - in dir: " + path); ProcessHelper.CmdExecute(@"./electron ""../../main.js"" " + arguments, path); } return true; })); }
static int Main(string[] args) { SimpleCommandLineParser parser = new SimpleCommandLineParser(args); parser.addOption("rf", ARGUMENT_TYPE.MUST); parser.addOption("rt", ARGUMENT_TYPE.MUST); parser.addOption("ie", ARGUMENT_TYPE.MUSTNOT); parser.addOption("ic", ARGUMENT_TYPE.MUSTNOT); parser.addOption("cf", ARGUMENT_TYPE.MUSTNOT); parser.addOption("ca", ARGUMENT_TYPE.MUSTNOT); parser.addOption("blob", ARGUMENT_TYPE.MUSTNOT); parser.addOption("h", ARGUMENT_TYPE.MUSTNOT); parser.addOption("?", ARGUMENT_TYPE.MUSTNOT); parser.Parse(); if (parser["h"] != null || parser["?"] != null) { ShowHelp(); return(0); } if (parser["ca"] != null) { // check argument StringBuilder sb = new StringBuilder(); if (parser["rf"] != null) { sb.Append("rf:"); sb.AppendLine(parser["rf"].ToString()); } if (parser["rt"] != null) { sb.Append("rt:"); sb.AppendLine(parser["rt"].ToString()); } if (parser["ie"] != null) { sb.AppendLine("ie"); } if (parser["ic"] != null) { sb.AppendLine("ic"); } if (parser["ca"] != null) { sb.AppendLine("ca"); } if (parser["cf"] != null) { sb.AppendLine("cf"); } if (parser["blob"] != null) { sb.AppendLine("blob"); } if (parser["h"] != null) { sb.AppendLine("h"); } if (parser["?"] != null) { sb.AppendLine("?"); } MessageBox.Show(sb.ToString(), Application.ProductName + " " + "check arg", MessageBoxButtons.OK, MessageBoxIcon.Information); return(0); } if (parser["rf"] == null || parser["rt"] == null) { ShowAlert(Properties.Resources.MUST_SPECIFY_RF_RT); return(1); } string f = parser["rf"].ToString(); string t = parser["rt"].ToString(); if (parser.MainargLength == 0) { ShowAlert(Properties.Resources.NO_FILE); return(1); } Regex regf = null; try { if (parser["ic"] != null) { regf = new Regex(f, RegexOptions.IgnoreCase); } else { regf = new Regex(f); } } catch (Exception ex) { CppUtils.CenteredMessageBox(ex.Message); return(1); } bool isAlsoExt = null != parser["ie"]; bool dryrun = parser["cf"] != null; Dictionary <string, string> targets = new Dictionary <string, string>(); string[] mainArgs = ConstructMainArgs(parser); try { foreach (string orgFullorRelativeFileName in mainArgs)// (int i = 0; i < parser.MainargLength; ++i) { FileInfo fiorig = new FileInfo(orgFullorRelativeFileName); string orgFileName = getProperName(fiorig, isAlsoExt); string orgFolder = fiorig.DirectoryName; string newFileName = regf.Replace(orgFileName, t); if (!isAlsoExt) { newFileName += fiorig.Extension; } //if (dryrun) //{ // sbDry.AppendLine(string.Format("\"{0}\" -> \"{1}\"", // fiorig.FullName, orgFolder + @"\" + newFileName)); //} //else //{ // fiorig.MoveTo(orgFolder + @"\" + newFileName); //} targets.Add(fiorig.FullName, orgFolder + @"\" + newFileName); } if (dryrun) { StringBuilder sbDry = new StringBuilder(); foreach (string org in targets.Keys) { sbDry.AppendFormat("\"{0}\" -> \"{1}\"", org, targets[org]); sbDry.AppendLine(); sbDry.AppendLine(); } sbDry.AppendLine(); sbDry.AppendLine(Properties.Resources.DO_YOU_WANT_TO_PERFORM); if (DialogResult.Yes != MessageBox.Show( sbDry.ToString(), Application.ProductName + " " + Properties.Resources.CONFIRM, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2)) { return(0); } } foreach (string org in targets.Keys) { if (Directory.Exists(org)) { Directory.Move(org, targets[org]); } else { File.Move(org, targets[org]); } } return(0); } catch (Exception e) { MessageBox.Show( e.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error); return(-1); } }