Come posso evitare di avere un TypeDescriptionProvider personalizzato separato per ciascuna delle mie classi?

Question

Ho aggiunto funzionalità per il mio progetto che permette agli utenti di aggiungere le proprie proprietà personalizzate agli oggetti. Ho creato il mio personalizzato TypeDescriptor , PropertyDescriptor e TypeDescriptorProviders , ecc .. ecc .. per fare questo.

Ecco il mio problema. In questo momento ho tutto di lavoro, ma ha dovuto creare un separato TypeDescriptionProvider per ogni tipo di oggetto oggetto che può avere le proprietà personalizzate. Ecco ciò che il mio TypeDescriptionProviders assomigliare

//type AClass Custom Provider
class AClassTypeProvider : TypeDescriptionProvider
{
    private static TypeDescriptionProvider defaultTypeProvider = TypeDescriptor.GetProvider(typeof(AClass));

    public AClassTypeProvider (): base(defaultTypeProvider)
    {

    }

    public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
    {
        ICustomTypeDescriptor defaultDescriptor = base.GetTypeDescriptor(objectType, instance);

        //returns a custom type descriptor based on a UserPropertyHostType enum value, and the default descriptor
        return new InfCustomTypeDescriptor(UserPropertyHostType.SiteRegion, defaultDescriptor);
    }
}


//type BClass Custom Provider
class BClassTypeProvider : TypeDescriptionProvider
{
    private static TypeDescriptionProvider defaultTypeProvider =   TypeDescriptor.GetProvider(typeof(BClass));

    public BClassTypeProvider (): base(defaultTypeProvider)
    {

    }

    public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
    {
        ICustomTypeDescriptor defaultDescriptor = base.GetTypeDescriptor(objectType, instance);

        //returns a custom type descriptor based on a UserPropertyHostType enum value, and the default descriptor
        return new InfCustomTypeDescriptor(UserPropertyHostType.Building, defaultDescriptor);
    }
}

Quindi, ognuno di mia abitudine TypeDescriptionProviders chiama la base (genitore TypeDescriptionProvider) costruttore di base facendola passare il default TypeDescriptionProvider di un tipo specifico.

Il GetTypeDescriptor () le chiamate al metodo base.GetTypeDescriptor () per ottenere il descrittore predefinito che viene poi utilizzato dal mio descrittore di tipo personalizzato di aggiungere le proprietà personalizzate.

C'è qualche modo per combinare questi in un unico personalizzato generica TypeDescriptionProvider , che ha le stesse funzionalità, ma non è legato ad un tipo specifico? Posso saltare fornendo il genitore TypeDescriptionProvider nel costruttore, ma in seguito posta in metodo GetTypeDescriptor () quando so precisamente che tipo di oggetto viene interrogato? O c'è qualche altro modo di ottenere il descrittore predefinito di un tipo diverso da allora chiamando il base.GetTypeDescriptor (tipo T, ins oggetto) metodo?

Answer 1

Questa classe generica dovrebbe fare quello che vuoi:

class CustomTypeProvider<T> : TypeDescriptionProvider
{
    private static TypeDescriptionProvider defaultTypeProvider = TypeDescriptor.GetProvider(typeof(T));

    public CustomTypeProvider(): base(defaultTypeProvider)
    {

    }

    public override ICustomTypeDescriptor GetTypeDescriptor(Type objectType, object instance)
    {
        ICustomTypeDescriptor defaultDescriptor = base.GetTypeDescriptor(objectType, instance);

        //returns a custom type descriptor based on a UserPropertyHostType enum value, and the default descriptor
        return new InfCustomTypeDescriptor(UserPropertyHostType.SiteRegion, defaultDescriptor);
    }
}

Answer 2

ho gestito questo in passato, utilizzando un tipo generico:

public class MyTypeDescriptionProvider<T> : TypeDescriptionProvider
{
  public MyTypeDescriptionProvider()
    : base(TypeDescriptor.GetProvider(typeof(T)))
  {
  }
}

Sono abbastanza sicuro che si potrebbe gestire la cosa in modo simile in un tipo non generico passando il tipo come parametro del costruttore:

public class MyTypeDescriptionProvider : TypeDescriptionProvider
{
  public MyTypeDescriptionProvider(Type t)
    : base(TypeDescriptor.GetProvider(t))
  {
  }
}

Questo è probabilmente preferibile se non è necessario utilizzare il tipo all'interno del fornitore -. Non ho ancora testato, però

Poi, quando si utilizza questo provider, le classi sono registrate lungo le linee di:

TypeDescriptor.AddProvider(new MyTypeDescriptionProvider<ClassA>(), typeof(ClassA));
TypeDescriptor.AddProvider(new MyTypeDescriptionProvider<ClassB>(), typeof(ClassB));

ecc.