Discussion :

[Seth77]

Salut

j'ai une fonction que je veux appelle avec differents type de donnée ... mais le traitement est toujours le meme ...

Est il possible d'ecrire la fonction UNE SEUL FOIS ?

thx @+

[tanita-twist]

Ce que tu veux faire est possible grâce à la généricité. Avec la nouvelle version de .NET, c'est possible facilement.

Sinon, faut utiliser la classe Object et récupérer la vraie classe de l'objet dynamiquement

[Seth77]

merci

comment fait on pour récupérer la vraie classe de l'objet ?
C'est a dire comment fait on un cast dynamiquement ?

[Seth77]

Salut

j'ai fais un debut de classe...qu'en pensez vous ?

Code :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
internal abstract class DB_Objet
    {
        private ADOX.DataTypeEnum _type;
        private bool _primary_key;
        private int _size;
        private String _name;
        private bool _nullable;
 
        public override String ToString()
        {
            String aPrimaryKey = "\t \t";
            String aNullable = "";
            if (this._primary_key) aPrimaryKey = "\tX\t";
            if (this._nullable) aNullable = "Nullable";
 
            return aPrimaryKey + " " + this._name + "\t\t\t\t\t\t\t\t\t" + this._type.ToString() + "\t" + this._size + "\t\t\t\t\t\t" + aNullable;
        }
 
        public DB_Objet(ADOX.DataTypeEnum theType, int theSize, bool thePrimaryKey)
        {
            this._type = theType;
            this._primary_key = false;
            this._size = theSize;
            this._name = "";
            this._nullable = true;
            this._primary_key = thePrimaryKey;
        }
 
        public bool PrimaryKey
        {
            get { return this._primary_key; }
        }
 
        public String Name
        {
            set { this._name = this.CheckStrName(value); }
            get { return this._name; }
        }
 
        protected String CheckStrName(String theStr)
        {
            String aNewStr = theStr.Trim();
 
            aNewStr = aNewStr.Replace(".", "");
            aNewStr = aNewStr.Replace("!", "");
            aNewStr = aNewStr.Replace("[", "");
            aNewStr = aNewStr.Replace("]", "");
 
            if (aNewStr.Length > 64) aNewStr = aNewStr.Substring(0, 64);        
 
            return aNewStr;
        }
 
        private String CheckStrValue(String theValue)
        {
            String aNewStr = theStr.Trim();
 
            aNewStr = aNewStr.Replace("'", "''");
            aNewStr = aNewStr.Replace("\"", "\"\"");
 
            return aNewStr;
        }
 
        public int Size
        {
            protected set { this._size = value; }
            get { return this._size; }
        }
 
        public bool Nullable
        {
            protected set { this._nullable = value; }
            get { return this._nullable; }
        }
 
        public override int GetHashCode()
        {
            return this._name.ToLowerInvariant().GetHashCode();
        }
 
        public override bool Equals(object obj)
        {
            DB_Objet t = obj as DB_Objet;
            return t._name == this._name;
        }
    }

et voici un exemple d'objet qui en derive :

Code :

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
    class DB_Binary : DB_Objet
    {
        private String _value;
 
        public DB_Binary(String theName)
            : base(DataTypeEnum.adBinary, 64, false)
        {
            base.Name = theName;
            this._value = null;
        }
 
        public String Value
        {
            set { this._value = value; }
            get { return this._value; }
        }
 
        public new int Size { set { base.Size = value; } }
        public new bool Nullable { set { base.Nullable = value; }}
    }
 
    class DB_Boolean : DB_Objet
    {
        private bool _value;
 
        public DB_Boolean(String theName)
            : base(DataTypeEnum.adBoolean, 4, false)
        {
            base.Name = theName;
            this._value = true;
        }
 
        public DB_Boolean(String theName, bool thePrimaryKey)
            : base(DataTypeEnum.adBoolean, 4, thePrimaryKey)
        {
            base.Name = theName;
            this._value = true;
        }
 
        public bool Value
        {
            set { this._value = value; }
            get { return this._value; }
        }
 
        public new bool Nullable { set { base.Nullable = value; } }
    }

thx @+

[Seth77]

En fait je cherche un avis sur la facon dont j'ai structure les classes entres elles ....

[Matthieu MEZIL]

c'est koi ce new de m... ! Utilise virtual / override pour faire cela !
En effet, si je comprends bien, tu ne veux pas qu'on puisse affecter la propriété Nullable dans une instance de DB_Objet mais tu ne peux pas avoir d'instance de DB_Objet car elle est abstract !

[Jérôme Lambert]

c'est koi ce new de m... ! Utilise virtual / override pour faire cela !

http://msdn2.microsoft.com/fr-fr/lib...w2(VS.80).aspx

[Matthieu MEZIL]

Merci, je sais à quoi sers un new ! je trouve juste que ce n'est pas adapté à son cas ! En effet, s'il veut affecter la propriété Nullable de plusieurs instances de classes dérivant de DB_Objet dans un foreach par exemple, il ne pourra pas le faire comme ça :
foreach (DB_Object dbo in myList)
dbo.Nullable = false;
Je pense qu'il devrait mettre le set de Nullable à public et le mettre virtual s'il veut faire un traitement spécifique dans le set de cette propriété dans une classe dérivée

[Jérôme Lambert]

C'était aussi pour que Seth77 sache ce qu'il fait lorsqu'il utilise new sur un membre de la classe

[Seth77]

Finalement quelle est la difference entre override et new ?

Et mis a part cela ?

[Thomas Lebrun]

Finalement quelle est la difference entre override et new ?

Regarde cet exemple:

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
 
 public class ClassA
    {
        public virtual void Test()
        {
            Console.WriteLine("Test");
        }
    }
 
    public class ClassB : ClassA
    {
        public override void Test()
        {
            base.Test();
        }
    }
 
    public class ClassC : ClassA
    {
        new public void Test()
        {
            Console.WriteLine("Nouveau");
        }
    }

Résultat:

Test
Test
Nouveau

Imagine que dans ma classC (qui hérite de ma classA), je veuille utiliser un champ/une méthode qui porte le même nom que dans ma classe mère (classA).

Si je prend mon exemple, override (classB) va me permettre de rappeller la méthode définie dans la classe mère (classA).

A l'inverse, si j'utilise un new, je vais masquer la méthode/le champ de la classe mère et je vais pouvoir changer le code fonctionnel de ma méthode.

Donc, pour faire simple:
- override: pour rappeller le code d'une méthode/d'un champ de la classe mère
- new: lorsque l'on veut, dans une classe enfant, avoir une méthode/un champ qui porte le même nom que dans la classe parent.



C'est plus clair ?

[shwin]

[Edit]Trop rapide Thomas [/Edit]

L'override sert a overrider une méthode de la base déclarer en virtual.
Le new sert a caché une méthode de la base. C'est utile par exemple dans ce cas

Code :

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
26
27
28
29
30
 
public class Human
    {
        public Human()
        { }
 
        public virtual void DoSomething()
        {
            System.Diagnostics.Debug.WriteLine("Base :: DoSomething()");
        }
 
        public void MyType()
        {
            System.Diagnostics.Debug.WriteLine("Human");
        }
    }
 
    public class Person: Human
    {
        public override void DoSomething()
        {
            base.DoSomething();
            System.Diagnostics.Debug.WriteLine("DoSomething() different!");
        }
 
        public new void MyType()
        {
            System.Diagnostics.Debug.WriteLine("Human");
        }
    }

Code :

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

1
2
3
4
5
6
7
8
 
Human h = new Human();
h.MyType();
 
Person p = new Person();
p.MyType();
 
 p.DoSomething();

p.DoSomething() est overrider par Person, car je veux faire qqechose de plus dans mon cas, un debug de plus.

MyType est déclaré avec un new. car si je met pas le new, je cache pas le membre de la base, donc si je ferais p.MyType, il va appeler sa base donc il va faire un debug("Human") et non pas debug("Personn")

Bref l'override sert a mettre des fonctionnalité de plus a une methode de la base.
Le new sert a caché le membre de la base pour etre capable d'appeler la méthode selon le bon type!

[Seth77]

Ok merci

Donc l'override rajoute du "code" a la fonction mere et le new remplace le "code" existant ...


Et concernant la contruction de la classe qu'en pensez vous ?