Most efficient way to select a specific object type in Dictionary and delete it.

Question

Okay I have a series of objects based on a base class which are stored randomly in a Dictionary object. e.g.

class TypeA
{
   public int SomeNumber {get; set;}
   public void SomeFunction()
}

class TypeB : TypeA
{
   public string SomeString {get; set;}
}

class TypeC : TypeA
{
   public bool StuffReady()
}


Dictionary listOfClasses <long, TypeA>;

The Key value is a running count of the number of objects that have ever been placed into the dictionary. It does not match the current Dictionary count.

I wish to locate an object of TypeB where its SomeString == "123" say, and remove it. What would be the best way of doing this?

Answer 1

There doesn't appear to be a mapping between the TypeA class and the Key of the Dictionary. The key is of type long and there is no property of that type on the class. So you'll have to search the collection of KeyValuePair instances which will give you direct access to the key.

Try the following

var found = listOfClasses
  .Where(p => p.Value.SomeString == "123").
  .Where(p => p.Value.GetType() == typeof(TypeB))
  .Single();
listOfClasses.Remove(found.Key);

Answer 2

If you're sure that there will only be a single matching object (or if you only want to remove the first occurrence):

var found = listOfClasses.FirstOrDefault
    (
        x => (x.Value is TypeB) && (((TypeB)x.Value).SomeString == "123")
    );

if (found.Value != null)
{
    listOfClasses.Remove(found.Key);
}

If there could be multiple matching objects and you want to remove them all:

var query = listOfClasses.Where
    (
        x => (x.Value is TypeB) && (((TypeB)x.Value).SomeString == "123")
    );

// the ToArray() call is required to force eager evaluation of the query
// otherwise the runtime will throw an InvalidOperationException and
// complain that we're trying to modify the collection in mid-enumeration
foreach (var found in query.ToArray())
{
    listOfClasses.Remove(found.Key);
}

Answer 3

You need to store the running length in each object. Add a property say RunningLength in TypeA. Then use two dictionaries one to store TypeA objects and other for TypeB objects.

Whenever you create a object (of any type descending from TypeA) add it to first dictionary. If the object created is of TypeB add it to the second dictionary:

Dictionary listOfClasses <long, TypeA>;
Dictionary listOfTypeBClasses <string, TypeB>;

TypeA newOject = TypeAFactory.Create();

if(newObject is TypeB)
{
  TypeB objB = newObj as TypeB;
  listOfTypeBClasses[objB.SomeString] = objB;
}

To remove a object of TypeB with SomeString = "123"

if(listOfTypeBClasses.ContainsKey("123"))
{
  long keyA = listOfTypeBClasses["123"].RunningLength;
  listOfClasses.Remove(keyA);
  // if required remove the item from listOfTypeBClasses as well
  listOfTypeBClasses.Remove("123");
}

Answer 4

If you are looking in terms of performance then for loop is better way to go but if you are looking from compactness of code or from code management point of view then LINQ is the way.