Object Identity and implicit Interface Implementations

Hi there,

I am excited about LINQ. To use it in our applications we need the following:

- A an object loaded from several queries should be the same, that is only instanciated once in memory (at least as an option). [This is what typical O/R Mappers do]. However there are variations of this pattern when it comes to implementing nested transactions on memory objects.

- If I load any object from the database that has a name property/column and let there be an interface INamedObject that requires one name property. Can I then cast the retrieved object to INamedObject without any hassel If so, then this means I could cast loaded objects to any interface that they could implement. Much like delegates only require the signature to be corrrect only.

This is useful when passing the object to a method that accepts objects of type INameObject.

However there is a semantical problem with this approach, as the interface or contract will only check for members not for behaviour. I am not sure what the Spec# guys would say to this

What is your answer regarding the application of business logic to loaded objects using interfaces

Thanks

Tim

Please reply to: tfischer@tangible.de, Tim F. Fischer CEO , tangible engineering

Answer this question

Object Identity and implicit Interface Implementations

pgpkeys

Implicit typing isn't, I believe, supported yet in the CLR. However, if you hunt on CodeProject, there are examples of how to go about emulating such a thing.

You could, for example, use lightweight code generation. Here's a sketch of how I think it could work:

public class NamedObject<T>: INamedObject
{
   private readonly T _obj;

   public T InternalObject { get { return _obj; } }

   public NamedObject(T obj)
   {
      this._obj = obj;

      if (GetName == null) // you'd want to lock this section for thread safety
      {
         // use lightweight code generation to
         // create a delegate to retrieve the
         // name property from obj

         // store the delegate in GetName
      }
   }

   public string Name { get { return GetName(this.InternalObject); } }

   private static delegate string NameGetter(T obj);

   private static NameGetter GetName;

   // guessing that this explicit cast operator may work -- haven't tried it
   public explicit operator NamedObject<T>(T obj)
   {
      return new NamedObject(obj);
   }
}

If the explicit cast operator works, I think you could take some object T and then do:

foo.MethodTakingINamedObject((NamedObject<namedType>) namedObj);

otherwise I'd say

foo.MethodTakingINamedObject(new NamedObject<namedType>(namedObj));

Because static members of a generic class are static to the specialization of the generic, there will be a version of GetName for each type T, and because you can use LCG to create a strong-typed version of GetName per T, you can get pretty good speed. Of course, implicit typing *would* be nice, but there are workarounds. Hopefully the above is useful to you.

Forgive any mistakes here -- I'm doing this in my head based on work I did for http://www.codeproject.com/csharp/GenericOperators.asp.

Object Identity and implicit Interface Implementations

Answer this question