c# strip - Come posso ottenere il percorso dell'applicazione in un'applicazione console .NET?




13 Answers

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

Combinalo con System.IO.Path.GetDirectoryName se tutto ciò che vuoi è la directory.

1 Secondo il commento di Mr.Mindor:
System.Reflection.Assembly.GetExecutingAssembly().Location restituisce dove si trova attualmente l'assembly in esecuzione, che può essere o non essere dove si trova l'assembly quando non è in esecuzione. Nel caso degli assembly di copia shadow, si otterrà un percorso in una directory temporanea. System.Reflection.Assembly.GetExecutingAssembly().CodeBase restituirà il percorso 'permanente' dell'assembly.

html agility

Come trovo il percorso dell'applicazione in un'applicazione console?

In Windows Form , posso usare Application.StartupPath per trovare il percorso corrente, ma questo non sembra essere disponibile in un'applicazione console.




Hai due opzioni per trovare la directory dell'applicazione, che hai scelto dipenderà dal tuo scopo.

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



Per chiunque sia interessato alle app web di asp.net. Ecco i miei risultati di 3 diversi metodi

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

risultato

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

l'app è fisicamente in esecuzione da "C: \ inetpub \ SBSPortal_staging", quindi la prima soluzione non è assolutamente appropriata per le app Web.




Potresti voler fare questo:

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



puoi usare questo invece.

System.Environment.CurrentDirectory



Lo uso se si suppone che l'exe venga chiamato facendo doppio clic su di esso

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



È possibile semplicemente aggiungere al progetto riferimenti System.Windows.Forms e quindi utilizzare System.Windows.Forms.Application.StartupPath come al solito.

Quindi, non è necessario disporre di metodi più complicati o utilizzare il riflesso.




Se stai cercando un modo compatibile con .NET Core, usa

System.AppContext.BaseDirectory

Questo è stato introdotto in .NET Framework 4.6 e .NET Core 1.0 (e .NET Standard 1.3). Vedi: Proprietà AppContext.BaseDirectory .

Secondo questa pagina ,

Questa è la sostituzione preferita per AppDomain.CurrentDomain.BaseDirectory in .NET Core




AppDomain.CurrentDomain.BaseDirectory

Risolverà il problema per fare riferimento ai file di riferimento di terze parti con i pacchetti di installazione.




Nessuno di questi metodi funziona in casi particolari come l'utilizzo di un collegamento simbolico con l'exe, essi restituiranno la posizione del collegamento non l'exe effettivo.

Quindi puoi usare QueryFullProcessImageName per QueryFullProcessImageName a questo:

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



La seguente linea ti darà un percorso applicativo:

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

La soluzione di cui sopra funziona correttamente nelle seguenti situazioni:

  • semplice app
  • in un altro dominio dove Assembly.GetEntryAssembly () restituisce null
  • La DLL viene caricata dalle risorse incorporate come array di byte e caricata in AppDomain come Assembly.Load (byteArrayOfEmbeddedDll)






Ecco una soluzione affidabile che funziona con applicazioni a 32 bit e 64 bit .

Aggiungi questi riferimenti:

utilizzando System.Diagnostics;

using System.Management;

Aggiungi questo metodo al tuo progetto:

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

Ora usalo in questo modo:

int RootProcessId = Process.GetCurrentProcess().Id;

GetProcessPath(RootProcessId);

Si noti che se si conosce l'id del processo, questo metodo restituirà l'ExecutePath corrispondente.

Extra, per chi è interessato:

Process.GetProcesses() 

... ti fornirà una serie di tutti i processi attualmente in esecuzione, e ...

Process.GetCurrentProcess()

... ti fornirà il processo corrente, insieme alle loro informazioni, ad es. Id, ecc. e anche controllo limitato, ad esempio Kill, ecc. *




Related