코드가있는 어셈블리의 경로를 어떻게 얻습니까?

코드가있는 어셈블리의 경로를 어떻게 얻습니까?

---

현재 코드가있는 어셈블리의 경로를 가져 오는 방법이 있습니까? 코드를 포함하는 호출 어셈블리의 경로를 원하지 않습니다.

기본적으로 내 단위 테스트는 dll과 관련된 일부 xml 테스트 파일을 읽어야합니다. 테스트 dll이 TestDriven.NET, MbUnit GUI 또는 다른 것에서 실행되는지 여부에 관계없이 경로가 항상 올바르게 해결되기를 원합니다.

편집 : 사람들은 내가 요구하는 것을 오해하는 것 같습니다.

내 테스트 라이브러리는 say에 있습니다.

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

이 경로를 얻고 싶습니다.

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

지금까지 MbUnit Gui에서 실행할 때 세 가지 제안이 실패했습니다.

• Environment.CurrentDirectory제공 \ 프로그램 파일 \ MbUnit에 C :

• System.Reflection.Assembly.GetAssembly(typeof(DaoTests)).Location제공 \ 문서 및 설정 \ 조지 \ 로컬 설정 \ 임시 \ .... \ DaoTests.dll : C

• System.Reflection.Assembly.GetExecutingAssembly().Location 이전과 동일합니다.

---

단위 테스트에서 자주 사용하므로 다음 속성을 정의했습니다.

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

이 Assembly.Location속성은 가끔 NUnit (어셈블리가 임시 폴더에서 실행되는 어셈블리)을 사용할 때 몇 가지 재미있는 결과 CodeBase를 제공 하므로 URI 형식으로 경로를 제공 한 다음 처음에 를 UriBuild.UnescapeDataString제거 하고 일반 Windows 형식으로 변경하는 것을 선호 합니다. .File://GetDirectoryName

---

도움이 되나요?

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

---

다음과 같이 간단합니다.

var dir = AppDomain.CurrentDomain.BaseDirectory;

---

John의 대답과 동일하지만 약간 덜 자세한 확장 방법입니다.

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

이제 다음을 수행 할 수 있습니다.

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

또는 원하는 경우 :

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

---

CodeBase 및 UNC Network 공유를 사용할 때 저에게 효과가 있었던 유일한 솔루션은 다음과 같습니다.

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

일반 URI에서도 작동합니다.

---

어셈블리가 섀도 복사 되지 않는 한 작동합니다 .

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

---

이것에 대해 :

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

---

AppDomain.CurrentDomain.BaseDirectory

MbUnit GUI에서 작동합니다.

---

여기서 진짜 문제는 테스트 러너가 어셈블리를 다른 위치에 복사하고 있다는 것입니다. 런타임에 어셈블리가 어디에서 복사되었는지 알 수있는 방법은 없지만 스위치를 뒤집어 테스트 실행기에 어셈블리를 실행하고 섀도 디렉터리에 복사하지 않도록 지시 할 수 있습니다.

물론 이러한 스위치는 테스트 실행기마다 다를 수 있습니다.

XML 데이터를 테스트 어셈블리 내부에 리소스로 포함하는 것을 고려해 보셨습니까?

---

내가 말할 수있는 한, 대부분의 다른 답변에는 몇 가지 문제가 있습니다.

디스크 기반 (웹 기반이 아닌) 비 GAC 어셈블리 에 대해이 작업을 수행하는 올바른 방법 은 현재 실행중인 어셈블리의 CodeBase속성 을 사용하는 것 입니다.

그러면 URL ( file://) 이 반환 됩니다. 문자열 조작 또는 을 엉망으로 만드는 대신의 속성을 UnescapeDataString활용하여 최소한의 번거 로움으로 변환 할 수 있습니다 .LocalPathUri

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

---

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

---

다음은 John Sibly 코드의 VB.NET 포트입니다. Visual Basic은 대소 문자를 구분하지 않으므로 그의 변수 이름 중 몇 개가 형식 이름과 충돌했습니다.

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

---

이것은 어떤가요 ...

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

그런 다음 필요하지 않은 것을 해킹하십시오.

---

현재 존재하는 디렉토리.

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

빌드와 함께 .xml 파일을 복사하면 찾을 수 있습니다.

또는

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

// The location of the Assembly
assembly.Location;

---

Location 대신 Assembly.CodeBase를 사용하고 있습니다.

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("/", "\\");

It's been working, but I'm no longer sure it is 100% correct. The page at http://blogs.msdn.com/suzcook/archive/2003/06/26/assembly-codebase-vs-assembly-location.aspx says:

"The CodeBase is a URL to the place where the file was found, while the Location is the path where it was actually loaded. For example, if the assembly was downloaded from the internet, its CodeBase may start with "http://", but its Location may start with "C:\". If the file was shadow-copied, the Location would be the path to the copy of the file in the shadow copy dir. It’s also good to know that the CodeBase is not guaranteed to be set for assemblies in the GAC. Location will always be set for assemblies loaded from disk, however."

You may want to use CodeBase instead of Location.

---

In all these years, nobody has actually mentioned this one. A trick I learned from the awesome ApprovalTests project. The trick is that you use the debugging information in the assembly to find the original directory.

This will not work in RELEASE mode, nor with optimizations enabled, nor on a machine different from the one it was compiled on.

But this will get you paths that are relative to the location of the source code file you call it from

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

---

You can get the bin path by AppDomain.CurrentDomain.RelativeSearchPath

---

All of the proposed answers work when the developer can change the code to include the required snippet, but if you wanted to do this without changing any code you could use Process Explorer.

It will list all executing dlls on the system, you may need to determine the process id of your running application, but that is usually not too difficult.

I've written a full description of how do this for a dll inside II - http://nodogmablog.bryanhogan.net/2016/09/locating-and-checking-an-executing-dll-on-a-running-web-server/

---

in a windows form app, you can simply use Application.StartupPath

but for DLLs and console apps the code is much harder to remember...

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

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

---

I believe this would work for any kind of application:

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

---

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

---

You will get incorrect directory if a path contains the '#' symbol. So I use a modification of the John Sibly answer that is combination UriBuilder.Path and 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);
     }
}

---

This is what I came up with. In between web projects, unit tests (nunit and resharper test runner); I found this worked for me.

I have been looking for code to detect what configuration the build is in, Debug/Release/CustomName. Alas, the #if DEBUG. So if someone can improve that!

Feel free to edit and improve.

Getting app folder. Useful for web roots, unittests to get the folder of test files.

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

Getting bin folder: Useful for executing assemblies using reflection. If files are copied there due to build properties.

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

---

This should work:

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

I am using this to deploy DLL file libraries along with some configuration file (this is to use log4net from within the DLL file).

---

I find my solution adequate for the retrieval of the location.

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

---

I got the same behaviour in the NUnit in the past. By default NUnit copies your assembly into the temp directory. You can change this behaviour in the NUnit settings:

Maybe TestDriven.NET and MbUnit GUI have the same settings.

---

I use this to get the path to the Bin Directory:

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

You get this result:

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

---

Web application?

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

참고URL : https://stackoverflow.com/questions/52797/how-do-i-get-the-path-of-the-assembly-the-code-is-in