WPF源代码分析系列一：剖析WPF模板机制的内部实现

Posted 2020-12-22 zencoder

(注：本文是《剖析WPF模板机制的内部实现》系列文章的第四篇，查看上一篇文章请点这里)

 

4. DataTemplate

上一篇文章我们讨论了ItemsPanelTemplate类，这一篇和下一篇将讨论DataTemplate类。

DataTemplate类型的变量非常多，主要有：

ComboBox.SelectionBoxItemTemplate

ContentControl.ContentTemplate

ContentPresenter.ContentTemplate

ContentPresenter.Template

DataGrid.RowHeaderTemplate

DataGridColumn.HeaderTemplate

DataGridRow.HeaderTemplate

DataGridRow.DetailsTemplate

DataGridTemplateColumn.CellTemplate

DataGridTemplateColumn.CellEditingTemplate

GridView.ColumnHeaderTemplate

GridViewColumn.HeaderTemplate

GridViewColumn.CellTemplate

GridViewHeaderRowPresenter.ColumnHeaderTemplate

GroupStyle.HeaderTemplate

HeaderedContentControl.HeaderTemplate

HeaderedItemsControl.HeaderTemplate

HierarchicalDataTemplate.ItemTemplate

ItemsControl.ItemTemplate

TabControl.SelectedContentTemplate

TabControl.ContentTemplate

我们这里只重点分析比较重要和有代表性的三个：ContentControl.ContentTemplate，ContentPresenter.ContentTemplate和ItemsControl.ItemTemplate。本篇文章只讨论前两个，ItemsControl.ItemTemplate留待下一篇文章讨论。

4.1）ContentControl.ContentTemplate和ContentPresenter.ContentTemplate

ContentControl和ContentPresenter的父类分别是Control和FrameworkElement，这意味着ContentControl也继承了Control.Template属性和模板选择机制。那么ContentControl.ContentTemplate属性和其Template属性究竟有什么关系？ContentControl和ContentPresenter的ContentTemplate属性在模板应用的角色是什么，二者又有什么联系？

要回答这些问题，我们先看ContentPresenter.ContentTemplate的定义：

//************ContentPresenter.cs**************public static readonly DependencyProperty ContentTemplateProperty =
                ContentControl.ContentTemplateProperty.AddOwner(
                        typeof(ContentPresenter),
                        new FrameworkPropertyMetadata(
                                (DataTemplate)null,
                                FrameworkPropertyMetadataOptions.AffectsMeasure,
                                new PropertyChangedCallback(OnContentTemplateChanged)));

 

        /// <summary>
        ///     ContentTemplate is the template used to display the content of the control.
        /// </summary>
        public DataTemplate ContentTemplate
        {
            get { return (DataTemplate) GetValue(ContentControl.ContentTemplateProperty); }
            set { SetValue(ContentControl.ContentTemplateProperty, value); }
        }

        private static void OnContentTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ContentPresenter ctrl = (ContentPresenter)d;
            ctrl._templateIsCurrent = false;
            ctrl.OnContentTemplateChanged((DataTemplate) e.OldValue, (DataTemplate) e.NewValue);
        }


        protected virtual void OnContentTemplateChanged(DataTemplate oldContentTemplate, DataTemplate newContentTemplate)
        {
            Helper.CheckTemplateAndTemplateSelector("Content", ContentTemplateProperty, ContentTemplateSelectorProperty, this);

            // if ContentTemplate is really changing, remove the old template
            this.Template = null;
        }

首先可以注意到依赖属性ContentTemplateProperty的注册没有使用DependencyProperty.Register()，而是用的ContentControl.ContentTemplateProperty.AddOwner()，此外ContentTemplate的读写也是用的ContentControl.ContentTemplateProperty。这意味着如果ContentPresenter处在ContentControlContent的visual tree上，那么其ContentTemplateProperty属性将继承ContentControl.ContentTemplateProperty的值。这就是WPF中依赖属性的继承。利用同样的方法，ContentPresenter还继承了ContentControl.ContentProperty属性。而我们还知道，就像ItemsControl的默认Template会包含一个ItemsPresenter控件（参见上一篇文章），ContentControl的默认Template模板也包含一个ContentPresenter控件。这意味着当ContentControl在应用模板生成visual tree时，将创建一个ContentPresenter控件，并把自己的ContentTemplate和Content属性的值传递给它的ContentPresenter控件，进而触发其调用自己的ApplyTemplate。ContentControl（以及ItemsPresenter）的模板应用就是这样一个大概可以分为两个步骤的级联过程。

ContentControl的模板应用机制这样基本就清楚了，不过为了搞清楚这个级联过程的第二个步骤，我们需要进一步剖析一下ContentPresenter的模板应用机制。

首先，从回调函数可以看出，一旦ContentPresenter.ContentTemplate属性被改变，无论这种任何变化，ContentPresenter.Template属性都将被清空。这个属性的定义如下：

//***********ContentPresenter.cs**************


        internal static readonly DependencyProperty TemplateProperty =
                DependencyProperty.Register(
                        "Template",
                        typeof(DataTemplate),
                        typeof(ContentPresenter),
                        new FrameworkPropertyMetadata(
                                (DataTemplate) null,  // default value
                                FrameworkPropertyMetadataOptions.AffectsMeasure,
                                new PropertyChangedCallback(OnTemplateChanged)));


        private DataTemplate Template
        {
            get {  return _templateCache; }
            set { SetValue(TemplateProperty, value); }
        }

        // Internal helper so FrameworkElement could see call the template changed virtual
        internal override void OnTemplateChangedInternal(FrameworkTemplate oldTemplate, FrameworkTemplate newTemplate)
        {
            OnTemplateChanged((DataTemplate)oldTemplate, (DataTemplate)newTemplate);
        }

        private static void OnTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ContentPresenter c = (ContentPresenter) d;
            StyleHelper.UpdateTemplateCache(c, (FrameworkTemplate) e.OldValue, (FrameworkTemplate) e.NewValue, TemplateProperty);
        }

这里可以看到，ContentPresenter.Template与Control.Template、ItemsPresenter的定义如出一辙，都以_templateCache字段作为支撑字段，只不过Template的类型这次被换成了DataTemplate。不过与ItemsPresenter相同，ContentPresenter类也覆写了FrameworkElement.OnPreApplyTemplate()方法，自定义了一个模板选择机制。这个方法先是调用EnsureTemplate()，而后者接着又调用了ChooseTemplate()来根据一定的优先顺序来选择一个合适的DataTemplate，并用这个确定是非空的模板更新其Template属性进而_templateCache字段，从而保证Framework在调用ApplyTemplate()时TemplateInternal是非空的。

这里有必要贴一下ContentPresenter.ChooseTemplate()方法的源代码，看一下ContentPresenter选择模板的优先级：

//***********ContentPresenter**************

 

        /// <summary>
        /// Return the template to use.  This may depend on the Content, or
        /// other properties.
        /// </summary>
        /// <remarks>
        /// The base class implements the following rules:
        ///   (a) If ContentTemplate is set, use it.
        ///   (b) If ContentTemplateSelector is set, call its
        ///         SelectTemplate method.  If the result is not null, use it.
        ///   (c) Look for a DataTemplate whose DataType matches the
        ///         Content among the resources known to the ContentPresenter
        ///         (including application, theme, and system resources).
        ///         If one is found, use it.
        ///   (d) If the type of Content is "common", use a standard template.
        ///         The common types are String, XmlNode, UIElement.
        ///   (e) Otherwise, use a default template that essentially converts
        ///         Content to a string and displays it in a TextBlock.
        /// Derived classes can override these rules and implement their own.
        /// </remarks>
        protected virtual DataTemplate ChooseTemplate()
        {
            DataTemplate template = null;
            object content = Content;
 

            // ContentTemplate has first stab
            template = ContentTemplate;

            // no ContentTemplate set, try ContentTemplateSelector
            if (template == null)
            {
                if (ContentTemplateSelector != null)
                {
                    template = ContentTemplateSelector.SelectTemplate(content, this);
                }
            }

            // if that failed, try the default TemplateSelector
            if (template == null)
            {
                template = DefaultTemplateSelector.SelectTemplate(content, this);
            }

            return template;
        }

 

可以看出，ContentPresenter在选择Template时，会优先选择ContentTemplate，如果为空，则会尝试调用ContentTemplateSelector.SelectTemplate()（DataTemplateSelector类型），如果再失败，会尝试调用其DefaultTemplateSelector.SelectTemplate()方法。

静态属性DefaultTemplateSelector是DefaultSelector类型 ，后者又继承自DataTemplateSelector类。DefaultSelector在覆写DataTemplateSelector.SelectTemplate()方法时引入了一套复杂的模板选择规则，以确保最终可以返回一个有效的DataTemplate：

//*******************DefaultSelector***********************

            /// <summary>
            /// Override this method to return an app specific <seealso cref="Template"/>.
            /// </summary>
            /// <param name="item">The data content</param>
            /// <param name="container">The container in which the content is to be displayed</param>
            /// <returns>a app specific template to apply.</returns>
            public override DataTemplate SelectTemplate(object item, DependencyObject container)
            {

                DataTemplate template = null;

                // Lookup template for typeof(Content) in resource dictionaries.
                if (item != null)
                {
                    template = (DataTemplate)FrameworkElement.FindTemplateResourceInternal(container, item, typeof(DataTemplate));
                }

                // default templates for well known types:
                if (template == null)
                {
                    TypeConverter tc = null;
                    string s;
 
                    if ((s = item as string) != null)
                        template = ((ContentPresenter)container).SelectTemplateForString(s);
                    else if (item is UIElement)
                        template = UIElementContentTemplate;
                    else if (SystemXmlHelper.IsXmlNode(item))
                        template = ((ContentPresenter)container).SelectTemplateForXML();
                    else if (item is Inline)
                        template = DefaultContentTemplate;
                    else if (item != null &&
                                (tc = TypeDescriptor.GetConverter(ReflectionHelper.GetReflectionType(item))) != null &&
                                tc.CanConvertTo(typeof(UIElement)))
                        template = UIElementContentTemplate;
                    else
                        template = DefaultContentTemplate;
                }

                return template;
            }
        }

 

至此，ContentPresenter在模板应用中的角色也一目了然了。可以看到ContentPresenter和ItemsPresenter的模板应用机制大同小异，它们都定义了一个_templateCache字段，并都覆写了FrameworkElement.TemplateInternal属性，使其返回值为_templateCache字段，同时又都覆写FrameworkElement.OnPreApplyTemplate()方法，来嵌入一个自定义的模板选择机制，并用选定的模板更新_templateCache字段。于是，它们利用这种模式实现了FrameworkElement.TemplateInternal属性的多态性，从而变相实现了FrameworkElement.ApplyTemplate()的多态性。

至此，两个重要的DataTemplate类型ContentControl.ContentTemplate和ContentPresenter.ContentTemplate就介绍了完毕，下一篇文章将介绍DataTemplate类型的另一个重要变量ItemsControl.ItemTemplate。