So... I used to think that when you accessed a file but specified the name without a path (CAISLog.csv in my case) that .NET would expect the file to reside at the same path as the running .exe.
This works when I'm stepping through a solution (C# .NET2.* VS2K5) but when I run the app in normal mode (Started by a Websphere MQ Trigger monitor & running in the background as a network service) instead of accessing the file at the path where the .exe is it's being looked for at C:\WINDOWS\system32. If it matters The parent task's .exe is in almost the same folder structure/path as my app
I get a matching error: "System.UnauthorizedAccessException: Access to the path 'C:\WINDOWS\system32\CAISLog.csv' is denied."
My workaround is to just fully qualify the location of my file. What I want to understand, however is "What is the .NET rule that governs how a path is resolved when only the file name is specified during IO?" I feel I'm missing some basic concept and it's bugging me bad.
edit - I'm not sure it's a.NET rule per se but Schmuli seems to be explaining the concept a little clearer. I will definitely try Rob Prouse's suggestions in the future so +1 on that too.
If anyone has some re-wording suggestions that emphasize I don't really care about finding the path to my .exe - rather just didn't understand what was going on with relative path resolution (and I may still have my terminlogy screwed up)...
When an application (WinForms) starts up, the Environment.CurrentDirectory contains the path to the application folder (i.e. the folder that contains the .exe assembly). Using any of the File Dialogs, ex. OpenFileDialog, SaveFileDialog, etc. will cause the current directory to change (if a different folder was selected).
When running a Windows Service, its containing folder is C:\Windows\System32, as that is the System folder and it is the System (i.e. the Operation System) that is actually running your Windows Service.
Note that specifying a relative path in most of the System.IO objects, will fall back to using the Environment.CurrentDirectory property.
As mentioned, there are several ways to obtain the path of the service executable, using Assembly.GetEntryAssembly() or Assembly.GetExecutingAssembly() and then using either the Location property or the CodeBase property (be aware that this is the file path, not directory, of the executable).
Another option is to use:
`System.IO.Directory.SetCurrentDirectory( System.AppDomain.CurrentDomain.BaseDirectory );`
Make the call in the Service's OnStart method, applying it to the whole application.
It is based on the current working directory which may or may not be the same as where your application resides, especially if started from a different program or a shortcut with a different working directory.
Rather than hard code the path, get the path to your program and use it. You can do this with something like this
Assembly ass = Assembly.GetEntryAssembly();
string dir = Path.GetDirectoryName(ass.Location);
string filename = Path.Combine( dir, "CAISLog.csv" );
This assumes that the entry assembly is where your file is. If not, you can change up getting the assembly for something like;
Assembly ass = Assembly.GetAssembly( typeof( AClassInYourAssembly ) );
Relative Path resolution never works against the path of the launching executable. It always works against the process' Current Directory, and you can't really expect that to always be set to the directory the .exe lives in.
If you need that behavior, then take care to find out the right path on your own and provide a fully qualified path to the file operations.
You can use this to specify a path that resides at the same path of your exe #"..\CAISLog.csv". Please note that the double dots refer to the parent directory of where ever your .exe lies.
RWendi
Related
I am loading this file which is located in a folder i created, the same folder is also rendered in the bin/debug folder, but i need to locate the file in the folder i created, the thing is the method which should find the path of the file by its name gives me the path of the debug folder instead of the on i created.
I have harcoded the path to show you the real location.
var path2 = System.IO.Path.Combine(Environment.CurrentDirectory, "xulrunner");
var hardcodedPath= "C:\\Users\\Alan\\Desktop\\TabControl\\TabControl\\TabControl\\TabControl\\xulrunner";
This is the result of path2 variable:
C:\\Users\\Alan\\Desktop\\TabControl\\TabControl\\TabControl\\TabControl\\bin\\Debug\\xulrunner"
As you can see its pointing to different folder as hardcoded path.
When running from Visual Studio, the working directory is different from your project location, usually it is two folders up (from bin\Debug\). In your distributed application, the working directory might be the same as that of other files you want to access since you copy some other files to the working directory.
I would recommend to keep your code the same, and copy the files you require from your project to the output directory. You can do that by simply setting the Copy to Output Directory setting to Copy always or Copy if newer.
Changing the path to go two folders up is a bad idea, since this won't be true in production scenarios, and will thus break your code.
To get exactly what you are looking for, you could do the following:
var path2 = System.IO.Path.GetFullPath(System.IO.Path.Combine(Environment.CurrentDirectory, "..\\..\\xulrunner"));
However, please be aware that Environment.CurrentDirectory can change as your program runs. I have found that using the %PROGRAMDATA% environment variable works well for creating a location where you save data. It allows for a more consistent solution for using paths.
Additionally, the code snippet provided will only really be useful when you are running through the IDE's debugger. When you deploy, it will likely not give you what you are expecting.
It would help to know what is the overall functional result you are hoping for.
How can we get a file in another folder of a console application?
I have an image file in a folder relative to the.cs file which is trying to access it.
For now I am using the exact path to the file, but when I ship this application to the client, it may not work as the path would not be valid on the client's machine.
Here's the code I am using right now:
workSheetIntroduction.Pictures.Add(5,1, #"C:\Users\Charu\Documents\Visual Studio 2013\Projects\AsmEpmReports\EmpReports.DomainLayer\Resources\Images\EpmLogo.png");
The Microsoft ideal is to install the application and then use the user path.
The files are then saved to the user's tree. If you cannot do an install, you can check if the directory exists before saving and then create it. You can also have the application ask for the directory and then create it where the user desires it. Or set it up as a configuration variable.
Lots of options. I would choose the first, if possible, as that is the preferred Microsoft method.
As Gregory said, relative paths would be the ideal, but you could ensure that the file is in the relative path by performing a FILE.Exists(<path>) where <path> is the relative path of the file to be used.
See Naming Files, Paths, and Namespaces for more information on relative vs. absolute paths.
i have a bizzare issue with a program ive written where the command File.Exists() doesnt allways detect the same file in the same directory as the executable.
i have somthing like:
if (File.Exists("TextFile1.txt"))
{
//do some stuff
}
but the odd thing is if i run this executable in the cmd prompt it doesnt detect the file. BUT if i start this executable via another process it will detect the File Fine.
Any ideas on this bizzare issue?
Thanks.
This is a relative file path to the working directory of the executable. When you run the application from the command prompt the working directory is set to the directory where the executable is located. When you run this executable via another process (Process.Start), the working directory is the working directory of the host process. You can either modify the working directory before running the process or work with absolute file paths.
Another thing to bear in mind is that the File.Exists might return false if the account you are running your code under doesn't have sufficient permissions to the folder.
true if the caller has the required permissions and path contains the
name of an existing file; otherwise, false. This method also returns
false if path is null, an invalid path, or a zero-length string. If
the caller does not have sufficient permissions to read the specified
file, no exception is thrown and the method returns false regardless
of the existence of path.
The file path is relative to the CurrentDirectory not where the executable is located. You should fully qualify the file path, or get the location of the executable.
Since you're using a relative path I have a hunch that the location of the executing assembly is not what you think it is.
In your code try checking where the exe was launched from with:
System.IO.Path.GetDirectoryName(
System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase );
(from http://msdn.microsoft.com/en-us/library/aa457089.aspx)
From MSDN:
The path parameter is permitted to specify relative or absolute path
information. Relative path information is interpreted as relative to
the current working directory. To obtain the current working
directory, see GetCurrentDirectory.
And when you look at GetCurrentDirectory:
The current directory is distinct from the original directory, which
is the one from which the process was started.
The issue is most likely that the CurrentDirectory varies between processes.
However, an alternative issue could be that each process runs as a different user/permissions and the command prompt doesn't have access to the folder in which the file resides.
I am creating a c# class (Class.cs) that needs to look for a file(FileINeedToFind.cs) by name from a local directory. The directory is in a different directory from the class file.
folder structure:
Root
-> ClassFolder
--> Class.cs
-> FileFolder
--> FileINeedToFind.cs
When I run a test for the class, it always comes back with the test results path.
How can I get the class to get its own local path, and not that of the test results assembly?
When a program runs, you should assume that an object has no awareness of the source code that generated it. The code is compiled into an assembly, and that assembly is loaded when you run the program, so the "current" directory by default is the location of the executing assembly.
In short, this is not something you can cleanly do. It's best if your code does not rely on the concept of source-relative directories. It may help you to achieve your goals if you change the build action for the file you're looking for so it's copied to the output directory. Then that file's relative path at runtime should mirror the relative path within your project folder.
To get the path to the executing assembly (the "current" path may be changed by any other executing code, so it's best to not rely on that), use this code:
System.IO.Path.GetDirectoryName(
System.Reflection.Assembly.GetExecutingAssembly().CodeBase);
In MSTest, tests are (by default) executed in a different folder than the folder which contains your code, via test deployment. You can configure what gets deployed, but I tend to agree with #Jacob that this isn't something you typically want to do.
However, I differ with #Jacob about how to get the current directory in a test. In MSTest, the right way to do this is with TestContext.DeploymentDirectory.
I am developing an application in C#. I have a folder called myfolder it contains a file called mypoints.bmp. The folder myfolder is in my project folder it is in D drive. The path is D:\Myproject\myfolder\mypoints.bmp.
Now, in my program, whereever I need mypoints.bmp I have hardcoded the whole path. When my project is copied in to a different system under C drive, I am not able to run my project because of the hardcoded path. How can I give the path so that there will not be any problem even if it is loaded in to a different system under a different drive.
The best would be to store the path in a configuration file.
Add -> New Item -> Application Configuration File
Then you can use the following class to pull the value you're looking for:
System.Configuration.ConfigurationManager
Have a look here on the usage.
If the images you are referring to are non-changing and are simply acting as a resource for your application then you could consider embedding them in resource files which are compiled as part of your assembly. That way you need never worry about paths or copying them.
If the BMP file is used in the code and is accessed in runtime, there is no point in keeping it just in the project directory. it should be also present in the outputdirectory.
i.e you could write a post-build command to copy your folder to the output directory.
like copy "$(ProjectDir)\MyFolder\*.*" "$(OutDir)"
then in the code you could just write the relative path i.e "MyFolder\MyPoints.bmp"
But please remember one thing. If this BMP file is not going to change through out your program execution, it is better that you put it as a resource.
You can use something like GetCurrentPath(), which will return your .exe file path, then add to this path your \myfolder\mypoints.bmp. This will not be depend on C or D or ... drive and folder
There is one path that you can always reliably find, no matter how your program got deployed to the target machine: the directory in which your .exe is stored.
Take advantage of this, put the .bmp file in the same directory. Or a subdirectory of the install directory. You didn't say what kind of program you wrote, it is easy with Application.ExecutablePath in Windows Forms. But the generic solution that works everywhere:
public static string GetImagePath(string filename) {
string exeFile = System.Reflection.Assembly.GetEntryAssembly().Location;
string exePath = System.IO.Path.GetDirectoryName(exeFile);
string imgPath = System.IO.Path.Combine(exePath, #"images");
string imgFile = System.IO.Path.Combine(imgPath, filename);
return imgFile;
}
Which assumes the images are stored in a subdirectory named "images". Tweak as necessary.
Last but not least: don't forget that you can add images to your program's resources so it is baked in the .exe file. Project + Properties, Resources tab. Highly recommended.
You can also use predefined or existed system variable. Anyway you must decide when the user (or you) have to define that path (in config file or wherever) - during instalaltion, first run, before first run or in any time when app is running.
Personally I would use the Environment class in C#. Then I will locate the local app settings folder using the Environment.SpecialFolder enum.
I will then store all my applications specific files inside a folder in the local app settings folder.
This way you are also UAC safe, since UAC will complain if you want to store files in Program Files if you are not Administrator.