8
votes

jeter implicitement un générique retour à t

Si j'écris une classe générique comme classe myGeneric est-il possible d'écrire une moulage implicite à type T, afin que je puisse faire des choses comme: xxx < P> Est-il possible de le faire en surchargeant des opérateurs? Je sais que cela pourrait être fait si ma classe n'était pas générique ...


0 commentaires

4 Réponses :


19
votes

Eh bien, oui, mais pour l'amour de Zombie Jésus, je ne fais pas ça. C'est vraiment déroutant. Vous avez un peu mal compris le but des génériques, je pense. Il n'est pas utilisé pour "tourner" une classe sur ce type, il est utilisé pour que ce type (myGenericstring) soit "au courant" du type que vous souhaitez, à diverses fins (généralement celles-ci sont des fins de collecte).


1 commentaires

Je suis d'accord, cette fonctionnalité est utile, mais l'exemple donné semble être un mauvais et indique un éventuel malentendu du but des génériques.



21
votes

YEP..Mais ne le faites pas trop, cela a tendance à confondre les gens. Je ne l'utiliserais que pour les types d'emballage.

class Wrapper<T>
{
    public T Value {get; private set;}
    public Wrapper(T val) {Value = val;}

    public static implicit operator T(Wrapper<T> wrapper) {return wrapper.Value;}
    public static implicit operator Wrapper<T>(T val) {return new Wrapper<T>(val);}
}



var intWrapper = new Wrapper<int>(7);
var usingIt = 7 * intWrapper; //49

Wrapper<int> someWrapper = 9; //woohoo


4 commentaires

Je t'ai précipité, car il est techniquement correct (le meilleur type de correct), mais vraiment, je pense qu'il n'est presque jamais approprié de le faire. J'espère que le OP réalise que.


Merci. Je t'ai suscité aussi, pour Zombie Jésus, et parce que je suis d'accord.


J'aimerais voir une utilisation pratique pour cela.


@nobugz: NULLLABLE a un opérateur Explicit Explicit T . Et une conversion implicite de t . C'est assez pratique!



0
votes

Oui, il est possible d'utiliser implicite Surcharge de l'opérateur de conversion

class Program
{
    static void Main(string[] args)
    {
        myclass<string> a = new myclass<string>();
        a.inner = "Hello";
        string b = a;
        Console.WriteLine(b);
    }
}

class myclass<T>
{
    public T inner;
    public myclass()
    {

    }
    public static implicit operator T(myclass<T> arg1)
    {
        return arg1.inner;
    }
}


0 commentaires

14
votes

Comme d'autres personnes ont dit, c'est légal mais dangereux . Il y a beaucoup de pièges que vous pouvez tomber dans. Par exemple, supposons que vous ayez défini un opérateur de conversion défini par l'utilisateur entre C et T. Ensuite, vous dites xxx

Que se passe-t-il? Votre conversion définie par l'utilisateur est-elle exécutée ou non? non, car c est déjà un objet.

Comme je l'ai dit, il y a des situations folles que vous pouvez entrer lorsque vous essayez de définir des opérateurs de conversion génériques ; Ne le faites pas si vous avez une compréhension approfondie et détaillée de la section 10.10.3 de la spécification.


0 commentaires