基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：78630559

本次赞助数额为： 2 元　

支付宝支付

微信支付

   源码介绍

---

按行读文件

核心代码：

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
namespace Junior.Utils
{
    class FileReader : IDisposable
    {
        private string fileExt = null;
        private FileStream fs = null;
        private StreamReader sr = null;
        private string path = string.Empty;
        private Encoding encode = Encoding.Default;
        private FileInfo fileInfo = null;
        private bool eof;
        

        #region FileSize
        /// <summary>
        /// 文件大小
        /// </summary>
        public long FileSize
        {
            get
            {
                if (fileInfo != null)
                    return fileInfo.Length;
                fileInfo = new FileInfo(path);
                return fileInfo.Length;
            }

        } 
        #endregion


        #region FileClusterSize
        //// <summary>
        /// 结构。硬盘信息
        /// </summary>
        private struct DiskInfo
        {
            //public string RootPathName;
            //每簇的扇区数
            public int SectorsPerCluster;
            //每扇区字节
            public int BytesPerSector;
            //public int NumberOfFreeClusters;
            //public int TotalNumberOfClusters;
        }

        //调用windows API获取磁盘空闲空间
        //导入库
        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        static extern bool GetDiskFreeSpace([MarshalAs(UnmanagedType.LPTStr)]string rootPathName,
        ref int sectorsPerCluster, ref int bytesPerSector, ref int numberOfFreeClusters, ref int totalNumbeOfClusters);

        private DiskInfo GetDiskInfo(string rootPathName)
        {

            DiskInfo diskInfo = new DiskInfo();
            int sectorsPerCluster = 0, bytesPerSector = 0, numberOfFreeClusters = 0, totalNumberOfClusters = 0;
            GetDiskFreeSpace(rootPathName, ref sectorsPerCluster, ref bytesPerSector, ref numberOfFreeClusters, ref totalNumberOfClusters);
            //每簇的扇区数
            diskInfo.SectorsPerCluster = sectorsPerCluster;
            //每扇区字节
            diskInfo.BytesPerSector = bytesPerSector;
            return diskInfo;
        }

        /// <summary>
        /// 文件每簇的字节
        /// </summary>
        public long FileClusterSize
        {
            get
            {
                long clusterSize = 0;
                DiskInfo diskInfo = new DiskInfo();
                diskInfo = GetDiskInfo(fileInfo.Directory.Root.FullName);
                clusterSize = (diskInfo.BytesPerSector * diskInfo.SectorsPerCluster);
                return clusterSize;
            }
        } 
        #endregion

        public long FileSizeOnDisk
        {
            get 
            {
                long temp = 0;
                long clusterSize = FileClusterSize;
                if (fileInfo.Length % clusterSize != 0)
                {
                    decimal res = fileInfo.Length / clusterSize;
                    int clu = Convert.ToInt32(Math.Ceiling(res))   1;
                    temp = clusterSize * clu;
                }
                else
                {
                    return fileInfo.Length;
                }
                return temp;
            }
        }

        public bool EOF
        {
            
            get
            {
                try { return sr.EndOfStream; }
                catch { eof = true; return eof; }
            }
        }
        /// <summary>
        /// 获取总行数 - 会重新创建文件流
        /// </summary>
        public int TotalLines
        {
            get
            {
                using (FileStream tempfs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                {
                    int count = 0;

                    using (StreamReader tempsr = new StreamReader(tempfs, encode))
                    {

                        while (!tempsr.EndOfStream)
                        {
                            count  ;
                            tempsr.ReadLine();
                        }
                    }

                    return count;
                }
            }
        }
        /// <summary>
        /// 创建一个读文件对象
        /// </summary>
        /// <param name="path"></param>
        public FileReader(string path)
        {
            try
            {
                this.path = path;
                fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                sr = new StreamReader(fs, Encoding.Default);
                fileExt = Path.GetExtension(path);
                fileInfo = new FileInfo(path);
            }
            catch
            {
                throw new FileNotFoundException("文件未找到");
            }
        }
        public FileReader(string path, Encoding encoding)
        {
            try
            {
                this.path = path;
                encode = encoding;
                fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                sr = new StreamReader(fs, encoding);
                fileExt = Path.GetExtension(path);
                fileInfo = new FileInfo(path);
            }
            catch
            {
                throw new FileNotFoundException("文件未找到");
            }
        }

        public List<string> AutoReadToList(bool filterDuplicate)
        {
            switch (fileExt)
            {
                case ".txt": return this.ReadTxtToList(filterDuplicate);
                case ".csv": return this.ReadCsvToList(0, filterDuplicate);
                default: throw new Exception("不能读取"   fileExt   "扩展名的文件");
            }
        }
        /// <summary>
        /// 读取Txt中的行到list中
        /// </summary>
        /// <param name="filterSame">是否过滤重复</param>
        /// <returns>Line List</returns>
        public List<string> ReadTxtToList(bool filterDuplicate)
        {
            List<string> lineList = null;
            string line = "";

            //判断读文件流是否为空
            if (sr != null)
            {
                //是否过滤重复
                if (filterDuplicate)
                {
                    lineList = new List<string>();
                    while (!sr.EndOfStream)
                    {
                        line = sr.ReadLine();
                        if (line.Trim().Length > 0)
                            if (!lineList.Contains(line))
                            {
                                lineList.Add(line);
                            }
                    }
                }
                else
                {
                    lineList = new List<string>();
                    while (!sr.EndOfStream)
                    {
                        line = sr.ReadLine();
                        if (line.Trim().Length > 0)
                            lineList.Add(line);
                    }
                }
            }
            line = null;
            return lineList;
        }
        /// <summary>
        /// 读取Csv文件暂时不支持带"，"的列
        /// </summary>
        /// <param name="nReadColumn">读取第几行</param>
        /// <param name="filterDuplicate">是否过滤重复</param>
        /// <returns>返回List</returns>
        public List<string> ReadCsvToList(int nReadColumn, bool filterDuplicate)
        {
            List<string> filedList = null;
            string[] splitTest = null;
            //判断读文件流是否为空
            if (sr != null)
            {
                //是否过滤重复
                if (filterDuplicate)
                {
                    filedList = new List<string>();
                    while (!sr.EndOfStream)
                    {
                        splitTest = sr.ReadLine().Split(',');
                        if (splitTest[nReadColumn].Trim().Length > 0)
                            if (!filedList.Contains(splitTest[nReadColumn]))
                                filedList.Add(splitTest[nReadColumn]);
                    }
                }
                else
                {
                    filedList = new List<string>();
                    while (!sr.EndOfStream)
                    {
                        splitTest = sr.ReadLine().Split(',');
                        if (splitTest[nReadColumn].Trim().Length > 0)
                            filedList.Add(splitTest[nReadColumn]);
                    }
                }
            }
            splitTest = null;
            return filedList;
        }

        /// <summary>
        /// 读Txt文件中的链接到Dictionary中按照域名分组
        /// </summary>
        /// <param name="filterDuplicate">是否过滤重复</param>
        /// <returns>Dictionary按照域名分组后的对象</returns>
        public Dictionary<string, List<string>> ReadTXTFileToDictionaryWithDomain(bool filterDuplicate)
        {
            Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>();
            Uri uri = null;
            string line = "";
            //判断读文件流是否为空
            if (sr != null)
            {
                //是否过滤重复
                if (filterDuplicate)
                {
                    while (!sr.EndOfStream)
                    {
                        line = sr.ReadLine();
                        if (line.Trim().Length > 0)
                        {
                            try
                            {
                                uri = new Uri(line);

                                if (dictionary.ContainsKey(uri.Host))
                                {
                                    if (!dictionary[uri.Host].Contains(line))
                                    {
                                        dictionary[uri.Host].Add(line);
                                    }
                                }
                                else
                                {
                                    dictionary.Add(uri.Host, new List<string>());
                                    dictionary[uri.Host].Add(line);
                                }
                            }
                            catch
                            {
                                //string msg = "出错啦";
                            }
                        }
                    }
                }
                else
                {
                    while (!sr.EndOfStream)
                    {
                        line = sr.ReadLine();
                        if (line.Trim().Length > 0)
                        {
                            try
                            {
                                uri = new Uri(line);
                                if (dictionary.ContainsKey(uri.Host))
                                {
                                    dictionary[uri.Host].Add(line);
                                }
                                else
                                {
                                    dictionary.Add(uri.Host, new List<string>());
                                    dictionary[uri.Host].Add(line);
                                }
                            }
                            catch
                            {
                                //string msg = "出错啦";
                            }
                        }
                    }
                }
            }
            line = null;
            return dictionary;
        }
        public string ReadTXTLine()
        {
            if (!sr.EndOfStream)
            {
                return sr.ReadLine();
            }
            return null;
        }
        public string ReadToEnd()
        {
            if (!sr.EndOfStream)
            {
                return sr.ReadToEnd();
            }
            return null;
        }
        /// <summary>
        /// 关闭流
        /// </summary>
        public void Close()
        {
            if (this.sr != null) sr.Close();
            if (this.fs != null) fs.Close();
        }
        /// <summary>
        /// 释放此对象引用的所有资源
        /// </summary>
        public void Dispose()
        {
            if (this.sr != null) sr.Close();
            if (this.fs != null) fs.Close();
            if (this.sr != null) sr.Dispose();
            if (this.fs != null) fs.Dispose();
        }
    }
}