CODEWITHSUNDEEP
c#genericstype-constraints
Danicco
Danicco

Reputation: 1673

Generic class with non-generic method constraint?

I have this class working as my repository:

public class Repository<T> where T : class, new()
{
    public T GetByID(int id)
    {
        //Code...
    }        
}

But there a few cases where I don't want to leave a class' default public constructor (such as some specific model properties that require some logic), like this:

public class Person
{
    public CPersonID PersonID { get; private set; }

    //This shouldn't exist outside Person, and only Person knows the rules how to handle this
    public class CPersonID 
    {
        internal CPersonID() { }
    }
}

This makes the Repository template class invalid because of the new() constraint. I'd like to make something like this:

public class Repository<T> where T : class
{
    //This function should be created only when the T has new()
    public GetByID(int id) where T : new()
    {            
    }

    //And this could be the alternative if it doesn't have new()
    public GetByID(T element, int id)
    {
    }
}

Is there any way I can accomplish this?

Edit: Example of a Get method:

public IList<T> GetAll()
{
    IList<T> list = new List<T>();

    using(IConnection cn = ConnectionFactory.GetConnection())
    {
        ICommand cm = cn.GetCommand();
        cm.CommandText = "Query";

        using (IDataReader dr = cm.ExecuteReader())
        {
            while(dr.Read())
            {
                T obj = new T(); //because of this line the class won't compile if I don't have the new() constraint
                //a mapping function I made to fill it's properties
                LoadObj(obj, dr);
                list.Add(obj);
            }
        }
    }

    return list;
}

Upvotes: 1

Views: 449

Answers (3)

user743382
user743382

Reputation:

As Lasse V. Karlsen already answered, this is not directly possible. However, you can get very close, close enough for practical purposes.

Given public class Repository<T> where T : class, you cannot define instance methods that only exist when T has a parameterless constructor. You don't need that. You just need repository.GetByID(3) to work. That can work if GetByID is an instance method, but also if it is an extension method, and extension methods can add requirements to T.

public static class RepositoryExtensions
{
  public T GetByID(this Repository<T> repo, int id) where T : class, new()
  {
    ...
  }
}

Note that extension methods don't work if an instance method of the same name already exists, so if you go with this, you need both overloads of GetByID to be extension methods, not just this one.

The actual logic belongs in the Repository class, but you can forward to that:

public class Repository<T> where T : class
{
  internal T GetByIDImpl(int id, Func<T> factory)
  {
    ...
  }
}

public static class RepositoryExtensions
{
  public T GetByID(this Repository<T> repo, int id) where T : class, new()
  {
    return repo.GetByIDImpl(id, () => new T());
  }
  public T GetByID(this Repository<T> repo, T element, int id) where T : class
  {
    return repo.GetByIDImpl(id, () => element);
  }
}

Upvotes: 3

dav_i
dav_i

Reputation: 28157

If you want it as a compile-time constraint, you can do

public class Class<T> where T : class
{
    public void Method<U> where U : T, new()
    {
        // ...
    }
}

but this has the disadvantage that you'd have to do

new Class<HasConstructor>().Method<HasConstructor>();

as the type won't be implicitly picked up. The advantage is that the following won't compile:

new Class<NoConstructor>().Method<NoConstructor>();

Upvotes: 0

Lasse V. Karlsen
Lasse V. Karlsen

Reputation: 391664

No, you can't do it this way.

All constraints have to be specified the place where you introduce the generic parameter, in this case at the class level.

As such you have two options:

  1. Add , new() as a constraint, limiting the use of the repository class to use types that have a public parameterless constructor
  2. Not add it as a constraint, and use reflection to try to construct the object at runtime

Note that point 2 there may fail (at runtime) if the type does not have a valid constructor.

There is no way you can ask the compiler to create a class where the ability to call a specific method is conditional, ie. "Only let me call GetByID if the type has a constructor".

Upvotes: 2

Related Questions