Table de recherche en C # avec types et actions

Vous pouvez créer un Dictionary > :

dict[propertyType](propertyType)

Et puis l'appeler comme ceci:

var dict = new Dictionary<Type, Action<Type>>() {
    {typeof(bool), DoBool},
    {typeof(bool?), DoBool},
    {typeof(DateTime), DoDateTime},
    {typeof(Datetime?), DoDateTime},
    {typeof(Guid), DoGuid},
    {typeof(Guid?), DoGuid}
};

Vous pouvez créer une méthode pour initialiser votre table de recherche avec le type spécifié, pour éviter de se répéter.

private void AddEntry<T>(Action<Type> action) where T : struct
{       
    _lookup[typeof(T)] = action;
    _lookup[typeof(Nullable<T>)] = action;
}

private void DoInt(Type type) { /* implementation */ }

AddEntry<bool>(type => { /* implementation */ });
AddEntry<int>(DoInt);

alors vous pouvez définir la méthode pour initialiser le _dict ,

private readonly IDictionary<Type, Action<Type>> _lookup;

Puisqu'il s'agit plus de contrôler le flux du code que de recherche pure, j'utiliserais probablement une approche orientée objet et placerais le code pour chaque "gestionnaire" dans des classes séparées (avec des éléments communs dans une classe de base).

Vous pouvez créer une interface commune comme

public interface ITypeHandler {
    void HandleType(Type type);
}

... et mettre l'implémentation des gestionnaires dans un dictionnaire de type Dictionary si vous le souhaitez, ou vous pouvez avoir une propriété sur l'interface révélant le type qu'elle gère et sélectionner dans une liste de gestionnaires (peut-être dépendants injectés) basés sur cette propriété.

séparation des préoccupations, testabilité, etc.

(Notez que * Handler n'est pas un très bon nom, vous devrez créer un meilleur nom en fonction du scénario que vous couvrez.)

J'ai créé ma propre implémentation qui est un peu différente, mais j'ai utilisé la suggestion @DaggeJ, alors merci!

J'ai d'abord créé une classe de gestionnaire de base. Après cela, j'ai utilisé cette base sur différentes classes de types. Vous pouvez le voir ci-dessous.

public IQueryable<T> GetQuery()
{
    var queryHandlerList = new List<QueryHandler<T>>()
    {
        new IntQuery<T>(//Properties),
        new DateTimeQuery<T>(//Properties),
        new StringQuery<T>(//Properties),
        new BoolQuery<T>(//Properties),
        new GuidQuery<T>(//Properties),
        new EnumQuery<T>(//Properties)
    };
}

return query = queryHandlerList.FirstOrDefault(h => GetType<T>(h, property.PropertyType)).Handle();

private bool GetType<T>(QueryHandler<T> handler, Type type) where T: class
{
    if (handler.Types.FirstOrDefault(t => t == type) == type || handler.Types.FirstOrDefault(t => t == type.BaseType) == type.BaseType) return true;

    return false;
}

Classe descendante:

internal class GuidQuery<T> : QueryHandler<T> where T : class
{
    public override Type[] Types => new Type[] { typeof(Guid), typeof(Guid?) };

    public GuidQuery(//Properties) : base(//Properties)
    {
    }

    public override IQueryable<T> Handle()
    {
        // Implementation
    }
}