How to use relative paths in a Windows Service

By default, when a Windows Service is running, its working directory is often set to system folders like C:\Windows\System32 or C:\Windows\SysWOW64. This can lead to issues, as relative paths will be resolved based on these directories, causing problems with file reading/writing operations.

Common Problems

File or Directory Not Found: You might get an error like this if the relative path resolves incorrectly:

System.IO.DirectoryNotFoundException: Could not find a part of the path 'C:\Windows\system32\Documents\MyFile.txt'.

Access Denied Errors: If your service tries to access a restricted system folder, you may encounter an error like:

System.UnauthorizedAccessException: Access to the path 'C:\Windows\system32\MyApp.log' is denied.

Unexpected File Location: When writing a file, it may appear in a system folder instead of your expected directory:

C:\Windows\System32\MyApp.log

These issues are not exclusive to Windows Services they occur any time relative paths are used while the application is running in a different working directory than expected.

How to Handle Relative Paths in a Windows Service

Change the Current Working Directory

Before performing any file operations, change the current working directory to where your executable is located.

System.IO.Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);

Resolve Paths Based on the Executable's Location

If changing the working directory is not an option, you can manually resolve the paths based on the location of the executable.

private string ResolvePath(string filePath)
{
    if (Path.IsPathRooted(filePath)) 
    {
        return filePath; // Already an absolute path.
    }
    else
    {
        return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filePath); // Resolve to executable's directory.
    }
}

For example, Use this method when reading or writing files:

private string ReadFile(string filePath)
{
    return File.ReadAllText(ResolvePath(filePath));
}

private void WriteFile(string filePath, string content)
{
    File.WriteAllText(ResolvePath(filePath), content);
}

For example, how you can implement the solution in your Windows Service.

protected override void OnStart(string[] args)
{
    // This option can be used if changing the working directory is feasible.
    // System.IO.Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);

    EventLog.WriteEntry($"Current working directory: {System.IO.Directory.GetCurrentDirectory()}");

    string configFilePath = @".\Configs\MyConfig.xml"; // Relative path for configuration file
    string logFilePath = "MyApp.log"; // Relative path for log file

    string fileContents = "";

    try
    {
        fileContents = ReadFile(configFilePath); // Reading the config file
    }
    catch (Exception ex)
    {
        fileContents = $"Exception while trying to read the file. {ex}";
    }

    WriteFile(logFilePath, fileContents); // Writing the content to the log file
}

private string ResolvePath(string filePath)
{
    if (Path.IsPathRooted(filePath)) 
    {
        return filePath; // If it's an absolute path, return it directly.
    }
    else
    {
        return Path.Combine(AppDomain.CurrentDomain.BaseDirectory, filePath); // Resolve to the executable’s directory.
    }
}

private string ReadFile(string filePath)
{
    return File.ReadAllText(ResolvePath(filePath)); // Use resolved path to read the file
}

private void WriteFile(string filePath, string content)
{
    File.WriteAllText(ResolvePath(filePath), content); // Use resolved path to write the file
}

Using relative paths in a Windows Service can cause issues when the service runs with an unexpected working directory. To handle this, you can either change the working directory to the executable’s location or resolve relative paths manually using the executable's base directory.