基于XML文件实现AvalonEdit嵌套代码补全（WCF应用场景）

Alright, let's get your nested IntelliSense working in AvalonEdit with that dynamically updating XML file in your WCF app. I've broken this down into actionable steps with code examples you can adapt:

First, we need to detect when your XML file changes so we can refresh our completion structure automatically. Use FileSystemWatcher to track modifications:

private FileSystemWatcher _xmlWatcher;
private CompletionNode _rootCompletionNode;
private readonly string _xmlFilePath = @"C:\Path\To\Your\RelativeRegion.xml"; // Update this path

private void InitializeXmlMonitor()
{
    var xmlDir = Path.GetDirectoryName(_xmlFilePath);
    _xmlWatcher = new FileSystemWatcher(xmlDir)
    {
        Filter = Path.GetFileName(_xmlFilePath),
        NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size,
        EnableRaisingEvents = true
    };
    _xmlWatcher.Changed += OnXmlFileUpdated;
    
    // Load the initial XML structure
    RefreshCompletionTree();
}

private void OnXmlFileUpdated(object sender, FileSystemEventArgs e)
{
    // Avoid duplicate events from file write operations
    Thread.Sleep(100);
    // Update the completion tree on the UI thread (AvalonEdit is UI-bound)
    Application.Current.Dispatcher.Invoke(RefreshCompletionTree);
}

We'll convert the XML's nested structure into a tree of nodes that AvalonEdit can use to serve nested completions. First, define a simple node class:

public class CompletionNode
{
    public string ElementName { get; set; }
    public List<CompletionNode> ChildNodes { get; set; } = new List<CompletionNode>();
    public CompletionNode ParentNode { get; set; }
}

Then write a method to build this tree from the XML:

private void RefreshCompletionTree()
{
    try
    {
        var xmlDoc = XDocument.Load(_xmlFilePath);
        var rootXmlNode = xmlDoc.Root;
        _rootCompletionNode = new CompletionNode { ElementName = rootXmlNode.Name.LocalName };
        
        // Recursively build the tree from XML elements
        BuildCompletionNodeTree(rootXmlNode, _rootCompletionNode);
    }
    catch (Exception ex)
    {
        // Handle invalid XML gracefully (log error, show user message)
        Debug.WriteLine($"Failed to parse XML: {ex.Message}");
    }
}

private void BuildCompletionNodeTree(XElement xmlElement, CompletionNode parentCompletionNode)
{
    foreach (var childXmlElement in xmlElement.Elements())
    {
        var childCompletionNode = new CompletionNode
        {
            ElementName = childXmlElement.Name.LocalName,
            ParentNode = parentCompletionNode
        };
        parentCompletionNode.ChildNodes.Add(childCompletionNode);
        
        // Recurse for nested elements
        BuildCompletionNodeTree(childXmlElement, childCompletionNode);
    }
}

AvalonEdit uses ICompletionData for completion items and CompletionWindow to display them. First, create a custom completion data class:

public class XmlElementCompletionData : ICompletionData
{
    public XmlElementCompletionData(string elementName)
    {
        ElementName = elementName;
    }

    public string ElementName { get; }
    public string Text => ElementName;
    public object Content => ElementName;
    public object Description => $"Insert XML element: <{ElementName}>";
    public ImageSource Image => null; // Add icons here if you want visual cues
    public double Priority => 1.0; // Higher priority = shows first in list

    public void Complete(TextArea textArea, ISegment completionSegment, EventArgs insertionRequestEventArgs)
    {
        // Replace the placeholder with the element name
        textArea.Document.Replace(completionSegment, ElementName);
        // Optional: Auto-close the tag for better UX
        textArea.Document.Insert(textArea.CaretOffset, $"></{ElementName}>");
        textArea.CaretOffset -= ElementName.Length + 2; // Move cursor inside the tag
    }
}

Next, add logic to trigger the completion window and show the correct nested items based on the user's current context:

private void AvalonEditTextArea_KeyDown(object sender, KeyEventArgs e)
{
    // Trigger completion on Ctrl+Space, or adjust to auto-trigger when typing '<'
    if (e.Key == Key.Space && (Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control)
    {
        ShowNestedCompletionWindow();
        e.Handled = true;
    }
}

private void ShowNestedCompletionWindow()
{
    var textArea = _avalonEdit.TextArea; // Your AvalonEdit control instance
    var currentText = textArea.Document.Text.Substring(0, textArea.CaretOffset);
    var currentNodePath = GetCurrentOpenXmlElementPath(currentText);
    
    // Find the corresponding node in our completion tree
    var currentCompletionNode = GetCurrentCompletionNode(_rootCompletionNode, currentNodePath);
    if (currentCompletionNode == null) return;

    // Create and show the completion window
    var completionWindow = new CompletionWindow(textArea);
    var completionList = completionWindow.CompletionList.CompletionData;
    
    // Add all child elements of the current node to the completion list
    foreach (var childNode in currentCompletionNode.ChildNodes)
    {
        completionList.Add(new XmlElementCompletionData(childNode.ElementName));
    }

    completionWindow.Show();
    completionWindow.Closed += (s, args) => completionWindow.Dispose();
}

// Helper to parse the current open XML elements from the user's input
private List<string> GetCurrentOpenXmlElementPath(string currentText)
{
    var openTags = new Stack<string>();
    var tagRegex = new Regex(@"<(/?)(\w+)");
    var matches = tagRegex.Matches(currentText);

    foreach (Match match in matches)
    {
        var isClosingTag = !string.IsNullOrEmpty(match.Groups[1].Value);
        var tagName = match.Groups[2].Value;

        if (isClosingTag)
        {
            // Pop the tag from the stack if it matches the top open tag
            if (openTags.Count > 0 && openTags.Peek() == tagName)
                openTags.Pop();
        }
        else
        {
            openTags.Push(tagName);
        }
    }

    // Reverse the stack to get the path from root to current node
    return openTags.Reverse().ToList();
}

// Helper to traverse our completion tree to find the current context node
private CompletionNode GetCurrentCompletionNode(CompletionNode root, List<string> path)
{
    var currentNode = root;
    foreach (var tagName in path)
    {
        currentNode = currentNode.ChildNodes.FirstOrDefault(n => n.ElementName == tagName);
        if (currentNode == null) break;
    }
    return currentNode;
}

• Initialize the monitor: Call InitializeXmlMonitor() when your WCF app starts (e.g., in your main window's constructor or view model initialization).
• Thread safety: Always update UI-related components (like the completion tree) via the UI dispatcher, since FileSystemWatcher events fire on background threads.
• Error handling: Add more robust XML parsing error handling to avoid crashes if the XML file is invalid during an update.
• Auto-trigger completion: Modify the KeyDown logic to trigger the completion window automatically when the user types <, instead of relying only on Ctrl+Space.
• Refine context parsing: The GetCurrentOpenXmlElementPath method is a simplified parser—you can enhance it to handle attributes, comments, or self-closing tags if needed.

内容的提问来源于stack exchange，提问作者Sharon