Question

Simple class

public class Group
{
    public Int16 ID { get; private set; }
    public string Name { get; set; }
    public Group ( Int16 id, string name ) 
    { ID = id; Name = name; }
}

What I would like is an ObservableCollection where the collection forces uniqueness on ID and CaseInsensitive uniqueness on Name.

What I tried is:

public class Group
{
    public Int16 ID { get; private set; }
    public string Name { get; set; }

    public override bool Equals(System.Object obj)
    {
        // If parameter is null return false.
        if (obj == null)
        {
            return false;
        }

        // If parameter cannot be cast to Point return false.
        Group g = obj as Group;
        if ((System.Object)g == null)
        {
            return false;
        }

        // Return true if either fields match:
        return ( ID == g.ID || string.Compare(Name, g.Name, true) == 0 ) ;
    }

    public bool Equals(Group g)
    {
        // If parameter is null return false:
        if ((object)g == null)
        {
            return false;
        }

        // Return true if either fields match:
        return ( ID == g.ID || string.Compare(Name, g.Name, true) == 0 ) ;
    }

    public override int GetHashCode()
    {
        return ID; // ^ (Int32)Name.ToLower();
    }

    public Group ( Int16 id, string name ) 
    { ID = id; Name = name; }
}

HashSet &lt Group &gt

That prevents adding a group with the same ID not doe not prevent adding a group with the same Name. And it does not stop renaming a Name to an existing Name.

Answer 1

It will take a little tweaking of your class but here is how to do it. First you need group to notify the collection that you are about to change the name, do this by adding a event and modifying the setter of Name.

First Add this Interface and event handeler.

public delegate void TestForColisions(object sender, TestForColisionsArgs e);

public class TestForColisionsArgs : CancelEventArgs
{
    public TestForColisionsArgs(object newValue)
    {
        NewValue = newValue;
    }

    public object NewValue { get; private set; }
}


public interface ITestForColisions
{
    /// <summary>
    /// Set the event to Canceled if there will be a collision.
    /// </summary>
    event TestForColisions TestForCollision;
}

Then have your class implement the interface

public class Group : ITestForColisions, IEquateable<Group>
{
    public Int16 ID { get; private set; }

    private string _Name;
    public string Name 
    {
        get { return _Name; }
        set
        {
            //If RaiseNameChanging returns true there was a collision.
            if (RaiseNameChanging(value))
            {
                throw new ArgumentException(String.Format("The name {0} is in use in the collection", value));
            }
            else
            {
                _Name = value;
            }
        }
    }

    protected virtual bool RaiseNameChanging(string name)
    {
        //Make a copy with the new name.
        var newGroup = (Group)this.MemberwiseClone();
        newGroup.Name = name;

        var cancelEventArgs = new TestForColisionsArgs(newGroup);
        if (TestForCollision != null)
        {
            TestForCollision(this, cancelEventArgs);
        }
        return cancelEventArgs.Cancel;
    }

   //(...)
}

Then you will need a custom collection that listens for TestForCollision events and handles accordingly. For most of the methods you can just call the parent _BaseSet‘s version, however for any of the methods that modify the set you will need to either subscribe or un-subscribe to the event. I have done Clear, Add and Remove for you.

public class ColisionTestedCollection<T> : ISet<T>
    where T : ITestForColisions
{
    public ColisionTestedCollection(ISet<T> baseSet)
    {
        _BaseSet = baseSet;
        _EqualityComparer = EqualityComparer<T>.Default;
    }

    public ColisionTestedCollection(ISet<T> baseSet, IEqualityComparer<T> equalityComparer)
    {
        _BaseSet = baseSet;
        _EqualityComparer = equalityComparer;
    }

    private ISet<T> _BaseSet;
    private IEqualityComparer<T> _EqualityComparer;


    void TestItemsForCollision(object sender, TestForColisionsArgs e)
    {
        if (_BaseSet.Contains((T)e.NewValue, _EqualityComparer))
        {
            e.Cancel = true;
        }
    }

    public bool Add(T item)
    {
        bool added = _BaseSet.Add(item);
        if(added)
            item.TestForCollision += TestItemsForCollision;
        return added;
    }

    void ICollection<T>.Add(T item)
    {
        ((ICollection<T>)_BaseSet).Add(item);
        item.TestForCollision += TestItemsForCollision;
    }

    public bool Remove(T item)
    {
        bool removed = _BaseSet.Remove(item);
        if (removed)
            item.TestForCollision -= TestItemsForCollision;
        return removed;
    }

    public void Clear()
    {
        foreach (var item in _BaseSet)
            item.TestForCollision -= TestItemsForCollision;
        _BaseSet.Clear();
    }

    public void ExceptWith(IEnumerable<T> other)
    {
        throw new NotImplementedException();
    }

    public void IntersectWith(IEnumerable<T> other)
    {
        throw new NotImplementedException();
    }

    public void SymmetricExceptWith(IEnumerable<T> other)
    {
        throw new NotImplementedException();
    }

    public void UnionWith(IEnumerable<T> other)
    {
        throw new NotImplementedException();
    }

    //The rest of the functions will just be simply calling _BaseSet's version of the method. 
    public bool IsProperSubsetOf(IEnumerable<T> other)
    {
        return _BaseSet.IsProperSubsetOf(other);
    }
    //(snip)
}