_purecall : quand le GC .NET libère un objet COM au mauvais moment
Retour d'expérience EvoStock : un crash natif en production, causé par des objets COM Sage 100 libérés par le CLR au mauvais moment et dans le mauvais ordre. Dumps, WinDbg, cause et correctif.
Sur EvoStock, l'app de gestion de stock que je développe chez EvoFlux, le serveur ASP.NET Core communique avec Sage 100 via les Objets Métiers, une API COM. Ce retour d'expérience raconte un crash natif qui m'a occupé environ trois mois, et ce qu'il m'a appris sur la façon dont .NET libère les objets COM.
Pour suivre, mieux vaut connaître la mémoire en C# et le garbage collector.
# Le symptôme
- Le service serveur s'arrête net en production, à des moments imprévisibles.
- Aucune exception .NET, aucune stack trace dans les logs : le process est tué.
- Au début, impossible à reproduire en test. Plus tard, le crash est devenu reproductible sur une seule opération, puis même au repos.
- Seul indice :
_purecall.
# Ce que signifie _purecall
_purecall est une fonction du runtime C++ de Microsoft. Elle est appelée quand le programme invoque une fonction virtuelle pure : une méthode déclarée sans implémentation, l'équivalent C++ d'une méthode abstraite en C#.
En temps normal, c'est impossible : on ne peut pas instancier une classe abstraite. Ça arrive pourtant dans un cas précis : un objet en cours de destruction, ou déjà détruit, reçoit encore un appel. Pendant la destruction, l'objet redevient peu à peu sa classe de base abstraite, et l'appel tombe sur une méthode qui n'a pas de corps. _purecall appelle alors abort(), qui tue le processus.
En clair : du code natif utilise un objet qui n'existe déjà plus.
# Le diagnostic
Capturer ce que les logs ne montrent pas
Un crash natif ne laisse rien dans les logs .NET. J'ai donc activé les dumps complets de Windows Error Reporting (clé LocalDumps, DumpType=2) pour capturer la mémoire du process au moment du crash, puis je les ai analysés avec WinDbg (!analyze -v).
Le dump est clair : exception 0xC0000409 (un fail fast : le process s'arrête volontairement), et la chaîne d'appels part d'un destructeur Sage :
CBaseObjet::CMETATABLE::~CMETATABLE -> _purecall -> abortCBaseObjet::CMETATABLE::~CMETATABLE -> _purecall -> abortUn objet Sage, pendant sa destruction, appelle une méthode d'un objet déjà détruit.
Un premier contournement qui ne règle rien
Premier réflexe : forcer les choses. FinalReleaseComObject au lieu de ReleaseComObject, un GC.Collect() suivi de GC.WaitForPendingFinalizers(), et un verrou global autour des appels Sage.
Deux mois plus tard, le crash revient avec exactement la même signature dans le dump. Le contournement n'avait rien réglé.
Le thread fautif n'est pas le nôtre
En relisant les dumps, un détail saute aux yeux : le thread qui crashe n'est pas un thread .NET. C'est un thread créé par COM, en train de traiter un Release venu d'un autre thread.
L'explication est dans le registre : les objets Sage sont enregistrés sans ThreadingModel. Pour COM, ça veut dire qu'ils doivent vivre dans le STA (Single-Threaded Apartment) principal du process. Or notre serveur ASP.NET Core les appelait depuis des threads du pool, qui sont en MTA. COM créait donc un thread STA à part pour héberger les objets Sage, et chaque appel comme chaque Release passait par un proxy entre les deux.
Le crash résiduel qui donne la clé
Premier vrai correctif : un thread STA dédié, propriétaire de tout le COM Sage. Test terrain concluant... jusqu'à un nouveau crash, au repos, après 80 minutes d'inactivité. Signature différente cette fois : un accès à un pointeur nul (0xC0000005) dans le code Sage.
Mais ce dump-là contient enfin la preuve. La pile montre le nettoyage des RCW par le CLR (RCWCleanupList::ReleaseRCWListInCorrectCtx), exécuté sur notre thread STA via sa boucle de messages. Et !DumpRCW sur l'objet en cours de nettoyage révèle un IEnumVARIANT : l'énumérateur créé par un foreach sur une collection Sage, jamais libéré, et nettoyé par le CLR longtemps après la fermeture de la session Sage.
# La cause : le CLR choisit le moment et l'ordre
Quand du code .NET manipule un objet COM, il ne le touche jamais directement. Le CLR crée un RCW (Runtime Callable Wrapper), un objet .NET qui détient une référence sur l'objet COM natif, et ne la relâche que lorsqu'il est lui-même libéré.
Si le code ne libère pas un RCW explicitement, le CLR s'en charge après son passage au GC. Et il le fait correctement sur un point : la libération s'exécute dans l'apartment propriétaire de l'objet, donc sur le bon thread. Nos dumps le confirment, avant comme après le correctif.
| Ce que le CLR garantit | Ce qu'il ne garantit pas |
|---|---|
| Chaque RCW finit par être libéré | Le moment de la libération, qui dépend du GC |
| La libération se fait sur le bon apartment | L'ordre entre objets liés : un enfant peut partir après son parent |
| Que la session Sage soit encore ouverte à ce moment-là |
Or le code laissait beaucoup d'objets COM au CLR : des objets intermédiaires obtenus en passant, des sous-objets lus plusieurs fois, et les énumérateurs cachés de chaque foreach. Environ 70 RCW orphelins au total. Le CLR les nettoyait plus tard, dans un ordre arbitraire, parfois après leur objet parent ou après la fermeture de la session. Le destructeur Sage tombait alors sur un état interne déjà détruit : _purecall, ou pointeur nul.

Le bug n'était donc pas une course entre threads, mais une question d'ordre et de moment. Et c'est le GC qui décidait du moment : d'où le caractère aléatoire.
# Le correctif : plus aucun objet COM laissé au GC
Le principe tient en une phrase : tout ce qu'on obtient de Sage, on le libère soi-même, dans l'ordre inverse, avant de fermer la session. En pratique, trois briques.
1. Un thread STA dédié, qui pompe les messages
Un seul thread possède tout le COM Sage : création, appels et libération. Il doit pomper les messages Windows : c'est par là que COM et le CLR lui délivrent les appels entrants, dont le nettoyage des RCW. Un thread STA qui attend sans pomper bloque ces appels.
// Thread STA unique, propriétaire de tout le COM Sage : création, appels et libération.
// Condensé du code réel : arrêt, réentrance et déclarations P/Invoke (user32) omis.
public sealed class SageComExecutor
{
[ThreadStatic] private static bool _isSageStaThread;
public static bool IsOnSageStaThread => _isSageStaThread;
private readonly ConcurrentQueue<Action> _work = new();
private readonly AutoResetEvent _wake = new(false);
private readonly Thread _thread;
public SageComExecutor()
{
_thread = new Thread(ThreadMain) { IsBackground = true, Name = "Sage-STA" };
_thread.SetApartmentState(ApartmentState.STA);
_thread.Start();
}
public Task<T> InvokeAsync<T>(Func<T> work)
{
var tcs = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
_work.Enqueue(() =>
{
try { tcs.SetResult(work()); }
catch (Exception ex) { tcs.SetException(ex); }
});
_wake.Set();
return tcs.Task;
}
private void ThreadMain()
{
_isSageStaThread = true;
IntPtr[] handles = [_wake.SafeWaitHandle.DangerousGetHandle()];
while (true)
{
while (_work.TryDequeue(out Action? job)) job();
// Attend du travail OU un message Windows : les appels COM entrants,
// dont le nettoyage des RCW par le CLR, arrivent par la file de messages.
uint r = MsgWaitForMultipleObjectsEx(1, handles, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE);
if (r == WAIT_OBJECT_0 + 1) PumpMessages(); // PeekMessage, TranslateMessage, DispatchMessage
}
}
}// Thread STA unique, propriétaire de tout le COM Sage : création, appels et libération.// Condensé du code réel : arrêt, réentrance et déclarations P/Invoke (user32) omis.public sealed class SageComExecutor{ [ThreadStatic] private static bool _isSageStaThread; public static bool IsOnSageStaThread => _isSageStaThread; private readonly ConcurrentQueue<Action> _work = new(); private readonly AutoResetEvent _wake = new(false); private readonly Thread _thread; public SageComExecutor() { _thread = new Thread(ThreadMain) { IsBackground = true, Name = "Sage-STA" }; _thread.SetApartmentState(ApartmentState.STA); _thread.Start(); } public Task<T> InvokeAsync<T>(Func<T> work) { var tcs = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously); _work.Enqueue(() => { try { tcs.SetResult(work()); } catch (Exception ex) { tcs.SetException(ex); } }); _wake.Set(); return tcs.Task; } private void ThreadMain() { _isSageStaThread = true; IntPtr[] handles = [_wake.SafeWaitHandle.DangerousGetHandle()]; while (true) { while (_work.TryDequeue(out Action? job)) job(); // Attend du travail OU un message Windows : les appels COM entrants, // dont le nettoyage des RCW par le CLR, arrivent par la file de messages. uint r = MsgWaitForMultipleObjectsEx(1, handles, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE); if (r == WAIT_OBJECT_0 + 1) PumpMessages(); // PeekMessage, TranslateMessage, DispatchMessage } }}Côté ASP.NET Core, chaque opération Sage passe par ce thread :
await sageSta.InvokeAsync(() =>
{
using var scope = new SageScope(server, database, user, password);
// lectures et écritures Sage, chaque objet COM suivi par le scope
return true;
});await sageSta.InvokeAsync(() =>{ using var scope = new SageScope(server, database, user, password); // lectures et écritures Sage, chaque objet COM suivi par le scope return true;});2. Un scope qui suit et libère chaque objet COM
SageScope ouvre la session, garde la trace de chaque objet COM obtenu, et libère tout en ordre inverse avant de fermer la session. Il refuse d'être créé hors du thread STA dédié.
// Une opération Sage : ouvre la session, suit chaque objet COM obtenu,
// libère tout en ordre inverse, puis ferme la session.
public sealed class SageScope : IDisposable
{
private readonly List<object> _comObjects = [];
public BSCIALApplication100c Connection { get; }
public SageScope(string server, string database, string user, string password)
{
if (!SageComExecutor.IsOnSageStaThread)
throw new InvalidOperationException("COM Sage hors du thread STA dédié.");
Connection = new BSCIALApplication100c { CompanyServer = server, CompanyDatabaseName = database };
var loggable = Connection.Loggable; // sous-objet COM : lu une seule fois, libéré tout de suite
loggable.UserName = user;
loggable.UserPwd = password;
Marshal.ReleaseComObject(loggable);
Connection.Open();
}
public T Suivre<T>(T comObj)
{
if (comObj is not null) _comObjects.Add(comObj);
return comObj;
}
// Parcours par index (base 1) : un foreach créerait un IEnumVARIANT jamais libéré.
public List<T> Lister<T>(IBICollection collection)
{
int n = collection.Count;
var items = new List<T>(n);
for (int i = 1; i <= n; i++) items.Add((T)Suivre(collection[i]));
return items;
}
public void Dispose()
{
// Enfants avant parents, et tout avant la fermeture de la session.
for (int i = _comObjects.Count - 1; i >= 0; i--)
if (Marshal.IsComObject(_comObjects[i])) Marshal.ReleaseComObject(_comObjects[i]);
_comObjects.Clear();
try { Connection.Close(); }
finally { Marshal.ReleaseComObject(Connection); }
}
}// Une opération Sage : ouvre la session, suit chaque objet COM obtenu,// libère tout en ordre inverse, puis ferme la session.public sealed class SageScope : IDisposable{ private readonly List<object> _comObjects = []; public BSCIALApplication100c Connection { get; } public SageScope(string server, string database, string user, string password) { if (!SageComExecutor.IsOnSageStaThread) throw new InvalidOperationException("COM Sage hors du thread STA dédié."); Connection = new BSCIALApplication100c { CompanyServer = server, CompanyDatabaseName = database }; var loggable = Connection.Loggable; // sous-objet COM : lu une seule fois, libéré tout de suite loggable.UserName = user; loggable.UserPwd = password; Marshal.ReleaseComObject(loggable); Connection.Open(); } public T Suivre<T>(T comObj) { if (comObj is not null) _comObjects.Add(comObj); return comObj; } // Parcours par index (base 1) : un foreach créerait un IEnumVARIANT jamais libéré. public List<T> Lister<T>(IBICollection collection) { int n = collection.Count; var items = new List<T>(n); for (int i = 1; i <= n; i++) items.Add((T)Suivre(collection[i])); return items; } public void Dispose() { // Enfants avant parents, et tout avant la fermeture de la session. for (int i = _comObjects.Count - 1; i >= 0; i--) if (Marshal.IsComObject(_comObjects[i])) Marshal.ReleaseComObject(_comObjects[i]); _comObjects.Clear(); try { Connection.Close(); } finally { Marshal.ReleaseComObject(Connection); } }}3. Zéro orphelin, appel par appel
Il a ensuite fallu reprendre chaque fonction qui appelle Sage. Exemple réel, la mise à jour des quantités reçues sur les lignes d'un bon de commande :
// Avant : bc.FactoryDocumentLigne et sa liste ne sont stockés nulle part,
// et le foreach crée un énumérateur COM caché. 2 RCW + 1 énumérateur laissés au GC.
foreach (IBODocumentAchatLigne3 ligne in bc.FactoryDocumentLigne.List)
{
if (!quantites.TryGetValue(ligne.DL_No, out double qte)) continue;
ligne.DL_QteBL = qte;
ligne.Write();
}
// Après : chaque objet est suivi par le scope, la collection est lue par index.
var factoryLignes = scope.Suivre(bc.FactoryDocumentLigne);
var lignes = scope.Suivre(factoryLignes.List);
foreach (var ligne in scope.Lister<IBODocumentAchatLigne3>(lignes)) // List<T> .NET : pas d'énumérateur COM
{
if (!quantites.TryGetValue(ligne.DL_No, out double qte)) continue;
ligne.DL_QteBL = qte;
ligne.Write();
}// Avant : bc.FactoryDocumentLigne et sa liste ne sont stockés nulle part,// et le foreach crée un énumérateur COM caché. 2 RCW + 1 énumérateur laissés au GC.foreach (IBODocumentAchatLigne3 ligne in bc.FactoryDocumentLigne.List){ if (!quantites.TryGetValue(ligne.DL_No, out double qte)) continue; ligne.DL_QteBL = qte; ligne.Write();} // Après : chaque objet est suivi par le scope, la collection est lue par index.var factoryLignes = scope.Suivre(bc.FactoryDocumentLigne);var lignes = scope.Suivre(factoryLignes.List);foreach (var ligne in scope.Lister<IBODocumentAchatLigne3>(lignes)) // List<T> .NET : pas d'énumérateur COM{ if (!quantites.TryGetValue(ligne.DL_No, out double qte)) continue; ligne.DL_QteBL = qte; ligne.Write();}Résultat : un week-end entier de test d'endurance sans crash, puis une mise en production. Aucun crash de ce type depuis.
# Les pièges à connaître
Les objets intermédiaires
Chaque . qui traverse un objet COM crée un RCW. Une ligne comme ligne.Article.FactoryArticleDepot.ReadDepot(om.FactoryDepot.ReadCompteur(deNo)) en laisse quatre au GC. Il faut décomposer : un objet par variable, chacune suivie.
Les sous-objets lus plusieurs fois
Chaque lecture d'une propriété qui renvoie un objet COM incrémente le compteur interne du RCW. Lire Connection.Loggable deux fois demande deux ReleaseComObject. Le plus simple : lire une seule fois, dans une variable.
foreach sur une collection COM
Un foreach (comme Cast<T>() ou toute requête LINQ) sur une collection COM crée un énumérateur COM caché, IEnumVARIANT, que personne ne libère. Parcourir par index.
FinalReleaseComObject casse l'ordre
Il force le compteur du RCW à zéro d'un coup. Si le même objet a été suivi plusieurs fois, il est libéré dès sa première occurrence dans la boucle inverse, donc avant des objets qui en dépendent. ReleaseComObject décrémente d'un : une libération par acquisition.
Forcer le GC déplace le problème
GC.Collect() + GC.WaitForPendingFinalizers() change le moment de la libération, pas l'ordre. C'était notre premier contournement, et le crash est revenu à l'identique (au passage, forcer le GC est rarement une bonne idée).
# Ce que j'en retiens
- Le CLR garantit le bon thread pour libérer un objet COM, pas le moment ni l'ordre. Avec du COM, tout ce qu'on obtient se libère explicitement, dans l'ordre inverse.
- Un contournement qui ne s'attaque pas à la cause ne fait que retarder le crash suivant. La même signature deux mois plus tard l'a prouvé.
- Un crash natif sans stack trace .NET n'est pas une impasse : un dump complet et WinDbg disent presque tout.
- Un bug aléatoire n'existe pas : c'est un bug dont on ne connaît pas encore le déclencheur. Ici, le passage du GC.