O tipo deve ser um tipo de referência para usá-lo como parâmetro 'T' no tipo ou método genérico

Estou aprofundando os genéricos e agora tenho uma situação em que preciso de ajuda. Eu recebo um erro de compilação na classe 'Derivado' abaixo, como mostrado no título do assunto. Vejo muitos outros posts semelhantes a este, mas não estou vendo o relacionamento. Alguém pode me dizer como resolver isso?

using System;
using System.Collections.Generic;


namespace Example
{
    public class ViewContext
    {
        ViewContext() { }
    }

    public interface IModel
    {
    }

    public interface IView<T> where T : IModel 
    {
        ViewContext ViewContext { get; set; }
    }

    public class SomeModel : IModel
    {
        public SomeModel() { }
        public int ID { get; set; }
    }

    public class Base<T> where T : IModel
    {

        public Base(IView<T> view)
        {
        }
    }

    public class Derived<SomeModel> : Base<SomeModel> where SomeModel : IModel
    {

        public Derived(IView<SomeModel> view)
            : base(view)
        {
            SomeModel m = (SomeModel)Activator.CreateInstance(typeof(SomeModel));
            Service<SomeModel> s = new Service<SomeModel>();
            s.Work(m);
        }
    }

    public class Service<SomeModel> where SomeModel : IModel
    {
        public Service()
        {
        }

        public void Work(SomeModel m)
        {

        }
    }
}

Não consigo reproduzir, mas suspeito que no seu código real há uma restrição em algum lugar que T : class- você precisa propagá-lo para deixar o compilador feliz, por exemplo (difícil dizer com certeza sem um exemplo de reprodução):

public class Derived<SomeModel> : Base<SomeModel> where SomeModel : class, IModel
                                                                    ^^^^^
                                                                 see this bit

Você recebe esse erro se tiver restringido Ta ser umclass

Se você colocar restrições em uma classe ou método genérico, todas as outras classes ou métodos genéricos que estiverem em uso precisarão ter "pelo menos" essas restrições.