Working with an unknown number of unknown types - .NET

Question

hey guys, I've removed some of the complexities of my needs to the core of what I need to know.

I want to send a collection of Values to a method, and inside that method I want to test the Value against, say, a property of an Entity. The property will always be of the same Type as the Value.

I also want to test if the value is null, or the default value, obviously depending on whether the value type is a reference type, or a value type.

Now, if all the values sent to the method are of the same type, then I could do this using generics, quite easily, like this:

public static void testGenerics<TValueType>(List<TValueType> Values) {

        //test null/default
        foreach (TValueType v in Values) {
            if (EqualityComparer<TValueType>.Default.Equals(v, default(TValueType))) {
                //value is null or default for its type
            } else {
                //comapre against another value of the same Type
                if (EqualityComparer<TValueType>.Default.Equals(v, SomeOtherValueOfTValueType)) {
                    //value equals
                } else {
                    //value doesn't equal
                }
            }
        }
    }

My questions is, how would I carry out the same function, if my Collection contained values of different Types.

My main concerns are successfully identifying null or default values, and successfully identifying if each value passed in, equals some other value of the same type.

Can I achieve this by simply passing the type object? I also can't really use the EqualityComparers as I can't use generics, because I'm passing in an unknown number of different Types.

is there a solution?

thanks

UPDATE

ok, searching around, could I use the following code to test for null/default successfully in my scenario (taken from this SO answer):

object defaultValue = type.IsValueType ? Activator.CreateInstance(type) : null;

I reckon this might work.

Now, how can I successfully compare two values of the same Type, without knowing their types successfully and reliably?

Answer 1

The short answer is "yes", but the longer answer is that it's possible but will take a non-trivial amount of effort on your part and some assumptions in order to make it work. Your issue really comes when you have values that would be considered "equal" when compared in strongly-typed code, but do not have reference equality. Your biggest offenders will be value types, as a boxed int with a value of 1 won't have referential equality to another boxed int of the same value.

Given that, you have to go down the road of using things like the IComparable interface. If your types will always specifically match, then this is likely sufficient. If either of your values implements IComparable then you can cast to that interface and compare to the other instance to determine equality (==0). If neither implements it then you'll likely have to rely on referential equality. For reference types this will work unless there is custom comparison logic (an overloaded == operator on the type, for example).

Just bear in mind that the types would have to match EXACTLY. In other words, an int and an short won't necessarily compare like this, nor would an int and a double.

You could also go down the path of using reflection to dynamically invoke the Default property on the generic type determined at runtime by the supplied Type variable, but I wouldn't want to do that if I didn't have to for performance and compile-time safety (or lack thereof) reasons.

Answer 2

Is the list of types you need to test a pre-determined list? If so, you can use the Visitor Pattern (and maybe even if not since we have Generics). Create a method on your Entities (can be done using partial classes) that takes in an interface. Your class then calls a method on that interface passing itself. The interface method can be generic, or you can create an overload for each type you want to test.

Battery about to die otherwise would give example.

---

Fifteen seconds after hitting "Save" the machine went into hibernate.

After thinking about it, the Visitor pattern might not solve your specific problem. I thought you were trying to compare entities, but it appears you are testing values (so potentially ints and strings).

But for the sake of completion, and because the visitor pattern is kind of cool once you realize what it does, here's an explanation.

The Visitor pattern allows you to handle multiple types without needing to figure out how to cast to the specific type (you decouple the type from the item using that type). It works by having two interfaces - the visitor and the acceptor:

interface IAcceptor
{
  void Accept(IVisitor visitor);
}

interface IVisitor
{
  void Visit(Type1 type1);
  void Visit(Type2 type2);
  .. etc ..
}

You can optionally use a generic method there:

interface IVisitor
{
  void Visit<T>(T instance);
}

The basic implementation of the accept method is:

  void Accept(IVisitor visitor)
  {
    visitor.Visit(this);
  }

Because the type implementing Accept() knows what type it is, the correct overload (or generic type) is used. You could achieve the same thing with reflection and a lookup table (or select statement), but this is much cleaner. Also, you don't have to duplicate the lookup among different implementations -- various classes can implement IVisitor to create type-specific functionality.

The Visitor pattern is one way of doing "Double Dispatch". The answer to this question is another way and you might be able to morph it into something that works for your specific case.

Basically, a long-winded non-answer to your problem, sorry. :) The problem intrigues me, though -- like how do you know what property on the entity you should test against?

Answer 3

There is Object.Equals(object left, object right) static method, it internally relies on Equals(object) implementation available at one of provided arguments. Why do you avoid using it?

The rules of implementing equality members are nearly the following:

1. Required: Override Equals(object) and GetHashCode() methods
2. Optional: Implement IEquatable<T> for your type (this is what EqualityComparer.Default relies on)
3. Optional: Implement == and != operators

So as you see, if you'll rely on object.Equals(object left, object right), this will be the best solution relying on strongly required part of equality implementation pattern.

Moreover, it will be the fastest option, since it relies just on virtual methods. Otherwise you'll anyway involve some reflection.

public static void TestGenerics(IList values) {
  foreach (object v in values) {
    if (ReferenceEquals(null,v)) {
      // v is null reference
    }
    else {
      var type = v.GetType();
      if (type.IsValueType && Equals(v, Activator.CreateInstance(type))) {
        // v is default value of its value type
      }
      else {
        // v is non-null value of some reference type
      }
    }
  }
}