Question

I have a situation where I need to determine whether or not an inherited class is a specific inherited class, but the type expected in the model is the base class, and it is stored using nHibernate/Fluent nHibernate using a Table Per Concrete Class Hierarchy. So my structure looks a bit like this..

class Mutation : Entity {
   virtual Aspect Aspect { get; set; }
   virtual Measurement Measurement { get; set; }
}

abstract class Measurement : Entity {
   // does nothing on its own, really.
}

class Numeric : Measurement {
   virtual int Value { get; set; }
   // may have some other properties
}

class Observable : Measurement {
  virtual Aspect Aspect { get; set; }
}

So basically, what is going on here is this. Mutation expects to be pointed to a type of data, and a Measured change (there could be other ways to change the data, not just flat numerics). So then I would have an object that merely expects an IList<Mutation> and map each subsequent type of Measurement to its own specific table, sharing the Identity with the base Measurement class. That works fine so far.

Now an Observable is different in that it does not store its own value, but rather it points again to another Aspect that may have its own set of mutations and changes. The idea is that the value will always be retrieved from the intended source, and not saved as a flat value in the database. (There is a reason for wanting this behavior that is beyond the scope of this question)

So then, my thought was basically to put in an evaluation like this ..

foreach(var measurement in list) {
   if(measurement is Observable){
      // then we know to lookup the other value
   }
}

That didn’t work. I still get the proxied result of just MeasurementProxy. But the same code works fine in a standalone C# application without the use of nHibernate, so I feel a great deal of confidence that the issue is with the proxy.

I then added the following method to my base Entity class…

        /// <summary>
        /// Unwrap the type from whatever proxy it may be
        /// behind, returning the actual .NET <typeparamref name="System.Type"/>.
        /// </summary>
        /// <returns>
        /// A pure <typeparamref name="System.Type"/> that is no longer proxied.
        /// </returns>
        public virtual Type Unwrap() {
            return GetType();
        } 

Now if I do a Console.WriteLine(measurement.Unwrap()); I get the right type, but the same evaluation …

foreach(var measurement in list) {
   if(measurement.Unwrap() is Observable){
      // then we know to lookup the other value
   }
}

still does not function. It never runs. Can anyone help me out here?

Answer 1

That’s because Unwrap() returns a Type, so measurement.Unwrap() is Observable will always be false, and measurement.Unwrap() is Type would always be true.

Use the typeof operator and reference equality instead:

if (measurement.Unwrap() == typeof(Observable)) {
    // Then we know to lookup the other value.
}