WPF源代碼分析系列一：剖析WPF模板機制的內部實作（五）

(注：本文是《剖析WPF模板機制的內部實作》系列文章的最后一篇文章，查看上一篇文章請點這里)

上一篇文章我們討論了DataTemplate型別的兩個重要變數，ContentControl.ContentTemplate和ContentPresenter.ContentTemplate，這一篇將討論這個型別的另一個重要變數ItemsControl.ItemTemplate，

4.2）ItemsControl.ItemTemplate

我們都知道ItemsControl控制元件在WPF中的重要性，ItemsControl.ItemTemplate用的也非常多，那么其在模板應用中的角色是什么呢？要回答這個問題，我們先看其定義：

    public static readonly DependencyProperty ItemTemplateProperty =
                DependencyProperty.Register(
                        "ItemTemplate",
                        typeof(DataTemplate),
                        typeof(ItemsControl),
                        new FrameworkPropertyMetadata(
                                (DataTemplate) null,
                                OnItemTemplateChanged));

        /// <summary>
        ///     ItemTemplate is the template used to display each item.
        /// </summary>public DataTemplate ItemTemplate
        {
            get { return (DataTemplate) GetValue(ItemTemplateProperty); }
            set { SetValue(ItemTemplateProperty, value); }
        }

        private static void OnItemTemplateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            ((ItemsControl) d).OnItemTemplateChanged((DataTemplate) e.OldValue, (DataTemplate) e.NewValue);
        }

        protected virtual void OnItemTemplateChanged(DataTemplate oldItemTemplate, DataTemplate newItemTemplate)
        {
            CheckTemplateSource();
 
            if (_itemContainerGenerator != null)
            {
                _itemContainerGenerator.Refresh();
            }
        }

 可以看到當ItemsControl.ItemTemplate改變時，會呼叫_itemContainerGenerator.Refresh()，這個方法的定義如下：

        // regenerate everything
        internal void Refresh()
        {
            OnRefresh();
        }

        // Called when the items collection is refreshed
        void OnRefresh()
        {
            ((IItemContainerGenerator)this).RemoveAll();

            // tell layout what happened
            if (ItemsChanged != null)
            {
                GeneratorPosition position = new GeneratorPosition(0, 0);
                ItemsChanged(this, new ItemsChangedEventArgs(NotifyCollectionChangedAction.Reset, position, 0, 0));
            }
        }

可見這個方法呼叫OnRefresh()，后者的主要作業是清空已經生成的元素，并觸發ItemsChanged事件，通知所有監聽者串列已經被重置，

查找ItemsControl.ItemTemplate的參考會發現一個值得注意的方法ItemsControl.PrepareContainerForItemOverride：

//*********************ItemsControl*************************

        /// <summary>
        /// Prepare the element to display the item.  This may involve
        /// applying styles, setting bindings, etc.
        /// </summary>
        protected virtual void PrepareContainerForItemOverride(DependencyObject element, object item)
        {
            // Each type of "ItemContainer" element may require its own initialization.
            // We use explicit polymorphism via internal methods for this.
            //
            // Another way would be to define an interface IGeneratedItemContainer with
            // corresponding virtual "core" methods.  Base classes (ContentControl,
            // ItemsControl, ContentPresenter) would implement the interface
            // and forward the work to subclasses via the "core" methods.
            //

            // While this is better from an OO point of view, and extends to
            // 3rd-party elements used as containers, it exposes more public API.
            // Management considers this undesirable, hence the following rather
            // inelegant code.

            HeaderedContentControl hcc;
            ContentControl cc;
            ContentPresenter cp;
            ItemsControl ic;
            HeaderedItemsControl hic;

            if ((hcc = element as HeaderedContentControl) != null)
            {
                hcc.PrepareHeaderedContentControl(item, ItemTemplate, ItemTemplateSelector, ItemStringFormat);
            }
            else if ((cc = element as ContentControl) != null)
            {
                cc.PrepareContentControl(item, ItemTemplate, ItemTemplateSelector, ItemStringFormat);
            }
            else if ((cp = element as ContentPresenter) != null)
            {
                cp.PrepareContentPresenter(item, ItemTemplate, ItemTemplateSelector, ItemStringFormat);
            }
            else if ((hic = element as HeaderedItemsControl) != null)
            {
                hic.PrepareHeaderedItemsControl(item, this);
            }
            else if ((ic = element as ItemsControl) != null)
            {
                if (ic != this)
                {
                    ic.PrepareItemsControl(item, this);
                }
            }
        }

這個方法共兩個引數，第一個引數element的作用是作為第二個引數item的容器（container），這個item實際就是ItemsControl.ItemsSource（IEnumerable型別）串列的資料項，這個方法的主要作業是根據引數element的型別，做一些準備作業：如HeaderedContentControl和HeaderedItemsControl會把ItemTemplate的值賦給HeaderTemplate，而ContentControl和ContentPresenter則會用它更新ContentTemplate，如果是element也是ItemsControl，這意味著一個ItemsControl的ItemTemplate里又嵌套了一個ItemsControl，這時就把父控制元件的ItemTemplate傳遞給子控制元件的ItemTemplate，

現在關鍵的問題是這里的引數element和item到底是怎么來的？要回答這個問題我們需要搞清楚ItemsControl.PrepareContainerForItemOverride()方法是怎么被呼叫的，查看參考可以發現ItemsControl.PrepareItemContainer()方法呼叫了這個方法，其代碼如下：

//**************ItemsControl****************

        /// <summary>
        /// Prepare the element to act as the ItemContainer for the corresponding item.
        /// </summary>
        void IGeneratorHost.PrepareItemContainer(DependencyObject container, object item)
        {
            // GroupItems are special - their information comes from a different place
            GroupItem groupItem = container as GroupItem;
            if (groupItem != null)
            {
                groupItem.PrepareItemContainer(item, this);
                return;
            }

            if (ShouldApplyItemContainerStyle(container, item))
            {
                // apply the ItemContainer style (if any)
                ApplyItemContainerStyle(container, item);
            }

            // forward ItemTemplate, et al.
            PrepareContainerForItemOverride(container, item);


            .........此處省略**行代碼
        }

可以看到這個方法調首先會檢查這個container是否GroupItem型別，如果不是則呼叫PrepareContainerForItemOverride()，并把container作為其第一引數，繼續追蹤這個方法的參考，我們會發現：ItemContainerGenerator類的PrepareItemContainer()呼叫了這個方法：

//*****************ItemContainerGenerator********************

        /// <summary>
        /// Prepare the given element to act as the container for the
        /// corresponding item.  This includes applying the container style,
        /// forwarding information from the host control (ItemTemplate, etc.),
        /// and other small adjustments.
        /// </summary>
        /// <remarks>
        /// This method must be called after the element has been added to the
        /// visual tree, so that resource references and inherited properties
        /// work correctly.
        /// </remarks>
        /// <param name="container"> The container to prepare.
        /// Normally this is the result of the previous call to GenerateNext.
        /// </param>
        void IItemContainerGenerator.PrepareItemContainer(DependencyObject container)
        {
            object item = container.ReadLocalValue(ItemForItemContainerProperty);
            Host.PrepareItemContainer(container, item);
        }

這個方法的注釋講的比較清楚：這個方法的作用是對這個containter做一些預處理作業，包括應用樣式，“轉交”（forward）一些來自宿主控制元件（我們這個例子是ItemsControl）的資訊（例如ItemTemplate等），為了讓資源參考和依賴屬性繼承正常作業，這個container在被加入visual tree前必須呼叫這個方法，

這個方法的第一個陳述句告訴我們資料項item可以通過container讀取ItemForItemContainerProperty的值獲得，這個屬性是附加屬性，ItemContainerGenerator有一個靜態方法LinkContainerToItem()，是專門用來為每個container設定（連接）這個屬性的：

//*****************ItemContainerGenerator********************

        // establish the link from the container to the corresponding item
        internal static void LinkContainerToItem(DependencyObject container, object item)
        {
            // always set the ItemForItemContainer property
            container.ClearValue(ItemForItemContainerProperty);
            container.SetValue(ItemForItemContainerProperty, item);

            // for non-direct items, set the DataContext property
            if (container != item)
            {
                container.SetValue(FrameworkElement.DataContextProperty, item);
            }
        }

這個方法在ItemContainerGenerator類內部被多次呼叫，其中關鍵的一次是在其內部類Generator的GenerateNext()方法，此外這個方法關于引數container的注釋也表明，這個container是通過呼叫GenerateNext()獲得的，因此這個方法無疑是例外重要的，其代碼如下：

//****************ItemContainerGenerator*******************

            /// <summary> Generate UI for the next item or group</summary>
            public DependencyObject GenerateNext(bool stopAtRealized, out bool isNewlyRealized)
            {
                DependencyObject container = null;
                isNewlyRealized = false;

                while (container == null)
                {
                    UnrealizedItemBlock uBlock = _cachedState.Block as UnrealizedItemBlock;
                    IList items =_factory.ItemsInternal;
                    int itemIndex = _cachedState.ItemIndex;
                    int incr = (_direction == GeneratorDirection.Forward) ? +1 : -1;

                    if (_cachedState.Block == _factory._itemMap)
                        _done = true;            // we've reached the end of the list

                    if (uBlock == null && stopAtRealized)
                        _done = true;

                    if (!(0 <= itemIndex && itemIndex < items.Count))
                        _done = true;

                    if (_done)
                    {
                        isNewlyRealized = false;
                        return null;
                    }

                    object item = items[itemIndex];

                    if (uBlock != null)
                    {
                        // We don't have a realized container for this item.  Try to use a recycled container
                        // if possible, otherwise generate a new container.

                        isNewlyRealized = true;
                        CollectionViewGroup group = item as CollectionViewGroup;

                        // DataGrid needs to generate DataGridRows for special items like NewItemPlaceHolder and when adding a new row.
                        // Generate a new container for such cases.
                        bool isNewItemPlaceHolderWhenGrouping = (_factory._generatesGroupItems && group == null);

                        if (_factory._recyclableContainers.Count > 0 && !_factory.Host.IsItemItsOwnContainer(item) && !isNewItemPlaceHolderWhenGrouping)
                        {
                            container = _factory._recyclableContainers.Dequeue();
                            isNewlyRealized = false;
                        }
                        else
                        {
                            if (group == null || !_factory.IsGrouping)
                            {
                                // generate container for an item
                                container = _factory.Host.GetContainerForItem(item);
                            }
                            else
                            {
                                // generate container for a group
                                container = _factory.ContainerForGroup(group);
                            }
                        }

                        // add the (item, container) to the current block
                        if (container != null)
                        {
                            ItemContainerGenerator.LinkContainerToItem(container, item);

                            _factory.Realize(uBlock, _cachedState.Offset, item, container);

                            // set AlternationIndex on the container (and possibly others)
                            _factory.SetAlternationIndex(_cachedState.Block, _cachedState.Offset, _direction);
                        }
                    }
                    else
                    {
                        // return existing realized container
                        isNewlyRealized = false;
                        RealizedItemBlock rib = (RealizedItemBlock)_cachedState.Block;
                        container = rib.ContainerAt(_cachedState.Offset);
                    }

                    // advance to the next item
                    _cachedState.ItemIndex = itemIndex;
                    if (_direction == GeneratorDirection.Forward)
                    {
                        _cachedState.Block.MoveForward(ref _cachedState, true);
                    }
                    else
                    {
                        _cachedState.Block.MoveBackward(ref _cachedState, true);
                    }
                }

                return container;
            }

從代碼可以看出，一個Generator在GenerateNext時，需要從_factory的ItemsInternal串列讀取一個item，然后再呼叫_factory欄位的Host屬性的GetContainerForItem()方法來為這個item生成一個container，那么這個關鍵的_factory欄位從何而來？事實上，_factory欄位是ItemsContainerGenerator型別，另外ItemsContainerGenerator類內部有一個Generator型別的欄位_generator，這個欄位在創建物件時會將這個ItemsContainerGenerator自身作為引數，傳給其_factory欄位，

Generator.GenerateNext()方法一共被呼叫了兩次，都是在兩個被多載的ItemsContainerGenerator.GenerateNext()方法里：

        DependencyObject IItemContainerGenerator.GenerateNext()
        {
            bool isNewlyRealized;
            if (_generator == null)
                throw new InvalidOperationException(SR.Get(SRID.GenerationNotInProgress));

            return _generator.GenerateNext(true, out isNewlyRealized);
        }

        DependencyObject IItemContainerGenerator.GenerateNext(out bool isNewlyRealized)
        {
            if (_generator == null)
                throw new InvalidOperationException(SR.Get(SRID.GenerationNotInProgress));

            return _generator.GenerateNext(false, out isNewlyRealized);
        }

其中，第一個方法比較重要，它一共被呼叫了三次，其中兩次是在Panel類：一次在Panel.GenerateChildren()，一次在Panel.AddChildren()，二者大同小異，我們只看第一個就足夠了：

        internal virtual void GenerateChildren()
        {
            // This method is typically called during layout, which suspends the dispatcher.
            // Firing an assert causes an exception "Dispatcher processing has been suspended, but messages are still being processed."
            // Besides, the asserted condition can actually arise in practice, and the
            // code responds harmlessly.

            IItemContainerGenerator generator = (IItemContainerGenerator)_itemContainerGenerator;
            if (generator != null)
            {
                using (generator.StartAt(new GeneratorPosition(-1, 0), GeneratorDirection.Forward))
                {
                    UIElement child;
                    while ((child = generator.GenerateNext() as UIElement) != null)
                    {
                        _uiElementCollection.AddInternal(child);
                        generator.PrepareItemContainer(child);
                    }
                }
            }
        }

從代碼可以看到，Panel會回圈呼叫其_itemContainerGenerator欄位(Generator屬性)的GenerateNext()方法直到無法繼續，每次呼叫都會生成一個UIElement型別的child，這個child將被加入Panel的內部UI元素串列，并對其呼叫_itemContainerGenerator.PrepareItemContainer(child)方法，而這里的這個child就是我們前面提到的container，

至此，container和item的來龍去脈我們算基本搞清楚了，

但是，這里的問題是，Panel類的這個神秘的_itemContainerGenerator欄位是從哪里來的？一個Panel怎么會和ItemContainerGenerator扯上關系？秘密就在下面這個方法：

//*************Panel*************


        private void ConnectToGenerator()
        {
            ItemsControl itemsOwner = ItemsControl.GetItemsOwner(this);

            if (itemsOwner == null)
            {
                // This can happen if IsItemsHost=true, but the panel is not nested in an ItemsControl
                throw new InvalidOperationException(SR.Get(SRID.Panel_ItemsControlNotFound));
            }

            IItemContainerGenerator itemsOwnerGenerator = itemsOwner.ItemContainerGenerator;

            if (itemsOwnerGenerator != null)
            {
                _itemContainerGenerator = itemsOwnerGenerator.GetItemContainerGeneratorForPanel(this);

                if (_itemContainerGenerator != null)
                {
                    _itemContainerGenerator.ItemsChanged += new ItemsChangedEventHandler(OnItemsChanged);
                    ((IItemContainerGenerator)_itemContainerGenerator).RemoveAll();
                }
            }
        }

可以看到，這個方法會先呼叫靜態方法ItemsControl.GetItemsOwner()獲得這個Panel所處的ItemsControl，這個方法的定義如下：

//****************ItemsControl******************* 

       /// <summary>
        ///     Returns the ItemsControl for which element is an ItemsHost.
        ///     More precisely, if element is marked by setting IsItemsHost="true"
        ///     in the style for an ItemsControl, or if element is a panel created
        ///     by the ItemsPresenter for an ItemsControl, return that ItemsControl.
        ///     Otherwise, return null.
        /// </summary>
        public static ItemsControl GetItemsOwner(DependencyObject element)
        {
            ItemsControl container = null;
            Panel panel = element as Panel;

            if (panel != null && panel.IsItemsHost)
            {
                // see if element was generated for an ItemsPresenter
                ItemsPresenter ip = ItemsPresenter.FromPanel(panel);

                if (ip != null)
                {
                    // if so use the element whose style begat the ItemsPresenter
                    container = ip.Owner;
                }
                else
                {
                    // otherwise use element's templated parent
                    container = panel.TemplatedParent as ItemsControl;
                }
            }

            return container;
        }

這個方法的邏輯很簡單：在獲取一個Panel所關聯的ItemsControl時，如果這個Panel的IsItemsHost屬性非真則回傳空值；不然，那么如果這個Panel的TemplateParent是ItemsPresenter，則回傳其Owner，否則則直接回傳這個Panel的TemplateParent，

在知道自己所在的ItemsControl后，這個Panel就能呼叫這個ItemsControl的ItemContainerGenerator屬性的GetItemContainerGeneratorForPanel()方法來獲得一個正確的ItemContainerGenerator給其_itemContainerGenerator欄位（Panel的Generator屬性）賦值，

現在問題的關鍵是，一個Panel的TemplateParent是怎么和一個ItemsControl扯上關系的？我們在第三篇文章介紹ItemsPanelTemplate時曾提到過，ItemsControl的默認Template里的ItemsPresenter只起一個占位符（placeholder）的作用，它的主要角色是接收ItemsControl的ItemsPanel模板，并在ItemsControl應用模板時應用這個模板，

我們再可以看一下ItemsControl的默認ItemsPanel模板：

        <ItemsPanelTemplate x:Key="ItemsPanelTemplate1">
            <StackPanel/>
        </ItemsPanelTemplate>

 （我們前面提到過，ItemsControl類在注冊ItemsPanelTemplateProperty依賴屬性時，其默認值就是StackPanel，另外值得一提的時：ListBox和ListView的默認ItemsPanel都是VirtualizingStackPanel，Menu類是WrapPanel，StatusBar類是DockPanel），

而我們知道，要想讓這個ItemsPanel模板起作用，ItemsControl的Template內還必須包含一個ItemsPresenter：

        <Style TargetType="{x:Type ItemsControl}">
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="{x:Type ItemsControl}">
                        <Border>
                            <ItemsPresenter />
                        </Border>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>

這時一個ItemsControl的Template模板里的ItemsPresenter在應用這個ItemsControl的ItemsPanel模板時，會將模板里面的Panel類控制元件的TemplateParent設定為這個ItemsControl，同時將其IsItemsHost屬性標識為true，

ItemsControl還有一種用法是忽略ItemsPanel，直接在其Template內指定一個"ItemsPanel"，如下面的代碼：

        <Style TargetType="{x:Type ItemsControl}">
            <Setter Property="Template">
                <Setter.Value>
                    <ControlTemplate TargetType="{x:Type ItemsControl}">
                        <Border>
                           <StackPanel IsItemsHost="True"/>
                        </Border>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>

這時ItemsPanel模板的設定將被直接忽略，不過，這時一定要將這個Panel的IsItemsHost設定為True，否則ItemsControl將找不到一個合適的ItemsPanel來顯示串列項，

最后，結合第三篇文章的內容，我們再按照從上至下的順序從整體上梳理一下ItemsControl的模板應用機制：一個ItemsControl在應用模板時，首先會應用Template模板（ControlTemplate型別）生成自身的visual tree（Control類的模板機制），然后Template模板中的ItemsPresenter應用其TemplateParent（即這個ItemsControl）的ItemsPanel模板（ItemsPanelTemplate型別）生成一個visual tree，并把這個visual tree放置在這個ItemsPresenter的位置（ItemsPresenter這時起到占位符的作用），在ItemsPanel模板被應用時，這個面板的TemplateParent會被指向這個ItemsControl，同時其IsItemsHost屬性被標識為true，ItemsControl的ItemContainerGeneror在遍歷自己的ItemsInternal串列并為每個串列項（item）生成一個container，并將ItemsControl的ItemTemplate模板“轉交”（forward）給這個container，這樣這個container就可以應用模板，為與自己對應的資料項（item）生成一個由這個ItemTemplate定義的visual tree，當然具體程序要復雜的多，

至此，本文算全部寫完了，最后再強行總結一下WPF的模板機制：

1.FrameworkTemplate是所有模板類的基類，FrameworkElement類有一個FrameworkTemplate型別的TemplateInternal屬性，FrameworkElement.ApplyTemplate()將使用這個屬性的模板物件來生成visual tree，并將這個visual tree賦值給自己的TemplateChild屬性，從而在兩個Visual類物件之間建立起parent-child relationship；

2.FrameworkElement的TemplateInternal屬性是虛屬性，FrameworkElement子類可以通過覆寫這個屬性來自定義模板，只有四個類Control、ContentPresenter、ItemsPresenter、Page覆寫了這個屬性，這意味著只有這4個類及其子類控制元件才能應用自定義的模板，它們也是WPF模板機制的實作基礎；

3.FrameworkTemplate類有三個子類：ControlTemplate、ItemsPanelTemplate和DataTemplate，WPF中這些模板類定義的變數很多，它們的內部實作也不盡相同，不過萬變不離其宗，所有模板類最終都要把自己傳遞到FrameworkElement.TemplateInternal屬性上，才能被應用，生成的visual tree才能被加載到整體的visual tree中，FrameworkElement.ApplyTemplate()方法是FrameworkElement及其子類模板應用的總入口，

（WPF源代碼：https://github.com/dotnet/wpf，）

（感謝閱讀，歡迎批評指正，轉載請注明出處）

標籤：.NET技术

上一篇：基于.NetCore3.1系列 —— 日志記錄之初識Serilog

下一篇：WCF 動態代理與攔截器