Different perfomance and SelectedItem of ListBox having the same visual tree

I have created test WPF application with ListBox. I fill it with 100000 file names (string). The goal is to retrieve ListBoxItem object from user's selection by SelectedItem property. However, not is all that simple. The property SelectedItem returns different objects when filling ListBox with different ways. So, here's code.

#define USE_VISUAL_TREE

namespace WPFTest
{
    enum FileTest
    {
        ItemsSource,
        ForEachAddString,
        ForEachAddListBoxItem
    }

    public partial class Test : Window
    {
        FileTest test;

        string folder = Path.Combine(Directory.GetCurrentDirectory(), "A lot of files");

        private void ShowFiles(object sender, RoutedEventArgs e)
        {
            listBox.ItemsSource = null;
            listBox.Items.Clear();
            var files = Directory.EnumerateFiles(folder);

            switch (cmbTest.SelectedIndex)
            {
                case 0: //Way 1: The fastest way - immediately
                {
                    test = FileTest.ItemsSource;
                    listBox.ItemsSource = files;
                    break;
                }
                case 1: //Way 2: Takes 1 second more than Way 1
                {
                    test = FileTest.ForEachAddString;
                    files.ForEach(f => listBox.Items.Add(f));
                    break;
                }
                case 2: //Way 3: The slowest way
                {
                    test = FileTest.ForEachAddListBoxItem;
                    files.ForEach(f => listBox.Items.Add(new ListBoxItem { Content = f }));
                    break;
                }
            }
        }

        object GetElementInVisualTree(DependencyObject obj, int[] indexes)
        {
            for (int i = 0; i <= indexes.GetUpperBound(0); i++)
                obj = VisualTreeHelper.GetChild(obj, indexes[i]);
            return obj;
        }

        private void OnListBoxSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            object element;
            ListBox list = (ListBox)sender;

#if USE_VISUAL_TREE
            int index = list.SelectedIndex;
            element = GetElementInVisualTree(list, indexes: new int[] { 0, 0, 0, 1, 0, 0, index });
#else
            element = list.SelectedItem;
#endif
            ListBoxItem item = element as ListBoxItem;
            if (item != null)
            {
                Title = item.Content.ToString();
            }

        }

    }

    internal static class StringExtensions
    {
        internal static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
        {
            var enumerator = enumerable.GetEnumerator();
            while (enumerator.MoveNext())
                action(enumerator.Current);
        }
    }

}

The problem is that SelectedItem returns String when using ItemsSource (Way 1) and using ForEach with filling strings (Way 2). Filling ListBox with direct adding ListBoxItem (Way 3) correctly gives ListBoxItem. One can say that "So, what? Just add ListBoxItem directly. What's wrong with it?". That is why I created so many files - to test the speed of each way. What I have got:

1) ItemsSource is the fastest way - almost immediately.

2) ForEach with adding string takes 1 second more than ItemsSource.

3) The slowest is adding ListBoxItem directly - it takes 7 seconds.

Although the chances that a user will have 100000 files are slim to none, anyway it's 700% slower.

And here's the main weird behavior of ListBox - the visual tree for all three ways is THE SAME! Here are screen shots of all three visual trees (can't upload third screenshot because of limitation, but it is the same):

What each way returns by invoking SelecteItem property:

1) Way 1 (ItemsSource) - returns String.

2) Way 2 (ForEach with adding string) - returns String.

3) Way 3 (ForEach with adding ListBoxItem) - returns ListBoxItem.

So, if I choose ItemsSource, then I have to retrieve ListBoxItem someway. The way I have found is traversing visual tree (GetElementInVisualTree method). It is not the desired way.

SUMMARY:ListBox creates one and the same visual tree for each way, and at the same time these ways are different in speed and return different object in SelectedItem!

Can anyone explain such weird behavior?

There is no knowledge that is not power.