Comment obtenir le chemin de l'assembly dans lequel se trouve le code?

Existe-t-il un moyen d'obtenir le chemin de l'assembly dans lequel réside le code actuel? Je ne veux pas le chemin de l'assembly appelant, juste celui contenant le code.

Fondamentalement, mon test unitaire doit lire certains fichiers de test XML qui se trouvent par rapport à la DLL. Je veux que le chemin soit toujours résolu correctement, que la DLL de test soit exécutée à partir de TestDriven.NET, de l'interface graphique MbUnit ou d'autre chose.

Edit : Les gens semblent mal comprendre ce que je demande.

Ma bibliothèque de tests est située à Say

C: \ projects \ myapplication \ daotests \ bin \ Debug \ daotests.dll

et je voudrais obtenir ce chemin:

C: \ projects \ myapplication \ daotests \ bin \ Debug \

Jusqu'à présent, les trois suggestions me manquent lorsque je cours depuis le MbUnit Gui:

• Environment.CurrentDirectory donne c: \ Program Files \ MbUnit

• System.Reflection.Assembly.GetAssembly(typeof(DaoTests)).Location donne C: \ Documents and Settings \ george \ Local Settings \ Temp \ .... \ DaoTests.dll

• System.Reflection.Assembly.GetExecutingAssembly().Location donne la même chose que la précédente.

J'ai défini la propriété suivante car nous l'utilisons souvent dans les tests unitaires.

public static string AssemblyDirectory
{
    get
    {
        string codeBase = Assembly.GetExecutingAssembly().CodeBase;
        UriBuilder uri = new UriBuilder(codeBase);
        string path = Uri.UnescapeDataString(uri.Path);
        return Path.GetDirectoryName(path);
    }
}

La Assembly.Locationpropriété vous donne parfois des résultats amusants lorsque vous utilisez NUnit (où les assemblys s'exécutent à partir d'un dossier temporaire), donc je préfère utiliser CodeBasece qui vous donne le chemin au format URI, puis UriBuild.UnescapeDataStringsupprime le File://au début et le GetDirectoryNamechange au format Windows normal .

est-ce que cela aide?

//get the full location of the assembly with DaoTests in it
string fullPath = System.Reflection.Assembly.GetAssembly(typeof(DaoTests)).Location;

//get the folder that's in
string theDirectory = Path.GetDirectoryName( fullPath );

C'est aussi simple que ça:

var dir = AppDomain.CurrentDomain.BaseDirectory;

Identique à la réponse de John, mais une méthode d'extension légèrement moins détaillée.

public static string GetDirectoryPath(this Assembly assembly)
{
    string filePath = new Uri(assembly.CodeBase).LocalPath;
    return Path.GetDirectoryName(filePath);            
}

Vous pouvez maintenant:

var localDir = Assembly.GetExecutingAssembly().GetDirectoryPath();

ou si vous préférez:

var localDir = typeof(DaoTests).Assembly.GetDirectoryPath();

La seule solution qui a fonctionné pour moi lors de l'utilisation des partages CodeBase et UNC Network était:

System.IO.Path.GetDirectoryName(new System.Uri(System.Reflection.Assembly.GetExecutingAssembly().CodeBase).LocalPath);

Il fonctionne également avec les URI normaux.

Cela devrait fonctionner, sauf si l'assembly est copié en double :

string path = System.Reflection.Assembly.GetExecutingAssembly().Location

Et ça:

System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);

Je soupçonne que le vrai problème ici est que votre exécuteur de test copie votre assemblage vers un emplacement différent. Il n'y a aucun moyen au moment de l'exécution de dire d'où l'assembly a été copié, mais vous pouvez probablement actionner un commutateur pour dire au testeur d'exécuter l'assembly à partir de son emplacement et de ne pas le copier dans un répertoire caché.

Un tel commutateur est susceptible d'être différent pour chaque testeur, bien sûr.

Avez-vous envisagé d'intégrer vos données XML en tant que ressources dans votre assembly de test?

AppDomain.CurrentDomain.BaseDirectory

fonctionne avec MbUnit GUI.

Je crois que cela fonctionnerait pour tout type d'application:

AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory

Pour autant que je sache, la plupart des autres réponses ont quelques problèmes.

La façon correcte de le faire pour un assembly basé sur disque (par opposition à basé sur le Web), non GACed est d'utiliser la CodeBasepropriété de l'assembly en cours d'exécution .

Cela renvoie une URL ( file://). Au lieu de jouer avec la manipulation de chaînes ou UnescapeDataString, cela peut être converti avec un minimum d'agitation en tirant parti de la LocalPathpropriété de Uri.

var codeBaseUrl = Assembly.GetExecutingAssembly().CodeBase;
var filePathToCodeBase = new Uri(codeBaseUrl).LocalPath;
var directoryPath = Path.GetDirectoryName(filePathToCodeBase);

Que dis-tu de ça ...

string ThisdllDirectory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);

Ensuite, piratez simplement ce dont vous n'avez pas besoin

var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var assemblyPath = assembly.GetFiles()[0].Name;
var assemblyDir = System.IO.Path.GetDirectoryName(assemblyPath);

Voici un port VB.NET du code de John Sibly. Visual Basic n'est pas sensible à la casse, donc quelques-uns de ses noms de variables entraient en collision avec des noms de type.

Public Shared ReadOnly Property AssemblyDirectory() As String
    Get
        Dim codeBase As String = Assembly.GetExecutingAssembly().CodeBase
        Dim uriBuilder As New UriBuilder(codeBase)
        Dim assemblyPath As String = Uri.UnescapeDataString(uriBuilder.Path)
        Return Path.GetDirectoryName(assemblyPath)
    End Get
End Property

Pendant toutes ces années, personne n'a vraiment mentionné celui-ci. Une astuce que j'ai apprise du génial projet ApprovalTests . L'astuce consiste à utiliser les informations de débogage dans l'assembly pour rechercher le répertoire d'origine.

Cela ne fonctionnera pas en mode RELEASE, ni avec les optimisations activées, ni sur une machine différente de celle sur laquelle elle a été compilée.

Mais cela vous donnera des chemins relatifs à l'emplacement du fichier de code source à partir duquel vous l'appelez

public static class PathUtilities
{
    public static string GetAdjacentFile(string relativePath)
    {
        return GetDirectoryForCaller(1) + relativePath;
    }
    public static string GetDirectoryForCaller()
    {
        return GetDirectoryForCaller(1);
    }


    public static string GetDirectoryForCaller(int callerStackDepth)
    {
        var stackFrame = new StackTrace(true).GetFrame(callerStackDepth + 1);
        return GetDirectoryForStackFrame(stackFrame);
    }

    public static string GetDirectoryForStackFrame(StackFrame stackFrame)
    {
        return new FileInfo(stackFrame.GetFileName()).Directory.FullName + Path.DirectorySeparatorChar;
    }
}

Le répertoire courant où vous existez.

Environment.CurrentDirectory;  // This is the current directory of your application

Si vous copiez le fichier .xml avec build, vous devriez le trouver.

ou

System.Reflection.Assembly assembly = System.Reflection.Assembly.GetAssembly(typeof(SomeObject));

// The location of the Assembly
assembly.Location;

J'ai utilisé Assembly.CodeBase au lieu de Location:

Assembly a;
a = Assembly.GetAssembly(typeof(DaoTests));
string s = a.CodeBase.ToUpper(); // file:///c:/path/name.dll
Assert.AreEqual(true, s.StartsWith("FILE://"), "CodeBase is " + s);
s = s.Substring(7, s.LastIndexOf('/') - 7); // 7 = "file://"
while (s.StartsWith("/")) {
    s = s.Substring(1, s.Length - 1);
}
s = s.Replace("/", "\\");

Cela fonctionne, mais je ne suis plus sûr qu'il soit correct à 100%. La page à http://blogs.msdn.com/suzcook/archive/2003/06/26/assembly-codebase-vs-assembly-location.aspx dit:

"Le CodeBase est une URL vers l'endroit où le fichier a été trouvé, tandis que l'emplacement est le chemin où il a été réellement chargé. Par exemple, si l'assembly a été téléchargé à partir d'Internet, son CodeBase peut commencer par" http: // " , mais son emplacement peut commencer par "C: \". Si le fichier a été copié en double, l'emplacement sera le chemin d'accès à la copie du fichier dans le répertoire de cliché instantané. Il est également bon de savoir que le CodeBase n'est pas garanti à définir pour les assemblys dans le GAC. Cependant, l'emplacement sera toujours défini pour les assemblys chargés à partir du disque. "

Vous pouvez utiliser CodeBase au lieu de Location.

Vous pouvez obtenir le chemin du bac par AppDomain.CurrentDomain.RelativeSearchPath

Toutes les réponses proposées fonctionnent lorsque le développeur peut modifier le code pour inclure l'extrait de code requis, mais si vous souhaitez le faire sans modifier le code, vous pouvez utiliser Process Explorer.

Il répertorie toutes les DLL en cours d'exécution sur le système, vous devrez peut-être déterminer l'ID de processus de votre application en cours d'exécution, mais ce n'est généralement pas trop difficile.

J'ai écrit une description complète de la façon de procéder pour une DLL à l'intérieur de II - http://nodogmablog.bryanhogan.net/2016/09/locating-and-checking-an-executing-dll-on-a-running-web -serveur/

dans une application de formulaire Windows, vous pouvez simplement utiliser Application.StartupPath

mais pour les DLL et les applications console, le code est beaucoup plus difficile à retenir ...

string slash = Path.DirectorySeparatorChar.ToString();
string root = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);

root += slash;
string settingsIni = root + "settings.ini"

string path = Path.GetDirectoryName(typeof(DaoTests).Module.FullyQualifiedName);

Vous obtiendrez un répertoire incorrect si un chemin contient le symbole «#». J'utilise donc une modification de la réponse de John Sibly qui est la combinaison UriBuilder.Path et UriBuilder.Fragment:

public static string AssemblyDirectory
{
    get
    {
        string codeBase = Assembly.GetExecutingAssembly().CodeBase;
        UriBuilder uri = new UriBuilder(codeBase);
        //modification of the John Sibly answer    
        string path = Uri.UnescapeDataString(uri.Path.Replace("/", "\\") + 
          uri.Fragment.Replace("/", "\\"));
        return Path.GetDirectoryName(path);
     }
}

C'est ce que j'ai trouvé. Entre les projets Web, tests unitaires (exécuteur de test de nunit et resharper) ; J'ai trouvé que cela fonctionnait pour moi.

Je cherchais code pour détecter quelle configuration la construction est, Debug/Release/CustomName. Hélas, le #if DEBUG. Donc, si quelqu'un peut améliorer cela !

N'hésitez pas à modifier et à améliorer.

Obtention du dossier d'application . Utile pour les racines web, unittests pour obtenir le dossier des fichiers de test.

public static string AppPath
{
    get
    {
        DirectoryInfo appPath = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);

        while (appPath.FullName.Contains(@"\bin\", StringComparison.CurrentCultureIgnoreCase)
                || appPath.FullName.EndsWith(@"\bin", StringComparison.CurrentCultureIgnoreCase))
        {
            appPath = appPath.Parent;
        }
        return appPath.FullName;
    }
}

Obtenir le dossier bin : utile pour exécuter des assemblys à l'aide de la réflexion. Si des fichiers y sont copiés en raison de propriétés de construction.

public static string BinPath
{
    get
    {
        string binPath = AppDomain.CurrentDomain.BaseDirectory;

        if (!binPath.Contains(@"\bin\", StringComparison.CurrentCultureIgnoreCase)
            && !binPath.EndsWith(@"\bin", StringComparison.CurrentCultureIgnoreCase))
        {
            binPath = Path.Combine(binPath, "bin");
            //-- Please improve this if there is a better way
            //-- Also note that apps like webapps do not have a debug or release folder. So we would just return bin.
#if DEBUG
            if (Directory.Exists(Path.Combine(binPath, "Debug"))) 
                        binPath = Path.Combine(binPath, "Debug");
#else
            if (Directory.Exists(Path.Combine(binPath, "Release"))) 
                        binPath = Path.Combine(binPath, "Release");
#endif
        }
            return binPath;
    }
}

Cela devrait fonctionner:

ExeConfigurationFileMap fileMap = new ExeConfigurationFileMap();
Assembly asm = Assembly.GetCallingAssembly();
String path = Path.GetDirectoryName(new Uri(asm.EscapedCodeBase).LocalPath);

string strLog4NetConfigPath = System.IO.Path.Combine(path, "log4net.config");

J'utilise ceci pour déployer des bibliothèques de fichiers DLL avec un fichier de configuration (c'est pour utiliser log4net à partir du fichier DLL).

Je trouve ma solution adéquate pour la récupération de l'emplacement.

var executingAssembly = new FileInfo((Assembly.GetExecutingAssembly().Location)).Directory.FullName;

J'ai eu le même comportement NUnitdans le passé. Par défaut, NUnitcopie votre assembly dans le répertoire temporaire. Vous pouvez modifier ce comportement dans les NUnitparamètres:

Peut TestDriven.NET- être que l' MbUnitinterface graphique a les mêmes paramètres.

J'utilise ceci pour obtenir le chemin vers le répertoire Bin:

var i = Environment.CurrentDirectory.LastIndexOf(@"\");
var path = Environment.CurrentDirectory.Substring(0,i); 

Vous obtenez ce résultat:

"c: \ users \ ricooley \ documents \ visual studio 2010 \ Projects \ Windows_Test_Project \ Windows_Test_Project \ bin"

Application Web?

Server.MapPath("~/MyDir/MyFile.ext")