761 lines
28 KiB
C#
761 lines
28 KiB
C#
using Entities.DTO;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text.RegularExpressions;
|
||
|
||
namespace TechHelper.Client.Exam
|
||
{
|
||
// --- 新增错误处理相关类 ---
|
||
public class ParseError
|
||
{
|
||
public ParseErrorType Type { get; }
|
||
public string Message { get; }
|
||
public int? Index { get; } // 错误发生的文本索引或匹配项索引
|
||
public string MatchedText { get; } // 如果与某个匹配项相关，记录其文本
|
||
public Exception InnerException { get; } // 捕获到的原始异常
|
||
|
||
public ParseError(ParseErrorType type, string message, int? index = null, string matchedText = null, Exception innerException = null)
|
||
{
|
||
Type = type;
|
||
Message = message;
|
||
Index = index;
|
||
MatchedText = matchedText;
|
||
InnerException = innerException;
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
var sb = new System.Text.StringBuilder();
|
||
sb.Append($"[{Type}] {Message}");
|
||
if (Index.HasValue) sb.Append($" (Index: {Index.Value})");
|
||
if (!string.IsNullOrEmpty(MatchedText)) sb.Append($" (MatchedText: '{MatchedText}')");
|
||
if (InnerException != null) sb.Append($" InnerException: {InnerException.Message}");
|
||
return sb.ToString();
|
||
}
|
||
}
|
||
|
||
public enum ParseErrorType
|
||
{
|
||
Validation = 1, // 输入验证失败
|
||
DataParsing = 2, // 数据解析失败（如数字转换）
|
||
Structural = 3, // 结构性问题（如选项没有对应的问题）
|
||
RegexMatchIssue = 4, // 正则表达式匹配结果不符合预期
|
||
UnexpectedError = 5 // 未预料到的通用错误
|
||
}
|
||
|
||
|
||
public class ExamPaper
|
||
{
|
||
public string AssignmentTitle { get; set; } = "未识别试卷标题";
|
||
public string Description { get; set; } = "未识别试卷描述";
|
||
public string SubjectArea { get; set; } = "试卷类别";
|
||
public List<MajorQuestionGroup> QuestionGroups { get; set; } = new List<MajorQuestionGroup>();
|
||
public List<PaperQuestion> TopLevelQuestions { get; set; } = new List<PaperQuestion>();
|
||
public List<ParseError> Errors { get; set; } = new List<ParseError>();
|
||
}
|
||
|
||
public class MajorQuestionGroup
|
||
{
|
||
public string Title { get; set; } = string.Empty;
|
||
public string Descript { get; set; } = string.Empty;
|
||
public float Score { get; set; }
|
||
public List<MajorQuestionGroup> SubQuestionGroups { get; set; } = new List<MajorQuestionGroup>();
|
||
public List<PaperQuestion> SubQuestions { get; set; } = new List<PaperQuestion>();
|
||
public int Priority { get; set; }
|
||
public bool bGroup { get; set; } = true;
|
||
}
|
||
|
||
public class PaperQuestion
|
||
{
|
||
public string Number { get; set; } = string.Empty;
|
||
public string Stem { get; set; } = string.Empty;
|
||
public float Score { get; set; }
|
||
public List<Option> Options { get; set; } = new List<Option>();
|
||
public List<PaperQuestion> SubQuestions { get; set; } = new List<PaperQuestion>();
|
||
public string SampleAnswer { get; set; } = string.Empty;
|
||
public string QuestionType { get; set; } = string.Empty;
|
||
public int Priority { get; set; }
|
||
}
|
||
|
||
public class Option
|
||
{
|
||
public string Label { get; set; } = string.Empty;
|
||
public string Text { get; set; } = string.Empty;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 表示一个带有优先级的正则表达式配置
|
||
/// </summary>
|
||
public class RegexPatternConfig
|
||
{
|
||
public string Pattern { get; set; } // 正则表达式字符串
|
||
public int Priority { get; set; } // 优先级，数字越小优先级越高
|
||
public Regex Regex { get; private set; } // 编译后的Regex对象，用于性能优化
|
||
|
||
public RegexPatternConfig(string pattern, int priority)
|
||
{
|
||
Pattern = pattern;
|
||
Priority = priority;
|
||
Regex = new Regex(pattern, RegexOptions.Multiline | RegexOptions.Compiled); // 多行模式，编译以提高性能
|
||
}
|
||
}
|
||
|
||
public enum ExamParserEnum
|
||
{
|
||
MajorQuestionGroupPatterns = 0,
|
||
QuestionPatterns,
|
||
OptionPatterns
|
||
}
|
||
|
||
/// <summary>
|
||
/// 试卷解析的配置类，包含所有正则表达式
|
||
/// </summary>
|
||
public class ExamParserConfig
|
||
{
|
||
public List<RegexPatternConfig> MajorQuestionGroupPatterns { get; set; } = new List<RegexPatternConfig>();
|
||
public List<RegexPatternConfig> QuestionPatterns { get; set; } = new List<RegexPatternConfig>();
|
||
public List<RegexPatternConfig> OptionPatterns { get; set; } = new List<RegexPatternConfig>();
|
||
|
||
public ExamParserConfig()
|
||
{
|
||
MajorQuestionGroupPatterns.Add(new RegexPatternConfig(@"^([一二三四五六七八九十]+)[、\.]\s*(.+?)(?:\s*\(((\d+(?:\.\d+)?))\s*分\))?\s*$", 1));
|
||
QuestionPatterns.Add(new RegexPatternConfig(@"^\(([一二三四五六七八九十]{1,2}|十[一二三四五六七八九])\)\s*(.+?)(?:\s*\(((\d+(?:\.\d+)?))\s*分\))?\s*$", 1));
|
||
|
||
|
||
// 模式 1: "1. 这是一个题目 (5分)" 或 "1. 这是一个题目"
|
||
QuestionPatterns.Add(new RegexPatternConfig(@"^(\d+)\.\s*(.+?)(?:\s*\(((\d+(?:\.\d+)?))\s*分\))?\s*$", 2));
|
||
|
||
// 模式 2: "(1) 这是一个子题目 (3分)" 或 "(1) 这是一个子题目"
|
||
QuestionPatterns.Add(new RegexPatternConfig(@"^\((\d+)\)\s*(.+?)(?:\s*\(((\d+(?:\.\d+)?))\s*分\))?\s*$", 3));
|
||
|
||
// 模式 3: "① 这是一个更深层次的子题目 (2分)" 或 "① 这是一个更深层次的子题目"
|
||
QuestionPatterns.Add(new RegexPatternConfig(@"^[①②③④⑤⑥⑦⑧⑨⑩]+\s*(.+?)(?:\s*\(((\d+(?:\.\d+)?))\s*分\))?\s*$", 4));
|
||
|
||
|
||
OptionPatterns.Add(new RegexPatternConfig(@"([A-Z]\.)\s*(.*?)(?=[A-Z]\.|$)", 1)); // 大写字母选项
|
||
OptionPatterns.Add(new RegexPatternConfig(@"([a-z]\.)\s*(.*?)(?=[a-z]\.|$)", 1)); // 小写字母选项
|
||
|
||
}
|
||
}
|
||
|
||
|
||
public class PotentialMatch
|
||
{
|
||
public int StartIndex { get; set; }
|
||
public int EndIndex { get; set; } // 匹配到的结构在原始文本中的结束位置
|
||
public string MatchedText { get; set; } // 匹配到的完整行或段落
|
||
public Match RegexMatch { get; set; } // 原始的Regex.Match对象，方便获取捕获组
|
||
public RegexPatternConfig PatternConfig { get; set; } // 匹配到的模式配置
|
||
public MatchType Type { get; set; } // 枚举：MajorQuestionGroup, Question, Option, etc.
|
||
}
|
||
|
||
public enum MatchType
|
||
{
|
||
MajorQuestionGroup,
|
||
Question,
|
||
Option,
|
||
Other // 如果有其他需要识别的类型
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 负责扫描原始文本，收集所有潜在的匹配项（题组、题目、选项）。
|
||
/// 它只进行匹配，不进行结构化归属。
|
||
/// </summary>
|
||
public class ExamDocumentScanner
|
||
{
|
||
private readonly ExamParserConfig _config;
|
||
|
||
public ExamDocumentScanner(ExamParserConfig config)
|
||
{
|
||
_config = config ?? throw new ArgumentNullException(nameof(config)); // 确保配置不为空
|
||
}
|
||
|
||
/// <summary>
|
||
/// 扫描给定的文本，返回所有潜在的匹配项，并按起始位置排序。
|
||
/// </summary>
|
||
/// <param name="text">要扫描的文本</param>
|
||
/// <returns>所有匹配到的 PotentialMatch 列表</returns>
|
||
public List<PotentialMatch> Scan(string text)
|
||
{
|
||
if (string.IsNullOrEmpty(text))
|
||
{
|
||
return new List<PotentialMatch>(); // 对于空文本，直接返回空列表
|
||
}
|
||
|
||
var allPotentialMatches = new List<PotentialMatch>();
|
||
|
||
// 扫描所有题组模式
|
||
foreach (var patternConfig in _config.MajorQuestionGroupPatterns)
|
||
{
|
||
foreach (Match match in patternConfig.Regex.Matches(text))
|
||
{
|
||
allPotentialMatches.Add(new PotentialMatch
|
||
{
|
||
StartIndex = match.Index,
|
||
EndIndex = match.Index + match.Length,
|
||
MatchedText = match.Value,
|
||
RegexMatch = match,
|
||
PatternConfig = patternConfig,
|
||
Type = MatchType.MajorQuestionGroup
|
||
});
|
||
}
|
||
}
|
||
|
||
// 扫描所有题目模式
|
||
foreach (var patternConfig in _config.QuestionPatterns)
|
||
{
|
||
foreach (Match match in patternConfig.Regex.Matches(text))
|
||
{
|
||
allPotentialMatches.Add(new PotentialMatch
|
||
{
|
||
StartIndex = match.Index,
|
||
EndIndex = match.Index + match.Length,
|
||
MatchedText = match.Value,
|
||
RegexMatch = match,
|
||
PatternConfig = patternConfig,
|
||
Type = MatchType.Question
|
||
});
|
||
}
|
||
}
|
||
|
||
// 扫描所有选项模式
|
||
foreach (var patternConfig in _config.OptionPatterns)
|
||
{
|
||
foreach (Match match in patternConfig.Regex.Matches(text))
|
||
{
|
||
allPotentialMatches.Add(new PotentialMatch
|
||
{
|
||
StartIndex = match.Index,
|
||
EndIndex = match.Index + match.Length,
|
||
MatchedText = match.Value,
|
||
RegexMatch = match,
|
||
PatternConfig = patternConfig,
|
||
Type = MatchType.Option
|
||
});
|
||
}
|
||
}
|
||
|
||
// 统一按起始位置排序
|
||
return allPotentialMatches.OrderBy(pm => pm.StartIndex).ToList();
|
||
}
|
||
}
|
||
|
||
public class ExamStructureBuilder
|
||
{
|
||
private readonly ExamParserConfig _config;
|
||
|
||
public ExamStructureBuilder(ExamParserConfig config)
|
||
{
|
||
_config = config ?? throw new ArgumentNullException(nameof(config), "ExamParserConfig cannot be null.");
|
||
}
|
||
|
||
|
||
|
||
///
|
||
/// 一.基础
|
||
/// 1.听写
|
||
/// 2.阅读
|
||
/// 二.提升
|
||
/// 1.阅读
|
||
/// (1).选择
|
||
/// (2).填空
|
||
/// 三.写
|
||
/// (一)课文
|
||
///
|
||
///
|
||
///
|
||
|
||
|
||
/// <summary>
|
||
/// Builds the ExamPaper structure from raw text and potential matches.
|
||
/// Collects and returns parsing errors encountered during the process.
|
||
/// </summary>
|
||
/// <param name="fullExamText">The complete text of the exam paper.</param>
|
||
/// <param name="allPotentialMatches">A list of all identified potential matches.</param>
|
||
/// <returns>An ExamPaper object containing the parsed structure and a list of errors.</returns>
|
||
/// <exception cref="ArgumentException">Thrown if fullExamText is null or empty.</exception>
|
||
/// <exception cref="ArgumentNullException">Thrown if allPotentialMatches is null.</exception>
|
||
public ExamPaper BuildExam(string fullExamText, List<PotentialMatch> allPotentialMatches)
|
||
{
|
||
// 核心输入验证仍然是必要的，因为这些错误是无法恢复的
|
||
if (string.IsNullOrWhiteSpace(fullExamText))
|
||
{
|
||
throw new ArgumentException("Full exam text cannot be null or empty.", nameof(fullExamText));
|
||
}
|
||
if (allPotentialMatches == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(allPotentialMatches), "Potential matches list cannot be null.");
|
||
}
|
||
|
||
var examPaper = new ExamPaper(); // ExamPaper 现在包含一个 Errors 列表
|
||
|
||
// 尝试获取试卷标题
|
||
try
|
||
{
|
||
examPaper.AssignmentTitle = GetExamTitle(fullExamText);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 如果获取标题失败，记录错误而不是抛出致命异常
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.UnexpectedError, "Failed to extract exam title.", innerException: ex));
|
||
examPaper.AssignmentTitle = "未识别试卷标题"; // 提供默认值
|
||
}
|
||
|
||
var majorQGStack = new Stack<MajorQuestionGroup>();
|
||
MajorQuestionGroup currentMajorQG = null;
|
||
|
||
var questionStack = new Stack<PaperQuestion>();
|
||
PaperQuestion currentQuestion = null;
|
||
|
||
int currentContentStart = 0;
|
||
|
||
// 处理试卷开头的描述性文本
|
||
if (allPotentialMatches.Any() && allPotentialMatches[0].StartIndex > 0)
|
||
{
|
||
string introText = fullExamText.Substring(0, allPotentialMatches[0].StartIndex).Trim();
|
||
if (!string.IsNullOrWhiteSpace(introText))
|
||
{
|
||
examPaper.Description += (string.IsNullOrWhiteSpace(examPaper.Description) ? "" : "\n") + introText;
|
||
}
|
||
}
|
||
|
||
currentContentStart = allPotentialMatches[0].StartIndex;
|
||
|
||
for (int i = 0; i < allPotentialMatches.Count; i++)
|
||
{
|
||
var pm = allPotentialMatches[i];
|
||
|
||
|
||
try
|
||
{
|
||
// **数据验证：不再抛出，而是记录错误**
|
||
if (pm.StartIndex < currentContentStart || pm.EndIndex > fullExamText.Length || pm.StartIndex > pm.EndIndex)
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.Validation,
|
||
$"PotentialMatch at index {i} has invalid start/end indices. Start: {pm.StartIndex}, End: {pm.EndIndex}, CurrentContentStart: {currentContentStart}, FullTextLength: {fullExamText.Length}",
|
||
index: i, matchedText: pm.MatchedText));
|
||
currentContentStart = Math.Max(currentContentStart, pm.EndIndex); // 尝试跳过这个损坏的匹配项
|
||
continue; // 跳过当前循环迭代，处理下一个匹配项
|
||
}
|
||
if (pm.RegexMatch == null || pm.PatternConfig == null)
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.Validation,
|
||
$"PotentialMatch at index {i} is missing RegexMatch or PatternConfig.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
currentContentStart = Math.Max(currentContentStart, pm.EndIndex); // 尝试跳过这个损坏的匹配项
|
||
continue; // 跳过当前循环迭代，处理下一个匹配项
|
||
}
|
||
|
||
string precedingText = fullExamText.Substring(currentContentStart, pm.StartIndex - currentContentStart).Trim();
|
||
if (!string.IsNullOrWhiteSpace(precedingText))
|
||
{
|
||
if (currentQuestion != null)
|
||
{
|
||
// 将 examPaper.Errors 传递给 ProcessQuestionContent 收集错误
|
||
ProcessQuestionContent(currentQuestion, precedingText,
|
||
GetSubMatchesForRange(allPotentialMatches, currentContentStart, pm.StartIndex, examPaper.Errors),
|
||
examPaper.Errors);
|
||
}
|
||
else if (currentMajorQG != null)
|
||
{
|
||
currentMajorQG.Descript += (string.IsNullOrWhiteSpace(currentMajorQG.Descript) ? "" : "\n") + precedingText;
|
||
}
|
||
else
|
||
{
|
||
examPaper.Description += (string.IsNullOrWhiteSpace(examPaper.Description) ? "" : "\n") + precedingText;
|
||
}
|
||
}
|
||
|
||
if (pm.Type == MatchType.MajorQuestionGroup)
|
||
{
|
||
// 对 MajorQuestionGroup 的处理
|
||
try
|
||
{
|
||
while (majorQGStack.Any() && pm.PatternConfig.Priority <= majorQGStack.Peek().Priority)
|
||
{
|
||
majorQGStack.Pop();
|
||
}
|
||
|
||
// RegexMatch Groups 验证：不再抛出，记录错误
|
||
if (pm.RegexMatch.Groups.Count < 2 || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[1].Value))
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.RegexMatchIssue,
|
||
$"MajorQuestionGroup match at index {i} does not have enough regex groups or a valid title group (Group 1). Skipping this group.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
currentContentStart = pm.EndIndex; // 继续，尝试跳过此项
|
||
continue;
|
||
}
|
||
|
||
float score = 0;
|
||
// 使用 float.TryParse 避免异常
|
||
if (pm.RegexMatch.Groups.Count > 3 && pm.RegexMatch.Groups[4].Success) // 假设纯数字分数是 Group 4
|
||
{
|
||
if (!float.TryParse(pm.RegexMatch.Groups[4].Value, out score))
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.DataParsing,
|
||
$"Failed to parse score '{pm.RegexMatch.Groups[4].Value}' for MajorQuestionGroup at index {i}. Defaulting to 0.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
}
|
||
}
|
||
|
||
MajorQuestionGroup newMajorQG = new MajorQuestionGroup
|
||
{
|
||
Title = pm.RegexMatch.Groups[2].Value.Trim(), // 标题是 Group 2
|
||
Score = score,
|
||
Priority = pm.PatternConfig.Priority,
|
||
bGroup = true
|
||
};
|
||
|
||
if (majorQGStack.Any())
|
||
{
|
||
majorQGStack.Peek().SubQuestionGroups.Add(newMajorQG);
|
||
}
|
||
else
|
||
{
|
||
examPaper.QuestionGroups.Add(newMajorQG);
|
||
}
|
||
|
||
currentContentStart = pm.EndIndex;
|
||
majorQGStack.Push(newMajorQG);
|
||
currentMajorQG = newMajorQG;
|
||
questionStack.Clear();
|
||
currentQuestion = null;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred during processing MajorQuestionGroup at index {i}.",
|
||
index: i, matchedText: pm.MatchedText, innerException: ex));
|
||
currentContentStart = pm.EndIndex; // 尝试跳过此项
|
||
continue;
|
||
}
|
||
}
|
||
else if (pm.Type == MatchType.Question)
|
||
{
|
||
// 对 Question 的处理
|
||
try
|
||
{
|
||
while (questionStack.Any() && pm.PatternConfig.Priority <= questionStack.Peek().Priority)
|
||
{
|
||
questionStack.Pop();
|
||
}
|
||
|
||
// RegexMatch Groups 验证
|
||
if (pm.RegexMatch.Groups.Count < 3 || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[1].Value) || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[2].Value))
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.RegexMatchIssue,
|
||
$"Question match at index {i} does not have enough regex groups or valid number/text groups (Group 1/2). Skipping this question.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
currentContentStart = pm.EndIndex; // 尝试跳过此项
|
||
continue;
|
||
}
|
||
|
||
float score = 0;
|
||
// 使用 float.TryParse 避免异常
|
||
if (pm.RegexMatch.Groups.Count > 4 && pm.RegexMatch.Groups[4].Success) // 假设纯数字分数是 Group 4
|
||
{
|
||
if (!float.TryParse(pm.RegexMatch.Groups[4].Value, out score))
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.DataParsing,
|
||
$"Failed to parse score '{pm.RegexMatch.Groups[4].Value}' for Question at index {i}. Defaulting to 0.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
}
|
||
}
|
||
|
||
PaperQuestion newQuestion = new PaperQuestion
|
||
{
|
||
Number = pm.RegexMatch.Groups[1].Value.Trim(),
|
||
Stem = pm.RegexMatch.Groups[2].Value.Trim(),
|
||
Priority = pm.PatternConfig.Priority,
|
||
Score = score // 赋值解析到的分数
|
||
};
|
||
|
||
if (questionStack.Any())
|
||
{
|
||
questionStack.Peek().SubQuestions.Add(newQuestion);
|
||
}
|
||
else if (currentMajorQG != null)
|
||
{
|
||
currentMajorQG.SubQuestions.Add(newQuestion);
|
||
}
|
||
else
|
||
{
|
||
examPaper.TopLevelQuestions.Add(newQuestion);
|
||
}
|
||
|
||
currentContentStart = pm.EndIndex;
|
||
questionStack.Push(newQuestion);
|
||
currentQuestion = newQuestion;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred during processing Question at index {i}.",
|
||
index: i, matchedText: pm.MatchedText, innerException: ex));
|
||
currentContentStart = pm.EndIndex; // 尝试跳过此项
|
||
continue;
|
||
}
|
||
}
|
||
else if (pm.Type == MatchType.Option)
|
||
{
|
||
// 对 Option 的处理
|
||
try
|
||
{
|
||
if (currentQuestion != null)
|
||
{
|
||
// RegexMatch Groups 验证
|
||
if (pm.RegexMatch.Groups.Count < 3 || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[1].Value) || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[2].Value))
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.RegexMatchIssue,
|
||
$"Option match at index {i} does not have enough regex groups or valid label/text groups (Group 1/2). Skipping this option.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
currentContentStart = pm.EndIndex; // 尝试跳过此项
|
||
continue;
|
||
}
|
||
|
||
Option newOption = new Option
|
||
{
|
||
Label = pm.RegexMatch.Groups[1].Value.Trim(),
|
||
Text = pm.RegexMatch.Groups[2].Value.Trim()
|
||
};
|
||
currentQuestion.Options.Add(newOption);
|
||
}
|
||
else
|
||
{
|
||
// 结构性问题：找到孤立的选项，记录错误但继续
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.Structural,
|
||
$"Found isolated Option at index {i}. Options must belong to a question. Ignoring this option.",
|
||
index: i, matchedText: pm.MatchedText));
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred during processing Option at index {i}.",
|
||
index: i, matchedText: pm.MatchedText, innerException: ex));
|
||
// 这里不需要 `continue`，因为即使出错也可能只是该选项的问题，不影响后续处理
|
||
}
|
||
}
|
||
|
||
currentContentStart = pm.EndIndex; // 更新当前内容起点
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 捕获任何在处理单个 PotentialMatch 过程中未被更具体 catch 块捕获的意外错误
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred during main loop processing of PotentialMatch at index {i}.",
|
||
index: i, matchedText: pm.MatchedText, innerException: ex));
|
||
currentContentStart = Math.Max(currentContentStart, pm.EndIndex); // 尝试跳过当前匹配项，继续下一项
|
||
// 这里不 `continue` 是因为外层循环会推进 `i`，但确保 `currentContentStart` 更新以避免无限循环
|
||
}
|
||
}
|
||
|
||
// --- 处理所有匹配项之后的剩余内容 ---
|
||
if (currentContentStart < fullExamText.Length)
|
||
{
|
||
try
|
||
{
|
||
string remainingText = fullExamText.Substring(currentContentStart).Trim();
|
||
if (!string.IsNullOrWhiteSpace(remainingText))
|
||
{
|
||
if (currentQuestion != null)
|
||
{
|
||
ProcessQuestionContent(currentQuestion, remainingText,
|
||
GetSubMatchesForRange(allPotentialMatches, currentContentStart, fullExamText.Length, examPaper.Errors),
|
||
examPaper.Errors);
|
||
}
|
||
else if (currentMajorQG != null)
|
||
{
|
||
currentMajorQG.Descript += (string.IsNullOrWhiteSpace(currentMajorQG.Descript) ? "" : "\n") + remainingText;
|
||
}
|
||
else
|
||
{
|
||
examPaper.Description += (string.IsNullOrWhiteSpace(examPaper.Description) ? "" : "\n") + remainingText;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
examPaper.Errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
"An unexpected error occurred while processing remaining text after all potential matches.",
|
||
innerException: ex));
|
||
}
|
||
}
|
||
|
||
return examPaper;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Extracts the exam title (simple implementation).
|
||
/// Logs errors to the provided error list instead of throwing.
|
||
/// </summary>
|
||
private string GetExamTitle(string examPaperText)
|
||
{
|
||
// 内部不再直接抛出异常，而是让外部的 try-catch 负责
|
||
var firstLine = examPaperText.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
|
||
.FirstOrDefault(line => !string.IsNullOrWhiteSpace(line));
|
||
return firstLine ?? "未识别试卷标题";
|
||
}
|
||
|
||
/// <summary>
|
||
/// Gets a subset of the given PotentialMatch list within a specified range.
|
||
/// Logs errors to the provided error list instead of throwing.
|
||
/// </summary>
|
||
private List<PotentialMatch> GetSubMatchesForRange(List<PotentialMatch> allMatches, int start, int end, List<ParseError> errors)
|
||
{
|
||
// 输入验证，如果输入错误，记录错误并返回空列表
|
||
if (start < 0 || end < start)
|
||
{
|
||
errors.Add(new ParseError(ParseErrorType.Validation,
|
||
$"Invalid range provided to GetSubMatchesForRange. Start: {start}, End: {end}.",
|
||
index: start)); // 使用 start 作为大概索引
|
||
return new List<PotentialMatch>();
|
||
}
|
||
// allMatches 为 null 的情况已经在 BuildExamPaper 顶部处理，这里为了方法的健壮性可以再加一次检查
|
||
if (allMatches == null)
|
||
{
|
||
return new List<PotentialMatch>();
|
||
}
|
||
|
||
try
|
||
{
|
||
return allMatches.Where(pm => pm.StartIndex >= start && pm.StartIndex < end).ToList();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred getting sub-matches for range [{start}, {end}).",
|
||
innerException: ex));
|
||
return new List<PotentialMatch>(); // 出错时返回空列表
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Processes the content of a Question, mainly for parsing Options and identifying unstructured text.
|
||
/// Logs errors to the provided error list instead of throwing.
|
||
/// </summary>
|
||
private void ProcessQuestionContent(PaperQuestion question, string contentText, List<PotentialMatch> potentialMatchesInScope, List<ParseError> errors)
|
||
{
|
||
// 参数验证，这些是内部方法的契约，如果违反则直接抛出，因为这意味着调用者有错
|
||
if (question == null) throw new ArgumentNullException(nameof(question), "Question cannot be null in ProcessQuestionContent.");
|
||
if (contentText == null) throw new ArgumentNullException(nameof(contentText), "Content text cannot be null in ProcessQuestionContent.");
|
||
if (potentialMatchesInScope == null) throw new ArgumentNullException(nameof(potentialMatchesInScope), "Potential matches in scope cannot be null.");
|
||
|
||
|
||
try
|
||
{
|
||
int lastOptionEndIndex = 0;
|
||
|
||
foreach (var pm in potentialMatchesInScope.OrderBy(p => p.StartIndex))
|
||
{
|
||
// 对每个匹配项的内部处理，记录错误但继续
|
||
try
|
||
{
|
||
if (pm.Type == MatchType.Option)
|
||
{
|
||
// 验证索引，记录错误但继续
|
||
if (pm.StartIndex < lastOptionEndIndex || pm.StartIndex > contentText.Length || pm.EndIndex > contentText.Length)
|
||
{
|
||
errors.Add(new ParseError(ParseErrorType.Validation,
|
||
$"Option match at index {pm.StartIndex} has invalid indices within content text. MatchedText: '{pm.MatchedText}'. Skipping.",
|
||
index: pm.StartIndex, matchedText: pm.MatchedText));
|
||
continue; // 跳过当前选项
|
||
}
|
||
|
||
// 处理选项前的文本
|
||
if (pm.StartIndex > lastOptionEndIndex)
|
||
{
|
||
string textBeforeOption = contentText.Substring(lastOptionEndIndex, pm.StartIndex - lastOptionEndIndex).Trim();
|
||
if (!string.IsNullOrWhiteSpace(textBeforeOption))
|
||
{
|
||
question.Stem += (string.IsNullOrWhiteSpace(question.Stem) ? "" : "\n") + textBeforeOption;
|
||
}
|
||
}
|
||
|
||
// RegexMatch Groups 验证，记录错误但继续
|
||
if (pm.RegexMatch.Groups.Count < 3 || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[1].Value) || string.IsNullOrWhiteSpace(pm.RegexMatch.Groups[2].Value))
|
||
{
|
||
errors.Add(new ParseError(ParseErrorType.RegexMatchIssue,
|
||
$"Option regex match '{pm.MatchedText}' does not have enough groups (expected 3) for label and text. Skipping option.",
|
||
index: pm.StartIndex, matchedText: pm.MatchedText));
|
||
lastOptionEndIndex = pm.EndIndex; // 更新索引，避免卡死
|
||
continue; // 跳过当前选项
|
||
}
|
||
|
||
var newOption = new Option
|
||
{
|
||
Label = pm.RegexMatch.Groups[1].Value.Trim(),
|
||
Text = pm.RegexMatch.Groups[2].Value.Trim()
|
||
};
|
||
question.Options.Add(newOption);
|
||
lastOptionEndIndex = pm.EndIndex;
|
||
}
|
||
else
|
||
{
|
||
question.Stem += contentText;
|
||
}
|
||
}
|
||
catch (Exception innerEx)
|
||
{
|
||
errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred during processing a potential match ({pm.Type}) within question content.",
|
||
index: pm.StartIndex, matchedText: pm.MatchedText, innerException: innerEx));
|
||
lastOptionEndIndex = pm.EndIndex; // 尝试更新索引，避免无限循环
|
||
continue; // 尝试继续下一个匹配项
|
||
}
|
||
}
|
||
|
||
// 处理所有选项之后的剩余文本
|
||
if (lastOptionEndIndex < contentText.Length)
|
||
{
|
||
string remainingContent = contentText.Substring(lastOptionEndIndex).Trim();
|
||
if (!string.IsNullOrWhiteSpace(remainingContent))
|
||
{
|
||
question.Stem += (string.IsNullOrWhiteSpace(question.Stem) ? "" : "\n") + remainingContent;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// 捕获 ProcessQuestionContent 整个方法内部的意外错误
|
||
errors.Add(new ParseError(ParseErrorType.UnexpectedError,
|
||
$"An unexpected error occurred while processing content for Question '{question.Number}'.",
|
||
innerException: ex));
|
||
}
|
||
}
|
||
}
|
||
|
||
public class ExamParser
|
||
{
|
||
private readonly ExamParserConfig _config;
|
||
private readonly ExamDocumentScanner _scanner;
|
||
private readonly ExamStructureBuilder _builder;
|
||
|
||
public ExamParser(ExamParserConfig config)
|
||
{
|
||
_config = config ?? throw new ArgumentNullException(nameof(config));
|
||
_scanner = new ExamDocumentScanner(_config);
|
||
_builder = new ExamStructureBuilder(_config);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析给定的试卷文本，返回结构化的 ExamPaper 对象。
|
||
/// </summary>
|
||
/// <param name="examPaperText">完整的试卷文本</param>
|
||
/// <returns>解析后的 ExamPaper 对象</returns>
|
||
public ExamPaper ParseExamPaper(string examPaperText)
|
||
{
|
||
// 1. 扫描：一次性扫描整个文本，收集所有潜在的匹配项
|
||
// Scan 方法现在已经优化为不抛出 ArgumentNullException
|
||
List<PotentialMatch> allPotentialMatches = _scanner.Scan(examPaperText);
|
||
|
||
// 2. 构建：根据扫描结果和原始文本，线性遍历并构建层级结构
|
||
// BuildExamPaper 现在会返回一个包含错误列表的 ExamPaper 对象
|
||
// 外部不再需要捕获内部解析异常，只需检查 ExamPaper.Errors 列表
|
||
return _builder.BuildExam(examPaperText, allPotentialMatches);
|
||
}
|
||
}
|
||
} |