Wielkie zdjęcie:

Znalazłem coś, co wydaje się ograniczać Razor i mam kłopoty z wymyśleniem dobrej drogi.

Gracze:

Powiedzmy, że mam taki model:

public abstract class BaseFooModel<T>
    where T : BaseBarType
{
    public abstract string Title { get; } // ACCESSED BY VIEW
    public abstract Table<T> BuildTable();

    protected Table<T> _Table;
    public Table<T> Table // ACCESSED BY VIEW
    {
        get
        {
            if (_Table == null)
            {
                _Table = BuildTable();
            }
            return _Table;
        }
    }
}

I taka podklasa:

public class MyFooModel : BaseFooModel<MyBarType>
{
    // ...
}

public class MyBarType : BaseBarType
{
    // ...
}

Chcę móc przejśćMyFooModel w widok brzytwy zdefiniowany w ten sposób:

// FooView.cshtml
@model BaseFooModel<BaseBarType>

Ale to nie działa. Mówię o błędzie w czasie wykonywaniaFooView oczekujeBaseFooModel<BaseBarType> ale dostajeMyFooModel. Odwołaj toMyFooModel w herits fromBaseFooModel<MyBarType> iMyBarType dziedziczy zBaseBarType.

Co próbowałem:

Wypróbowałem to w krainie nie do golenia, aby sprawdzić, czy to samo jest prawdą. Musiałem użyć paramatu szablonu w widoku, aby go uruchomić. Oto widok bez maszynki do golenia:

public class FooView<T>
    where T : BaseBarType
{
    BaseFooModel<T> Model;
    public FooView(BaseFooModel<T> model)
    {
        Model = model;
    }
}

Z tą strukturą, co następujedziała:

new FooView<MyBarType>(new MyFooModel());

Moje pytanie:

Jak mogę to zrobić za pomocą Razor? Jak mogę przejść w typie, z którym robięFooView?
Nie mogę, ale czy jest jakiś sposób na to? Czy mogę jakoś osiągnąć tę samą architekturę?

Daj mi znać, jeśli mogę podać więcej informacji. Używam .NET 4 i MVC 3.

EDYTOWAĆ:
Na razie dodaję widok maszynki do golenia dla każdej podklasyBaseFooModel<BaseBarType>. Nie jestem zafascynowany tym, ponieważ nie chcę tworzyć nowego widoku za każdym razem, gdy dodam nowy model.

Inną opcją jest skorzystanie z faktu, że jarano w stanie uzyskać to działając w zwykłych klasach c # bez brzytwy. Mogłem po prostu zobaczyć mój brzytwa@inherits widok c #, a następnie wywołaj metodę renderowania. Nie podoba mi się ta opcja, ponieważ nie lubię mieć dwóch sposobów renderowania HTML.

Jakieś inne pomysły? Wiem, że trudno mi zrozumieć kontekst problemu, kiedy podaję nazwy klasFoo iBar, ale nie mogę podać zbyt wielu informacji, ponieważ jest to trochę wrażliwe. Przepraszam za to.

Co mam do tej pory, używając odpowiedzi Benjamina:

public interface IFooModel<out T> 
    where T : BaseBarModel
{
    string Title { get; }
    Table<T> Table { get; } // this causes an error:
                            // Invalid variance: The type parameter 'T' must be 
                            // invariantly valid on IFooModel<T>.Table. 
                            // 'T' is covariant.
}

public abstract class BaseFooModel<T> : IFooModel<T>
    where T : BaseBarModel
{
    // ...
}

Co skończyło się pracą:

public interface IFooModel<out T> 
    where T : BaseBarModel
{
    string Title { get; }
    BaseModule Table { get; } // Table<T> inherits from BaseModule
                              // And I only need methods from BaseModule
                              // in my view. 
}

public abstract class BaseFooModel<T> : IFooModel<T>
    where T : BaseBarModel
{
    // ...
}