[Débutant] AccessViolationException au déclenchement d'un évênement

AccessViolationException au déclenchement d'un évênement

Bonjour et merci de m'acceuillir pour mon premier problème.

Pour un de mes cours je dois faire une application en C# avec des services (WCF), une BDD pour la persistance des données du service (Linq to SQL) et une architecture MVVM pour mon application cliente avec deux vues.

Ma première vue contient une liste d'objets personnes basiques (récupérer grâce au service sur la BDD) et 3 boutons : ajouter, éditer, supprimer.

Lorsque je clique sur ajouter ou éditer la deuxième vue pop et me permet de saisir les informations ou éditer les informations d'une personne : nom, prénom, age et sexe.

Mon problème étant que mes boutons ne fonctionnent pas, et qu'à force de cliquer dessus (en étant patient entre chaque clic) cette exception me saute au nez. Alors que ca marchait plutôt bien avant (sur un autre de mes TP reprenant la même idée et la même structure pour le client, et donc sans service et sans BDD, mais je l'ai perdu... too bad...).

Je sais que cette exception vient du fait que le logiciel essai surement de taper sur un pointeur qui n'existe pas ou sur une zone mémoire auquel il n'a pas accès. Mais je ne trouve pas ce qui provoque ça dans mon code...

Pour gérer les évênements clic j'utilise du Binding sur une ICommand qui déclenche l'évênement auquel est abonné un BusinessController qui se charge d'ouvrir l'autre vue en initialisant ses variables utiles.

Bref, une idée ou des conseils pour trouver ce qui déclenche l'exception?

P.S : la gestion de l'évênements se fait dans plusieurs fichier différents donc j'ai préférer ne pas vous afficher d'extrait, mon post étant déjà assez tordu...

Bonjour,

Ma boule de cristal ne me permet pas de te répondre donc sans code nous ne pouvons rien deviner...

Ok, je pensais que mon problème était relativement courant pour un débutant et que vous auriez des pistes sans que j'ai à alourdir mon premier posts.

Donc, phase 2 : les scripts!

L'explorateur de la solution :
http://img802.imageshack.us/img802/4...rdesolutio.jpg

ListWindowViewModel.cs :
C'est donc la que la vue et tout ce qui me permet de la gérer est inscrit.

Code:

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Input;
using TP5.Events;
using TP5.Utilities;
using System.Collections.ObjectModel;
using Contrat;
 
namespace TP5.VueListWindow
{
    public class ListViewModel : DependencyObject
    {
        public ListWindowModel Model { get; set; }
 
        public ListWindow View { get; set; }
 
        public ListViewModel()
        {
            Model = new ListWindowModel();
            View = new ListWindow();
 
            OpenAddCommand = new Command(new Action<object>(ExecuteOpenAddCommand));
            OpenEditCommand = new Command(new Action<object>(ExecuteOpenEditCommand));
 
            Model.uneListePersonne = TP5.Controllers.BusinessController.do_getListPersonne();
 
            View.DataContext = Model;
        }
 
        #region OpenDialogCommand
 
        private void ExecuteOpenAddCommand(object obj)
        {
            Model_BtnAddClicked();
        }
 
        public ICommand OpenAddCommand
        {
            get { return (ICommand)GetValue(OpenAddCommandProperty); }
            set { SetValue(OpenAddCommandProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for OpenAddCommand.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty OpenAddCommandProperty =
            DependencyProperty.Register("OpenAddCommand", typeof(ICommand), typeof(ListViewModel), new UIPropertyMetadata(null));
 
 
 
        private void ExecuteOpenEditCommand(object obj)
        {
            Model_BtnEditClicked();
        }
 
        public ICommand OpenEditCommand
        {
            get { return (ICommand)GetValue(OpenEditCommandProperty); }
            set { SetValue(OpenEditCommandProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for OpenDialogCommand.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty OpenEditCommandProperty =
            DependencyProperty.Register("OpenEditCommand", typeof(ICommand), typeof(ListViewModel), new UIPropertyMetadata(null));
 
        #endregion
 
        private void Model_BtnAddClicked()
        {
            TP5.Events.Dispatcher.RaiseBtnAddClicked();
        }
 
        private void Model_BtnEditClicked()
        {
            if (Model.currentItem != null)
            {
                TP5.Events.Dispatcher.RaiseBtnEditClicked(Model.currentItem);
            }
        }
    }
}

EditionViewModel.cs :
La fenêtre qui me permet de gérer la vue qui me permet d'éditer une personne

Code:

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
88
89
90
91
92
93
94
95
96
97
98
99
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Input;
using TP5.Events;
using TP5.Utilities;
using Contrat;
 
namespace TP5.VueEditWindow
{
    public class EditionViewModel : DependencyObject
    {
        /**Déclaration des propriétés du Model et de la vue**/
 
        //Permet de référencer le Model
        public EditionModel Model { get; set; }
 
        //Permet de référencer la View
        public Edition View { get; set; }
 
        //Méthode permettant d'initialiser la vue Edition (Model, Vue et DataContext)
        public EditionViewModel()
        {
            BtnCancelCommand = new Command(new Action<object>(ExecuteBtnCancelCommand));
            BtnOkCommand = new Command(new Action<object>(ExecuteBtnOkCommand));
 
            Model = new EditionModel();
            View = new Edition();
 
            View.DataContext = this;
        }
 
 
 
 
        // Méthode d'initialisation du binding
        public void Start()
        {
            View.Show();
        }
 
        #region BtnOkCommand
 
        private void ExecuteBtnOkCommand(object obj)
        {
            Model.unePersonne.nom = Model.nom;
            Model.unePersonne.prenom = Model.prenom;
            Model.unePersonne.age = Model.age;
            Model.unePersonne.sexe = Model.sexe;
 
            if (Model.modeAjout)
            {
                TP5.Controllers.BusinessController.do_addPersonne(Model.unePersonne);
            }
            else
            {
                TP5.Controllers.BusinessController.do_editPersonne(Model.unePersonne);
            }
 
            View.Close();
        }
 
        public ICommand BtnOkCommand
        {
            get { return (ICommand)GetValue(BtnOkCommandProperty); }
            set { SetValue(BtnOkCommandProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for OpenDialogCommand.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty BtnOkCommandProperty =
            DependencyProperty.Register("BtnOkCommand", typeof(ICommand), typeof(EditionViewModel), new UIPropertyMetadata(null));
 
        #endregion
 
 
        #region BtnCancelCommand
 
        private void ExecuteBtnCancelCommand(object obj)
        {
            View.Close();
        }
 
        public ICommand BtnCancelCommand
        {
            get { return (ICommand)GetValue(BtnCancelCommandProperty); }
            set { SetValue(BtnCancelCommandProperty, value); }
        }
 
        // Using a DependencyProperty as the backing store for OpenDialogCommand.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty BtnCancelCommandProperty =
            DependencyProperty.Register("BtnCancelCommand", typeof(ICommand), typeof(EditionViewModel), new UIPropertyMetadata(null));
 
        #endregion
 
 
    }
}

Dispatcher.cs :
Centralisation des évênements

Code:

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using Contrat;
 
namespace TP5.Events
{
    public static class Dispatcher
    {
        public static void RaiseBtnAddClicked()
        {
            if (OpenAddWindow != null)
            {
                OpenAddWindow();
            }
        }
 
        public static event Action OpenAddWindow;
 
        public static void RaiseBtnEditClicked(Personne parameter)
        {
            if (OpenEditWindow != null)
            {
                OpenEditWindow(parameter);
            }
        }
 
        public static event Action<Personne> OpenEditWindow;
 
        public static void RaiseBtnDelClicked(Personne parameter)
        {
            if (DeletePersonne != null)
            {
                DeletePersonne(parameter);
            }
        }
 
        public static event Action<Personne> DeletePersonne;
 
    }
}

BusinessController.cs :
Gestion de tous les évênements et qui gère les actions lié au service IServicePersonne.

Code:

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using Contrat;
using System.Collections.ObjectModel;
using TP5.VueEditWindow;
 
namespace TP5.Controllers
{
    public class BusinessController
    {
        public BusinessController()
        {
            // Le business controller s'abonne aux evenements qui l'interesse
            //Events.Dispatcher.Additionne += Dispatcher_Additionne;
            Events.Dispatcher.OpenAddWindow += Dispatcher_OpenAddWindow;
            Events.Dispatcher.OpenEditWindow += Dispatcher_OpenEditWindow;
        }
 
        public static IServicePersonne GetProxy()
        {
            // Le client doit connaitre l'addresse du service
            var addresse = new EndpointAddress("net.tcp://localhost:50000/ServicePersonne");
 
            // ChannelFactory permet de créer un proxy sur le service qui va gerer le coté réseau et SOA
            // On a besoin du contrat de service, du Binding et de l'addresse (ABC)
            var service = ChannelFactory<IServicePersonne>.CreateChannel(new NetTcpBinding(), addresse);
 
            return service;
        }
 
        #region Evenements
 
        private void Dispatcher_OpenEditWindow(Personne unePersonne)
        {
            var viewModel = new EditionViewModel();
            viewModel.Model.modeAjout = false;
            viewModel.Model.unePersonne = unePersonne;
            viewModel.Start();
        }
 
        private void Dispatcher_OpenAddWindow()
        {
            var viewModel = new EditionViewModel();
            viewModel.Model.modeAjout = true;
            viewModel.Model.unePersonne = new Personne();
            viewModel.Start();
        }
 
        //private void Dispatcher_Additionne(int a, int b)
        //{
        //    var resultat = Addition(a, b);
 
        //    Events.Dispatcher.RaiseResultat(resultat);
        //}
 
        #endregion
 
        #region Méthodes
 
        public static void do_addPersonne(Personne unePersonne)
        {
            // On appelle la ou les operations a partir du proxy recuperé
            GetProxy().addPersonne(unePersonne);
        }
 
        public static void do_editPersonne(Personne unePersonne)
        {
            // On appelle la ou les operations a partir du proxy recuperé
            GetProxy().editPersonne(unePersonne);
        }
 
        public static ObservableCollection<Personne> do_getListPersonne()
        {
            // On appelle la ou les operations a partir du proxy recuperé
            return GetProxy().getListPersonne();
        }
 
        #endregion
    }
}

Donc j'espère avoir fourni tout ce dont vous avez besoin pour m'aider. Si quelque chose n'est pas clair je m'empresserai de tenter de vous éclaircir, après tout, c'est moi qui appelle à l'aide ;).

Merci de votre aide et de prendre la peine de me lire ^^.

Non, cela n'inspire personne?

Bonsoir,

Comment t'expliquer qu'il y a un juste milieu entre expliquer vaguement un problème sans bout de code et fournir un million de lignes de code (c'est juste pour caricaturer, ce n'est pas vraiment un million...). Nous sommes là pour t'aider, certes, mais nous n'avons pas forcément le temps ni la motivation de lire tout ton code. C'est certainement pour cette raison que tu n'as pas eu beaucoup de réponses.

Si je peux me permettre de te donner un conseil, il faut exposer ton problème brièvement avec un ou des extraits de code judicieux de quelques lignes. Cela a plusieurs effets, pour toi tout d'abord, arriver à savoir d'où viens ton problème et mettre tes idées au clair pour pouvoir exposer ton problème simplement. Ensuite pour nous, arriver à comprendre rapidement ton besoin et éventuellement y répondre si nous avons une solution à t'apporter, une idée à te proposer etc...

N'ayant pas cette motivation, je te propose poser à nouveau ta question en suivant les conseils que je t'ai donné.

Tu as peut être intérêt à regarder la stacktrace de ton exception.

Ca te permettra de cibler précisément la ligne de code qui déclenche ton AccessViolation.

Résolu!

Bien, le problème venait d'un mauvais DataContext.

En fait, mon professeur à essayé sur son propre ordinateur et ça n'as pas déclenché d'erreur, par contre il a repéré l'erreur de DataContext, et en la corrigeant chez moi cela fonctionne.

Le bug venait surement de la version de Windows ou Visual Studio différente, what else?

Donc j'avais ma commande déclarer dans ma ListWindowViewModel et mon DataContext était basé sur mon ListWindowModel, ce qui fait que le binding sur ma commande ne marchait pas, et qui faisait tout bugué.

Désolé pour la façon dont j'ai demandé de l'aide qui était maladroite.