C# System.IO.Directory、System.IO.File文件操作

已于 2024-06-06 11:11:18 修改
阅读量3.5k 收藏 8
点赞数 1
分类专栏： .Net技术 文章标签： File Directory
于 2016-12-15 16:10:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KingCruel/article/details/53671670
版权

System.IO.Directory、System.IO.File文件操作

/// <summary>
/// 删除文件
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static bool DeleteFile(string file)
{
    try
    {
        System.IO.File.Delete(file);
        //System.IO.File.Delete(@"C:\Users\Public\DeleteTest\test.txt");
        return true;
    }
    catch (Exception ex)
    {
    }
    return false;
}


/// <summary>
/// 删除文件夹
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static bool DeleteFolder(string path)
{
    try
    {
        if (Directory.Exists(path))
        {
            ///删除文件夹
            System.IO.Directory.Delete(path, true);

            ///创建文件夹
            Directory.CreateDirectory(path);
        }
        return true;
    }
    catch (Exception ex)
    {
    }
    return false;
}

/// <summary>
/// 删除文件夹内所有文件
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public static bool DeleteAllFile(string path)
{
    try
    {
        DirectoryInfo dir = new DirectoryInfo(path);
        FileInfo[] files = dir.GetFiles();
        if (files.Count() > 0)
        {
            foreach (var item in files)
            {
                if (!item.ToString().Contains("$") && (!item.ToString().Contains("Boot")))
                {
                    System.IO.File.Delete(dir.ToString() + "\\" + item.ToString());
                }
            }
        }

        return true;
    }
    catch (Exception ex)
    {
    }
    return false;
}

*

using System;
using System.IO;
using System.Linq;
using System.Web;

namespace CoreLibrary
{
    public class FileHelper
    {
        /// <summary>
        /// 创建文件夹路径名称
        /// </summary>
        /// <param name="dir"></param>
        /// <returns></returns>
        public static string CreatDirectoryPath(string path)
        {
            string result = string.Empty;
            try
            {
                string year = DateTime.Now.Year.ToString();
                string month = DateTime.Now.Month.ToString();
                if (month.Length == 1)
                    month = "0" + month;
                result = path + year + "/" + month + "/";
            }
            catch (Exception)
            {
                result = path;
            }
            return result;
        }

        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="path"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public static bool CreateDirectory(string path, out string message)
        {
            bool IsSuccess = false;
            message = "";
            if (!Directory.Exists(path))
            {
                try
                {
                    Directory.CreateDirectory(path);
                    IsSuccess = true;
                }
                catch (UnauthorizedAccessException)
                {
                    message = "创建目录失败，因为没有足够的权限。";
                }
                catch (PathTooLongException)
                {
                    message = "路径或者文件名超过系统定义的最大长度。";
                }
                catch (DirectoryNotFoundException)
                {
                    message = "保存目录没有找到。";
                }
            }
            else
                IsSuccess = true;
            return IsSuccess;
        }

        /// <summary>
        /// 根据Base64字符串,保存文件
        /// </summary>
        /// <param name="fileBase"></param>
        /// <param name="saveFolder"></param>
        /// <param name="IsApi"></param>
        /// <returns></returns>
        public static FileUploadResult CreateBase64ToImage(string fileBase, string saveFolder, bool IsApi)
        {
            FileUploadResult result = null;
            string savePath = string.Empty;
            string message = string.Empty;
            string fileName = string.Empty;
            if (IsApi)
                savePath = StringPlus.GetWebConfigKey("APIFilePath") + saveFolder;
            else
                savePath = ConstantParamInfo.PhysicalApplicationPath + saveFolder;

            try
            {
                if (CreateDirectory(savePath, out message))
                {
                    string dt = DateTime.Now.ToString("yyyyMMddHHmmss.fff");
                    byte[] file = Convert.FromBase64String(fileBase);

                    fileName = dt + ".jpg";
                    File.WriteAllBytes(savePath + fileName, file);

                    result = new FileUploadResult(saveFolder + fileName);
                }
                else
                {
                    result = new FileUploadResult(-2, message);
                }
            }
            catch (Exception ex)
            {
                result = new FileUploadResult(ex);
            }
            return result;
        }

        /// <summary>
        /// 根据HttpPostedFileBase,保存文件
        /// </summary>
        /// <param name="postedFile"></param>
        /// <param name="saveFolder"></param>
        /// <returns></returns>
        public static FileUploadResult CreatePostedFileToImage(HttpPostedFileBase postedFile, string saveFolder)
        {
            //在网站根目录下创建日志目录
            string savePath = ConstantParamInfo.PhysicalApplicationPath + saveFolder;
            string message = string.Empty;
            FileUploadResult result = null;
            try
            {
                if (CreateDirectory(savePath, out message))
                {
                    string dt = DateTime.Now.ToString("yyyyMMddHHmmss.fff");
                    if (postedFile != null && postedFile.ContentLength > 0)
                    {
                        string fileName = string.Empty;
                        string fileExtension = string.Empty;
                        string filePath = string.Empty;

                        fileName = Path.GetFileName(postedFile.FileName);//文件名称
                        fileExtension = Path.GetExtension(postedFile.FileName).ToLower();//文件的后缀名(小写)
                        filePath = savePath + dt + fileExtension;
                        postedFile.SaveAs(filePath);

                        result = new FileUploadResult(saveFolder + dt + fileExtension);
                    }
                }
                else
                {
                    result = new FileUploadResult(message);
                }
            }
            catch (Exception ex)
            {
                result = new FileUploadResult(ex);
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static FileUploadResult CreateUploadFile(FileUploadParam data)
        {
            //网站根目录路径设置
            string ApplicationPath = string.Empty;
            if (data.IsApplicationPath)
                ApplicationPath = ConstantParamInfo.PhysicalApplicationPath + data.SaveFolder;
            else
                ApplicationPath = data.CustomApplicationPath + data.SaveFolder;

            string message = string.Empty;
            FileUploadResult result = null;
            try
            {
                if (CreateDirectory(ApplicationPath, out message))
                {
                    string dt = DateTime.Now.ToString("yyyyMMddHHmmss.fff");
                    string fileName = string.Empty;
                    string fileExtension = string.Empty;
                    string saveFilePath = string.Empty;

                    if (data.ResourceType == (int)ResourceTypeEnum.Base64String)
                    {
                        byte[] file = Convert.FromBase64String(data.Base64String);

                        fileName = dt + ".jpg";
                        saveFilePath = data.SaveFolder + fileName;

                        ///保存文件
                        File.WriteAllBytes(ApplicationPath + fileName, file);

                        result = new FileUploadResult(saveFilePath);
                    }
                    else if (data.ResourceType == (int)ResourceTypeEnum.PostedFile)
                    {
                        if (data.PostedFile != null && data.PostedFile.ContentLength > 0)
                        {
                            bool isSuccess = true;

                            fileExtension = Path.GetExtension(data.PostedFile.FileName).ToLower();//文件的后缀名(小写)
                            if (data.FileExtension != null)
                            {
                                if (!data.FileExtension.Contains(fileExtension))
                                    isSuccess = false;
                            }
                            if (isSuccess)
                            {
                                //fileName = Path.GetFileName(data.PostedFile.FileName);//文件名称
                                fileName = dt + fileExtension;
                                saveFilePath = data.SaveFolder + dt + fileExtension;

                                ///保存文件
                                data.PostedFile.SaveAs(ApplicationPath + fileName);

                                result = new FileUploadResult(saveFilePath);
                            }
                            else
                            {
                                result = new FileUploadResult(-2, InformationPrompt.SAVE_FILE_TYPE_ERROR);
                            }
                        }
                    }
                }
                else
                {
                    result = new FileUploadResult(-2, message);
                }
            }
            catch (Exception ex)
            {
                result = new FileUploadResult(ex);
            }
            return result;
        }

        /// <summary>
        /// 根据Base64字符串,保存文件
        /// </summary>
        /// <param name="path"></param>
        /// <param name="fileName"></param>
        /// <param name="fileBase"></param>
        /// <param name="mesage"></param>
        /// <returns></returns>
        public static bool CreateBase64ToImage(string path, string fileName, string fileBase, out string mesage)
        {
            bool IsSuccess = false;
            mesage = "";
            if (!Directory.Exists(path))
            {
                try
                {
                    Directory.CreateDirectory(path);
                    IsSuccess = true;
                    mesage = "创建成功。";
                }
                catch (UnauthorizedAccessException)
                {
                    mesage = "创建目录失败，因为没有足够的权限。";
                }
                catch (PathTooLongException)
                {
                    mesage = "路径或者文件名超过系统定义的最大长度。";
                }
                catch (DirectoryNotFoundException)
                {
                    mesage = "保存目录没有找到。";
                }
            }
            else
                IsSuccess = true;

            if (IsSuccess)
            {
                try
                {
                    byte[] file = Convert.FromBase64String(fileBase);
                    File.WriteAllBytes(path + fileName, file);
                }
                catch (Exception ex)
                {
                    mesage = ex.Message;
                }
            }
            return IsSuccess;
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static bool DeleteFile(string file)
        {
            try
            {
                System.IO.File.Delete(file);
                //System.IO.File.Delete(@"C:\Users\Public\DeleteTest\test.txt");
                return true;
            }
            catch (Exception ex)
            {
            }
            return false;
        }

        /// <summary>
        /// 删除文件夹
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static bool DeleteFolder(string path)
        {
            try
            {
                if (Directory.Exists(path))
                {
                    ///删除文件夹
                    System.IO.Directory.Delete(path, true);

                    ///创建文件夹
                    Directory.CreateDirectory(path);
                }
                return true;
            }
            catch (Exception ex)
            {
            }
            return false;
        }

        /// <summary>
        /// 删除文件夹内所有文件
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static bool DeleteAllFile(string path)
        {
            try
            {
                DirectoryInfo dir = new DirectoryInfo(path);
                FileInfo[] files = dir.GetFiles();
                if (files.Count() > 0)
                {
                    foreach (var item in files)
                    {
                        if (!item.ToString().Contains("$") && (!item.ToString().Contains("Boot")))
                        {
                            System.IO.File.Delete(dir.ToString() + "\\" + item.ToString());
                        }
                    }
                }

                return true;
            }
            catch (Exception ex)
            {
            }
            return false;
        }
    }

    /// <summary>
    /// 创建文件夹返回结果
    /// </summary>
    public class CreateDirectoryResult
    {
        public int Code { get; set; }

        public string Path { get; set; }

        public string Msg { get; set; }
    }

    /// <summary>
    /// 参数设置
    /// </summary>
    public class FileUploadParam
    {
        public FileUploadParam()
        {
            IsApplicationPath = true;
        }

        /// <summary>
        /// 是否保存至项目根目录
        /// </summary>
        public bool IsApplicationPath { get; set; }

        /// <summary>
        /// 自定义项目根目录
        /// </summary>
        public string CustomApplicationPath { get; set; }

        /// <summary>
        /// 资源类型
        /// </summary>
        public int ResourceType { get; set; }

        /// <summary>
        /// 保存路径：/upload/banner/123.jpg
        /// </summary>
        public string SaveFolder { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public HttpPostedFileBase PostedFile { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public string Base64String { get; set; }

        /// <summary>
        /// 文件后缀
        /// </summary>
        public string[] FileExtension { get; set; }
    }

    /// <summary>
    /// 返回结果
    /// </summary>
    public class FileUploadResult
    {
        public FileUploadResult()
        {
            this.Code = 200;
            this.Msg = "success";
        }

        public FileUploadResult(string resultPath)
            : this()
        {
            this.Path = resultPath;
        }

        public FileUploadResult(int code, string resultPath)
            : this()
        {
            this.Code = code;
            this.Path = resultPath;
        }

        public FileUploadResult(Exception ex)
            : this()
        {
            this.Code = -1;
            this.Path = "";
            this.Msg = ex.Message;
        }

        public int Code { get; set; }

        public string Path { get; set; }

        public string Msg { get; set; }
    }

    /// <summary>
    /// 
    /// </summary>
    public enum ResourceTypeEnum
    {
        /// <summary>
        /// 
        /// </summary>
        None = 0,

        /// <summary>
        /// Base64字符串
        /// </summary>
        Base64String = 1,

        /// <summary>
        /// HttpPostedFileBase
        /// </summary>
        PostedFile = 2,
    }
}

*、FileHelper.cs

using ICSharpCode.SharpZipLib.Checksum;
using ICSharpCode.SharpZipLib.Zip;
using System.IO;
using System.Text;
using Yuebon.Commons.Extend;
using Yuebon.Commons.Log;

namespace Yuebon.Commons.Helpers
{
    /// <summary>
    /// 文件处理帮助类
    /// </summary>
    public class FileHelper
    {

        /// <summary>
        /// 制作压缩包（多个文件压缩到一个压缩包，支持加密、注释）
        /// </summary>
        /// <param name="topDirectoryName">压缩文件目录</param>
        /// <param name="zipedFileName">压缩包文件名</param>
        /// <param name="compresssionLevel">压缩级别 1-9 </param>
        /// <param name="password">密码</param>
        /// <param name="comment">注释</param>
        /// <param name="filetype">文件类型</param>
        public static void ZipFiles(string topDirectoryName, string zipedFileName, int compresssionLevel, string password, string comment, string filetype)
        {
            using (ZipOutputStream zos = new ZipOutputStream(File.Open(zipedFileName, FileMode.OpenOrCreate)))
            {
                if (compresssionLevel != 0)
                {
                    zos.SetLevel(compresssionLevel);//设置压缩级别
                }
                if (!string.IsNullOrEmpty(password))
                {
                    zos.Password = password;//设置zip包加密密码
                }
                if (!string.IsNullOrEmpty(comment))
                {
                    zos.SetComment(comment);//设置zip包的注释
                }
                //循环设置目录下所有的*.jpg文件（支持子目录搜索）
                foreach (string file in Directory.GetFiles(topDirectoryName, filetype, SearchOption.AllDirectories))
                {
                    if (File.Exists(file))
                    {
                        FileInfo item = new FileInfo(file);
                        FileStream fs = File.OpenRead(item.FullName);
                        byte[] buffer = new byte[fs.Length];
                        fs.Read(buffer, 0, buffer.Length);
                        ZipEntry entry = new ZipEntry(item.Name);
                        zos.PutNextEntry(entry);
                        zos.Write(buffer, 0, buffer.Length);
                        fs.Close();
                    }
                }
                zos.Close();
            }
        }

        /// <summary>
        /// 压缩多层目录
        /// </summary>
        /// <param name="topDirectoryName">压缩文件目录</param>
        /// <param name="zipedFileName">压缩包文件名</param>
        /// <param name="compresssionLevel">压缩级别 1-9 </param>
        /// <param name="password">密码</param>
        /// <param name="comment">注释</param>
        /// <param name="filetype">文件类型</param>
        public static void ZipFileDirectory(string topDirectoryName, string zipedFileName, int compresssionLevel, string password, string comment, string filetype)
        {
            using (System.IO.FileStream ZipFile = File.Open(zipedFileName, FileMode.OpenOrCreate))
            {
                using (ZipOutputStream zos = new ZipOutputStream(ZipFile))
                {
                    if (compresssionLevel != 0)
                    {
                        zos.SetLevel(compresssionLevel);//设置压缩级别
                    }
                    if (!string.IsNullOrEmpty(password))
                    {
                        zos.Password = password;//设置zip包加密密码
                    }
                    if (!string.IsNullOrEmpty(comment))
                    {
                        zos.SetComment(comment);//设置zip包的注释
                    }
                    ZipSetp(topDirectoryName, zos, "", filetype);
                }
            }
        }

        /// <summary>
        /// 递归遍历目录
        /// </summary>
        /// <param name="strDirectory">The directory.</param>
        /// <param name="s">The ZipOutputStream Object.</param>
        /// <param name="parentPath">The parent path.</param>
        /// <param name="filetype"></param>
        private static void ZipSetp(string strDirectory, ZipOutputStream s, string parentPath, string filetype)
        {
            if (strDirectory[strDirectory.Length - 1] != Path.DirectorySeparatorChar)
            {
                strDirectory += Path.DirectorySeparatorChar;
            }

            Crc32 crc = new Crc32();

            string[] filenames = Directory.GetFileSystemEntries(strDirectory, filetype);
            foreach (string file in filenames)// 遍历所有的文件和目录
            {
                if (Directory.Exists(file))// 先当作目录处理如果存在这个目录就递归Copy该目录下面的文件
                {
                    string pPath = parentPath;
                    pPath += file.Substring(file.LastIndexOf("\\") + 1);
                    pPath += "\\";
                    ZipSetp(file, s, pPath, filetype);
                }
                else // 否则直接压缩文件
                {
                    //打开压缩文件
                    using (FileStream fs = File.OpenRead(file))
                    {
                        byte[] buffer = new byte[fs.Length];
                        fs.Read(buffer, 0, buffer.Length);
                        string fileName = parentPath + file.Substring(file.LastIndexOf("\\") + 1);
                        ZipEntry entry = new ZipEntry(fileName);
                        entry.DateTime = DateTime.Now;
                        entry.Size = fs.Length;
                        fs.Close();
                        crc.Reset();
                        crc.Update(buffer);
                        entry.Crc = crc.Value;
                        s.PutNextEntry(entry);
                        s.Write(buffer, 0, buffer.Length);
                    }
                }
            }
        }
        #region 读取文件
        /// <summary>
        /// 读文件
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static string ReadFile(string path)
        {
            path = path.ToFilePath();
            if (!File.Exists(path))
                return "";
            using (StreamReader stream = new StreamReader(path))
            {
                return stream.ReadToEnd(); // 读取文件
            }
        }

        /// <summary>
        /// 文件是否存在
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static bool Exists(string path)
        {
            if (!File.Exists(path))
                return false;
            else
                return true;
        }
        /// <summary>
        /// 读文件
        /// </summary>
        /// <param name="Path">文件路径</param>
        /// <param name="encode">编码格式</param>
        /// <returns></returns>
        public static string ReadFile(string Path, Encoding encode)
        {
            string s = "";
            if (!File.Exists(Path))
                s = "不存在相应的目录";
            else
            {
                StreamReader f2 = new StreamReader(Path, encode);
                s = f2.ReadToEnd();
                f2.Close();
                f2.Dispose();
            }

            return s;
        }
        #endregion
        /// <summary>
        /// 写文件
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <param name="fileName">文件名称</param>
        /// <param name="content">文件内容</param>
        /// <param name="appendToLast">是否追加到最后</param>
        public static void WriteFile(string path, string fileName, string content, bool appendToLast = false)
        {
            if (!path.EndsWith("\\"))
            {
                path = path + "\\";
            }
            path = path.ToFilePath();
            if (!Directory.Exists(path))//如果不存在就创建file文件夹
            {
                Directory.CreateDirectory(path);
            }
            using (FileStream stream = File.Open(path + fileName, FileMode.OpenOrCreate, FileAccess.Write))
            {
                byte[] by = Encoding.Default.GetBytes(content);
                if (appendToLast)
                {
                    stream.Position = stream.Length;
                }
                else
                {
                    stream.SetLength(0);
                }
                stream.Write(by, 0, by.Length);
            }
        }

        #region 直接删除指定目录下的所有文件及文件夹(保留目录)
        /// <summary>
        /// 删除指定目录下的所有文件及文件夹(保留目录)
        /// </summary>
        /// <param name="file">文件目录</param>
        public static void DeleteDirectory(string file)
        {
            try
            {
                //判断文件夹是否还存在
                if (Directory.Exists(file))
                {
                    DirectoryInfo fileInfo = new DirectoryInfo(file);
                    //去除文件夹的只读属性
                    fileInfo.Attributes = FileAttributes.Normal & FileAttributes.Directory;
                    foreach (string f in Directory.GetFileSystemEntries(file))
                    {
                        if (File.Exists(f))
                        {
                            //去除文件的只读属性
                            File.SetAttributes(file, FileAttributes.Normal);
                            //如果有子文件删除文件
                            File.Delete(f);
                        }
                        else
                        {
                            //循环递归删除子文件夹
                            DeleteDirectory(f);
                        }
                    }
                    //删除空文件夹
                    Directory.Delete(file);
                }

            }
            catch (Exception ex) // 异常处理
            {
                Log4NetHelper.Error("删除文件异常", ex);
            }
        }

        #endregion



        #region 获取文件的编码类型

        /// <summary>
        /// 获取文件编码
        /// </summary>
        /// <param name="filePath">文件绝对路径</param>
        /// <returns></returns>
        public static Encoding GetEncoding(string filePath)
        {
            return GetEncoding(filePath, Encoding.Default);
        }

        /// <summary>
        /// 获取文件编码
        /// </summary>
        /// <param name="filePath">文件绝对路径</param>
        /// <param name="defaultEncoding">找不到则返回这个默认编码</param>
        /// <returns></returns>
        public static Encoding GetEncoding(string filePath, Encoding defaultEncoding)
        {
            Encoding targetEncoding = defaultEncoding;
            using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4))
            {
                if (fs != null && fs.Length >= 2)
                {
                    long pos = fs.Position;
                    fs.Position = 0;
                    int[] buffer = new int[4];
                    //long x = fs.Seek(0, SeekOrigin.Begin);
                    //fs.Read(buffer,0,4);
                    buffer[0] = fs.ReadByte();
                    buffer[1] = fs.ReadByte();
                    buffer[2] = fs.ReadByte();
                    buffer[3] = fs.ReadByte();

                    fs.Position = pos;

                    if (buffer[0] == 0xFE && buffer[1] == 0xFF)//UnicodeBe
                    {
                        targetEncoding = Encoding.BigEndianUnicode;
                    }
                    if (buffer[0] == 0xFF && buffer[1] == 0xFE)//Unicode
                    {
                        targetEncoding = Encoding.Unicode;
                    }
                    if (buffer[0] == 0xEF && buffer[1] == 0xBB && buffer[2] == 0xBF)//UTF8
                    {
                        targetEncoding = Encoding.UTF8;
                    }
                }
            }

            return targetEncoding;
        }

        #endregion

    }
}


*
*
*

KingCruel
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c#使用file.copy实现文件备份示例
09-04
实现特定文件夹每天备份,下面使用file.copy实现一下这个功能”中涉及到的核心知识点是使用C#编程语言，利用.NET Framework提供的File.Copy方法来实现文件系统的备份操作。这一过程主要包括两个核心步骤：首先是筛选...
System.IO之File
G00d
08-13 2736
文章转自：https://msdn.microsoft.com/zh-cn/library/system.io.file(v=vs.110).aspx 提供用于创建、复制、删除、移动和打开单一文件的静态方法，并协助创建 FileStream 对象。 若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。 继承层次结构 System.Object  ...
【.Net实用方法总结】 整理并总结System.IO中File类及其方法介绍
baidu_33146219的博客
08-20 2万+
本文主要介绍System.IO命名空间的File 类，介绍其常用的方法和示例说明
C# Directory.GetFiles()获取多个类型格式的文件
dreamgis的专栏
07-25 1万+
转自：http://www.cnblogs.com/songxingzhu/p/6000070.html 第一种方式 System.IO.Directory.GetFiles()获取多个类型格式的文件 System.IO.Directory.GetFiles("c:\","(*.jpg|*.bmp)"); 第二种方式 var files = Directory.Get
C# system.io 操作文件
weixin_44513361的博客
08-29 409
文件与文件夹操作主要用到以下几个类： 1.File类: 提供用于创建、复制、删除、移动和打开文件的静态方法，并协助创建 FileStream 对象。 msdn:http://msdn.microsoft.com/zh-cn/library/system.io.file(v=VS.80).aspx 2.FileInfo类： 提供创建、复制、删除、移动和打开文件的实例方法，并且帮助创建...
C#(System.IO)文件处理方法（全面）
book_dw5189的博客
06-23 2908
C#(System.IO)文件处理方法（全面）
解决删除目录提示：System.IO.IOException: 目录不是空的。
08-23
在编程过程中，尤其是在使用C#进行文件系统操作时，可能会遇到这样一个问题：当你尝试删除一个目录，系统返回“System.IO.IOException: 目录不是空的”错误。这意味着该目录下仍有文件或子目录存在，因此无法直接...
Visual C# 2010文件IO与数据存取秘诀.rar
10-08
在Visual C# 2010中，System.IO命名空间提供了大量的类来支持文件和目录的操作，如FileStream、StreamReader、StreamWriter、File和Directory等。例如，使用`File.WriteAllText()`方法可以将字符串写入文件，而`File...
北大青鸟C#第九章 IO文件操作参考答案.zip
09-02
2. 使用File类：System.IO命名空间下的File类提供了大量静态方法，如File.Create、File.WriteAllText、File.ReadAllLines等，方便进行创建、读写和删除文件等基本操作。 3. 使用StreamReader和StreamWriter：当需要...
深入理解C#中的IO操作：File类的详解
最新发布
qq_35320456的博客
05-13 1397
File类位于System.IO命名空间中，它提供了静态方法，用于处理文件系统。这些方法可以用来读取、写入、创建、复制、移动和删除文件。由于File类是静态的，因此我们不需要创建它的实例就可以使用它的方法。File类是C#中进行文件操作的重要工具。通过掌握File类的常用方法，我们可以方便地进行文件的创建、读取、写入、复制、移动和删除等操作。在使用File类时，要注意处理异常，并合理地管理文件流，以确保文件操作的安全和高效。
【整理】C#文件操作大全(SamWang)
weixin_30652271的博客
02-27 698
【整理】C#文件操作大全(SamWang) 文件与文件夹操作主要用到以下几个类： 　　1.File类:　　 提供用于创建、复制、删除、移动和打开文件的静态方法，并协助创建FileStream对象。 　　　　msdn:http://msdn.microsoft.com/zh-cn/library/system.io.file(v=VS.80).aspx 　　2...
【.Net实用方法总结】 整理并总结System.IO中Directory类及其方法介绍
baidu_33146219的博客
08-17 1万+
博主针对.Net开发和C站问答过程中遇到的问题进行总结，形成本专栏，希望可以帮助到您解决问题。本文主要介绍System.IO命名空间的Directory 类，介绍其常用的方法和示例说明。
C#中Directory.GetFiles() 函数的使用方法(读取目录中的文件)
热门推荐
HsuanKeny的博客
09-28 7万+
转自:http://www.365jz.com/article/24023   C#中Directory.GetFiles(string path , string searchPattern, SearchOption searchOption ) 获取path目录中所有文件 注：红色字体部分为可选参数 参数 path 要搜索的目录的相对或绝对路径。此字符串不区分大小写。 sear...
Directory.GetFiles
weixin_34290390的博客
01-23 1438
http://blog.csdn.net/limlimlim/article/details/8260911 转载 https://msdn.microsoft.com/zh-cn/library/wz42302f.aspx 第一种方式 System.IO.Directory.GetFiles()获取多个类型格式的文件 System.IO.Directory.GetFiles("c:\","...
C#获取文件和文件名称
qq_24499417的博客
03-19 4426
使用System.IO里的Directory类.这是一个静态类，所以不需要new就能直接使用。 1.Directory.GetFiles 方法 Directory.GetFiles是一个重载的方法。可以直接提供文件夹的路径获取所在目录中文件,返回一个文件全名的字符串数组。 2个参数的里面,第二参数可以使用*和?通配符实现模糊匹配查找文件。注意这个参数是不支持正则表达式匹配的方式。 三参...
System.IO.Directory.Delete 方法的使用
weixin_30535843的博客
02-10 396
Directory有一个静态方法Delete用来删除指定的目录。它有两个重载版本，如下： 1.Delete(String path) 2.Delete(String path, Boolean recursive) 解释： 方法1：唯一一个参数path，就是要删除的目录的路径可以是相对的也可以是绝对的。（相对当前工作的路径，可参考GetCurrentDirectory）。这个方法...
C# System.IO.FileNotFoundException:未能加载文件或程序集xxx或它的某一个依赖项,系统找不到指定的文件2种情况解决
旭东怪的博客
12-18 3万+
问题描述： System.IO.FileNotFoundException:“未能加载文件或程序集“NSoup,Version=0.8.0.0,Culture=neutral,PublicKeyToken=6d44e53f0a65e802”或它的某一个依赖项。系统找不到指定的文件。 问题分析： 本人总结出了以下两种情况。 1、当前工程没有NSoup.dll程序集文件。 解决办法：将NSoup.dll文件复制到该工程的bin文件夹下。 2、当前工程的父级工程没有NSoup.dll程序集...
Linux常见问题及解决方案
liugan528的博客
06-10 7351
Linux常见问题及解决方案汇总，持续更新…… 1. 运行自己编译的程序时提示找不到.so文件 例如： ./mnist_caffe: error while loading shared libraries: libarmnn.so: cannot open shared object file: No such file ordirectory 出现该问题的原因是运行./mnist_ca..............................
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值