Generics where T is class implementing interface

Question

I have a interface:

interface IProfile { ... }

...and a class:

[Serializable]
class Profile : IProfile 
{ 
  private Profile()
  { ... } //private to ensure only xmlserializer creates instances
}

...and a manager with method:

class ProfileManager
{
  public T Load<T>(string profileName) where T : class, IProfile
  {
    using(var stream = new .......)
    {
      var ser = new XmlSerializer(typeof(T));
      return (T)ser.Deserialize(stream);
    }
  }
}

I expect the method to be used like this:

var profile = myManager.Load<Profile>("TestProfile"); // class implementing IProfile as T

...and throw compile time error on this:

var profile = myManager.Load<IProfile>("TestProfile"); // NO! IProfile interface entered!

However everything compiles, and only runtime errors is thrown by the XmlSerializer.

I thought the where T : class would ensure only class types where accepted?

Is it possible to make the compiler throw error if IProfile (or other interfaces inheriting from IProfile) is entered, and only types classes implementing IProfile are accepted?

Answer 1

According to MSDN class means that T must be a reference type; this applies also to any class, interface, delegate, or array type.

One work around would be to require that T implements the parameter less constructor so:

where T : class, IProfile, new()

Answer 2

Works for me

public interface IUser
{
    int AthleteId { get; set; }
    string GivenName { get; set; }
    string FamilyName { get; set; }         
    bool IsActive { get; set; }
}

public  class DjsNameAutoSearch<Result, User> : where User : class, IUser, new()