Question

In my code, I have a class that maintains a number of lists. We’ll focus on one of them for the moment, since it’s the one that highlighted the problem.

internal List<Badge> Badges { get; private set; }

In the code, I add Badge instances to this list when an XML document is parsed. Later, I want to update the individual instances in the list so I can have the data written back out to XML. Because of the way the data’s XML structure differs from the original file structure, there’s some hocus-pocus involved, but that’s largely mapped out. The surprise came when I attempted to update an item in the List<Badge>.

Specifically, the problematic code is here:

// Get the current badge from the loaded XML data, so we can update it.
var currentBadge = this.GameData.GetCurrentBadge();

I always get a valid badge back. The surprise, as I’ve come to find out, is that this simple test always fails:

var result = this.GameData.Badges.IndexOf(currentBadge);

result always evaluates to -1, indicating that the object doesn’t exist in the collection. (EDIT: Updating the properties on currentBadge has no effect whatsoever on the contents of the matching item in this.GameData.Badges.) Which leads me to conclude that I’m getting a copy of my object back, and not a reference, as I would have expected.

For the inquisitive, the code to retrieve badges from the GameData class is included below. I have a sneaking suspicion that this is a documented behavior of generic lists, and that this is the first time I’ve stumbled across it. If so, I’m in for a very rude awakening. If it’s not, I’d really like to know why my objects are coming back “disconnected” from their originals.

private Badge GetCurrentBadge()
{
    var badgeItem = GetCurrentBadgeItem();
    if (badgeItem != null)
    {
        return this.GameData.GetBadgeByText(badgeItem.Text);
    }
    return null;
}

private MenuOption GetCurrentBadgeItem()
{
    if (!(this.currentItem is MenuOption && 
         (this.currentItem as MenuOption).IsLocked))
    {
        return null;
    }

    MenuOption result = null;
    var children = this.currentMenu.Children;

    for (var n = children.Count - 1; n >= 0; n--)
    {
        var child = children[n] as MenuOption;
        if (child == null || !child.IsLocked)
        {
            break;
        }

        if (!child.Text.StartsWith(" "))
        {
            result = child;
            break;
        }
    }

    return result;
}

UPDATE: Per request, GetBadgeByText, which comes from the GameData class.

internal Badge GetBadgeByText(string badgeText)
{
    foreach (var badge in Badges)
    {
        if (badge.Text.ToLower() == badgeText.ToLower())
        {
            return badge;
        }
    }

    return null;
    // var b = (from l in Badges
    //         where l.Text.ToLower().StartsWith(badgeText.ToLower())
    //         select l).FirstOrDefault();
    //return b;
}

As you can see, I’ve tried it both with and without Linq, just to eliminate that as the culprit. Changing the implementation had no noticable effect.

And for the record, all the objects in this application are CLASSES. No structs anywhere.

UPDATE #2: The Badge class.

internal class Badge
         : GameDataItem
{
    public Badge()
        : base()
    {
    }

    public string AuthId { get; set; }

    public string Category { get; set; }

    public string Description { get; set; }

    public bool IsAccoladePower { get; set; }

    public string RequiredBadges { get; set; }

    public override string ToString()
    {
        return Text;
    }

    internal string ToXml()
    {
        var template = "<Badge value=\"{0}\" title=\"{1}\" category=\"{2}\" authid=\"{3}\" requires=\"{4}\" accolade=\"{5}\" description=\"{6}\" />";
        return string.Format(template,
            this.Value,
            this.Text,
            this.Category,
            this.AuthId,
            this.RequiredBadges,
            this.IsAccoladePower,
            this.Description);
    }
}

And just in case someone asks for it, the base class:

internal class GameDataItem
{
    private string _text;
    public string Text
    {
        get
        {
            return this._text;
        }
        set
        {
            this._text = value.Replace("&lt;", "<")
                         .Replace("&gt;", ">")
                         .Replace("&amp;", "&");
        }
    }
    public string Value { get; set; }
    public override string ToString()
    {
        return Text + "=\"" + Value + "\"";
    }
}

Answer 1

Looks to me like this has something to do with MenuOption‘s implementation of Equals(object). The IndexOf() method of the List<> will use Equals(object) when deciding what to return.