C# FileSystemInfo与File相关类操作

常用到FileSystemInfo等相关

        public static string ToDisplayString(this FileSystemInfo fileSysInfo)
        {
            string type = fileSysInfo.GetType().ToString();
            if (fileSysInfo is DirectoryInfo)
                type = "DIRECTORY";
            else if (fileSysInfo is FileInfo)
                type = "FILE";

            //return string.Format("type: {0}", fileSysInfo.Name);
            return $"{type}: {fileSysInfo.Name}";
        }

        public static void DisplayFilesAndSubDirectories(string path)
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                throw new ArgumentNullException(nameof(path));
            }


            string[] items = Directory.GetFileSystemEntries(path);
            Array.ForEach(items, item =>
            {
                Console.WriteLine(item);
            });
        }

        public static void DisplayDirectoryContents(string path)
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                throw new ArgumentNullException(nameof(path));
            }

            var mainDir = new DirectoryInfo(path);

            //mainDir.GetDirectories();

            var fileSystemDisplayInfos =
                (from fsi in mainDir.GetFileSystemInfos()
                 where fsi is FileSystemInfo || fsi is DirectoryInfo
                 select fsi.ToDisplayString()).ToArray();

            Array.ForEach(fileSystemDisplayInfos, s =>
            {
                Console.WriteLine(s);
            });
        }

        public static IEnumerable<FileSystemInfo> GetAllFilesAndDirectories(string dir)
        {
            if (string.IsNullOrWhiteSpace(dir))
                throw new ArgumentNullException(nameof(dir));

            var dirInfo = new DirectoryInfo(dir);
            Stack<FileSystemInfo> stack = new Stack<FileSystemInfo>();

            while (dirInfo != null || stack.Count > 0)
            {
                FileSystemInfo fileSystemInfo = null;
                DirectoryInfo subDirectoryInfo = null;
                if (stack.Count > 0)
                {
                    fileSystemInfo = stack.Pop();
                    subDirectoryInfo = fileSystemInfo as DirectoryInfo;
                }
                else
                {
                    subDirectoryInfo = dirInfo;
                }

                if (subDirectoryInfo != null)
                {
                    yield return subDirectoryInfo;

                    foreach (FileSystemInfo fsi in subDirectoryInfo.GetFileSystemInfos())
                        stack.Push(fsi);

                    dirInfo = subDirectoryInfo;
                }
                else
                {
                    yield return fileSystemInfo;
                    dirInfo = null;
                }
            }
        }

        public static IEnumerable<FileSystemInfo> GetAllFilesAndDirectoriesWithRecursion(string dir)
        {
            if (string.IsNullOrWhiteSpace(dir))
                throw new ArgumentNullException(nameof(dir));

            var dirInfo = new DirectoryInfo(dir);

            FileSystemInfo[] fileSystemInfos = dirInfo.GetFileSystemInfos();
            foreach (var fileSystemInfo in fileSystemInfos)
            {
                yield return fileSystemInfo;

                if (fileSystemInfo is DirectoryInfo)
                {
                    foreach (var fsi in GetAllFilesAndDirectoriesWithRecursion(fileSystemInfo.FullName))
                        yield return fsi;
                }
            }
        }

        public static void DisplayAllFilesWithExtension(string dir, string extension)
        {
            if (string.IsNullOrWhiteSpace(dir))
                throw new ArgumentNullException(nameof(dir));

            if (string.IsNullOrWhiteSpace(extension))
                throw new ArgumentNullException(nameof(extension));

            var strings = (from fileSystemInfo in GetAllFilesAndDirectories(dir)
                           where fileSystemInfo is FileInfo &&
                                 (string.Compare(fileSystemInfo.Extension, extension,
                                                 StringComparison.OrdinalIgnoreCase) == 0)
                           select fileSystemInfo.ToDisplayString()).ToArray();

            Array.ForEach(strings, s => { Console.WriteLine(s); });
        }

 

        public static void RunProcessToReadStandardInput()
        {
            Process app = new Process();

            // Run the command shell
            app.StartInfo.FileName = @"cmd.exe";

            // Turn on command extensions for cmd.exe
            app.StartInfo.Arguments = "/E:ON";
            app.StartInfo.RedirectStandardInput = true;
            app.StartInfo.UseShellExecute = false;
            app.Start();

            StreamWriter input = app.StandardInput;
            // Run the command to display the time
            input.WriteLine("TIME /T");

            // Stop the application we launched
            input.WriteLine("exit");
        }

锁定文件

        #region Lock file
        public static async Task CreateLockedFileAsync(string filename)
        {
            if (string.IsNullOrWhiteSpace(filename))
                throw new ArgumentNullException(nameof(filename));

            FileStream fileStream = null;
            try
            {
                fileStream = new FileStream(filename, 
                    FileMode.Create,
                    FileAccess.ReadWrite,
                    FileShare.ReadWrite, 4096, useAsync: true);

                using (StreamWriter writer = new StreamWriter(fileStream))
                {
                    await writer.WriteLineAsync("The First Line");
                    await writer.WriteLineAsync("The Second Line");
                    writer.Flush();
                    //await writer.FlushAsync();

                    try
                    {
                        // Lock all of the file.
                        fileStream.Lock(0, fileStream.Length);

                        // Do some lengthy processing here...

                        Thread.Sleep(1000);
                    }
                    finally
                    {
                        // Make sure we unlock the file
                        // If a process terminates with part of a file locked or
                        // close a file that has outstanding locks, the behavior
                        // is undefined which is MS speak for bad things...
                        fileStream.Unlock(0, fileStream.Length);
                    }

                    await writer.WriteLineAsync("The Third Line");
                    fileStream = null;
                }

            }
            catch (Exception e)
            {

                throw;
            }
            finally
            {
                if (fileStream != null)
                    fileStream.Dispose();
            }
        }
        #endregion