Finding my main executable's path using Assembly vs AppDomain

Question

Hi all, My first stackoverflow question, hurray to me.

I'm a .NET user, and my goal is as simple as finding the absolute path of the directory of my main executing assembly (the EXE file).

I have several candidates:

• Assembly.GetExecutingAssembly().CodeBase
• Assembly.GetExecutingAssembly().Location
• AppDomain.CurrentDomain.BaseDirectory

If to judge by the .NET documentation - I'm leaning towards CodeBase. Can anyone shed light over all three in a bit more specific terms than the .NET documentation? An example to demonstrate the difference perhaps?

Thanks, O

Answer 1

From: http://msdn.microsoft.com/en-us/library/system.reflection.assembly.codebase.aspx

Assembly.CodeBase

To get the absolute path to the loaded manifest-containing file, use the Assembly.Location property instead.

If the assembly was loaded as a byte array, using an overload of the Load method that takes an array of bytes, this property returns the location of the caller of the method, not the location of the loaded assembly.

For AppDomain.CurrentDomain.BaseDirectory, I honestly have no idea about the differences from a practical point of view.

Answer 2

I would use GetEntryAssembly() instead of GetExecutingAssembly().

To see why, do this:

• create a new console project
• add a class library project (ClassLibrary1) to the solution and reference it from the console project.

Put this in ClassLibrary1:

namespace ClassLibrary1
{
    using System;
    using System.IO;
    using System.Reflection;

    public class Class1
    {
        public void GetInfo(int n)
        {
            Assembly asm = Assembly.GetEntryAssembly();
            Console.WriteLine("[GetEntryAssembly {0}] Location:{1}", n, Path.GetDirectoryName(asm.Location));
            asm = Assembly.GetExecutingAssembly();
            Console.WriteLine("[GetExecutingAssembly() {0}] Location:{1}", n, Path.GetDirectoryName(asm.Location));
        }
    }
}

Put this in console's Program.cs:

namespace ConsoleApplication4
{
    using System;
    using System.IO;
    using System.Reflection;
    using ClassLibrary1;

    class Program
    {
        static void Main(string[] args)
        {
            Assembly asm = Assembly.GetEntryAssembly();
            Console.WriteLine("[GetEntryAssembly() 1] Location:{0}", Path.GetDirectoryName(asm.Location));
            asm = Assembly.GetExecutingAssembly();
            Console.WriteLine("[GetExecutingAssembly() 1] Location:{0}", Path.GetDirectoryName(asm.Location));

            Class1 obj1 = new Class1();
            obj1.GetInfo(2);

            asm = Assembly.LoadFile(@"C:\temp\ClassLibrary1.dll");
            Type t = asm.GetType("ClassLibrary1.Class1");
            object obj2 = asm.CreateInstance("ClassLibrary1.Class1");
            t.GetMethod("GetInfo").Invoke(obj2, new object[] { 3 });

            Console.ReadKey();
        }
    }
}

Build the solution, copy ClassLibrary1.dll to c:\temp and run.

As you will see, GetExecutingAssembly() may trick you in certain conditions.

One last note, if your app is a Windows Forms one, you can just use Application.ExecutablePath.

Answer 3

Unfortunately, all the methods above can fail if you use a virtualization like XenoCode postbuild. I have tested many methods and found another solution here. I've found that only the

System.Diagnostics.Process.GetCurrentProcess().ProcessName + ".exe"

returns the correct filename of the executable. So combining the filename with the path from Assembly.GetEntryAssembly().Location you will get the correct path of the executable.