Class FileService

Defines a service for file system operations.

Inheritance
object
ServiceFactoryEx<FileService, object, object, object, object, object, object, object, object, object>
ServiceFactoryEx<FileService>
FileService
Implements
Inherited Members
Namespace: Coree.NETStandard.Services.FileManagement
Assembly: Coree.NETStandard.dll
Syntax
public class FileService : ServiceFactoryEx<FileService>, IDisposable, IFileService
Remarks
// Configuring a self-contained ServiceStack setup using Host builder's CreateDefaultBuilder method.
FileService fileServiceService = FileService.CreateServiceFactory();

// Instantiating the FileService class directly
FileService fileService = new FileService();

// Implementing FileService in a Dependency Injection (DI) scenario
var builder = Host.CreateDefaultBuilder();
builder.ConfigureServices((context, services) =>
{
    services.AddSingleton>IFileService, FileService<();
});

Constructors

| Edit this page View Source

FileService(ILogger<FileService>?)

Initializes a new instance of the FileService class.

Declaration
public FileService(ILogger<FileService>? logger = null)
Parameters
Type Name Description
ILogger<FileService> logger

Optional logger instance for logging purposes.
Remarks

The logger provided here can be used with the field within the class. Be mindful that the logger may be null in scenarios where it's not explicitly provided.

Methods

| Edit this page View Source

GetValidUniquePaths()

Retrieves a list of valid and unique directory paths from the system's PATH environment variable.

Declaration
public List<string> GetValidUniquePaths()
Returns
Type Description
List<string>

A list of strings representing valid, unique, and normalized directory paths from the PATH environment. Returns an empty list if the PATH environment variable is not accessible or if no valid paths are found.
Remarks

This method processes each entry in the PATH environment variable by:

  • Normalizing the casing of each path using the TryFixPathCaseing method.
  • Checking each path for existence to ensure validity.
  • Ensuring that each path is unique within the context of the PATH variable to avoid duplicates.
  • Logging various statuses such as inaccessible PATH, skipped entries due to invalidity or duplication, and errors during processing. The method is robust against non-existent directories, permission issues, and other filesystem anomalies by logging and skipping over problematic entries.
Examples
var validPaths = GetValidUniquePaths();
foreach (var path in validPaths)
{
    Console.WriteLine(path); // Prints each valid and unique path
}
| Edit this page View Source

IsCommandAvailable(string?)

Checks if a specified command is available in the current directory or any of the directories listed in the system's PATH environment variable.

Declaration
public string? IsCommandAvailable(string? command)
Parameters
Type Name Description
string command

The name of the executable file to search for.
Returns
Type Description
string

The full path of the executable file with corrected casing if found; otherwise, returns null. The method returns null if the command parameter is null, or if the executable cannot be found in the current or PATH directories.
Remarks

This method performs the following operations:

  • Validates the command input.
  • Retrieves the current directory and the directories from the system's PATH environment using the GetValidUniquePaths method, which excludes invalid and duplicate paths.
  • Checks each directory for the existence of the specified command.
  • Utilizes the TryFixPathCaseing method to return the path in the correct casing.
  • Logs various informational messages during the process, including errors encountered, invalid path entries, and successful detection of the executable. This method ensures that the search includes the current directory, aligning with common command-line behaviors where the current directory is typically searched before the PATH directories.
Examples
string commandName = "example";
string executablePath = IsCommandAvailable(commandName);
if (executablePath != null)
{
    Console.WriteLine($"Executable found: {executablePath}");
}
else
{
    Console.WriteLine("Executable not found.");
}
| Edit this page View Source

IsExecutableFilePresent(string?, string?)

Checks if an executable file with the specified command name is present in the given directory path, considering platform-specific executable extensions.

Declaration
public string? IsExecutableFilePresent(string? command, string? path)
Parameters
Type Name Description
string command

The base name of the executable file to search for, without extension.
string path

The directory path where to look for the executable file.
Returns
Type Description
string

The full path of the executable file if found, otherwise null. The method returns null if the directory does not exist or the parameters are null or empty.
Remarks

This method supports different sets of executable extensions based on the operating system:

  • Windows: Includes common executable and script extensions such as .exe, .bat, .cmd, .ps1, .msi, .vbs, .com, and .scr.
  • Linux/macOS: Includes executable and script extensions like .sh, .bash, .run, .bin, as well as scripting languages such as .py, .pl, and .rb. Files without extensions are also considered in Unix/Linux environments where executables often do not have an extension. The method checks if the specified directory exists before attempting to find executables, improving efficiency by avoiding unnecessary file operations.
Examples
string commandName = "myapp";
string directoryPath = "/usr/local/bin";
string result = IsExecutableFilePresent(commandName, directoryPath);
if (result != null)
{
    Console.WriteLine("Executable found: " + result);
}
else
{
    Console.WriteLine("No executable found.");
}
| Edit this page View Source

IsValidLocation(string?)

Checks whether the specified path is a valid file or directory.

Declaration
public bool IsValidLocation(string? path)
Parameters
Type Name Description
string path

The path to be checked.
Returns
Type Description
bool

true if the path points to an existing file or directory; otherwise, false.
Remarks

This method returns false if the provided path is null or empty. It logs debug messages using the provided logger instance if any errors occur during the validation process.

| Edit this page View Source

TryCorrectDrivePathCase(string?)

Attempts to retrieve the correctly cased drive root path based on a provided drive name, ignoring case sensitivity.

Declaration
public string? TryCorrectDrivePathCase(string? drivename)
Parameters
Type Name Description
string drivename

The drive name to search for, case-insensitively.
Returns
Type Description
string

The correctly cased drive root path if found; otherwise, returns the original drivename.
Remarks

This method performs a case-insensitive comparison to find a matching drive among the available drives. If no matching drive is found or if an exception occurs during the drive search, the original drivename is returned. This ensures that the method fails gracefully, providing a fallback to the original input.

Examples
string drivePath = TryCorrectDrivePathCase("C:");
Console.WriteLine(drivePath); // Output might be "C:\", or "C:" if no match is found
| Edit this page View Source

TryFixPathCaseing(string?)

Attempts to correct the casing of the provided file or directory path by traversing each segment and matching it against actual filesystem entries.

Declaration
public string? TryFixPathCaseing(string? path)
Parameters
Type Name Description
string path

The file or directory path to correct.
Returns
Type Description
string

The path with corrected casing for each existing segment. For segments that do not correspond to existing entries, the original casing is used.
Remarks

This method operates by:

  • Resolving the full path and starting with the root, attempting to correct its casing.
  • Sequentially processing each subsequent segment of the path. Each segment's casing is corrected to match the actual filesystem entry if it exists.
  • If a segment (directory or file) does not exist, the segment from the original path is used as is, and traversal stops at this point. This approach ensures that the returned path is as accurate as possible up to the last existing segment. Errors and non-existing segments are handled gracefully by reverting to the original input for those segments. Exceptional conditions are logged for diagnostic purposes.
Examples
string originalPath = "c:\\users\\Public\\DESKTOP\\nonExistingFile.txt";
string correctedPath = TryFixPathCaseing(originalPath);
Console.WriteLine(correctedPath); // Output might be "C:\\Users\\Public\\Desktop\\nonExistingFile.txt"

Implements