Jak mogę pobrać ścieżkę aplikacji a.NET aplikacja konsolowa?

Możesz użyć poniższego kodu, aby uzyskać bieżący katalog aplikacji.

AppDomain.CurrentDomain.BaseDirectory

Masz dwie opcje znalezienia katalogu aplikacji, który wybierzesz będzie zależał od Twojego celu.

// 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);

Pewnie trochę za późno, ale warto o tym wspomnieć:

Environment.GetCommandLineArgs()[0];

Lub bardziej poprawnie, aby uzyskać tylko ścieżkę katalogu:

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

Edit:

Sporo osób zauważyło, że GetCommandLineArgs nie ma gwarancji powrotu nazwy programu. Zobacz pierwszym słowem w wierszu poleceń jest nazwa programu tylko według konwencji . Artykuł stwierdza, że " chociaż wyjątkowo niewiele programów Windows używa tego dziwactwa (sam nie jestem tego świadomy)". Tak więc możliwe jest 'spoof' GetCommandLineArgs, ale mówimy o aplikacji konsolowej. Aplikacje konsolowe są zwykle szybkie i brudne. Więc to pasuje do mojej filozofii pocałunku.

Dla wszystkich zainteresowanych asp.net aplikacje internetowe. Oto moje wyniki 3 różnych metod

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);
}

Wynik

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

Aplikacja działa fizycznie z "C:\inetpub\SBSPortal_staging", więc pierwsze rozwiązanie zdecydowanie nie jest odpowiednie dla aplikacji internetowych.

Powyższa odpowiedź stanowiła 90% tego, czego potrzebowałem, ale zwróciła mi Uri zamiast zwykłej ścieżki.

Jak wyjaśniono w poście na forum MSDN, Jak przekonwertować ścieżkę URI na normalną ścieżkę pliku?, użyłem następującego:

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

Możesz chcieć to zrobić:

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

Jeśli szukasz sposobu zgodnego z. NET Core, użyj

System.AppContext.BaseDirectory

Według tej strony ,

Jest to preferowany zamiennik dla AppDomain.CurrentDomain.BaseDirectory w. Net Core

Możesz użyć tego.

System.Environment.CurrentDirectory

Dla aplikacji konsolowych, możesz spróbować tego:

System.IO.Directory.GetCurrentDirectory();

Wyjście (na mojej lokalnej maszynie):

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

Lub możesz spróbować (na końcu jest dodatkowy ukośnik wsteczny):

AppDomain.CurrentDomain.BaseDirectory

Wyjście:

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

Użyłem tego kodu i uzyskałem rozwiązanie.

AppDomain.CurrentDomain.BaseDirectory

Następujący wiersz wyświetli ścieżkę aplikacji:

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

Powyższe rozwiązanie działa poprawnie w następujących sytuacjach:

• prosta aplikacja
• w innej domenie, gdzie montaż.GetEntryAssembly () zwróci null
• DLL jest ładowany z osadzonych zasobów jako tablica bajtów i ładowany do AppDomain jako Assembly.Load (byteArrayOfEmbeddedDll)
• z wiązkami Mono mkbundle (Inne metody nie działają)

Możesz po prostu dodać do swojego projektu referencje System.Windows.Forms, a następnie użyć System.Windows.Forms.Application.StartupPath Jak zwykle .

Więc, nie potrzeba bardziej skomplikowanych metod lub korzystania z odbicia.

Używam tego, jeśli exe ma być wywołane przez podwójne kliknięcie

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

Użyłem

System.AppDomain.CurrentDomain.BaseDirectory

Gdy chcę znaleźć ścieżkę względem folderu aplikacji. Działa to zarówno dla ASP.Net i aplikacji winform. Nie wymaga również odniesienia do systemu.Web assemblies.

Dlaczego nie metoda P / invoke?

    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());
                }
            }
    }

Użyłbyś go tak, jak aplikacja.StartupPath:

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

Assembly.GetEntryAssembly().Location lub Assembly.GetExecutingAssembly().Location

Użyj w połączeniu z System.IO.Path.GetDirectoryName(), aby uzyskać tylko katalog.

Ścieżki z GetEntryAssembly() i GetExecutingAssembly() mogą być różne, chociaż w większości przypadków katalog będzie taki sam.

Z GetEntryAssembly() musisz być świadomy, że może to zwrócić {[7] } jeśli moduł wejściowy jest niezarządzany(np. C++ lub VB6). W takich przypadkach możliwe jest użycie GetModuleFileName z API Win32:

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

W VB.net

My.Application.Info.DirectoryPath

Działa dla mnie (Typ aplikacji: Biblioteka klas). Nie jestem pewien co do C#... Zwraca ścieżkę bez nazwy pliku jako ciąg znaków

AppDomain.CurrentDomain.BaseDirectory

Rozwiąże problem z odesłaniem plików referencyjnych innych firm za pomocą pakietów instalacyjnych.

Spróbuj tego prostego wiersza kodu:

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

Nie widziałem, żeby ktoś przekonwertował ścieżkę lokalną dostarczoną przez. Net Core reflection na użyteczną System.IO / align = "left" /

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

   return new FileInfo(exePath).DirectoryName;
       
}

Zwróci pełną C:\\xxx\\xxx sformatowaną ścieżkę do miejsca, w którym znajduje się Twój kod.

Żadna z tych metod nie działa w szczególnych przypadkach, takich jak użycie dowiązania symbolicznego do exe, zwrócą lokalizację dowiązania, a nie rzeczywisty exe.

Więc można użyć QueryFullProcessImageName aby obejść to:

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) + @"\";
    }
}

Innym rozwiązaniem jest użycie ścieżek względnych wskazujących na bieżącą ścieżkę:

Path.GetFullPath(".")

Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName) Jest jedynym, który pracował dla mnie w każdym przypadku próbowałem.

Oto niezawodne rozwiązanie, które współpracuje z aplikacjami 32bit i 64bit.

Dodaj te referencje:

Korzystanie Z Systemu.Diagnostyka;

Korzystanie Z Systemu.Zarządzanie;

Dodaj tę metodę do swojego projektu:

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;
}

Teraz używaj go tak:

int RootProcessId = Process.GetCurrentProcess().Id;

GetProcessPath(RootProcessId);

Zauważ, że jeśli znasz id procesu, wtedy ta metoda zwróci odpowiednią ścieżkę ExecutePath.

Extra, dla zainteresowanych:

Process.GetProcesses() 

...da masz tablicę wszystkich aktualnie uruchomionych procesów, oraz...

Process.GetCurrentProcess()

...poda ci bieżący proces, wraz z ich informacjami np. Id, itp. a także ograniczoną kontrolę np. Kill, itp.*

Istnieje wiele sposobów na uzyskanie ścieżki wykonywalnej, która z nich powinna być użyta zależy od naszych potrzeb oto link, który omawia różne metody.

Różne sposoby uzyskania ścieżki wykonywalnej aplikacji

Możesz utworzyć nazwę folderu jako zasoby w projekcie za pomocą Eksploratora rozwiązań,a następnie wkleić plik w zasoby.

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);
}