Hello,

I've made a class that inherits List<> and adds some new properties. I cannot use it directly in the mapped class as nhibernate only accept interfaces. Why such a limitation ? Is there a way to get around it ? I know it is possible to use an IPropertyAccessor implementation to load custom collection but is there an easier way ?

Regards,

mathmax

mathmax,

I have written a series of posts concerning the use of custom collections with NHibernate. I believe that the solution I present is a good approach for keeping the doman layer very clean and simple while still enabling compatibility with NHibernate. As you implied, there isn't an easy way to get around using interfaces but I hope this solution is relatively easy for you to use.

The posts are as follows:

Why Bother?
The Basics
Refactoring the Solution for Reusability

Your feedback on this approach would be great to have...thanks!

Billy McCafferty

Thank you for your answer. It seems very interesting. One thing I'm not sure to understand. Should I write a persistent collection for each new custom collection I create or is there a generic class to use instead ?

Your solution doesn't fit me as I want to have a IDictionary<TKey, TValue>
:-(.

Perhabs you can explain your problem a little further, for instance provide your specialization of List<T> (that behaves like a IDictionary<TKey, TValue> ???? that sounds a litlle strange)

But lets see some code, im not sure i get your problem :-)

Sorry. It's a general problem. I need to easily create custom collection usable with nhibernate. At the beginning, I gave an example with a collection that inherits List<T>, but now I have a problem with a collection that hinerits Dictionary<T, U>.

I tried to write a IPropertyAccessor implementation :

public class DefaultAccessor : IPropertyAccessor
{
#region IPropertyAccessor Members

public IGetter GetGetter(System.Type theClass, string propertyName)
{
return new Getter(GetField(propertyName, theClass));
}

public ISetter GetSetter(System.Type theClass, string propertyName)
{
return new Setter(GetField(propertyName, theClass));
}

private FieldInfo GetField(string propertyName, System.Type theClass)
{
string fieldName = new HiddenFieldStrategy().GetFieldName(propertyName);
if(fieldName == null)
fieldName = new PascalCaseUnderscoreStrategy().GetFieldName(propertyName);

FieldInfo field = GetFieldInternal(theClass, fieldName);
if (field == null) throw new PropertyNotFoundException(theClass, fieldName);

return field;
}

private static FieldInfo GetFieldInternal(System.Type type, string fieldName)
{
if (type == null || type == typeof(object)) return null;

FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
return (field != null) ? field : GetFieldInternal(type.BaseType, fieldName);
}

#endregion

private class Setter : ISetter
{
private FieldInfo fieldInfo;

internal Setter(FieldInfo fieldInfo)
{
this.fieldInfo = fieldInfo;
}

public void Set(object target, object value)
{
fieldInfo.SetValue(target, Activator.CreateInstance(fieldInfo.FieldType,new IDictionaryToGenericIDictionaryAdaptator<Iso, string>((IDictionary)value)));
}

public string PropertyName
{
get { return null; }
}

public MethodInfo Method
{
get { return null; }
}
}

private class Getter : IGetter
{
private FieldInfo fieldInfo;
private System.Type returnType;

public Getter(FieldInfo fieldInfo)
{
this.fieldInfo = fieldInfo;
returnType = GetReturnType(fieldInfo);
}

public object Get(object target)
{
var obj = fieldInfo.GetValue(target);
if (obj == null) return null;
return new Dictionary<Iso, string>((IDictionary<Iso, string>)obj);
}

public System.Type ReturnType
{
get { return returnType; }
}

public string PropertyName
{
get { return null; }
}

public MethodInfo Method
{
get { return null; }
}

private static System.Type GetReturnType(FieldInfo field)
{
System.Type type = field.FieldType;

// pretend that it is still a collection, otherwise lazy initialization stuff won't work
if (type.IsGenericType && typeof(ICollection<>).IsAssignableFrom(type.GetGenericTypeDefinition()))
return typeof(ICollection<>).MakeGenericType(type.GetGenericArguments());

return type;
}
}
}

The data are loaded without problem in my objects. However, it doesn't succeed on commit(). I get the following error :

could not insert collection: [TestNhibernate.Test.Name#1]
Inner exception : {"Specified cast is not valid."}
Message : "could not insert collection: [TestNhibernate.Test.Name#1]"

Do you know what is the problem ? I don't insist on doing this way, I just want an easy solution to implement custom collections with nhibernate.

In the client side you must declare an interface because NH need to proxy your collection.
In a soon future (NH2.0) you can use your tuplizer to do what you want.
So far something that work similar of what you need is "dynamic-component".
http://www.hibernate.org/hib_docs/nhibe ... -component

Bye.