backstage | Backstage is an open platform for building developer portals | Continuous Deployment library

The reason that ContainerFromIndex returns null is that the container simply is not realized.

Returns the element corresponding to the item at the given index within the ItemCollection or returns null if the item is not realized.

This is controlled by the ItemContainerGenerator that is responsible for the following actions.

• Maintains an association between the data view of a multiple-item control, such as ContainerFromElement and the corresponding UIElement tasks.

• Generates UIElement items on behalf of a multiple-item control.

A ListBox is an ItemsControl that exposes the ItemsSource property for binding or assigning a collection.

A collection that is used to generate the content of the ItemsControl. The default is null.

Another option is to simply add items to the Items collection in XAML or code.

The collection that is used to generate the content of the ItemsControl. The default is an empty collection. [...]

The property to access the collection object itself is read-only, and the collection itself is read-write.

The Items property is of type ItemCollection, which is also a view.

If you have an ItemsControl, such as a ListBox that has content, you can use the Items property to access the ItemCollection, which is a view. Because it is a view, you can then use the view-related functionalities such as sorting, filtering, and grouping. Note that when ItemsSource is set, the view operations delegate to the view over the ItemsSource collection. Therefore, the ItemCollection supports sorting, filtering, and grouping only if the delegated view supported them.

You cannot use both ItemsSource and Items at the same time, they are related.

[...] you use either the Items or the ItemsSource property to specify the collection that should be used to generate the content of your ItemsControl. When the ItemsSource property is set, the Items collection is made read-only and fixed-size.

Both ItemsSource and Items either maintain a reference to or bind your data items, these are not the containers. The ItemContainerGenerator is responsible for creating the user interface elements or containers such as ListBoxItem and maintaining the relationship between the data and these items. These containers do not just exist throughout the lifecycle of your application, they get created and destroyed as needed. When does that happen? It depends. Containers are created or realized (using the internal terminology) when they are shown in the UI. That is why you only gain access to a container after it was first shown. How long they actually exist depends on factors like interaction, virtualization or container recycling. By interaction I mean any form of changing the viewport, which is the part of the list that you can actually see. Whenever items are scrolled into view, they need to be realized of course. For large lists with tens of thousands of items, realizing all containers in advance or keeping all containers once they are realized would hit performace and increase memory consumption drastically. That is where virtualization comes into play. See Displaying large data sets for reference.

UI Virtualization is an important aspect of list controls. UI virtualization should not be confused with data virtualization. UI virtualization stores only visible items in memory but in a data-binding scenario stores the entire data structure in memory. In contrast, data virtualization stores only the data items that are visible on the screen in memory.

By default, UI virtualization is enabled for the ListView and ListBox controls when their list items are bound to data.

This implies that containers are deleted, too. Additionally, there is container recycling:

When an ItemsControl that uses UI virtualization is populated, it creates an item container for each item that scrolls into view and destroys the item container for each item that scrolls out of view. Container recycling enables the control to reuse the existing item containers for different data items, so that item containers are not constantly created and destroyed as the user scrolls the ItemsControl. You can choose to enable item recycling by setting the VirtualizationMode attached property to Recycling.

The consequence of virtualization and container recycling is that containers for all items are not realized in general. There are only containers for a subset of your bound or assigned items and they may be recycled or detached. That is why it is dangerous to directly reference e.g. ListBoxItems. Even if virtualization is disabled, you can run into problems like yours, trying to access user interface elements with a different lifetime than your data items.

In essence, your approach can work, but I recommend a different approach that is much more stable and robust and compatible with all of the aforementioned caveats.

What is actually happening here? Let us explore the code in medium depth, as my wrists already hurt.

Here is the ContainerFromIndex method in the reference source of .NET.

• The for loop in line 931 iterates ItemBlocks using the Next property of the _itemMap.
• When your items were not shown, yet in the user interface, they are not realized.
• In this case, Next will return an UnrealizedItemBlock (derivative of ItemBlock).
• This item block will have a property ItemCount of zero.
• The if condition in line 933 will not be met.
• This continues until the item blocks are iterated and null is returned in line 954..

Once the ListBox and its items are shown, the Next iterator will return a RealizedItemBlock which has an ItemCount of greater than zero and will therefore yield an item.

How are the containers realized then? There are methods to generate containers.

• DependencyObject IItemContainerGenerator.GenerateNext(), see line 230.
• DependencyObject IItemContainerGenerator.GenerateNext(out bool isNewlyRealized), see line 239.

These are called in various places, like VirtualizingStackPanel - for virtualization.

• protected internal override void BringIndexIntoView(int index), see line 1576, which does exactly what it is called. When an item with a certain index needs to be brought into view, e.g. through scrolling, the panel needs to create the item container in order to show the item in the user interface.
• private void MeasureChild(...), see line 8005. This method is used when calculating the space needed to display a ListView, which is influenced by the number and size of its items as needed.
• ...

Over lots of indirections from a high-level ListBox over its base type ItemsControl, ultimately, the ItemContainerGenerator is called to realize items.

For all the previously stated issues, there is a simple, yet superior solution. Separate your data and application logic from the user interface. This can be done using the MVVM design pattern. For an introduction, you can refer to the Patterns - WPF Apps With The Model-View-ViewModel Design Pattern article by Josh Smith.

In this solution I use the Microsoft.Toolkit.Mvvm NuGet package from Microsoft. You can find an introduction and a detailed documentation here. I use it because for MVVM in WPF you need some boilerplate code for observable objects and commands that would bloat the example for a beginner. It is a good library to start and later learn the details of how the tools work behind the scenes.

So let us get started. Install the aforementioned NuGet package in a new solution. Next, create a type that represents our data item. It only contains two properties, one for the index, which is read-only and one for the checked state that can be changed. Bindings only work with properties, that is why we use them instead of e.g. fields. The type derives from ObservableObject which implements the INotifyPropertyChanged interface. This interface needs to be implemented to be able to notify that property values changed, otherwise the bindings that are introduced later will not know when to update the value in the user interface. The ObservableObject base type already provides a SetProperty method that will take care of setting a new value to the backing field of a property and automatically notify its change.