C# 2010 excuting a process

I have the following questions about a C# 2010 application calling another C# console application using the C# process method:
1. When using a process method, I have seen where you can use the process as either a static method call and also an object that can be instantiated. What is the preferred method and why?
2. If I instantiate a process as an object, do I need to delete that process in memory so that it does not stay around in memory? If so, how do you delete the process?
3. The following code is a snippet of what I have setup so far. Can you tell me if you see any problems with this code? If so can you tell me how to modify the code so that it works better?

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.ComponentModel;

namespace eScripts
{
class Run_e
{
private static String strConsoleAppLocation = "C:\\Program Files (x86)\\coname\\1.exe";
private static String strWebServiceurl = "https://etest//WebService1";
static void Main(string[] args)
{
Process eProcess = new Process();
try
{
String Process_Arguments = null;
eProcess.StartInfo.UseShellExecute = false;
eProcess.StartInfo.FileName = strConsoleAppLocation;
Process_Arguments = strWebServiceurl + " 164 " + cust1";
eProcess.StartInfo.Arguments = Process_Arguments;
eProcess.Start();
eRPT_Process.WaitForExit(1800);
Process_Arguments = null;
eDataContext rptData = new eDataContext();
string[] PkgIDs = rData.Trackings.Where(c => c.Received_Date != null
.Select(c => c.Package_ID).ToArray();
foreach (string PkgID in PkgIDs)
{
String Process1_Arguments = null;
Process Process1 = new Process();
Process1.StartInfo.FileName = strConsoleAppLocation;
Process1_Arguments = strWebServiceurl + " 10 " + PkgID;
Process1.StartInfo.Arguments = Process1_Arguments;
Process1.Start();
Process1.WaitForExit(1800);
Process1.Dispose();
Process1_Arguments = null;
}
ateTime StartDateTime = rData.Trackings.Where(c => c.Error_Report_Date != null).Select(c => c.Error_Report_Date).Max().GetValueOrDefault();
DateTime CurDateTime = DateTime.Now;
string[] AddPkgIDs = (from rData.Trackings.where(c.tNumber.Substring(0, 3) == "dis"
select TNumb).Distinct().ToArray();
if (AddPkgIDs != null)
{
foreach (string AddPkgID in AddPkgIDs)
{
String Process4_Arguments = null;
Process Process4 = new Process();
Process4.StartInfo.FileName = strConsoleAppLocation;
Process4_Arguments = strWebServiceurl + " 14295 " + AddPkgID;
Process4.StartInfo.Arguments = Process4_Arguments;
Process4.Start();
Process4.WaitForExit(1800); //waits 2 minutes
Process4.Dispose();
}
}
}

catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}

1. The static overloads of Process.Start tend to be used in simple cases where you just want to launch another application and (perhaps) pass it some command line arguments. However, having said that, there is a static overload which takes a ProcessStartInfo object and the method does return a reference to the Process object created so you can use this overload to do some more complicated things.

If you need as much control as possible such as the ability to attach eventhandlers, then you'd use the constructor to create a Process object and do whatever's needed with that object before calling the instance overload of Process.Start.

Subject to those observations, it makes no difference whether you use static or instance methods - it's just a matter of taste.

2. Unless your application will terminate just after launching the second application, it's best to call Process.Dispose() when you've finished using a Process object (and to set the variable reference to null if it won't otherwise go out of scope) so that unmanaged resources are released immediately and the memory used by the object is reclaimed in due course by the garbage collector.

3. I can't see any obvious problems with your code (except that 2 minutes is 120,000 rather than 1,800 milliseconds) and so, if it seems to be working OK, I'd leave it alone.

1 Reply

Know the answer? Post it — somebody with the same question will find it here.

Vulpes14y ago
Accepted answer
1. The static overloads of Process.Start tend to be used in simple cases where you just want to launch another application and (perhaps) pass it some command line arguments. However, having said that, there is a static overload which takes a ProcessStartInfo object and the method does return a reference to the Process object created so you can use this overload to do some more complicated things.

If you need as much control as possible such as the ability to attach eventhandlers, then you'd use the constructor to create a Process object and do whatever's needed with that object before calling the instance overload of Process.Start.

Subject to those observations, it makes no difference whether you use static or instance methods - it's just a matter of taste.

2. Unless your application will terminate just after launching the second application, it's best to call Process.Dispose() when you've finished using a Process object (and to set the variable reference to null if it won't otherwise go out of scope) so that unmanaged resources are released immediately and the memory used by the object is reclaimed in due course by the garbage collector.

3. I can't see any obvious problems with your code (except that 2 minutes is 120,000 rather than 1,800 milliseconds) and so, if it seems to be working OK, I'd leave it alone.
0