按行讀文件

核心代碼：

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>
        /// 結(jié)構(gòu)。硬盤信息
        /// </summary>
        private struct DiskInfo
        {
            //public string RootPathName;
            //每簇的扇區(qū)數(shù)
            public int SectorsPerCluster;
            //每扇區(qū)字節(jié)
            public int BytesPerSector;
            //public int NumberOfFreeClusters;
            //public int TotalNumberOfClusters;
        }

        //調(diào)用windows API獲取磁盤空閑空間
        //導(dǎo)入庫
        [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);
            //每簇的扇區(qū)數(shù)
            diskInfo.SectorsPerCluster = sectorsPerCluster;
            //每扇區(qū)字節(jié)
            diskInfo.BytesPerSector = bytesPerSector;
            return diskInfo;
        }

        /// <summary>
        /// 文件每簇的字節(jié)
        /// </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>
        /// 獲取總行數(shù) - 會重新創(chuàng)建文件流
        /// </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>
        /// 創(chuàng)建一個(gè)讀文件對象
        /// </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   "擴(kuò)展名的文件");
            }
        }
        /// <summary>
        /// 讀取Txt中的行到list中
        /// </summary>
        /// <param name="filterSame">是否過濾重復(fù)</param>
        /// <returns>Line List</returns>
        public List<string> ReadTxtToList(bool filterDuplicate)
        {
            List<string> lineList = null;
            string line = "";

            //判斷讀文件流是否為空
            if (sr != null)
            {
                //是否過濾重復(fù)
                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文件暫時(shí)不支持帶"，"的列
        /// </summary>
        /// <param name="nReadColumn">讀取第幾行</param>
        /// <param name="filterDuplicate">是否過濾重復(fù)</param>
        /// <returns>返回List</returns>
        public List<string> ReadCsvToList(int nReadColumn, bool filterDuplicate)
        {
            List<string> filedList = null;
            string[] splitTest = null;
            //判斷讀文件流是否為空
            if (sr != null)
            {
                //是否過濾重復(fù)
                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">是否過濾重復(fù)</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)
            {
                //是否過濾重復(fù)
                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 = "出錯(cuò)啦";
                            }
                        }
                    }
                }
                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 = "出錯(cuò)啦";
                            }
                        }
                    }
                }
            }
            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>
        /// 關(guān)閉流
        /// </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();
        }
    }
}