层次对象的通用类工厂或方法

Question

I have hierarchy class and generic class:

       public class Form
       {
           public string Name { get; set; }
           public string Producer { get; set; }
       }

       public class Book : Form
       {
           public string Topic { get; set; }
           public string Autor { get; set; }
       }

       public class Copybook : Form
       {
           public string Topic { get; set; }
           public int CountPages { get; set; }
       }

       public class Notebook : Form
       {
           public int Cost { get; set; }
       }

       public class Request<T> where T : Form
       {
           public T Form { get; set; }
       }

I want to make factory or method, which will create objects of generic class in depend of logic and params. How it make? I tried to do this, but the code did not work:

        public enum FormParams
        {
            Book,
            Copybook,
            Notebook
        }

        public static class RequestFactory
        {
            public static Request<Form> Create(FormParams formParams)
            {
                if (formParams == FormParams.Book)
                {
                    return new Request<Book>();
                }

                if (formParams == FormParams.Copybook)
                {
                    return new Request<Copybook>();
                }

                return new Request<Notebook>();
            }
        }

Answer 1

If you think carefully, what you're asking for doesn't really make sense. What if you did this?

var request = RequestFactory.Create(FormParams.CopyBook);
request.Form = new Book();

If the underlying type of request was Request<CopyBook> , then its Form property would have the type of CopyBook , and trying to set its value to a Book wouldn't make sense.

If you determine that the above use-case should never happen, you can formalize that fact by using an interface that doesn't allow the Form property to be set. Then you can make that interface covariant .

public class Request<T> : IRequest<T>
    where T : Form
{
    public T Form { get; set; }
}

public interface IRequest<out T> where T : Form
{
    T Form { get; }
}

...
    public static IRequest<Form> Create(FormParams formParams)

But in that case you may find there's no reason to have IRequest be generic at all.

public class Request<T> : IRequest
    where T : Form
{
    public T Form { get; set; }

    Form IRequest.Form => this.Form;
}

public interface IRequest
{
    Form Form { get; }
}

...
    public static IRequest Create(FormParams formParams)

Answer 2

You need to add an Interface to your hierarchy so you can flag the generic parameter as covariant.

public class Request<T> : IRequest<T> where T : Form
{
    public T Form { get; set; }
}

public interface IRequest<out T> 
{
    public T Form
    {
        get;
    }
}

And then you need to change the return type of your Create method to an IRequest<Form> .

public static class RequestFactory
{
    public static IRequest<Form> Create(FormParams formParams)
    {

        if (formParams == FormParams.Book)
        {
            return new Request<Book>();
        }

        if (formParams == FormParams.Copybook)
        {
            return new Request<Copybook>();
        }

        return new Request<Notebook>();
    } 
}