`

C#对文件、文件夹、Xml等操作

    博客分类：
  • C#
 
阅读更多 
 /// <summary>
    /// 对文件操作类
    /// </summary>
    public class FileOperat
    {
        /// <summary>
        /// 删除指定文件
        /// </summary>
        /// <param name="fileFullPath">要删除的文件路径</param>
        /// <returns>true/false</returns>
        public bool DeleteFile(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                if (File.GetAttributes(fileFullPath) == FileAttributes.Normal)//判断文件的属性，属于正常状态
                {
                    File.Delete(fileFullPath);
                }
                else
                {
                    File.SetAttributes(fileFullPath, FileAttributes.Normal);
                    File.Delete(fileFullPath);
                }
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 获取文件名
        /// </summary>
        /// <param name="fileFullPath">文件全路径</param>
        /// <returns>文件名</returns>
        public string GetFileName(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                FileInfo file = new FileInfo(fileFullPath);
                return file.Name;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 获取文件名
        /// </summary>
        /// <param name="fileFullPath">文件全路径</param>
        /// <param name="includingFileExtension">是否包含扩展名</param>
        /// <returns>string</returns>
        public string GetFileName(string fileFullPath, bool includingFileExtension)
        {
            if (File.Exists(fileFullPath))
            {
                FileInfo fileInfo = new FileInfo(fileFullPath);
                if (includingFileExtension == true)
                {
                    return fileInfo.Name;
                }
                else
                {
                    return fileInfo.Name.Replace(fileInfo.Extension, "");
                }
            }
            else
            {
                return null;
            }
        }


        /// <summary>
        /// 获取文件扩展名
        /// </summary>
        /// <param name="fileFullPath">文件全路径</param>
        /// <returns>string</returns>
        public string GetFileExtension(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                FileInfo fileInfo = new FileInfo(fileFullPath);
                return fileInfo.Extension;
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 根据传来的文件全路径,获取新的文件名称全路径(不存在),一般用如临时文件
        /// </summary>
        /// <param name="fileFullPath">文件名称全路径</param>
        /// <returns>新的文件名称全路径</returns>
        public string GetNewFileFullName(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                string TempFile = "";
                FileInfo fileInfo=new FileInfo(fileFullPath);
                for (int i = 0; i < 1000; i++)
                {
                    TempFile = fileInfo.Name.Replace(fileInfo.Extension, "");
                    fileFullPath = TempFile + i.ToString() + fileInfo.Extension;
                    if (File.Exists(fileFullPath))
                    {
                        break; //如果文件存在，中断循环
                    }
                }
            }
            return fileFullPath;
        }

        /// <summary>
        /// 打开文件
        /// </summary>
        /// <param name="fileFullPath"></param>
        /// <returns></returns>
        public bool OpenFile(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                System.Diagnostics.Process.Start(fileFullPath);
                return true;
            }
            else
            {
                return false;
            }
        }


        /// <summary>
        /// 得到文件的大小
        /// </summary>
        /// <param name="fileFullPath">文件全路径</param>
        /// <returns>string</returns>
        public string GetFileLength(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                FileInfo fileInfo = new FileInfo(fileFullPath);
                long f = fileInfo.Length;
                //KB MB GB TB
                if (f > 1024 * 1024 * 1024)//GB
                {
                    return Convert.ToString(Math.Round((f + 0.00) / (1024 * 1024 * 1024), 2)) + "GB";
                }
                if (f > 1024 * 1024) //MB
                {
                    return Convert.ToString(Math.Round((f + 0.00) / (1024 * 1024), 2)) + "MB";
                }
                else
                {
                    return Convert.ToString(Math.Round((f + 0.00) / 1024,2)) + "KB";
                }
            }
            else
            {
                return null;
            }
        }

        /// <summary>
        /// 文件转换成二进制流
        /// </summary>
        /// <param name="fileFullPath">要转换的文件全路径</param>
        /// <returns> Byte[] </returns>
        /// <remarks></remarks>
        public Byte[] FileToStreamByte(string fileFullPath)
        {
            Byte[] fileData = null;
            if (File.Exists(fileFullPath))
            {
                FileStream fs = new FileStream(fileFullPath, System.IO.FileMode.Open);
                fileData = new Byte[fs.Length];
                fs.Read(fileData, 0, fileData.Length);
                fs.Close();
                return fileData;
            }
            else
            {
                return null;
            }
        }



        /// <summary>
        /// 从二进制转换成文件
        /// </summary>
        /// <param name="createFileFullPath">要转换的文件全路径</param>
        /// <param name="streamByte">二进制流</param>
        /// <returns>True/False</returns>
        /// <remarks>True/False</remarks>
        public bool ByteSteramToFile(string createFileFullPath, Byte[] streamByte)
        {
            try
            {
                FileStream fs = null;
                if (File.Exists(createFileFullPath)) //如果文件存在，先删除
                {
                    DeleteFile(createFileFullPath);
                }
                fs = File.Create(createFileFullPath);
                fs.Write(streamByte,0, streamByte.Length);
                fs.Close();
                return true;
            }
            catch 
            {
                return false;
            }
        }


        /// <summary>
        /// 序列化Xml文件
        /// </summary>
        /// <param name="fileFullPath">要序列化的xml文件路径</param>
        /// <returns>True/False</returns>
        public bool SerializeXmlFile(string fileFullPath)
        {
            System.Data.DataSet ds = new System.Data.DataSet();
            if (File.Exists(fileFullPath))
            {
                try
                {
                    ds.ReadXml(fileFullPath);
                    FileStream fs = new FileStream(fileFullPath + ".tmp", FileMode.OpenOrCreate);
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter BF = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    BF.Serialize(fs, ds);//序例化ds,并将结果赋给fs
                    fs.Close();
                    DeleteFile(fileFullPath);//删除传入的xml文件
                    File.Move(fileFullPath + ".tmp", fileFullPath);//将序列化后的文件改为原来的Xml文件
                    return true;
                }
                catch 
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
         
        }

        /// <summary>
        /// 反序列化Xml
        /// </summary>
        /// <param name="fileFullPath">反序列化的Xml文件路径</param>
        /// <returns>True/False</returns>
        /// <remarks></remarks>
        public bool DescSerializeXmlFile(string fileFullPath)
        {
            if (File.Exists(fileFullPath))
            {
                try
                {
                    System.Data.DataSet ds = new System.Data.DataSet();
                    FileStream fs = new FileStream(fileFullPath, FileMode.Open);//打开xml文件,将内容读入到流中
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter BF = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    object descSeriResult = BF.Deserialize(fs);//反序列化
                    ((System.Data.DataSet)descSeriResult).WriteXml(fs + ".tmp");
                    fs.Close();//关闭流
                    DeleteFile(fileFullPath);//删除传入的xml文件
                    File.Move(fileFullPath + ".tmp", fileFullPath);//将反序列化后的文件改名传入的xml文件
                    return true;
                }
                catch 
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
    }


    /// <summary>
    /// 对文件目录操作的公共组件
    /// </summary>
    public class DirOperate
    {
        public enum OperateOption
        {
            /// <summary>
            /// 文件夹存在时删除
            /// </summary>
            ExistDelete,
            /// <summary>
            /// 文件夹存在时返回
            /// </summary>
            ExistReturn
        }

        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="dirFullPath">文件夹路径</param>
        /// <param name="dirOperateOption">文件夹操作选项</param>
        /// <returns>True/False</returns>
        public bool CreateDirOperate(string dirFullPath, OperateOption dirOperateOption)
        {
            try
            { 
                if (!Directory.Exists(dirFullPath))
                {
                    Directory.CreateDirectory(dirFullPath);
                }
                else if (dirOperateOption == OperateOption.ExistDelete)
                {
                    Directory.Delete(dirFullPath,true);
                    Directory.CreateDirectory(dirFullPath);
                }
                return true;
            }
            catch 
            {
                return false;
            }
        }

        /// <summary>
        /// 删除文件夹操作
        /// </summary>
        /// <param name="dirFullPath">文件夹路径</param>
        /// <returns>True/False</returns>
        public bool DeleteDirOperate(string dirFullPath)
        {
            if (Directory.Exists(dirFullPath))
            {
                Directory.Delete(dirFullPath, true);
                return true;
            }
            else
            {
                return false;
            }
        }


        /// <summary>
        /// 得到文件夹下的所有文件，不包含子文件夹
        /// </summary>
        /// <param name="dirFullPath">文件夹路径</param>
        /// <returns>string[]</returns>
        /// <remarks></remarks>
        public string[] GetDirFiles(string dirFullPath)
        {
            string[] fileList = null;
            if (Directory.Exists(dirFullPath))
            {
                return fileList = Directory.GetFiles(dirFullPath, "*.*", SearchOption.TopDirectoryOnly);

            }
            else
            {
                return null;
            }
        }


        /// <summary>
        /// 得到文件夹下的所有文件，按指定的搜索模式
        /// </summary>
        /// <param name="dirFullPath">文件夹路径</param>
        /// <param name="so">搜索类型</param>
        /// <returns>string[]</returns>
        /// <remarks></remarks>
        public string[] GetDirFiles(string dirFullPath,SearchOption so)
        {
            string[] fileList = null;
            if (Directory.Exists(dirFullPath))
            {
                return fileList = Directory.GetFiles(dirFullPath, "*.*",so);

            }
            else
            {
                return null;
            }
        }


        /// <summary>
        /// 得到文件夹下所有与文件类型匹配的文件
        /// </summary>
        /// <param name="dirFullPath">文件夹路径</param>
        /// <param name="SearchPattern">文件类型</param>
        /// <returns></returns>
        public string[] GetDirFiles(string dirFullPath,string SearchPattern)
        {
            string[] fileList = null;
            if (Directory.Exists(dirFullPath))
            {
                return fileList = Directory.GetFiles(dirFullPath, SearchPattern);

            }
            else
            {
                return null;
            }
        }


        /// <summary>
        /// 得到文件夹下所有文件
        /// </summary>
        /// <param name="dirFullPath">文件夹路径</param>
        /// <param name="SearchPattern">文件类型</param>
        /// <param name="so">搜索类型</param>
        /// <returns>string[]</returns>
        /// <remarks></remarks>
        public string[] GetDirFiles(string dirFullPath, string SearchPattern,SearchOption so)
        {
            string[] fileList = null;
            if (Directory.Exists(dirFullPath))
            {
                return fileList = Directory.GetFiles(dirFullPath, SearchPattern,so);

            }
            else
            {
                return null;
            }
        }

    }
分享到：
| TreeView控件操作开发篇之（三）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    C#操作XMl 三种方法 包括对读取入库

    本篇文章将详细介绍C#处理XML的三种方法，包括读取XML数据、对数据库进行操作以及修改XML节点。 首先，我们来探讨第一种方法：读取XML文件。在C#中，我们可以使用System.Xml命名空间下的类来实现这一功能。最常用的...

    C# 遍历文件夹文件写成xml

    在C#编程中，当你需要处理文件系统操作，如遍历文件夹并将其内容结构化存储时，XML是一种常见的选择。XML（可扩展标记语言）提供了数据的结构化表示，便于存储、检索和处理。本示例将详细介绍如何在Windows Forms...

    创建文件夹和xml文件并行xml文件中添加信息

    在编程领域中，创建文件夹是一项基本操作，尤其是在处理文件系统时。本例中的代码示例展示了如何使用C#语言创建多级目录结构。 #### 代码分析 ```csharp /// /// 创建路径 /// /// 存储信息的路径 /// 创建的路径...

    C# 根据XML存储的文件夹信息读取文件夹路径

    在C#编程中，我们经常需要处理文件和文件夹的操作，包括读取、写入、创建、删除等。在这个特定的场景中，我们要讨论的是如何根据XML文件存储的文件夹信息来读取相应的文件夹路径。这个过程通常分为两个主要步骤：...

    c#将XML文档保存到指定的文件

    根据给定的信息，本文将详细解释如何使用C#编程语言将XML文档保存到指定的文件。此示例涉及的关键概念包括XML文档操作、C#基本语法、事件处理以及Web应用程序中的页面生命周期管理。 ### 一、理解XML文档 XML...

    C# winform xml文件的拼插

    综上所述，C# WinForm应用中的XML文件拼插涉及到XML文件的读取、节点操作以及文件保存，通过System.Xml命名空间的类，我们可以高效地完成这个任务。对于大量XML文件的拼插，合理的设计和优化会显得尤为重要。

    C# 读取文件名构造XML文件并生成Tree

    综上所述，这个项目涵盖了文件操作、XML处理、数据绑定到UI控件以及事件驱动编程等重要概念。通过理解并实践这些知识点，开发者可以创建出一个功能丰富的应用程序，能够以可视化的方式管理和交互文件系统内容。

    系统文件管理和对XML文件操作管理

    总结来说，C#提供了强大的文件和文件夹管理以及XML操作功能，使得开发者能够轻松地实现各种文件相关的任务。通过结合WinForms，我们可以创建用户友好的界面，进一步提升用户体验。在"WindowsFormsApplication1"项目...

    C#批量创建文件夹并设置访问权限实例

    1. **C#文件系统操作** C#提供了丰富的类库用于文件和文件夹的操作，主要集中在`System.IO`命名空间下。例如，`Directory`类用于处理目录操作，如创建、删除、移动等；`FileInfo`类则用于文件操作。 2. **批量创建...

    C# 批量删除文件，文件夹源代码

    综上所述，这个“C# 批量删除文件，文件夹源代码”项目涵盖了文件系统操作、异常处理、用户界面设计等多个关键的C#编程知识点，是学习和实践这些技能的好例子。通过理解并运用这些原理，开发者可以创建出更强大、更...

    C#操作XML文件完整源码{201903}

    C#是微软开发的一种面向对象的编程语言，它提供了丰富的库支持对XML文件的操作。本教程将深入探讨如何使用C#进行XML文件的读取、写入、解析和修改。 首先，我们要了解C#中的System.Xml命名空间，它是处理XML文档的...

    C# EmguCV 人脸识别 训练库文件 xml

    "haarcascades"文件夹中的文件，通常是`.xml`格式，存储了这些经过训练的级联分类器参数。这些XML文件是预训练的模型，可以用来检测图像中的人脸。它们包含了多级特征（Haar特征），每一级都由一些矩形组成，这些...

    c#创建不可打开的文件夹

    C#中的`System.IO`命名空间提供了对文件和文件夹的访问权限管理。你可以使用`DirectoryInfo`类和`FileSystemAccessRule`类来设置特定用户的访问权限。 2. **创建文件夹**：首先，你需要使用`System.IO.Directory....

    Winform C# 从省市区的xml文件中读取的三级联动下拉选项实现

    在本文中，我们将深入探讨如何使用C# Winform来实现一个从XML文件中读取的省市区三级联动下拉选项。这个功能对于许多需要展示地理位置信息的桌面应用程序来说非常实用。我们将详细介绍整个过程，包括XML文件的结构、...

    亲测有效，C#通过配置文件，线程定时递归删除文件夹下所有文件，包括子文件夹中的文件，log4net记录删除日志

    在C#中，我们可以使用`System.Configuration`命名空间来读取和操作XML格式的配置文件。配置文件通常包含程序的设置，如定时任务的间隔时间、待删除的文件夹路径等。 **递归删除文件夹**在C#中可以通过`System.IO`...

    c#操作properties，读写配置文件

    ### C#操作Properties，读写配置文件 在C#编程中，经常需要处理应用程序的配置信息，例如数据库连接字符串、用户界面的语言设置等。这些配置信息通常存储在配置文件中，便于程序运行时动态加载和修改。C#提供了一种...

    C#开发Android 手机浏览文件夹等完整源码(使用Mono技术基于vs2010开发)

    综上所述，本项目涵盖了C#编程、Mono for Android框架、Visual Studio 2010 IDE的使用，以及Android平台的文件系统操作、权限管理、UI设计和组件交互等多个知识点。开发者通过学习和实践这个项目，不仅可以提升C#在...

    C# 基于XML实现增删改查 开发架构

    C#提供了丰富的类库，如System.Xml命名空间下的XmlNode、XmlElement、XmlDocument等，用于读写和操作XML文档。开发者可以通过这些类来创建XML结构，读取XML文件内容，修改XML节点，以及删除不需要的元素。例如，使用...

    c#系统监控软件,可以监控全盘文件及其子文件夹2019

    5. **文件I/O操作**：为了读取、写入或修改文件，C#提供了丰富的System.IO命名空间，包括File、Directory、FileInfo、DirectoryInfo等类，用于处理各种文件和目录操作。 6. **权限与安全性**：由于系统监控涉及到...

    C#实现的简单文件备份工具

    总之，这个C#实现的文件备份工具综合运用了文件操作、压缩技术、配置管理、系统托盘交互等多个C#核心知识点，是一个实用的桌面应用程序示例。开发者通过学习和理解这些技术，可以进一步提升在C#环境下的软件开发能力...

Magicbox
Global site tag (gtag.js) - Google Analytics