Jak uzyskać Visual Studio 2008 Windows Forms designer do renderowania formularza implementującego abstrakcyjną klasę bazową?

@ smelch, jest lepsze rozwiązanie, bez konieczności tworzenia Środkowej kontroli, nawet do debugowania.

Czego chcemy

Najpierw zdefiniujmy klasę końcową i podstawową klasę abstrakcyjną.

public class MyControl : AbstractControl
...
public abstract class AbstractControl : UserControl // Also works for Form
...

Teraz potrzebujemy tylko dostawcy opisu .

public class AbstractControlDescriptionProvider<TAbstract, TBase> : TypeDescriptionProvider
{
    public AbstractControlDescriptionProvider()
        : base(TypeDescriptor.GetProvider(typeof(TAbstract)))
    {
    }

    public override Type GetReflectionType(Type objectType, object instance)
    {
        if (objectType == typeof(TAbstract))
            return typeof(TBase);

        return base.GetReflectionType(objectType, instance);
    }

    public override object CreateInstance(IServiceProvider provider, Type objectType, Type[] argTypes, object[] args)
    {
        if (objectType == typeof(TAbstract))
            objectType = typeof(TBase);

        return base.CreateInstance(provider, objectType, argTypes, args);
    }
}

Na koniec po prostu zastosujemy atrybut TypeDescriptionProvider do kontrolki Abastract.

[TypeDescriptionProvider(typeof(AbstractControlDescriptionProvider<AbstractControl, UserControl>))]
public abstract class AbstractControl : UserControl
...

I klasa provider może być stosowana do tyle abstrakcyjnych podstaw, ile chcemy w tym samym rozwiązaniu.

* EDIT * W aplikacji potrzebne są również następujące elementy.config

<appSettings>
    <add key="EnableOptimizedDesignerReloading" value="false" />
</appSettings>

@Smelch, dzięki za pomocną odpowiedź, ponieważ ostatnio natknąłem się na ten sam problem.

Poniżej znajduje się drobna zmiana w Twoim poście, aby zapobiec ostrzeżeniom kompilacji (umieszczając klasę bazową w dyrektywie #if DEBUG pre-processor):

public class Form1
#if DEBUG  
 : MiddleClass 
#else  
 : BaseForm 
#endif 

Miałem podobny problem, ale znalazłem sposób na refaktoryzację rzeczy, aby użyć interfejsu zamiast abstrakcyjnej klasy bazowej:

interface Base {....}

public class MyUserControl<T> : UserControl, Base
     where T : /constraint/
{ ... }

Może to nie mieć zastosowania w każdej sytuacji, ale jeśli to możliwe, skutkuje czystszym rozwiązaniem niż kompilacja warunkowa.

Używam rozwiązania w tej odpowiedzi {[3] } na inne pytanie, które łączy Ten artykuł . Artykuł zaleca użycie niestandardowej TypeDescriptionProvider i konkretnej implementacji klasy abstrakcyjnej. Projektant zapyta dostawcę niestandardowego, jakich typów użyć, a Twój kod może zwrócić klasę concrete, aby projektant był zadowolony, podczas gdy Ty masz pełną kontrolę nad tym, jak klasa abstrakcyjna wygląda jako klasa concrete.

Update: dodałem udokumentowaną próbkę kodu w mojej odpowiedzi na to drugie pytanie. Kod tam działa, ale czasami muszę przejść przez cykl czyszczenia / budowania, jak wspomniano w mojej odpowiedzi, aby go uruchomić.

Mam wskazówkę dla rozwiązania Juana Carlosa Diaza.Dla mnie działa świetnie, ale był z tym jakiś problem. Kiedy uruchamiam VS i Wchodzę designer wszystko działa dobrze. Ale po uruchomieniu rozwiązania, następnie zatrzymać i zamknąć go, a następnie spróbować wprowadzić projektant wyjątek pojawia się ponownie i ponownie aż do ponownego uruchomienia VS. Ale znalazłem rozwiązanie dla niego-wszystko, co zrobić, to dodać poniżej do aplikacji.config

  <appSettings>
   <add key="EnableOptimizedDesignerReloading" value="false" />
  </appSettings>

Ponieważ klasa abstrakcyjna public abstract class BaseForm: Form daje błąd i pozwala uniknąć użycia designera, przyszedłem z użyciem wirtualnych członków. Zasadniczo, zamiast deklarować metody abstrakcyjne, zadeklarowałem metody wirtualne z minimalnym ciałem, jak to możliwe. Oto co zrobiłem:

public class DataForm : Form {
    protected virtual void displayFields() {}
}

public partial class Form1 : DataForm {
    protected override void displayFields() { /* Do the stuff needed for Form1. */ }
    ...
}

public partial class Form2 : DataForm {
    protected override void displayFields() { /* Do the stuff needed for Form2. */ }
    ...
}

/* Do this for all classes that inherit from DataForm. */

Ponieważ DataForm miała być klasą abstrakcyjną z członkiem abstrakcyjnym displayFields, "podrabiam" to zachowanie wirtualnymi członkami, aby uniknąć abstrakcji. Projektant już nie narzeka i wszystko działa dobrze dla mnie.

Jest to obejście bardziej czytelne, ale ponieważ nie jest abstrakcyjne, muszę się upewnić, że wszystkie klasy potomne DataForm mają swoją implementację displayFields. Dlatego należy zachować ostrożność podczas korzystania z tej techniki.

Mam kilka wskazówek dla osób, które mówią, że TypeDescriptionProvider autorstwa Juana Carlosa Diaza nie działa i nie podoba mi się kompilacja warunkowa:

Po Pierwsze, być może będziesz musiał zrestartować Visual Studio, aby zmiany w kodzie działały w form designer(musiałem, simple rebuild nie działało-lub nie za każdym razem).

Przedstawię moje rozwiązanie tego problemu w przypadku abstrakcyjnej formy bazowej. Załóżmy, że masz klasę BaseForm i chcesz mieć jakieś formularze w oparciu o to, aby było możliwe do zaprojektowania (będzie to Form1). TypeDescriptionProvider przedstawione przez Juana Carlosa Diaza również nie sprawdziły się dla mnie. Oto, jak to działa, łącząc go z rozwiązaniem MiddleClass (przez smelch), ale BEZ #if DEBUG kompilowanie warunkowe i z pewnymi poprawkami:

[TypeDescriptionProvider(typeof(AbstractControlDescriptionProvider<BaseForm, BaseFormMiddle2>))]   // BaseFormMiddle2 explained below
public abstract class BaseForm : Form
{
    public BaseForm()
    {
        InitializeComponent();
    }

    public abstract void SomeAbstractMethod();
}


public class Form1 : BaseForm   // Form1 is the form to be designed. As you see it's clean and you do NOTHING special here (only the the normal abstract method(s) implementation!). The developer of such form(s) doesn't have to know anything about the abstract base form problem. He just writes his form as usual.
{
    public Form1()
    {
        InitializeComponent();
    }

    public override void SomeAbstractMethod()
    {
        // implementation of BaseForm's abstract method
    }
}

Zwróć uwagę na atrybut na klasie BaseForm. Następnie musisz zadeklarować TypeDescriptionProvideri dwie klasy średnie, ale nie martw się, są one niewidzialne i nieistotne dla programista Form1 . Pierwsza implementuje elementy abstrakcyjne (i sprawia, że klasa bazowa nie jest abstrakcyjna). Drugi jest pusty - jest tylko wymagany do pracy projektanta formularzy VS. Następnie przypisujesz drugą klasę średnią do TypeDescriptionProvider z BaseForm. brak kompilacji warunkowej.

Miałem jeszcze dwa problemy:

• Problem 1: Po zmianie Form1 w designerze (lub jakimś kodzie) znowu dawał błąd (przy próbie aby otworzyć go ponownie w designerze).
• Problem 2: kontrolki BaseForm zostały umieszczone nieprawidłowo, gdy rozmiar formularza 1 został zmieniony w designerze, a Formularz został zamknięty i ponownie otwarty w form designer.

Pierwszy problem (możesz go nie mieć, ponieważ jest to coś, co prześladuje mnie w moim projekcie w kilku innych miejscach i zwykle tworzy wyjątek "nie można przekonwertować typu X na typ X"). Rozwiązałem to w TypeDescriptionProvider przez porównując nazwy typów (FullName) zamiast porównywania typów (patrz poniżej).

class BaseFormMiddle1 : BaseForm
{
    protected BaseFormMiddle1()
    {
    }

    public override void SomeAbstractMethod()
    {
        throw new NotImplementedException();  // this method will never be called in design mode anyway
    }
}


class BaseFormMiddle2 : BaseFormMiddle1  // empty class, just to make the VS designer working
{
}

A tutaj masz nieco zmodyfikowaną wersję TypeDescriptionProvider:

public class AbstractControlDescriptionProvider<TAbstract, TBase> : TypeDescriptionProvider
{
    public AbstractControlDescriptionProvider()
        : base(TypeDescriptor.GetProvider(typeof(TAbstract)))
    {
    }

    public override Type GetReflectionType(Type objectType, object instance)
    {
        if (objectType.FullName == typeof(TAbstract).FullName)  // corrected condition here (original condition was incorrectly giving false in my case sometimes)
            return typeof(TBase);

        return base.GetReflectionType(objectType, instance);
    }

    public override object CreateInstance(IServiceProvider provider, Type objectType, Type[] argTypes, object[] args)
    {
        if (objectType.FullName == typeof(TAbstract).FullName)  // corrected condition here (original condition was incorrectly giving false in my case sometimes)
            objectType = typeof(TBase);

        return base.CreateInstance(provider, objectType, argTypes, args);
    }
}

I to wszystko!

Nie musisz niczego wyjaśniać przyszłym twórcom formularzy opartych na Twojej bazie i nie muszą robić żadnych sztuczek, aby zaprojektować swoje formularze! Myślę, że jest to najbardziej czyste rozwiązanie, jakie może być (poza repozycjonowaniem sterowania).

Jeszcze jedna wskazówka:

Jeśli dla z jakiegoś powodu projektant nadal odmawia pracy dla Ciebie, zawsze możesz wykonać prostą sztuczkę, zmieniając public class Form1 : BaseForm na public class Form1 : BaseFormMiddle1 (lub BaseFormMiddle2) w pliku kodu, edytując go w vs form designer, a następnie zmieniając go z powrotem. Wolę ten trick niż kompilację warunkową, ponieważ jest mniej prawdopodobne, że zapomni i wyda złą wersję .

Projektant formularzy Windows tworzy instancję klasy bazowej formularza / kontrolki i stosuje wynik analizy InitializeComponent. Dlatego możesz zaprojektować formularz stworzony przez kreatora projektu nawet bez budowania projektu. Z powodu tego zachowania nie można również zaprojektować kontrolki pochodzącej z klasy abstrakcyjnej.

Możesz zaimplementować te abstrakcyjne metody i wyrzucić wyjątek, gdy nie jest on uruchomiony w Projektancie. Programista, który korzysta ze sterownika, musi zapewnić implementacja, która nie wywołuje implementacji klasy bazowej. W przeciwnym razie program się zawiesi.

Możesz po prostu warunkowo skompilować w słowie kluczowym abstract bez interpunkcji oddzielnej klasy:

#if DEBUG
  // Visual Studio 2008 designer complains when a form inherits from an 
  // abstract base class
  public class BaseForm: Form {
#else
  // For production do it the *RIGHT* way.
  public abstract class BaseForm: Form {
#endif

    // Body of BaseForm goes here
  }

Działa to pod warunkiem, że BaseForm nie ma żadnych abstrakcyjnych metod(dlatego słowo kluczowe abstract zapobiega tylko uruchomionej instancji klasy).