Discussion :

[duaner]

Bonjour,

Comment peut on faire pour changer la valeur contenue dans un objet de type Int32, je pensais que cela était simple mais je n'ai rien trouvé par moi même ou dans les docs.

Je voudrais faire cela :

Code :

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

1
2
3
4
5
 
            object monObjInt = 5;
            object pointeurSurMonInt = monObjInt;
            pointeurSurMonInt = -10;
            Console.WriteLine(monObjInt);//affiche 5, je voudrais -10

Le 5 affiché me parait normal, je déférence pointeurSurMonInt en le faisant pointer sur un autre objet.

Pour empecher cela, est ce qu'il y a quelque chose du type suivant qui existe :

Code :

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

1
2
3
4
5
 
            object monObjInt = 5;
            object pointeurSurMonInt = monObjInt;
            pointeurSurMonInt.Value = -10; //ce qu'il pourrait marcher mais...le .Value n'existe pas
            Console.WriteLine(monObjInt);//devrait afficher 10

[SaumonAgile]

Int32 est un type intégral et non un type référence.
Qu'est ce que tu voudrais faire exactement ?
Si c'est pour passer la variable par référence dans une méthode, tu peux utiliser ref ou out dans la déclaration de la méthode en question.

[Bluedeep]

Idem, je ne comprends pas ce que tu veux faire.

Pourquoi utiliser le type generique objet pour stocker un entier ?

C'est pas clair ta demande.

[duaner]

Je voudrais pouvoir avoir deux variables différentes qui correspondent au meme entier.

Ainsi quand je change la valeur d'une des deux variable, l'autre est aussi changée, genre je voudrais avoir une sorte de type référence pour les entiers. Je suis peut etre pas clair...

[Mehdi Feki]

Peut - être en mode unsafe

Code C# :

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

1
2
3
4
5
6
7
8
 
         unsafe
            {
                int x = 10;
                int* y = &x;
 
                System.Console.WriteLine(*y);
            }

[Bluedeep]

Peut - être en mode unsafe

Certes, mais on en revient au problème de son besoin, que je ne comprends pas.

[dev01]

Je voudrais pouvoir avoir deux variables différentes qui correspondent au meme entier.

L'intéret est ou ?

Ainsi quand je change la valeur d'une des deux variable, l'autre est aussi changée, genre je voudrais avoir une sorte de type référence pour les entiers. Je suis peut etre pas clair...

Ben tu encapsules :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public class MonInt32
{
    private int i;
 
    public int Value
    {
         get { return i; }
         set { i = value; }
    }
}

et tu utilises MonInt32 à la place ...

n'empeche que je suis comme les autres je comprend pas le besion la ...

[duaner]

Je vais essayer d'être plus complet et plus clair sur ce que je veux faire :

J'ai des fonctions qui agissent sur une liste d'input :

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
    //classe travaillant sur des inputs
    public abstract class ATraiteur
    {
        //liste des objets sur lesquels la classe travaille
        //la string est l'alias utilisé dans les fonctions de traitement et l'objet et l'objet surlekel on travail
        protected Dictionary<string, Object> _inputs = new Dictionary<string, object>();
 
        //une fonction de traitement
        public abstract void action(); 
 
        //ajout d'un objet sur lequel la classe pourra travailler
        public void addInput(string alias, object newInput)
        {
            _inputs.Add(alias, newInput);
        }
    }

Ces fonctions ne connaissent leurs inputs que via un alias, une implémentation de cette classe :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
    //une implémentation de ATraiteur
    public class traiteur1 : ATraiteur
    {
        public override  void action()
        {
            //il faut que _inputs contienne les entrées objectInt32 et objectMonInt32
            _inputs["objectInt32"] = 0;
            ((MonInt32)(_inputs["objectMonInt32"])).Value = 0;
        }
    }

et voici ce que je veux faire :

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
        static void Main(string[] args)
        {
            //creation des objets sur lesquels les fonctions traiteurs vont travailler
            int intNormal = 5;
            MonInt32 objMonInt32 = new MonInt32(5);
 
            //creation d'une fonction traiteur et liaison avec les objets précédemment créés
            traiteur1 t1 = new traiteur1();
            t1.addInput("objectInt32", intNormal);
            t1.addInput("objectMonInt32",objMonInt32);
 
            //traitement
            t1.action();
 
            //fin du traitement
            Console.WriteLine("intNormal : " + intNormal + ", objMonInt32 : " + objMonInt32.Value);
        }
    }

Console.WriteLine("intNormal : " + intNormal + ", objMonInt32 : " + objMonInt32.Value); affiche 5 et 0, je voudrais 0 et 0.

En faite, mes objets ATraiteur doivent travailler sur les mêmes inputs, ainsi si traiteur1 modifie l'objet objMonInt32 du programme principal alors traiteur2 (si il esixtait) devrait travailler sur la nouvelle valeur de objMonInt32.

Quand on a des objets avec des champs, il n'y a pas de probleme mais dans traiteur 1 quand je fait :

Code :

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

_inputs["objectInt32"] = 0;

c'est comme si je faisais :

Code :

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

_inputs["objectInt32"] = new Int32(0);

En passant par un objet monInt32 il n'y a pas de problème puis que je change la valeur d'un champ, je ne crée pas un nouvel objet.

Je voudrais pouvoir faire cela sans la classe monInt32, je pensais qu'il y avait une méthode pour changer la valeur d'un int genre :

Code :

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

1
2
3
int i;
i.Value = 3;
ou i.set(3);

J'espère que je me suis mieux exprimé...

[dev01]

J'espère que je me suis mieux exprimé...

oui tu t'es mieux exprimé mais ce que tu ne comprend toujours pas c'est que quant tu fait :

Code :

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

1
2
3
 
int i = 0;
int j = i;

C'est bien la valeur de i qui est copié dans j et non pas la référence. Tu ne peux donc pas pas faire ce que tu veux sans passer par une encapsulation

[Mehdi Feki]

Juste une question, tu traite toujours des entiers dans les valeurs de ton dictionnaire ?

[duaner]

mehdi_tn>non, mon dictionnaire contient toute sorte d'objets, des entiers, des strings et des objets d'autre classes que j'ai implémentées

dev01>Oui d'où mon problème...j'aurais aimé ne pas passer par une encapsulation. Je pensait qu'il y avait quelquechose de natif enC# qui faisait cela.

[Mehdi Feki]

Tu vas donc avoir des méthodes action pour chaque type ?

[duaner]

Dans mes méthodes actions, je suis obligé de toujours caster, chaque classe implémentant ATraiteur connais ses inputs et dans le programme principal il faut que ces inputs soit bien du type spécifié ex:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
    public class UneClasse
    {
        private int _id;
        private int _value;
 
        public void m1(int i)
        {
           ...
    }

exemple d'action

Code :

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

1
2
3
4
5
6
7
8
9
10
 
    public class unTraiteur : ATraiteur
    {
        public override void action()
        {
            //il faut que _inputs contienne l'entrée obj1
            ((UneClasse)(_inputs["obj1 "])).Value = 0; //je suis obliger de caster
            ((UneClasse)(_inputs["obj1 "])).m1(-42);
        }
    }

programme principal :

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
 
        //fonction correcte
        static void Main(string[] args)
        {
            UneClasse c = new UneClasse();
            ATraiteur t = new unTraiteur();
            t.addInput("obj1",c); //ajout de obj1
 
            t.action();//action va fontion correctement
         }
 
 
        //fonction incorrecte
        static void Main2(string[] args)
        {
            int c = 5;
            ATraiteur t = new unTraiteur();
            t.addInput("obj1",c); //ajout de obj1
 
            t.action();//va planter lors du cast
         }

En faite si je fait comme cela, c'est pour rester très générique dans la déclaration de ATraiteur et en plus mon dictionnaire ne contient pas forcément que des objets du meme type

[Mehdi Feki]

Je ne vois toujours pas comment ton action sait qu'il possede une clé obj1

Sinon pour faire plus propre, est-ce que t'as pensé aux generics ?

Code C# :

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

1
2
3
4
5
6
7
8
9
10
 
 public class TraiteurGeneric<T>
        {
            private Dictionary<string, T> _inputs = new Dictionary<string, T>();
 
            public void addInput(string alias, T newInput)
            {
                _inputs.Add(alias, newInput);
            }
        }

Ca ne veut pas dire que ça résourd pas ton problème intial mais ça permet d'éviter les casts.

[duaner]

Je ne vois toujours pas comment ton action sait qu'il possede une clé obj1

Et bein elle n'en sait rien, action espère que dans le programme principal il y a eu un addInput("obj1",o1); avec o1 du bon type...

Je n'utilise pas la généricité car il peut y avoir des objets de type différents dans le dictionnaire

[Mehdi Feki]

Là franchement je comprend plus rien. Est-ce ton code original ou tu l'ecris spécialement pour le fil ?

Si tu mets :

Code C# :

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

1
2
3
4
5
6
7
8
9
10
 
public class unTraiteur : ATraiteur
    {
        public override void action()
        {
            //il faut que _inputs contienne l'entrée obj1
            ((UneClasse)(_inputs["obj1 "])).Value = 0; //je suis obliger de caster
            ((UneClasse)(_inputs["obj1 "])).m1(-42);
        }
    }

C'est que le dictionnaire de unTraiteur n'accepte que des int sinon ton code levera une exception.

Chaque taiteur qui hérite de ATraiteur dispose de son propre dictionnaire n'est-ce pas ?

[duaner]

Là c'est mon code original (pour l'instant je regarde ce que je peux faire, après j'incorporerais à mn projet global celui ci)

C'est que le dictionnaire de unTraiteur n'accepte que des int sinon ton code levera une exception.

pourquoi?

D'ailleur il n'utilise pas que des ints...

Chaque taiteur qui hérite de ATraiteur dispose de son propre dictionnaire n'est-ce pas ?

Oui et il est du type Dictionary<string, Object>

[bilb0t]

Bonjour,

ton analyse me parait bancale... Tu as l'air d'être dans un cas ou tu as besoin d'interface...

Maintenant, il te reste 2 solutions:
1. Te convaincre que tu as raison et tordre le système pour le faire marcher (méthode habituelle...)
2. Refaire/Revalider ton analyse et voir ou ça coince...

[Mehdi Feki]

pourquoi?

Code C# :

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

((UneClasse)(_inputs["obj1 "])).Value = 0;

Marchera pas si à un type autre que UneClasse est affecté à obj1

Sinon par rapport au problème initial, pense à ce que dev01 t'as recommandé. Je pensais à te recommander d'utiliser les pointeurs mais le type (int *) n'est pas convertible en object.

[hed62]

Je suis aussi de cet avis : revois ta conception..

Je te propose d'utiliser une interface, et pourquoi pas une classe abstraite pour les méthodes communes.

Ainsi, tu pourra mettre tout ce que tu veux dans ton dico, en encapsulant les donnees dans une classe qui héritera de la classe abstraite.

Peux être pourrais tu jeter un oeil aux pattern "Patron de méthode" et "Factory" (pour encapsuler aisément des types primitifs)