Discussion :

[lerieure]

Bonjour,

Je vous expose mon problème qui serait surement très simple pour vous.

J'ai une classe Mère "Tree" qui possède une Interface :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
    // Résumé*:
    //     Fournit des fonctionnalités permettant créer un Objet sous forme d'arborescence intervallaire dynamique
    //     type générique qui permet de signifier que le type T pourra uniquement être utilisé comme type des paramètres
    //     des méthodes de cette interface. ITreeObject<Tree> pourra être considéré comme un type ITreeObject<Fal> etc.. si un objet Fal peut être converti en objet A
    public interface ITreeObject<in T>
    {
 
        int TreeId { get; set; }
 
        string TreeName{get; set;}
 
        int TreeLevel {get; set;}
 
 
    }

Elle spécialise aussi une classe BindableObject afin de pouvoir notifier ses changements
et trois (ca va augmenter) classes qui spécialise Tree : "Fal", "Program", "Station"

Ensuite j'ai créé une classe TreeData
Elle possède une interface :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
    //     type générique qui permet de signifier que le type T pourra uniquement être utilisé comme type des paramètres
    //     des méthodes de cette interface. ITreeData<Tree> pourra être considéré comme un type ITreeData<Fal> etc.. si un objet Fal peut être converti en objet Tree
    public interface ITreeData<in T>
    {
        ObservableCollection<T> GetTree {get; }
    }

elle possède un membre static ObservableCollection<Tree>


Quand je fais :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    public class TreeData : ITreeData<Tree> 
    {
        private static ObservableCollection<Tree> tree;

        public static ObservableCollection<Tree> GetTree
        {
            get
            {
                if (tree != null) return tree;
                else if (tree.GetType() == typeof(Fal))
                {
                    tree = new ObservableCollection<Fal>();                    //tree.Add(new Fal(1, "Fals", 18, 1, 0));
                    //tree.Add(new Fal(3, "AAA", 3, 2, 1));
                    //tree.Add(new Fal(4, "EE", 17, 4, 1));
                    //tree.Add(new Fal(5, "EEA", 6, 5, 2));
                    //tree.Add(new Fal(6, "EEB", 16, 7, 2));
                    //tree.Add(new Fal(7, "EEBA", 9, 8, 3));
                    //tree.Add(new Fal(8, "EEBB", 11, 10, 3));
                    //tree.Add(new Fal(9, "EEBC", 13, 12, 3));
                    //tree.Add(new Fal(10, "EEBD", 15, 14, 3));
                }

                return tree;
            }

il me marque impossible de faire une conversion implicite entre ObservableCollection<Fal>() et ObservableCollection<Tree>()

Help me, je sais pas comment faire...

[Nathanael Marchand]

Malheureusement il n'y a pas de contravariance sur ObservableCollection, ce qui explique ton problème.

[lerieure]

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
       public static ObservableCollection<Tree> GetTree
        {
            get
            {
                if (tree != null) return tree;
                else if (tree.GetType() == typeof(Fal))
                {
                    tree = new ObservableCollection<Tree>();                            tree.Add(new Fal(1, "Fals", 18, 1, 0));
                    tree.Add(new Fal(3, "AAA", 3, 2, 1));
                    tree.Add(new Fal(4, "EE", 17, 4, 1));
                    tree.Add(new Fal(5, "EEA", 6, 5, 2));
                    tree.Add(new Fal(6, "EEB", 16, 7, 2));
                    tree.Add(new Fal(7, "EEBA", 9, 8, 3));
                    tree.Add(new Fal(8, "EEBB", 11, 10, 3));
                    tree.Add(new Fal(9, "EEBC", 13, 12, 3));
                    tree.Add(new Fal(10, "EEBD", 15, 14, 3));
                }
 
                return tree;
            }

si je fais ça, ça marche par contre ...