scope namespace alias pour les types génériques en C #

Question

Jetons un exemple suivant:

public class X { }
public class Y { }
public class Z { }

public delegate IDictionary<Y, IList<Z>> Bar(IList<X> x, int i);

public interface IFoo
{
    // ...
    Bar Bar { get; }
}

public class Foo : IFoo
{
    // ...
    public Bar Bar
    {
        get
        {
            return null; //...
        }
    }
}

void Main()
{
    IFoo foo; //= ...
    IEnumerable<IList<X>> source; //= ...
    var results = source.Select(foo.Bar); // <- compile error here
}

Le compilateur dit:

  

Les arguments de type de procédé   « System.Linq.Enumerable.Select (System.Collections.Generic.IEnumerable,   System.Func) » ne peut pas   être déduit de l'utilisation. Essayer   spécifiant les arguments de type   explicitement.

Il est parce que, il ne peut pas convertir Bar à Func<IList<X>, int, IDictionary<Y, IList<Z>>>.

Ce serait génial si je pouvais créer espace de nommage scope alias de type pour les types génériques en C #. Ensuite, je définirais Bar pas en tant que délégué, mais je définirais comme un espace de noms scope alias pour Func<IList<X>, int, IDictionary<Y, IList<Z>>>.

public alias Bar = Func<IList<X>, int, IDictionary<Y, IList<Z>>>;

Je pourrais alors également définir alias scope espace de noms pour exemple IDictionary<Y, IList<Z>>.

Et si elle est utilisée de façon appropriée :), il fera le code plus lisible. Maintenant, je dois inline les types génériques et le code réel est pas bien lisible: (

Avez-vous trouver le même problème :)? Y at-il une bonne raison pour laquelle il est en C # 3.0? Ou il n'y a aucune raison, il est juste d'importance de l'argent et / ou le temps?

EDIT:. Je sais que je peux utiliser using, mais il est espace de noms qui ne se limitent - pas si pratique pour mon cas

EDIT2. Voir le commentaire par Joren où il suggère que le typage structurel pourrait aussi résoudre le problème

Answer 1

Vous êtes hors de la chance; la directive en utilisant uniquement son fichier affecte en cours. Il n'y a pas de mécanisme de aliasing de type espace de noms à l'échelle.

Ceci est une caractéristique assez souvent demandé, ce qui est des points pour cela. Mais il est aussi un « agréable d'avoir » fonctionnalité pratique par opposition à celui qui ajoute vraiment beaucoup de pouvoir de représentation à la langue, ce qui est des points contre elle. Ce serait bien de le faire, mais ce n'est pas vraiment haut sur la liste des priorités.

Answer 2

Si vous faites ...

var results = source.Select((x, i) => foo.Bar(x, i));

il peut comprendre les types pour vous, sans avoir à les spécifier explicitement.

(Il est vrai que cela est plus d'un travail autour d'une solution)