c# - remove - htmlagilitypack




Come posso ottenere il percorso dell'applicazione in un'applicazione console.NET? (18)

È possibile creare un nome di cartella come Risorse all'interno del progetto utilizzando Esplora soluzioni, quindi è possibile incollare un file all'interno delle risorse.

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

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.


È 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.



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. *


Ho usato questo codice e ottenere la soluzione.

AppDomain.CurrentDomain.BaseDirectory

La risposta sopra era il 90% di ciò di cui avevo bisogno, ma per me ha restituito un Uri invece di un percorso regolare.

Come spiegato nel post dei forum MSDN, Come convertire il percorso URI in normale filepath? , Ho usato il seguente:

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

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

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

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

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.


Per le applicazioni console, puoi provare questo:

System.IO.Directory.GetCurrentDirectory();

Uscita (sulla mia macchina locale):

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

Oppure puoi provare (c'è un backslash aggiuntivo alla fine):

AppDomain.CurrentDomain.BaseDirectory

Produzione:

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


Probabilmente un po 'tardi, ma vale la pena menzionarlo:

Environment.GetCommandLineArgs()[0];

O più correttamente per ottenere solo il percorso della directory:

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

Modificare:

Molte persone hanno sottolineato che GetCommandLineArgs non è garantito per restituire il nome del programma. Vedi La prima parola sulla riga di comando è il nome del programma solo per convenzione . L'articolo afferma che "Sebbene pochissimi programmi Windows usino questo strano capriccio (non ne sono a conoscenza nemmeno io)". Quindi è possibile "spoofare" GetCommandLineArgs , ma stiamo parlando di un'applicazione console. Le app della console sono in genere veloci e sporche. Quindi questo si adatta alla mia filosofia KISS.


Prova questa semplice riga di codice:

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

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


Voglio dire, perché non metodo ap / 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());
                }
            }
    }

Lo useresti proprio come Application.StartupPath:

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

in VB.net

My.Application.Info.DirectoryPath

funziona per me (Application Type: Class Library). Non sono sicuro di C # ... Restituisce il percorso w / o Nome file come stringa


puoi usare questo invece.

System.Environment.CurrentDirectory

Assembly.GetEntryAssembly().Location o Assembly.GetExecutingAssembly().Location

Utilizzare in combinazione con System.IO.Path.GetDirectoryName() per ottenere solo la directory.

I percorsi da GetEntryAssembly() e GetExecutingAssembly() possono essere diversi, anche se per la maggior parte dei casi la directory sarà la stessa.

Con GetEntryAssembly() devi essere consapevole che questo può restituire null se il modulo entry non è gestito (es. GetEntryAssembly() C ++ o VB6). In questi casi è possibile utilizzare GetModuleFileName dall'API Win32:

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

AppDomain.CurrentDomain.BaseDirectory

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





console-application