Conversion de generics Java en C#

Version imprimable

Bonsoir,
Après de nombreuses tentatives infructueuses pour essayer de coder l'équivalent du constructeur Java suivant en constructeur C#. Je me demande si une bonne âme de passage ne pourrait pas me donner au mieux la solution, sinon une piste.
Merci...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class Key<T> { protected String kindClassName; protected Key<?> parent; protected String name; public Key(Key<?> parent, Class<? extends T> kind, String name) { this.parent = parent; this.kindClassName = kind.getName(); this.name = name; } }

14/02/2011, 18h38
StormimOn

Le paramètre de type ? indique que le type est quelconque je suppose ? Auquel cas en .Net ça n'existe pas et le code ne peut donc pas être transposé directement.

Bonjour et merci pour la réponse,
J’avais compris que ce n’était pas transposable directement, c’est pour cela que j’ai essayé en utilisant l’héritage ou une interface. Mais je n’ai rien trouvé de satisfaisant (il faut que la déclaration reste Key<T>). J’aurais aimé avoir un constructeur, mais vu que ça ne semble pas possible j’ai tenté avec la méthode statique suivante.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class Key<T> { protected string name; protected Object parent; // Pas beau mais je n’ai pas trouvé mieux; public Key(String name) { this.name = name; } public static Key<T> MakeKeyWithParent(U u, String name) where U : Key { Key<T> k = new Key<T>(); k.name = name; parent = u; return k; } }
Mais le code suivant me renvoie une erreur :

Code:

Key<String> k = Key<String>.MakeKeyWithParent<Key<TextBox>>(new Key<TextBox>("test"), "Coucou");

Citation:

Le type Key<System.Windows.Forms.TextBox>' ne peut pas être utilisé comme paramètre de type 'U' dans le type ou la méthode générique 'Key<T>.MakeKeyWithParent(U, string)'. Il n'y a pas de conversion de référence implicite de ' Key<System.Windows.Forms.TextBox>' en 'Key<System.Windows.Forms.TextBox>>'.

Et là, je n’ai plus d’idée. Si quelqu’un possède la solution je suis preneur. Et si en plus il voit une astuce pour changer en Key le membre "Parent" au lieu d’Objet, il me comblera d’aise…
Merci…

15/02/2011, 11h19
Nathanael Marchand

Qu'est ce que concrètement tu cherches à modéliser?
15/02/2011, 11h47
scarlatine

Je cherche à créer en C# une classe Key venant d'Objectify (en Java à l'origine). Cela concerne des clefs qui identifient des enregistrements dans une base de données BigTable. La clef d'un enregistrement peut avoir un parent qui est la clef d'un autre enregistrement. Les enregistrements sont de type quelconque, d'où l'usage des génériques.
15/02/2011, 13h34
Arnard

Si ton parent est quelconque, pourquoi ne pas dire que c'est de type Object ?

Sinon

Code:

Class<? extends T>

doit signifier que ton type inconnu doit hériter de T ? Donc si on recoupe, c'est de type quelconque mais héritant de T ?

Citation:

Donc si on recoupe, c'est de type quelconque mais héritant de T ?

Oui d’accord merci, mais en C# ça donne quoi ?
Quant à mon parent, si je veux utiliser des méthodes de Key<T>, je ne pourrais les utiliser qu'en le castant s'il est du type Object.
Je me demande si finalement ce n'est pas moi qui ne sais pas déclarer. J'ai une erreur lorsque je tente de déclarer l'objet suivant :
Code:

1 2 3 4 5 public class Test<T> where T : List<T> { } Test<List<String>> t; /* Erreur : Le type 'System.Collections.Generic.List<string>' ne peut pas être utilisé comme paramètre de type 'T' dans le type ou la méthode générique 'Test<T>'. Il n'y a pas de conversion de référence implicite de 'System.Collections.Generic.List<string>' en 'System.Collections.Generic.List<System.Collections.Generic.List<string>>'.*/
Une idée ?

Compris, l'erreur est dans une définition cyclique :

Code:

1
2
3
4
5
6
7
 public static Key<T> MakeKeyWithParent<U>(Key<U> u, String name) 
  {
    Key<T> k = new Key<T>();
    k.name = name;
    parent = u;
    return k;
  }

Dans ton Cas, à dire que U est un Key, tu tournes en boucle, entrainant un Key<Key>

Pour le 2e cas, la encore ton souci est le where

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Program
    {
        static void Main(string[] args)
        {
            Test<List<String>> elems = new Test<List<string>>();
            elems.Value.Add("coucou");
            Debug.Assert(elems.Value.Count == 1);
 
            Console.WriteLine(elems.Value[0]);
            Console.ReadLine();
        }
    }
 
    public class Test<T> where T: new()
    {
        public T Value;
 
        public Test()
        {
            Value = new T();
        }
    }

j'ai ajouté le where T: new() pour simplifier l'instanciation de Value, mais tu peux le faire sauter, et affecter value à la main

Bonjour et merci beaucoup pour cette réponse claire et détaillée,
Je me doutais qu'il y avait une sorte de définition cyclique, mais je ne voyais pas comment faire autrement, manifestement il y avait une solution...
J'ai continué à chercher de mon coté et j'en suis arrivé à ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public interface IKey2 { String kindClassName { get; set; } IKey2 parent { get; set; } String name { get; set; } } public class Key2<T> : IKey2 where T : class { public String kindClassName { get; set; } public IKey2 parent { get; set; } public String name { get; set; } public Key2() : this(null, null) { } public Key2(IKey2 parent, String name) { this.parent = parent; this.kindClassName = typeof(T).ToString(); this.name = name; } }
Le fait d'utiliser une interface me permet de créer un constructeur (ce que je souhaitais au début) au lieu de "MakeKeyWithParent". Par contre, parent est devenu un type interface au lieu de Key<T>. Ca me fait donc deux solutions entre lesquelles j'hésite. Mais bon, mieux vaut trop de solutions que pas du tout...
Bonne journée…