C# generic ClientBase with interface confusion

Question

The C# definition of ClientBase is:

public abstract class ClientBase<TChannel> : ICommunicationObject, 
    IDisposable
where TChannel : class

Which clearly indicates the class constraint on the TChannel type. To the best of my knowledge, that means that you cannot use and interface type for the generic when declaring your own class. So given a service declared thusly:

public IMyService
...
public MyService : IMyService
...

This should work:

public MyServiceClient : ClientBase<MyService> 

This should NOT:

public MyServiceClient : ClientBase<IMyService> 

But clearly I am not understanding because the example shows a declaration of:

public partial class SampleServiceClient : 
    System.ServiceModel.ClientBase<ISampleService>, ISampleService

And more to the point, I am trying to abstract the authentication, and proper closing of the client with a utility method:

    public TResult WithClient<TInterface, T, TResult>(T service, 
        Func<TInterface, TResult> callback)
        where T : ClientBase<TInterface>, TInterface
    {
        service.ClientCredentials.UserName.UserName = userName;
        service.ClientCredentials.UserName.Password = password;

        try
        {
            var result = callback(service);
            service.Close();
            return result;
        }
        catch (Exception unknown)
        {
            service.Abort();
            throw unknown;
        }
    }

But this gives me the compiler error:

The type 'TInterface' must be a reference type in order to use it as parameter 'TChannel' in the generic type or method 'ClientBase<TChannel>'

Can somebody clear the confusion here? What am I doing wrong?

---- UPDATE ----

Per @InBetween, the resolution is to add the where TInterface : class constraint to my utility method:

    public TResult WithClient<TInterface, T, TResult>(T service, 
        Func<TInterface, TResult> callback)
        where TInterface : class
        where T : ClientBase<TInterface>, TInterface
    {
        service.ClientCredentials.UserName.UserName = userName;
        service.ClientCredentials.UserName.Password = password;

        try
        {
            var result = callback(service);
            service.Close();
            return result;
        }
        catch (Exception unknown)
        {
            service.Abort();
            throw unknown;
        }
    }

Answer 1

The class constraint constraints the generic type to a reference type. An interface is, by definition, a reference type. What you can't do is use a value type as the generic type: ClientBase<int> would be a compile time error.

As to the second error, you are not constraining TInterface and then using it inClientBase<TInterface>. Because ClientBase constraints its generic type to reference types (class), you need to constraint TInterface accordingly.