Invoking Console Application's Program.Main from another project

  • Thread starter Thread starter Shikari Shambu
  • Start date Start date
Hi,
Is it possible to invoke the entry point of a console application
project from another project. Or, do I have to invoke the associated
exe as per the post below
http://blogs.msdn.com/csharpfaq/archive/2004/06/01/146375.aspx

TIA
Click to expand...

Answer: As per the post below.


If you have control of the other program's source, you can refactor the
bits you want to call out of Main and call them. But, if not, you are
stuck with firing up via Process or using PInvoke to fire off the
process from the Win API (not wise if the process is .NET).


--
Gregory A. Beamer
MVP; MCP: +I, SE, SD, DBA

Twitter: @gbworld
Blog: http://gregorybeamer.spaces.live.com

*******************************************
| Think outside the box! |
*******************************************
 
Shikari Shambu said:
Is it possible to invoke the entry point of a console application
project from another project. Or, do I have to invoke the associated exe as
per the post below
http://blogs.msdn.com/csharpfaq/archive/2004/06/01/146375.aspx
Click to expand...

You could use reflection. Untested code follows:

// Runner program
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Start of runner.");
Assembly assembly = Assembly.LoadFrom("Example.exe");

foreach (Type type in assembly.GetTypes())
{
MethodInfo method = type.GetMethod("Main",
BindingFlags.Static |
BindingFlags.NonPublic | BindingFlags.Public);

if (method != null)
{
List<object> nulls = new List<object>();
for (int i = 0; i < method.GetParameters().Length; i++)
{
nulls.Add(null);
}
method.Invoke(null, nulls.ToArray());
}

}

Console.WriteLine("End of runner.");
}
}

// Simple example app, named Example.exe
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Inside example app.");
}
}
 
Scott Seligman said:
Shikari Shambu said:
Is it possible to invoke the entry point of a console application
project from another project. Or, do I have to invoke the associated exe
as
per the post below
http://blogs.msdn.com/csharpfaq/archive/2004/06/01/146375.aspx
Click to expand...

You could use reflection. Untested code follows:

// Runner program
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Start of runner.");
Assembly assembly = Assembly.LoadFrom("Example.exe");

foreach (Type type in assembly.GetTypes())
{
MethodInfo method = type.GetMethod("Main",
BindingFlags.Static |
BindingFlags.NonPublic | BindingFlags.Public);

if (method != null)
{
List<object> nulls = new List<object>();
for (int i = 0; i < method.GetParameters().Length; i++)
{
nulls.Add(null);
}
Click to expand...

Assembly has an EntryPoint property which lets you skip all that fragile
searching for "Main".
method.Invoke(null, nulls.ToArray());
}

}

Console.WriteLine("End of runner.");
}
}

// Simple example app, named Example.exe
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Inside example app.");
}
}

--
--------- Scott Seligman <scott at <firstname> and michelle dot
net> ---------
The trouble with computers, of course, is that they're very
sophisticated idiots.
-- The Doctor in Doctor Who:"The Robot"
Click to expand...
 
Ben Voigt said:
Assembly has an EntryPoint property which lets you skip all that fragile
searching for "Main".
Click to expand...

Right you are. That's what I get for typing without thinking.
 
Scott Seligman said:
Right you are. That's what I get for typing without thinking.
Click to expand...

I probably would have done the exact same thing, if I didn't know that the
C++/CLI compiler lets you name the entry point something else. I think the
C# compiler does too, and I'm positive that ilasm can, but I've not used the
C# alternate name feature.
 
Ben said:
Scott Seligman said:
Shikari Shambu said:
Is it possible to invoke the entry point of a console application
project from another project. Or, do I have to invoke the associated
exe as
per the post below
http://blogs.msdn.com/csharpfaq/archive/2004/06/01/146375.aspx
Click to expand...

You could use reflection. Untested code follows:

// Runner program
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Start of runner.");
Assembly assembly = Assembly.LoadFrom("Example.exe");

foreach (Type type in assembly.GetTypes())
{
MethodInfo method = type.GetMethod("Main",
BindingFlags.Static |
BindingFlags.NonPublic | BindingFlags.Public);

if (method != null)
{
List<object> nulls = new List<object>();
for (int i = 0; i < method.GetParameters().Length; i++)
{
nulls.Add(null);
}
Click to expand...

Assembly has an EntryPoint property which lets you skip all that fragile
searching for "Main".
method.Invoke(null, nulls.ToArray());
}

}

Console.WriteLine("End of runner.");
}
}

// Simple example app, named Example.exe
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Inside example app.");
}
}
Click to expand...
Click to expand...

I think the original poster were interested in running any EXE
not just .NET EXE's.

But if we focus on .NET EXE's, then there may be an easier
solution than reflection.

If the example.exe class and Main method has proper accessibility
it can be as simple as just calling it:

public class Runner
{
public static void Main(string[] args)
{
Program.Main(null);
}
}

Arne
 
I think the original poster were interested in running any EXE
not just .NET EXE's.
Click to expand...

non-.NET EXEs don't have Program.Main methods to run.
But if we focus on .NET EXE's, then there may be an easier
solution than reflection.

If the example.exe class and Main method has proper accessibility
it can be as simple as just calling it:

public class Runner
{
public static void Main(string[] args)
{
Program.Main(null);
}
}
Click to expand...

If you have the executable ahead of time to add as a reference, sure. If
you need to work with an arbitrary .NET executable, then reflection is
needed to load the assembly dynamically.
 
Ben said:
non-.NET EXEs don't have Program.Main methods to run.
Click to expand...

True.

But Program.Main were not mentioned by OP.

The link he gave ran a BAT file.
But if we focus on .NET EXE's, then there may be an easier
solution than reflection.

If the example.exe class and Main method has proper accessibility
it can be as simple as just calling it:

public class Runner
{
public static void Main(string[] args)
{
Program.Main(null);
}
}
Click to expand...

If you have the executable ahead of time to add as a reference, sure.
If you need to work with an arbitrary .NET executable, then reflection
is needed to load the assembly dynamically.
Click to expand...

True.

Arne
 
Arne Vajhøj said:
Peter said:
Ben Voigt [C++ MVP] wrote:
I think the original poster were interested in running any EXE
not just .NET EXE's.
non-.NET EXEs don't have Program.Main methods to run.

True.

But Program.Main were not mentioned by OP.
Click to expand...

Well, if you don't count the "Subject:" field. :)
Click to expand...

Ooops.

I missed that.
Click to expand...

A surprising number of posts here have crucial information only in the
subject field.

Some people even use it for their entire question.

Not that I approve or anything.
 
Back
Top