Lecture/écriture dans une mémoire protégée :S en C#

Décidément ce stage est plein de surprises ! ^^
Tout d'abord sachez que je passe quand même du temps à chercher sur google avant pour essayer de régler ça tout seul mais bon , ça m'aide pas toujours :S

Alors voilà, c'est assez long donc faut suivre :
je commence par initialiser cette variable :

Code:

1
2
3
BioAPI_CANDIDATE[] Candidates = new BioAPI_CANDIDATE[MaxNumberOfResults];
        for (int j = 0; j < MaxNumberOfResults; j++) Candidates[j] = new BioAPI_CANDIDATE();

ensuite j'appelle cette fonction :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
try
{
     bioReturn = bioapi_api.BioAPI_Identify(
                    gModuleHandle,
                    ref MaxFAR,
                    ref MaxFRR,
                    ref bPrecedence,
                    ref Population,
                    Binning,
                    MaxNumberOfResults,
                    ref NumberOfResults,
                    ref Candidates,
                    -1,
                    ref AuditData);
}
catch (Exception ex)
{
     Console.WriteLine("BioAPI_Identify Exception (button_Identify_Click): \n\tError Message = " + ex.Message);
     return;
}

ce qui me retourne ce message d'erreur :

Code:

1
2
3
4
BioAPI_Identify Exception (button_Identify_Click):
     Error Message = Tentative de lecture ou d'écriture de mémoire protégée.
Cela indique souvent qu'une autre mémoire est endommagée.

en creusant un peu j'ai trouvé que la fonction appelée passe par là :

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
public static BioAPI_RETURN BioAPI_Identify(
			BioAPI_HANDLE ModuleHandle,				//	[in]
			ref BioAPI_FAR MaxFARRequested,			//	[in]
			ref BioAPI_FRR MaxFRRRequested,			//	[in/optional]
			ref BioAPI_BOOL FARPrecedence,			//	[in]
			ref BioAPI_IDENTIFY_POPULATION Population,	//	[in]
			BioAPI_BOOL Binning,					//	[in]
			uint MaxNumberOfResults,				//	[in]
			ref uint NumberOfResults,				//	[out]
			ref BioAPI_CANDIDATE [] Candidates,		//	[out]
			int Timeout,							//	[in]
			ref BioAPI_BIR_HANDLE AuditData)		//	[out/optional]
		{
			BioAPI_RETURN bReturn = BioAPI_RETURN.BioAPI_OK;
			IntPtr ptrMaxFRRRequested = IntPtr.Zero;
			IntPtr ptrCandidates = IntPtr.Zero;
			IntPtr ptrAuditData = IntPtr.Zero;
            
			if (MaxFRRRequested >= (BioAPI_FRR) 0) 
			{ ptrMaxFRRRequested = BioAPIWin32.MarshalInt32((int) MaxFRRRequested); }

			if (AuditData >= (BioAPI_BIR_HANDLE) 0) 
			{ ptrAuditData = BioAPIWin32.MarshalInt32((int) AuditData); }

			try 
			{
				bReturn = BioAPIWin32.BioAPI_Identify(
					ModuleHandle,				//	[in]
					ref MaxFARRequested,		//	[in]
					ptrMaxFRRRequested,			//	[in/optional]
					ref FARPrecedence,			//	[in]
					ref Population,				//	[in]
					Binning,					//	[in]
					MaxNumberOfResults,			//	[in]
					ref NumberOfResults,		//	[out]
					ptrCandidates,  			//	[out]
					Timeout,					//	[in]
					ptrAuditData);				//  [out/optional]
			}
			catch (Exception ex) 
			{	
				Console.WriteLine ("BioAPIWin32.BioAPI_Identify Exception: \n\tError Message = " + ex.Message);
				return bReturn;
			}
            if (ptrAuditData != IntPtr.Zero) { }
			if (ptrMaxFRRRequested != IntPtr.Zero) Marshal.FreeCoTaskMem( ptrMaxFRRRequested );
            Console.WriteLine("ok");
            IntPtr ptrCandidate = Marshal.ReadIntPtr(ptrCandidates, 0);
            Console.WriteLine("ok");
			if (ptrCandidate != IntPtr.Zero)
			{
				int len = 0;
				BioAPI_CANDIDATE_Marshal [] mCandidates = new BioAPI_CANDIDATE_Marshal[NumberOfResults];
				Candidates = new BioAPI_CANDIDATE[NumberOfResults];
				IntPtr ptrNext = ptrCandidate;
				for (int i = 0; i < NumberOfResults; i++)
				{
					mCandidates[i].DoUnmarshal(ptrNext, ref len, false);
					Candidates[i] = new BioAPI_CANDIDATE();
					mCandidates[i].Unmarshal(Candidates[i], true);
					ptrNext = new IntPtr(ptrNext.ToInt32() + len);
				}
			}
			if (ptrAuditData != IntPtr.Zero) 
			{ AuditData = (BioAPI_BIR_HANDLE) BioAPIWin32.UnmarshalInt32(ptrAuditData, true); }
	
			return bReturn;
		}

j'ai donc découvert que l'erreur se produisait juste là :

Code:

1
2
IntPtr ptrCandidate = Marshal.ReadIntPtr(ptrCandidates, 0);

J'ai fait des recherches et apparemment cette fonction sert il me semble à créer un pointeur vers la mémoire de ptrCandidates pour pouvoir modifier cette mémoire par un autre programme, enfin d'après ce que j'ai compris :S.
Donc là je suis un peu larguer vue que le C# a encore quelques secrets pour moi ^^

ptrCandidates reste initialisé à IntPtr.Zero en permanence...

et bien la fonction appelée juste avant l'erreur est censé le modifier justement :S

Et comment ferait-elle ? Le pointeur lui est transmis par valeur...

mais pourquoi ça me fait une erreur ? ça ne devrait tout simplement pas rentrer dans le if après ?
je ne pense pas que l'erreur vienne du fait que le ptrCanditates reste inchangé.
Ca devrait marcher quand même non ?

bon et bien j'ai rajouté un test pour vérifié si il est égal à IntPtr.Zero et ça marche mais je ne comprend pas très bien pourquoi ça me met une erreur comme ça :S

Ben non, il ne rentre pas dans le if parce qu'il plante avant (ReadIntPtr sur un pointeur nul).

ah ok je pensais que la fonction renvérait une erreur au lieu de plantée :p