How can I get the application's path in a .NET console application?

System.Reflection.Assembly.GetExecutingAssembly().Location¹

Combine that with System.IO.Path.GetDirectoryName if all you want is the directory.

¹As per Mr.Mindor's comment:
System.Reflection.Assembly.GetExecutingAssembly().Location returns where the executing assembly is currently located, which may or may not be where the assembly is located when not executing. In the case of shadow copying assemblies, you will get a path in a temp directory. System.Reflection.Assembly.GetExecutingAssembly().CodeBase will return the 'permanent' path of the assembly.

• System.Reflection.Assembly.GetExecutingAssembly().Location returns where the executing assembly is currently located, which may or may not be where the assembly is located when not executing. In the case of shadow copying assemblies, you will get a path in a temp directory. System.Reflection.Assembly.GetExecutingAssembly().CodeBase will return the 'permenant' path of the assembly. - Mr.Mindor
• @SamGoldberg: That depend on how it is used: stackoverflow.com/q/1068420/391656 . Or you can ... new Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase).LocalPath - Mr.Mindor
• For whatever reason, in VS2013 (at least the copy I have) intellisense does not work past System.Reflection.Assembly. GetExeuctingAssembly() is there but you cannot see it. - PseudoToad
• GetExecutingAssembly returns assembly that contains the code that is currently executing. This may not necessarily be the console .exe assembly. It may be an assembly that has been loaded from a totally different location. You will have to use GetEntryAssembly! Also note that CodeBasemight not be set when the assembly is in the GAC. The better alternative is AppDomain.CurrentDomain.BaseDirectory. - bitbonk
• Please write code in 4 spaces so it is comfortable to copy - fnc12

You can use the following code to get the current application directory.

AppDomain.CurrentDomain.BaseDirectory

• Don't use this. The BaseDirectory can be set at runtime. It is not guaranteed to be correct (like the accepted answer is). - usr
• +1 This is likely the answer you want as it compensates for shadow copying. - George Mauer
• @usr What makes you think that BaseDirectory can be set at runtime? It only has a getter. - bitbonk
• @bitbonk it can be set at appdomain creation time. - usr
• Isn't it that BaseDirectory can be changed in a *.lnk file, in the "Start in:" field? - Alexander

You have two options for finding the directory of the application, which you chose will depend on your purpose.

// to get the location the assembly is executing from
//(not necessarily where the it normally resides on disk)
// in the case of the using shadow copies, for instance in NUnit tests, 
// this will be in a temp directory.
string path = System.Reflection.Assembly.GetExecutingAssembly().Location;

//To get the location the assembly normally resides on disk or the install directory
string path = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;

//once you have the path you get the directory with:
var directory = System.IO.Path.GetDirectoryName(path);

• Just wanted to say, obviously there are many more than 2 options by how many other choices are posted... - vapcguy
• If whatever you're trying to do with said path doesn't support URI format, use var localDirectory = new Uri(directory).LocalPath; - Okuma.Scott
• This is just wrong. What is the executable is not a .NET assembly at all? The right answer is to check the environment and inspect the command line. - mark

Probably a bit late but this is worth a mention:

Environment.GetCommandLineArgs()[0];

Or more correctly to get just the directory path:

System.IO.Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]);

Edit:

Quite a few people have pointed out that GetCommandLineArgs is not guaranteed to return the program name. See The first word on the command line is the program name only by convention. The article does state that "Although extremely few Windows programs use this quirk (I am not aware of any myself)". So it is possible to 'spoof' GetCommandLineArgs, but we are talking about a console application. Console apps are usually quick and dirty. So this fits in with my KISS philosophy.

• And maybe this: path = Environment.GetCommandLineArgs()[0].Substring(0, iniFilePath.LastIndexOf("\\") + 1); - fabspro
• @usr the situation you allude to is highly theoretical. In the context of a console application, it doesn't really make sense to use any other method. Keep it simple! - Steve Mc
• @usr mmm - looking at the taskmgr cmdline column sort of backs up what I'm saying. A few system services with just the exe name. Never mind. What I'm trying to say is that when developing a console application there is no need to make things more complicated than they need to be. Especially when we already have the information available. Now, if you are running a console application in such a way as to trick GetCommandLineArgs then you are already jumping through hoops and you would probably need to ask yourself if a console app is the right way to go. - Steve Mc
• Your "simple" solution involves two method calls. The "complicated" solution involves two method calls. No practical difference - except that the "simple" solution can give you the wrong answer under certain circumstances which aren't under your control when you're writing the program. Why take the risk? Use the other two method calls, and your program will be no more complicated but will be more reliable. - Chris
• Worked for my scenario, the other solutions did not, so thanks for providing another alternative :-) I was using ReSharper test runner to run an MS Unit test and the code I was testing needed a specific .dll to be in the executing directory...and Assembly.GetExecutingDirectory() weirdly returns a different result. - wallismark

For anyone interested in asp.net web apps. Here are my results of 3 different methods

protected void Application_Start(object sender, EventArgs e)
{
  string p1 = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
  string p2 = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath;
  string p3 = this.Server.MapPath("");
  Console.WriteLine("p1 = " + p1);
  Console.WriteLine("p2 = " + p2);
  Console.WriteLine("p3 = " + p3);
}

result

p1 = C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Temporary ASP.NET Files\root\a897dd66\ec73ff95\assembly\dl3\ff65202d\29daade3_5e84cc01
p2 = C:\inetpub\SBSPortal_staging\
p3 = C:\inetpub\SBSPortal_staging

the app is physically running from "C:\inetpub\SBSPortal_staging", so the first solution is definitely not appropriate for web apps.

The answer above was 90% of what I needed, but returned a Uri instead of a regular path for me.

As explained in the MSDN forums post, How to convert URI path to normal filepath?, I used the following:

// Get normal filepath of this assembly's permanent directory
var path = new Uri(
    System.IO.Path.GetDirectoryName(
        System.Reflection.Assembly.GetExecutingAssembly().CodeBase)
    ).LocalPath;

• this works well also if the exe in question is a windows service and current directory returns C:\Windows\system32. The above code returns the actual location of the exe - DaImTo
• Except if you then try to do something like File.CreateDirectory(path), it will give you the exception that it doesn't allow URI paths... - vapcguy
• Unfortunately this is doesn't work for paths that contain a fragment identifier (the # character). The identifier and everything following it is truncated from the resulting path. - Mark
• Why don't you swap new Uri and System.IO.Path.GetDirectoryName? That gives you a normal path string instead of a Uri. - Timo
• I find this the best one. This same approach has worked reliably for me in any environment. In production, debugging locally, unit testing... Want to open a content file that you included ("content - copy if newer") in a unit test? It's there. - Timo

You may be looking to do this:

System.IO.Path.GetDirectoryName(
    System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase)

you can use this one instead.

System.Environment.CurrentDirectory

• This will get the folder of the executable though - Iain
• Unless something has called Directory.SetCurrentDirectory()... - Matthew Watson
• @MatthewWatson or even simpler, the program was executed from another folder... - Ohad Schneider

For Console Applications, you can try this:

System.IO.Directory.GetCurrentDirectory();

Output (on my local machine):

c:\users\xxxxxxx\documents\visual studio 2012\Projects\ImageHandler\GetDir\bin\Debug

Or you can try (there's an additional backslash in the end):

AppDomain.CurrentDomain.BaseDirectory

Output:

c:\users\xxxxxxx\documents\visual studio 2012\Projects\ImageHandler\GetDir\bin\Debug\

I have used this code and get the solution.

AppDomain.CurrentDomain.BaseDirectory

If you are looking for a .NET Core compatible way, use

System.AppContext.BaseDirectory

This was introduced in .NET Framework 4.6 and .NET Core 1.0 (and .NET Standard 1.3). See: AppContext.BaseDirectory Property.

According to this page,

This is the prefered replacement for AppDomain.CurrentDomain.BaseDirectory in .NET Core

I use this if the exe is supposed to be called by double clicking it

var thisPath = System.IO.Directory.GetCurrentDirectory();

• This is not correct because you can get random directories in result. - amuliar

I have used

System.AppDomain.CurrentDomain.BaseDirectory

when I want to find a path relative to an applications folder. This works for both ASP.Net and winform applications. It also does not require any reference to System.Web assemblies.

You can simply add to your project references System.Windows.Forms and then use the System.Windows.Forms.Application.StartupPath as usual .

So, not need for more complicated methods or using the reflection.

• I used that one, and it works well. But one time I used the method having it in my unit test project. And of course, it failed because it was looking for my file in C:\PROGRAM FILES (X86)\MICROSOFT VISUAL STUDIO 14.0\COMMON7\IDE\COMMONEXTENSIONS\MICROSOFT\TESTWINDOW - ainasiart

I mean, why not a p/invoke method?

    using System;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.Text;
    public class AppInfo
    {
            [DllImport("kernel32.dll", CharSet = CharSet.Auto, ExactSpelling = false)]
            private static extern int GetModuleFileName(HandleRef hModule, StringBuilder buffer, int length);
            private static HandleRef NullHandleRef = new HandleRef(null, IntPtr.Zero);
            public static string StartupPath
            {
                get
                {
                    StringBuilder stringBuilder = new StringBuilder(260);
                    GetModuleFileName(NullHandleRef, stringBuilder, stringBuilder.Capacity);
                    return Path.GetDirectoryName(stringBuilder.ToString());
                }
            }
    }

You would use it just like the Application.StartupPath:

    Console.WriteLine("The path to this executable is: " + AppInfo.StartupPath + "\\" + System.Diagnostics.Process.GetCurrentProcess().ProcessName + ".exe");

• Why p/invoke when there is so much .NET for this? - ProfK
• Because why not? - user3596865
• @user3596865 because it requries a hard dependency to Windows and is not compatible with DNX or Mono. And maybe there is a breaking change in future Windows Versions. So again: why we should use pinvoke here? - Ben

Assembly.GetEntryAssembly().Location or Assembly.GetExecutingAssembly().Location

Use in combination with System.IO.Path.GetDirectoryName() to get only the directory.

The paths from GetEntryAssembly() and GetExecutingAssembly() can be different, even though for most cases the directory will be the same.

With GetEntryAssembly() you have to be aware that this can return null if the entry module is unmanaged (ie C++ or VB6 executable). In those cases it is possible to use GetModuleFileName from the Win32 API:

[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern int GetModuleFileName(HandleRef hModule, StringBuilder buffer, int length);

AppDomain.CurrentDomain.BaseDirectory

Will resolve the issue to refer the 3rd party reference files with installation packages.

• This answer has already been suggested 5 years ago, even more than once. - P-L

in VB.net

My.Application.Info.DirectoryPath

works for me (Application Type: Class Library). Not sure about C#... Returns the path w/o Filename as string

None of these methods work in special cases like using a symbolic link to the exe, they will return the location of the link not the actual exe.

So can use QueryFullProcessImageName to get around that:

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;
using System.Diagnostics;

internal static class NativeMethods
{
    [DllImport("kernel32.dll", SetLastError = true)]
    internal static extern bool QueryFullProcessImageName([In]IntPtr hProcess, [In]int dwFlags, [Out]StringBuilder lpExeName, ref int lpdwSize);

    [DllImport("kernel32.dll", SetLastError = true)]
    internal static extern IntPtr OpenProcess(
        UInt32 dwDesiredAccess,
        [MarshalAs(UnmanagedType.Bool)]
        Boolean bInheritHandle,
        Int32 dwProcessId
    );
}

public static class utils
{

    private const UInt32 PROCESS_QUERY_INFORMATION = 0x400;
    private const UInt32 PROCESS_VM_READ = 0x010;

    public static string getfolder()
    {
        Int32 pid = Process.GetCurrentProcess().Id;
        int capacity = 2000;
        StringBuilder sb = new StringBuilder(capacity);
        IntPtr proc;

        if ((proc = NativeMethods.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, pid)) == IntPtr.Zero)
            return "";

        NativeMethods.QueryFullProcessImageName(proc, 0, sb, ref capacity);

        string fullPath = sb.ToString(0, capacity);

        return Path.GetDirectoryName(fullPath) + @"\";
    }
}

Try this simple line of code:

 string exePath = Path.GetDirectoryName( Application.ExecutablePath);

Following line will give you an application path:

var applicationPath = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName)

Above solution is working properly in following situations:

• simple app
• in another domain where Assembly.GetEntryAssembly() would return null
• DLL is loaded from Embedded resources as byte array and loaded to AppDomain as Assembly.Load(byteArrayOfEmbeddedDll)

I didn't see anyone convert the LocalPath provided by .Net Core reflection into a usable System.IO path so here's my version.

public static string GetApplicationRoot()
{
   var exePath = new Uri(System.Reflection.
   Assembly.GetExecutingAssembly().CodeBase).LocalPath;

   return new FileInfo(exePath).DirectoryName;

}

This will return the full "C:\xxx\xxx" formatted path to where your code is.

There are many ways to get executable path, which one we should use it depends on our needs here is a link which discuss different methods.

Different ways to get Application Executable Path

You can use following code, you will get application full path:

 class Program
{
    static void Main(string[] args)
    {
        string AppPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
        WriteLine($"ApplicationPath ---{AppPath}");
        //OutPut// //ApplicationPath---C:\Users\TestUser\source\repos\ThreadStack\ThreadStack\bin\Debug\ThreadStack.exe
        ReadLine();
    }
}  

Here is a reliable solution that works with 32bit and 64bit applications.

Add these references:

using System.Diagnostics;

using System.Management;

Add this method to your project:

public static string GetProcessPath(int processId)
{
    string MethodResult = "";
    try
    {
        string Query = "SELECT ExecutablePath FROM Win32_Process WHERE ProcessId = " + processId;

        using (ManagementObjectSearcher mos = new ManagementObjectSearcher(Query))
        {
            using (ManagementObjectCollection moc = mos.Get())
            {
                string ExecutablePath = (from mo in moc.Cast<ManagementObject>() select mo["ExecutablePath"]).First().ToString();

                MethodResult = ExecutablePath;

            }

        }

    }
    catch //(Exception ex)
    {
        //ex.HandleException();
    }
    return MethodResult;
}

Now use it like so:

int RootProcessId = Process.GetCurrentProcess().Id;

GetProcessPath(RootProcessId);

Notice that if you know the id of the process, then this method will return the corresponding ExecutePath.

Extra, for those interested:

Process.GetProcesses() 

...will give you an array of all the currently running processes, and...

Process.GetCurrentProcess()

...will give you the current process, along with their information e.g. Id, etc. and also limited control e.g. Kill, etc.*

You can create a folder name as Resources within the project using Solution Explorer,then you can paste a file within the Resources.

private void Form1_Load(object sender, EventArgs e) {
    string appName = Environment.CurrentDirectory;
    int l = appName.Length;
    int h = appName.LastIndexOf("bin");
    string ll = appName.Remove(h);                
    string g = ll + "Resources\\sample.txt";
    System.Diagnostics.Process.Start(g);
}

• Using Environment.CurrentDirectory is very wrong, don't use this! this path can change at runtime. Even at startup it is non-deterministic. - usr