TempPath.cs

using System;
using System.IO;

namespace LazyPathDemo
{
    public class LazyDirectoryPath
    {
        // Parameters for path construction
        private readonly string _basePath;
        private readonly string[] _pathSegments;
        private readonly bool _createIfNotExists;
        private readonly LazyDirectoryPath _parentPath;
        
        // Lazy<T> instance to handle delayed initialization
        private readonly Lazy<string> _lazyPath;
        
        // Public property that uses lazy initialization
        public string Path => _lazyPath.Value;
        
        // Constructor without parent path
        public LazyDirectoryPath(string basePath, bool createIfNotExists, params string[] pathSegments)
            : this(basePath, createIfNotExists, null, pathSegments)
        {
        }
        
        // Constructor with parent path
        public LazyDirectoryPath(string basePath, bool createIfNotExists, LazyDirectoryPath parentPath, params string[] pathSegments)
        {
            _basePath = basePath;
            _pathSegments = pathSegments;
            _createIfNotExists = createIfNotExists;
            _parentPath = parentPath;
            
            // Initialize the Lazy<string> with a function that builds and potentially creates the path
            _lazyPath = new Lazy<string>(BuildAndCreatePath);
        }
        
        // Method that constructs the path and optionally creates the directory
        private string BuildAndCreatePath()
        {
            Console.WriteLine("Building directory path (this happens only once)");
            
            string fullPath;
            
            // If we have a parent path, use it as the base
            if (_parentPath != null)
            {
                fullPath = System.IO.Path.Combine(_parentPath.Path, _basePath);
            }
            else
            {
                fullPath = _basePath;
            }
            
            // Add all path segments
            foreach (var segment in _pathSegments)
            {
                fullPath = System.IO.Path.Combine(fullPath, segment);
            }
            
            // Create directory if requested and it doesn't exist
            if (_createIfNotExists && !Directory.Exists(fullPath))
            {
                Console.WriteLine($"Creating directory: {fullPath}");
                Directory.CreateDirectory(fullPath);
            }
            
            return fullPath;
        }
        
        // Get a new LazyDirectoryPath that's a subdirectory of this one
        public LazyDirectoryPath GetSubdirectory(string name, bool createIfNotExists = true)
        {
            return new LazyDirectoryPath(name, createIfNotExists, this);
        }
        
        // Override ToString to return the path
        public override string ToString()
        {
            return Path;
        }
        
        // Define implicit conversion operator from LazyDirectoryPath to string
        public static implicit operator string(LazyDirectoryPath path)
        {
            return path.Path;
        }
        
        // Check if the directory exists
        public bool Exists()
        {
            return Directory.Exists(Path);
        }
        
        // Get DirectoryInfo object
        public DirectoryInfo GetDirectoryInfo()
        {
            return new DirectoryInfo(Path);
        }
    }
    
    // Example usage
    public class Program
    {
        public static void Main()
        {
            // Create a base directory path
            var appDataPath = new LazyDirectoryPath(
                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                true);
            
            // Create a company directory under AppData
            var companyPath = appDataPath.GetSubdirectory("MyCompany");
            
            // Create an application directory under the company directory
            var appPath = companyPath.GetSubdirectory("MyApplication");
            
            // Create a logs directory
            var logsPath = appPath.GetSubdirectory("Logs");
            
            // Using the path will trigger creation of all directories in the chain
            Console.WriteLine($"Logs directory: {logsPath}");
            
            // You can also use it directly with file operations
            string logFilePath = System.IO.Path.Combine(logsPath, "application.log");
            File.WriteAllText(logFilePath, "Log entry: Application started");
            
            // Alternative way to create nested paths in one go
            var configPath = new LazyDirectoryPath(
                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                true,
                "MyCompany", "MyApplication", "Config");
                
            Console.WriteLine($"Config directory: {configPath}");
        }
    }
}