使用 C# 解析文本文件

Question

寻找一种解析此文本文件的好方法，使用 C# 用黄色框突出显示值。每个部分都由一个我忘记突出显示的术语# 来描述。尝试过这个：

string fileName = "ATMTerminalTotals.txt";
StreamReader sr = new StreamReader(fileName);
string[] delimiter = new string[] { " " };
while (!sr.EndOfStream)
{
     string[] lines = sr.ReadLine().Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
     foreach (string line in lines)
     {
         Console.WriteLine(line);
     }
}
Console.ReadLine();

可以肯定地说我正在正确阅读行并删除“空格”。尽管作为编程的业余爱好者，不确定是否有有效的方法来准确地“知道”我正在从这份报告中获取我需要的值。有什么建议吗？

Answer 1

我已经用一个非常简单的程序来测试这个来解析给定的文件，
基本上我创建了两个基本类，一个页面类包含终端报告类的集合（tran 类型行）
这些行甚至可以表示为事务和计费类，

首先解析数据，设置所需的参数，最后只是访问属性，

只是让它尽可能简单，没有错误处理等...它只是为了给出你知道我是如何开始解决这类任务的，希望它能帮助

亚当

namespace TerminalTest
{
    class Program
    {
        public class TerminalReport
        {
            public string Word { get; set; }

            public int Denials { get; set; }

            public int Approvals { get; set; }

            public int Reversals { get; set; }

            public double Amount { get; set; }

            public int ON_US { get; set; }

            public int Alphalink { get; set; }

            public int Interchange { get; set; }

            public int Surcharged { get; set; }

            public static TerminalReport FromLine(string line)
            {
                TerminalReport report = new TerminalReport();
                report.Word = line.Substring(0, 11);
                line = line.Replace(report.Word, string.Empty).Trim();
                string[] split = line.Split(' ');
                int i = 0;
                // transaction summary
                report.Denials = int.Parse(split[i++]);
                report.Approvals = int.Parse(split[i++]);
                report.Reversals = int.Parse(split[i++]);
                report.Amount = double.Parse(split[i++]);
                // billing counts
                report.ON_US = int.Parse(split[i++]);
                report.Alphalink = int.Parse(split[i++]);
                report.Interchange = int.Parse(split[i++]);
                report.Surcharged = int.Parse(split[i++]);

                return report;
            }
        }

        public class TerminalPage
        {
            public int PageNumber { get; set; }

            public double TotalSurcharges { get; set; }

            public List<TerminalReport> Rows { get; set; }

            public TerminalPage(int num)
            {
                PageNumber = num;
                Rows = new List<TerminalReport>();
            }

            public int TotalDenials
            {
                get
                {
                    return rows.Sum(r => r.Denials);
                }
            }

            public int TotalApprovals
            {
                get
                {
                    return Rows.Sum(r => r.Approvals;
                }
            }

            public int TotalReversals
            {
                get
                {
                    return Rows.Sum(r => r.Reversals;
                }
            }

            public double TotalAmount
            {
                get
                {
                    return Rows.Sum(r => r.Amount);
                }
            }

            public int TotalON_US
            {
                get
                {
                    return Rows.Sum(r => r.ON_US);
                }
            }

            public int TotalAlphalink
            {
                get
                {
                     return Rows.Sum(r => r.Alphalink);
                }
            }

            public int TotalInterchange
            {
                get
                {
                     return Rows.Sum(r => r.Interchange);
                }
            }

            public int TotalSurcharged
            {
                get
                {
                     return Rows.Sum(r => r.Surcharged);
                }
            }
        }

        private static string CleanString(string text)
        {
            return Regex.Replace(text, @"\s+", " ").Replace(",", string.Empty).Trim();
        }

        private static List<TerminalPage> ParseData(string filename)
        {
            using (StreamReader sr = new StreamReader(File.OpenRead(filename)))
            {
                List<TerminalPage> pages = new List<TerminalPage>();

                int pageNumber = 1;
                TerminalPage page = null;
                bool parse = false;
                while (!sr.EndOfStream)
                {
                    string line = sr.ReadLine();
                    line = CleanString(line);
                    if (line.StartsWith("TRAN TYPE"))
                    {
                        // get rid of the ----- line
                        sr.ReadLine();

                        parse = true;
                        if (page != null)
                        {
                            pages.Add(page);
                        }
                        page = new TerminalPage(pageNumber++);
                    }
                    else if (line.StartsWith("="))
                    {
                        parse = false;
                    }
                    else if (line.StartsWith("TOTAL SURCHARGES:"))
                    {
                        line = line.Replace("TOTAL SURCHARGES:", string.Empty).Trim();
                        page.TotalSurcharges = double.Parse(line);
                    }
                    else if (parse)
                    {
                        TerminalReport r = TerminalReport.FromLine(line);
                        page.Rows.Add(r);
                    }
                }
                if (page != null)
                {
                    pages.Add(page);
                }

                return pages;
            }
        }

        static void Main(string[] args)
        {
            string filename = @"C:\bftransactionsp.txt";
            List<TerminalPage> pages = ParseData(filename);

            foreach (TerminalPage page in pages)
            {
                Console.WriteLine("TotalSurcharges: {0}", page.TotalSurcharges);
                foreach (TerminalReport r in page.Rows)
                        Console.WriteLine(r.Approvals);

            }
        }
    }
}

Answer 2

我不确定我实际上会用空格将其分割。文本文件看起来像是分割成列。您可能想一次读取 10 个字符（或任何列的宽度）...我会将整个文件解析到字典中，这样您就可以获得像这样的条目

dict["WDL FRM CHK"]["# DENIALS"] = 236

，然后您可以轻松地从中检索您想要的值在那里，如果你将来需要更多的价值，你已经得到了它们。

---

或者，您可以使用正则表达式。您可以使用正则表达式获取第一个值，例如

^WDL FRM CHK\s+(?<denials>[0-9,]+)\s+(?<approvals>[0-9,]+)$

使用

m.Groups["approvals"]

Answer 3

无论如何，我建议您使用 using 块包装您的 StreamReader：

using (StreamReader sr = new StreamReader(fileName))
{
    // do stuff
}

阅读 MSDN

Answer 4

鉴于它似乎有一个标准的常规格式，我会使用正则表达式。您可以检查起始代码以找出您所在的行，然后解析数字并忽略空格的表达式很可能比手动处理更容易。

Answer 5

using System;
using System.Text.RegularExpressions;

namespace ConsoleApplication3
{
  class Program
  {
    static void Main(string[] args)
    {
      Regex exp = new Regex(@"WDL FRM CHK(\s)+[1-9,]+(\s)+(?<approvals>[1-9,]+)(\s)+");
      string str = "WDL FRM CHK   236   1,854   45,465  123     3";
      Match match = exp.Match(str);

      if (match.Success)
      {
        Console.WriteLine("Approvals: " + match.Groups["approvals"].Value);
      }

      Console.ReadLine();
    }
  }
}

改编自以下文章以解析您的一个号码：

• 如何匹配模式通过使用正则表达式和 Visual C#