如何将TextBlock绑定到包含格式化文本的资源？

Question

我在我的 WPF 窗口中有一个 TextBlock。

 <TextBlock>
     Some <Bold>formatted</Bold> text.
 </TextBlock>

渲染后的效果如下：

一些格式化的文本。

我的问题是，我能将这个内联“内容”绑定到我的应用程序资源吗？

我已经做到了：

创建一个应用程序资源字符串，

myText="Some <Bold>formatted</Bold> text."

以下是 XAML 代码（为保简洁省略了部分代码）：

 <Window xmlns:props="clr-namespace:MyApp.Properties">
     <Window.Resources>
         <props:Resources x:Key="Resources"/>
     </Window.Resources>
      <TextBlock x:Name="Try1" 
          Text="{Binding Source={StaticResource Resources} Path=myText}"/>
     <TextBlock x:Name="Try2">
          <Binding Source="{StaticResource Resources}" Path="myText" />
     </TextBlock>
 </Window>

尝试1会保留标签并不影响格式。

一些<Bold>格式化的<Bold>文本。

尝试2将无法编译或呈现，因为资源"myText"不是内联类型而是字符串。

这个看似简单的任务是否可能，如果可能该如何实现？

- Jodrell

Answer 1

这是我修改后的递归格式化文本的代码。它处理了加粗、斜体、下划线和换行符，但可以很容易地扩展以支持更多功能（修改switch语句）。

public static class MyBehavior
{
    public static string GetFormattedText(DependencyObject obj)
    {
        return (string)obj.GetValue(FormattedTextProperty);
    }

    public static void SetFormattedText(DependencyObject obj, string value)
    {
        obj.SetValue(FormattedTextProperty, value);
    }

    public static readonly DependencyProperty FormattedTextProperty =
        DependencyProperty.RegisterAttached("FormattedText",
        typeof(string),
        typeof(MyBehavior),
        new UIPropertyMetadata("", FormattedTextChanged));

    static Inline Traverse(string value)
    {
        // Get the sections/inlines
        string[] sections = SplitIntoSections(value);

        // Check for grouping
        if (sections.Length.Equals(1))
        {
            string section = sections[0];
            string token; // E.g <Bold>
            int tokenStart, tokenEnd; // Where the token/section starts and ends.

            // Check for token
            if (GetTokenInfo(section, out token, out tokenStart, out tokenEnd))
            {
                // Get the content to further examination
                string content = token.Length.Equals(tokenEnd - tokenStart) ?
                    null :
                    section.Substring(token.Length, section.Length - 1 - token.Length * 2);

                switch (token)
                {
                    case "<Bold>":
                        return new Bold(Traverse(content));
                    case "<Italic>":
                        return new Italic(Traverse(content));
                    case "<Underline>":
                        return new Underline(Traverse(content));
                    case "<LineBreak/>":
                        return new LineBreak();
                    default:
                        return new Run(section);
                }
            }
            else return new Run(section);
        }
        else // Group together
        {
            Span span = new Span();

            foreach (string section in sections)
                span.Inlines.Add(Traverse(section));

            return span;
        }
    }

    /// <summary>
    /// Examines the passed string and find the first token, where it begins and where it ends.
    /// </summary>
    /// <param name="value">The string to examine.</param>
    /// <param name="token">The found token.</param>
    /// <param name="startIndex">Where the token begins.</param>
    /// <param name="endIndex">Where the end-token ends.</param>
    /// <returns>True if a token was found.</returns>
    static bool GetTokenInfo(string value, out string token, out int startIndex, out int endIndex)
    {
        token = null;
        endIndex = -1;

        startIndex = value.IndexOf("<");
        int startTokenEndIndex = value.IndexOf(">");

        // No token here
        if (startIndex < 0)
            return false;

        // No token here
        if (startTokenEndIndex < 0)
            return false;

        token = value.Substring(startIndex, startTokenEndIndex - startIndex + 1);

        // Check for closed token. E.g. <LineBreak/>
        if (token.EndsWith("/>"))
        {
            endIndex = startIndex + token.Length;
            return true;
        }

        string endToken = token.Insert(1, "/");

        // Detect nesting;
        int nesting = 0;
        int temp_startTokenIndex = -1;
        int temp_endTokenIndex = -1;
        int pos = 0;
        do
        {
            temp_startTokenIndex = value.IndexOf(token, pos);
            temp_endTokenIndex = value.IndexOf(endToken, pos);

            if (temp_startTokenIndex >= 0 && temp_startTokenIndex < temp_endTokenIndex)
            {
                nesting++;
                pos = temp_startTokenIndex + token.Length;
            }
            else if (temp_endTokenIndex >= 0 && nesting > 0)
            {
                nesting--;
                pos = temp_endTokenIndex + endToken.Length;
            }
            else // Invalid tokenized string
                return false;

        } while (nesting > 0);

        endIndex = pos;

        return true;
    }

    /// <summary>
    /// Splits the string into sections of tokens and regular text.
    /// </summary>
    /// <param name="value">The string to split.</param>
    /// <returns>An array with the sections.</returns>
    static string[] SplitIntoSections(string value)
    {
        List<string> sections = new List<string>();

        while (!string.IsNullOrEmpty(value))
        {
            string token;
            int tokenStartIndex, tokenEndIndex;

            // Check if this is a token section
            if (GetTokenInfo(value, out token, out tokenStartIndex, out tokenEndIndex))
            {
                // Add pretext if the token isn't from the start
                if (tokenStartIndex > 0)
                    sections.Add(value.Substring(0, tokenStartIndex));

                sections.Add(value.Substring(tokenStartIndex, tokenEndIndex - tokenStartIndex));
                value = value.Substring(tokenEndIndex); // Trim away
            }
            else
            { // No tokens, just add the text
                sections.Add(value);
                value = null;
            }
        }

        return sections.ToArray();
    }

    private static void FormattedTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        string value = e.NewValue as string;

        TextBlock textBlock = sender as TextBlock;

        if (textBlock != null)
            textBlock.Inlines.Add(Traverse(value));
    }
}

---

编辑：（由Spook提议）

较短的版本，但需要文本是XML有效的：

using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Xml;

// (...)

public static class TextBlockHelper
{
    #region FormattedText Attached dependency property

    public static string GetFormattedText(DependencyObject obj)
    {
        return (string)obj.GetValue(FormattedTextProperty);
    }

    public static void SetFormattedText(DependencyObject obj, string value)
    {
        obj.SetValue(FormattedTextProperty, value);
    }

    public static readonly DependencyProperty FormattedTextProperty =
        DependencyProperty.RegisterAttached("FormattedText",
        typeof(string),
        typeof(TextBlockHelper),
        new UIPropertyMetadata("", FormattedTextChanged));

    private static void FormattedTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        string value = e.NewValue as string;

        TextBlock textBlock = sender as TextBlock;

        if (textBlock != null)
        {
            textBlock.Inlines.Clear();
            textBlock.Inlines.Add(Process(value));
        }
    }

    #endregion

    static Inline Process(string value)
    {
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(value);

        Span span = new Span();
        InternalProcess(span, doc.ChildNodes[0]);

        return span;
    }

    private static void InternalProcess(Span span, XmlNode xmlNode)
    {
        foreach (XmlNode child in xmlNode)
        {
            if (child is XmlText)
            {
                span.Inlines.Add(new Run(child.InnerText));
            }
            else if (child is XmlElement)
            {
                Span spanItem = new Span();
                InternalProcess(spanItem, child);
                switch (child.Name.ToUpper())
                {
                    case "B":
                    case "BOLD":
                        Bold bold = new Bold(spanItem);
                        span.Inlines.Add(bold);
                        break;
                    case "I":
                    case "ITALIC":
                        Italic italic = new Italic(spanItem);
                        span.Inlines.Add(italic);
                        break;
                    case "U":
                    case "UNDERLINE":
                        Underline underline = new Underline(spanItem);
                        span.Inlines.Add(underline);
                        break;
                }
            }
        }
    }
}

一个使用示例：

<RootItem xmlns:u="clr-namespace:MyApp.Helpers">
    <TextBlock u:TextBlockHelper.FormattedText="{Binding SomeProperty}" />
</RootItem>

- Vincent

---

我想简单地补充一下，这段代码的用户可能会考虑将令牌检查设置为不区分大小写。例如，使用 switch(token.ToUpper()) 并将选项转换为大写。谢谢，Vincent。 - Paul Prewett

@Vincent，如果您不介意的话，我已经添加了您代码的较短版本和使用示例。 - Spook

嗨，文森特，你的答案很棒。在我的代码中，我添加了与@Spook相同的textBlock.Inlines.Clear();在FormattedTextChanged方法中。这可以防止工具提示每次鼠标悬停时都不断添加文本。 - dev1998

运作得非常好！即使10年后... - keun

Answer 2

我已经为Vincent的解决方案添加了超链接和图像支持：

public static class FormattedTextBlock
{
    public static string GetFormattedText(DependencyObject obj)
    {
        return (string)obj.GetValue(FormattedTextProperty);
    }

    public static void SetFormattedText(DependencyObject obj, string value)
    {
        obj.SetValue(FormattedTextProperty, value);
    }

    public static readonly DependencyProperty FormattedTextProperty =
        DependencyProperty.RegisterAttached("FormattedText",
        typeof(string),
        typeof(FormattedTextBlock),
        new UIPropertyMetadata("", FormattedTextChanged));

    static Inline Traverse(string value)
    {
        // Get the sections/inlines
        string[] sections = SplitIntoSections(value);

        // Check for grouping
        if(sections.Length.Equals(1))
        {
            string section = sections[0];
            string token; // E.g <Bold>
            int tokenStart, tokenEnd; // Where the token/section starts and ends.

            // Check for token
            if(GetTokenInfo(section, out token, out tokenStart, out tokenEnd))
            {
                // Get the content to further examination
                string content = token.Length.Equals(tokenEnd - tokenStart) ?
                    null :
                    section.Substring(token.Length, section.Length - 1 - token.Length * 2);

                switch(token.ToUpper())
                {
                    case "<B>":
                    case "<BOLD>":
                        /* <b>Bold text</b> */
                        return new Bold(Traverse(content));
                    case "<I>":
                    case "<ITALIC>":
                        /* <i>Italic text</i> */
                        return new Italic(Traverse(content));
                    case "<U>":
                    case "<UNDERLINE>":
                        /* <u>Underlined text</u> */
                        return new Underline(Traverse(content));
                    case "<BR>":
                    case "<BR/>":
                    case "<LINEBREAK/>":
                        /* Line 1<br/>line 2 */
                        return new LineBreak();
                    case "<A>":
                    case "<LINK>":
                        /* <a>{http://www.google.de}Google</a> */
                        var start = content.IndexOf("{");
                        var end = content.IndexOf("}");
                        var url = content.Substring(start + 1, end - 1);
                        var text = content.Substring(end + 1);
                        var link = new Hyperlink();
                        link.NavigateUri = new System.Uri(url);
                        link.RequestNavigate += Hyperlink_RequestNavigate;
                        link.Inlines.Add(text);
                        return link;
                    case "<IMG>":
                    case "<IMAGE>":
                        /* <image>pack://application:,,,/ProjectName;component/directory1/directory2/image.png</image> */
                        var image = new Image();
                        var bitmap = new BitmapImage(new Uri(content));
                        image.Source = bitmap;
                        image.Width = bitmap.Width;
                        image.Height = bitmap.Height;
                        var container = new InlineUIContainer();
                        container.Child = image;
                        return container;
                    default:
                        return new Run(section);
                }
            }
            else return new Run(section);
        }
        else // Group together
        {
            Span span = new Span();

            foreach(string section in sections)
                span.Inlines.Add(Traverse(section));

            return span;
        }
    }

    static void Hyperlink_RequestNavigate(object sender, RequestNavigateEventArgs e)
    {
        Process.Start(e.Uri.ToString());
    }

    /// <summary>
    /// Examines the passed string and find the first token, where it begins and where it ends.
    /// </summary>
    /// <param name="value">The string to examine.</param>
    /// <param name="token">The found token.</param>
    /// <param name="startIndex">Where the token begins.</param>
    /// <param name="endIndex">Where the end-token ends.</param>
    /// <returns>True if a token was found.</returns>
    static bool GetTokenInfo(string value, out string token, out int startIndex, out int endIndex)
    {
        token = null;
        endIndex = -1;

        startIndex = value.IndexOf("<");
        int startTokenEndIndex = value.IndexOf(">");

        // No token here
        if(startIndex < 0)
            return false;

        // No token here
        if(startTokenEndIndex < 0)
            return false;

        token = value.Substring(startIndex, startTokenEndIndex - startIndex + 1);

        // Check for closed token. E.g. <LineBreak/>
        if(token.EndsWith("/>"))
        {
            endIndex = startIndex + token.Length;
            return true;
        }

        string endToken = token.Insert(1, "/");

        // Detect nesting;
        int nesting = 0;
        int temp_startTokenIndex = -1;
        int temp_endTokenIndex = -1;
        int pos = 0;
        do
        {
            temp_startTokenIndex = value.IndexOf(token, pos);
            temp_endTokenIndex = value.IndexOf(endToken, pos);

            if(temp_startTokenIndex >= 0 && temp_startTokenIndex < temp_endTokenIndex)
            {
                nesting++;
                pos = temp_startTokenIndex + token.Length;
            }
            else if(temp_endTokenIndex >= 0 && nesting > 0)
            {
                nesting--;
                pos = temp_endTokenIndex + endToken.Length;
            }
            else // Invalid tokenized string
                return false;

        } while(nesting > 0);

        endIndex = pos;

        return true;
    }

    /// <summary>
    /// Splits the string into sections of tokens and regular text.
    /// </summary>
    /// <param name="value">The string to split.</param>
    /// <returns>An array with the sections.</returns>
    static string[] SplitIntoSections(string value)
    {
        List<string> sections = new List<string>();

        while(!string.IsNullOrEmpty(value))
        {
            string token;
            int tokenStartIndex, tokenEndIndex;

            // Check if this is a token section
            if(GetTokenInfo(value, out token, out tokenStartIndex, out tokenEndIndex))
            {
                // Add pretext if the token isn't from the start
                if(tokenStartIndex > 0)
                    sections.Add(value.Substring(0, tokenStartIndex));

                sections.Add(value.Substring(tokenStartIndex, tokenEndIndex - tokenStartIndex));
                value = value.Substring(tokenEndIndex); // Trim away
            }
            else
            { // No tokens, just add the text
                sections.Add(value);
                value = null;
            }
        }

        return sections.ToArray();
    }

    private static void FormattedTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        string value = e.NewValue as string;

        TextBlock textBlock = sender as TextBlock;

        if(textBlock != null)
            textBlock.Inlines.Add(Traverse(value));
    }
}

感谢Vincent提供的优秀模板，它非常有效！

- dontbyteme

---

这是一段非常棒的代码，既高效又能处理嵌套格式。加一！ - James Westgate

Answer 3

如何使用附加行为？下面的代码仅处理粗体标记。每个应该粗体的单词都需要用粗体标记包装起来。您可能还想使类接受其他格式。此外，空格需要更好地处理，该类会剥离连续的空格并在末尾添加一个额外的空格。因此，请将下面的类视为演示代码，需要进一步完善才能实用，但它应该可以让您开始工作。

XAML:

<Window x:Class="FormatTest.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:FormatTest="clr-namespace:FormatTest"
    Title="Window1" Height="300" Width="300">

    <TextBlock FormatTest:FormattedTextBehavior.FormattedText="{Binding Path=Text}" />

</Window>

代码：

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;

namespace FormatTest
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();

            DataContext = this;
        }

        public string Text { get { return "Some <Bold>formatted</Bold> text."; } }
    }

    public static class FormattedTextBehavior
    {
        public static string GetFormattedText(DependencyObject obj)
        {
            return (string)obj.GetValue(FormattedTextProperty);
        }

        public static void SetFormattedText(DependencyObject obj, string value)
        {
            obj.SetValue(FormattedTextProperty, value);
        }

        public static readonly DependencyProperty FormattedTextProperty =
            DependencyProperty.RegisterAttached("FormattedText", 
                                                typeof(string),
                                                typeof(FormattedTextBehavior),
                                                new UIPropertyMetadata("", FormattedTextChanged));

        private static void FormattedTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            TextBlock textBlock = sender as TextBlock;
            string value = e.NewValue as string;
            string[] tokens = value.Split(' ');
            foreach (string token in tokens)
            {
                if (token.StartsWith("<Bold>") && token.EndsWith("</Bold>"))
                {
                    textBlock.Inlines.Add(new Bold(new Run(token.Replace("<Bold>", "").Replace("</Bold>", "") + " ")));
                }
                else
                {
                    textBlock.Inlines.Add(new Run(token + " "));
                }
            }
        }
    }
}

- Wallstreet Programmer

---

这很有趣。如果我正在创建一种新的格式类型，我会进一步调查，但感觉就像我在“重复造轮子”。 - Jodrell

Answer 4

编辑：

这行代码，

<props:Resources x:Key="Resources"/>

是访问Project.Properties.Resources命名空间的不好方法。重新编译时会导致尴尬的故障。

更好的方法是使用x:Static来做类似以下的事情，

Text="{x:Static props:Resources.SomeText}"

在你的绑定中。感谢Ben

---

好的，这就是我的做法。它不完美但是有效。

记住，有一个名为FormattedText的项目资源。

cs:

// TextBlock with a bindable InlineCollection property.

// Type is List(Inline) not InlineCollection becuase
// InlineCollection makes the IDE xaml parser complain
// presumably this is caused by an inherited attribute.

public class BindableTextBlock : TextBlock
{
    public static readonly DependencyProperty InlineCollectionProperty =
        DependencyProperty.Register(
            "InlineCollection",
            typeof(List<Inline>),
            typeof(BindableTextBlock),
            new UIPropertyMetadata(OnInlineCollectionChanged));

    private static void OnInlineCollectionChanged(DependencyObject sender,
        DependencyPropertyChangedEventArgs e)
    {
        BinableTextBlock instance = sender as BindableTextBlock;

        if (instance != null)
        {
            List<Inline> newText = e.NewValue as List<Inline>;
            if (newText != null)
            {
                // Clear the underlying Inlines property
                instance.Inlines.Clear();
                // Add the passed List<Inline> to the real Inlines
                instance.Inlines.AddRange(newText.ToList());
            }
        }
    }

    public List<Inline> InlineCollection
    {
        get
        {
            return (List<Inline>)GetValue(InlineCollectionProperty);
        }
        set
        {
            SetValue(InlineCollectionProperty, value);
        }
    }
}

// Convertor between a string of xaml with implied run elements
// and a generic list of inlines

[ValueConversion(typeof(string), typeof(List<Inline>))]
public class StringInlineCollectionConvertor : IValueConverter
{
    public object Convert(object value, 
        Type targetType, 
        object parameter, 
        System.Globalization.CultureInfo culture)
    {
        string text = value as String;

        // a surrogate TextBlock to host an InlineCollection
        TextBlock results = new TextBlock();

        if (!String.IsNullOrEmpty(text))
        {
            //Arbritary literal acting as a replace token, 
            //must not exist in the empty xaml definition.
            const string Replace = "xxx";

            // add a dummy run element and replace it with the text
            results.Inlines.Add(new Run(Replace));
            string resultsXaml = XamlWriter.Save(results);
            string resultsXamlWithText = resultsXaml.Replace(Replace, text);

            // deserialise the xaml back into our TextBlock
            results = XamlReader.Parse(resultsXamlWithText) as TextBlock;
        }
        return results.Inlines.ToList<Inline>();
    }

    // Not clear when this will be called but included for completeness

    public object ConvertBack(
        object value, 
        Type targetType, 
        object parameter, 
        System.Globalization.CultureInfo culture)
    {
        String results = String.Empty;

        InlineCollection inlines = value as InlineCollection;
        if (inlines != null)
        {
            //read the xaml as xml and return the "content"
            var reader = 
                XElement.Parse(XamlWriter.Save(inlines)).CreateReader();
            reader.MoveToContent();
            results = reader.ReadInnerXml();
        }
        return results;
    }
}

xaml:

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:props="clr-namespace:Project.Properties"
    xmlns:local="clr-namespace:Project">
    <Window.Resources>
        <props:Resources x:Key="Resources"/>
        <local:StringInlineCollectionConvertor x:Key="InlineConvert"/>
    </Window.Resources>
    <local:BindableTextBlock InlineCollection="
        {Binding Source={StaticResource Resources}, 
        Path=FormattedText, 
        Converter={StaticResource InlineConvert}}"/>
</Window>

我创建了两个类。一个是继承TextBlock的子类，具有“可绑定”的InlineCollection和一个IValueConverter，用于将集合从String转换为另一种格式。

直接使用InlineCollection作为属性类型会导致VS2010报错，尽管代码仍然可以正常运行。我改为使用Inlines的通用列表。我认为这是因为存在继承属性，告诉VS InlineCollection没有构造函数。

我尝试将InlineCollection属性设置为BindableTextBlock的ContentProperty，但遇到了问题并且时间不够。请随意采取下一步措施并告诉我相关信息。

对于任何排版错误，我深表歉意，因为这段代码必须被转录和清理。

如果有更好的方法，请告诉我。是否内置此功能或者我错过了什么？

- Jodrell

---

这样做有什么风险吗？ - tofutim

毫无疑问，如果文本中自然出现了“xxx”，那将是一个问题（可以随意用其他标记替换“xxx”）。还有其他可能性，你有什么想法吗？ - Jodrell

Answer 5

我最终需要在我的应用程序中执行此操作，并且必须支持 TextBlock 内联中通常可能的许多标记，因此我采用了 Wallstreet Programmer 上面的答案（这个答案非常完美，比我在这个话题上发现的大多数其他答案要简单得多），并对其进行了扩展。我想其他人可能会觉得这很有用。

我还没有对所有标记进行彻底测试，但我测试过的每一个标记都像魔法般地起作用。我还怀疑它不是世界上最快的代码，但是我的自己测试使用 ListView 中的几千条格式化消息似乎非常迅速。您的情况可能有所不同。 以下是代码：

XAML:

<Window x:Class="FormatTest.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:FormatTest="clr-namespace:FormatTest"
    Title="Window1" Height="300" Width="300">

    <TextBlock FormatTest:FormattedTextBehavior.FormattedText="{Binding Path=Text}" />

</Window>

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Media;

namespace FormatTest
{

public static class FormattedTextBehavior
{
    public class TextPart
    {
        public String mType = String.Empty;
        public Inline mInline = null;
        public InlineCollection mChildren = null;

        public TextPart() {}
        public TextPart(String t, Inline inline, InlineCollection col)
        {
            mType = t;
            mInline = inline;
            mChildren = col;
        }
    }

    private static Regex mRegex = new Regex(@"<(?<Span>/?[^>]*)>", RegexOptions.Compiled | RegexOptions.IgnoreCase);
    private static Regex mSpanRegex = new Regex("(?<Key>[^\\s=]+)=\"(?<Val>[^\\s\"]*)\"", RegexOptions.Compiled | RegexOptions.IgnoreCase);

    public static string GetFormattedText(DependencyObject obj)
    {
        return (string)obj.GetValue(FormattedTextProperty);
    }

    public static void SetFormattedText(DependencyObject obj, string value)
    {
        obj.SetValue(FormattedTextProperty, value);
    }

    public static readonly DependencyProperty FormattedTextProperty =
        DependencyProperty.RegisterAttached("FormattedText",
                                            typeof(string),
                                            typeof(FormattedTextBehavior),
                                            new UIPropertyMetadata("", FormattedTextChanged));

    private static void FormattedTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        TextBlock textBlock = sender as TextBlock;
        FormatText(e.NewValue as string, new TextPart("TextBlock", null, textBlock.Inlines));
    }

    public static void FormatText(String s, TextPart root)
    {
        int len = s.Length;
        int lastIdx = 0;
        List<TextPart> parts = new List<TextPart>();
        parts.Add(root);
        Match m = mRegex.Match(s);
        while (m.Success)
        {
            String tag = m.Result("${Span}");
            if (tag.StartsWith("/"))
            {
                String prevStr = s.Substring(lastIdx, m.Index - lastIdx);
                TextPart part = parts.Last();
                if (!String.IsNullOrEmpty(prevStr))
                {
                    if (part.mChildren != null)
                    {
                        part.mChildren.Add(new Run(prevStr));
                    }
                    else if (part.mInline is Run)
                    {
                        (part.mInline as Run).Text = prevStr;
                    }
                }
                if (!tag.Substring(1).Equals(part.mType, StringComparison.InvariantCultureIgnoreCase))
                {
                    Logger.LogD("Mismatched End Tag '" + tag.Substring(1) + "' (expected </" + part.mType + ">) at position " + m.Index.ToString() + " in String '" + s + "'");
                }
                if (parts.Count > 1)
                {
                    parts.RemoveAt(parts.Count - 1);
                    TextPart parentPart = parts.Last();
                    if (parentPart.mChildren != null)
                    {
                        parentPart.mChildren.Add(part.mInline);
                    }
                }
            }
            else
            {
                TextPart prevPart = parts.Last();
                String prevStr = s.Substring(lastIdx, m.Index - lastIdx);
                if (!String.IsNullOrEmpty(prevStr))
                {
                    if (prevPart.mChildren != null)
                    {
                        prevPart.mChildren.Add(new Run(prevStr));
                    }
                    else if (prevPart.mInline is Run)
                    {
                        (prevPart.mInline as Run).Text = prevStr;
                    }
                }

                bool hasAttributes = false;
                TextPart part = new TextPart();
                if (tag.StartsWith("bold", StringComparison.InvariantCultureIgnoreCase))
                {
                    part.mType = "BOLD";
                    part.mInline = new Bold();
                    part.mChildren = (part.mInline as Bold).Inlines;
                }
                else if (tag.StartsWith("underline", StringComparison.InvariantCultureIgnoreCase))
                {
                    part.mType = "UNDERLINE";
                    part.mInline = new Underline();
                    part.mChildren = (part.mInline as Underline).Inlines;
                }
                else if (tag.StartsWith("italic", StringComparison.InvariantCultureIgnoreCase))
                {
                    part.mType = "ITALIC";
                    part.mInline = new Italic();
                    part.mChildren = (part.mInline as Italic).Inlines;
                }
                else if (tag.StartsWith("linebreak", StringComparison.InvariantCultureIgnoreCase))
                {
                    part.mType = "LINEBREAK";
                    part.mInline = new LineBreak();
                }
                else if (tag.StartsWith("span", StringComparison.InvariantCultureIgnoreCase))
                {
                    hasAttributes = true;
                    part.mType = "SPAN";
                    part.mInline = new Span();
                    part.mChildren = (part.mInline as Span).Inlines;
                }
                else if (tag.StartsWith("run", StringComparison.InvariantCultureIgnoreCase))
                {
                    hasAttributes = true;
                    part.mType = "RUN";
                    part.mInline = new Run();
                }
                else if (tag.StartsWith("hyperlink", StringComparison.InvariantCultureIgnoreCase))
                {
                    hasAttributes = true;
                    part.mType = "HYPERLINK";
                    part.mInline = new Hyperlink();
                    part.mChildren = (part.mInline as Hyperlink).Inlines;
                }

                if (hasAttributes && part.mInline != null)
                {
                    Match m2 = mSpanRegex.Match(tag);
                    while (m2.Success)
                    {
                        String key = m2.Result("${Key}");
                        String val = m2.Result("${Val}");
                        if (key.Equals("FontWeight", StringComparison.InvariantCultureIgnoreCase))
                        {
                            FontWeight fw = FontWeights.Normal;
                            try
                            {
                                fw = (FontWeight)new FontWeightConverter().ConvertFromString(val);
                            }
                            catch (Exception)
                            {
                                fw = FontWeights.Normal;
                            }
                            part.mInline.FontWeight = fw;
                        }
                        else if (key.Equals("FontSize", StringComparison.InvariantCultureIgnoreCase))
                        {
                            double fs = part.mInline.FontSize;
                            if (Double.TryParse(val, out fs))
                            {
                                part.mInline.FontSize = fs;
                            }
                        }
                        else if (key.Equals("FontStretch", StringComparison.InvariantCultureIgnoreCase))
                        {
                            FontStretch fs = FontStretches.Normal;
                            try
                            {
                                fs = (FontStretch)new FontStretchConverter().ConvertFromString(val);
                            }
                            catch (Exception)
                            {
                                fs = FontStretches.Normal;
                            }
                            part.mInline.FontStretch = fs;
                        }
                        else if (key.Equals("FontStyle", StringComparison.InvariantCultureIgnoreCase))
                        {
                            FontStyle fs = FontStyles.Normal;
                            try
                            {
                                fs = (FontStyle)new FontStyleConverter().ConvertFromString(val);
                            }
                            catch (Exception)
                            {
                                fs = FontStyles.Normal;
                            }
                            part.mInline.FontStyle = fs;
                        }
                        else if (key.Equals("FontFamily", StringComparison.InvariantCultureIgnoreCase))
                        {
                            if (!String.IsNullOrEmpty(val))
                            {
                                FontFamily ff = new FontFamily(val);
                                if (Fonts.SystemFontFamilies.Contains(ff))
                                {
                                    part.mInline.FontFamily = ff;
                                }
                            }
                        }
                        else if (key.Equals("Background", StringComparison.InvariantCultureIgnoreCase))
                        {
                            Brush b = part.mInline.Background;
                            try
                            {
                                b = (Brush)new BrushConverter().ConvertFromString(val);
                            }
                            catch (Exception)
                            {
                                b = part.mInline.Background;
                            }
                            part.mInline.Background = b;
                        }
                        else if (key.Equals("Foreground", StringComparison.InvariantCultureIgnoreCase))
                        {
                            Brush b = part.mInline.Foreground;
                            try
                            {
                                b = (Brush)new BrushConverter().ConvertFromString(val);
                            }
                            catch (Exception)
                            {
                                b = part.mInline.Foreground;
                            }
                            part.mInline.Foreground = b;
                        }
                        else if (key.Equals("ToolTip", StringComparison.InvariantCultureIgnoreCase))
                        {
                            part.mInline.ToolTip = val;
                        }
                        else if (key.Equals("Text", StringComparison.InvariantCultureIgnoreCase) && part.mInline is Run)
                        {
                            (part.mInline as Run).Text = val;
                        }
                        else if (key.Equals("NavigateUri", StringComparison.InvariantCultureIgnoreCase) && part.mInline is Hyperlink)
                        {
                            (part.mInline as Hyperlink).NavigateUri = new Uri(val);
                        }
                        m2 = m2.NextMatch();
                    }
                }

                if (part.mInline != null)
                {
                    if (tag.TrimEnd().EndsWith("/"))
                    {
                        if (prevPart.mChildren != null)
                        {
                            prevPart.mChildren.Add(part.mInline);
                        }
                    }
                    else
                    {
                        parts.Add(part);
                    }
                }
            }
            lastIdx = m.Index + m.Length;
            m = m.NextMatch();
        }
        if (lastIdx < (len - 1))
        {
            root.mChildren.Add(new Run(s.Substring(lastIdx)));
        }
    }
}

}

- devnullicus

Answer 6

我用 Behavior 实现了相同的功能。以下是代码：

代码如下：

public class FormatTextBlock : Behavior<System.Windows.Controls.TextBlock>
{
    public static readonly DependencyProperty FormattedTextProperty = 
        DependencyProperty.Register(
            "FormattedText", 
            typeof(string),
            typeof(FormatTextBlock),
            new PropertyMetadata(string.Empty, OnFormattedTextChanged));

    public string FormattedText
    {
        get { return (string)AssociatedObject.GetValue(FormattedTextProperty); }
        set { AssociatedObject.SetValue(FormattedTextProperty, value); }
    }

    private static void OnFormattedTextChanged(DependencyObject textBlock, DependencyPropertyChangedEventArgs eventArgs)
    {
        System.Windows.Controls.TextBlock currentTxtBlock = (textBlock as FormatTextBlock).AssociatedObject;

        string text = eventArgs.NewValue as string;

        if (currentTxtBlock != null)
        {
            currentTxtBlock.Inlines.Clear();

            string[] strs = text.Split(new string[] { "<Bold>", "</Bold>" }, StringSplitOptions.None);

            for (int i = 0; i < strs.Length; i++)
            {
                currentTxtBlock.Inlines.Add(new Run { Text = strs[i], FontWeight = i % 2 == 1 ? FontWeights.Bold : FontWeights.Normal });
            }
        }
    }
}

XAML - 导入命名空间

<UserControl x:Class="MyClass"
         xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
         xmlns:behav="clr-namespace:myAssembly.myNameSapce;assembly=myAssembly"
>

接下来，使用该行为：

    <TextBlock TextWrapping="Wrap">
        <i:Interaction.Behaviors>
            <behav:FormatTextBlock FormattedText="{Binding Path=UIMessage}" />
        </i:Interaction.Behaviors>
    </TextBlock>

- Malu MN

Answer 7

这对我有用：

XAML：

<phone:PhoneApplicationPage x:Class="MyAPP.Views.Class"
                        xmlns:utils="clr-namespace:MyAPP.Utils">

以及您的TextBlock XAML：

<TextBlock utils:TextBlockHelper.FormattedText="{Binding Text}" />

代码：

public static class TextBlockHelper
{
    public static string GetFormattedText(DependencyObject textBlock)
    { 
        return (string)textBlock.GetValue(FormattedTextProperty); 
    }

    public static void SetFormattedText(DependencyObject textBlock, string value)
    { 
        textBlock.SetValue(FormattedTextProperty, value); 
    }

    public static readonly DependencyProperty FormattedTextProperty =
        DependencyProperty.RegisterAttached("FormattedText", typeof(string), typeof(TextBlock),
        new PropertyMetadata(string.Empty, (sender, e) =>
        {
            string text = e.NewValue as string;
            var textB1 = sender as TextBlock;
            if (textB1 != null)
            {
                textB1.Inlines.Clear();
                var str = text.Split(new string[] { "<b>", "</b>" }, StringSplitOptions.None);
                for (int i = 0; i < str.Length; i++)
                    textB1.Inlines.Add(new Run { Text = str[i], FontWeight = i % 2 == 1 ? FontWeights.Bold : FontWeights.Normal });

            }
        }));
}

在字符串绑定中使用：

String Text = Text <b>Bold</b>;

- Rodrigo Rodrigues

Answer 8

因此，将行为与获取附加属性相结合，并使用XamlReader的Jodrells，这是一个版本，可以处理大多数您希望在TextBlock中作为内联拥有的内容。仅支持默认和x：命名空间，但您可以扩展它。

public static readonly DependencyProperty FormattedTextProperty = DependencyProperty.RegisterAttached(
  "FormattedText",
  typeof(string),
  typeof(TextBlockBehaviour),
  new PropertyMetadata(default(string), FormattedTextChanged_));

public static bool GetFormattedText(TextBlock textBlock)
{
  return (bool)textBlock.GetValue(FormattedTextProperty);
}

public static void SetFormattedText(TextBlock textBlock, bool value)
{
  textBlock.SetValue(FormattedTextProperty, value);
}

private static void FormattedTextChanged_(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
  TextBlock textBlock = d as TextBlock;
  if (textBlock == null)
    return;

  textBlock.Inlines.Clear();

  string value = e.NewValue as string;
  if (string.IsNullOrEmpty(value))
  {
    textBlock.Text = null;
    return;
  }

  using (var stringReader = new StringReader($"<TextBlock xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\" xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\">{value}</TextBlock>"))
  {
    using (var xmlReader = XmlReader.Create(stringReader))
    {
      TextBlock newTextBlock = (TextBlock)XamlReader.Load(xmlReader);
      if (newTextBlock.Inlines.Count == 0)
      {
        textBlock.Text = newTextBlock.Text;
      }
      else
      {
        foreach (var inline in newTextBlock.Inlines.ToArray())
        {
          textBlock.Inlines.Add(inline);
        }
      }
    }
  }
}

- Ingeborg