Est-il possible d'intercepter (ou de connaître) le comptage de référence COM sur les objets CLR exposés à COM

je me rends compte que c'est une question un peu ancienne, mais j'ai obtenu la demande réelle de travailler quelque temps en arrière.

ce qu'il fait, c'est remplacer la version dans le(S) VTBL (s) de l'objet créé par une implémentation personnalisée qui appelle Dispose lorsque toutes les références ont été publiées. Notez qu'il n'y a aucune garantie à ce que cela fonctionne toujours. L'hypothèse principale est que toutes les méthodes de libération sur toutes les interfaces de la CCW standard sont la même méthode.

Utilisez à vos risques et périls. :)

/// <summary>
/// I base class to provide a mechanism where <see cref="IDisposable.Dispose"/>
/// will be called when the last reference count is released.
/// 
/// </summary>
public abstract class DisposableComObject: IDisposable
{
    #region Release Handler, ugly, do not look

    //You were warned.


    //This code is to enable us to call IDisposable.Dispose when the last ref count is released.
    //It relies on one things being true:
    // 1. That all COM Callable Wrappers use the same implementation of IUnknown.


    //What Release() looks like with an explit "this".
    private delegate int ReleaseDelegate(IntPtr unk);

    //GetFunctionPointerForDelegate does NOT prevent GC ofthe Delegate object, so we'll keep a reference to it so it's not GC'd.
    //That would be "bad".
    private static ReleaseDelegate myRelease = new ReleaseDelegate(Release);
    //This is the actual address of the Release function, so it can be called by unmanaged code.
    private static IntPtr myReleaseAddress = Marshal.GetFunctionPointerForDelegate(myRelease);


    //Get a Delegate that references IUnknown.Release in the CCW.
    //This is where we assume that all CCWs use the same IUnknown (or at least the same Release), since
    //we're getting the address of the Release method for a basic object.
    private static ReleaseDelegate unkRelease = GetUnkRelease();
    private static ReleaseDelegate GetUnkRelease()
    {
        object test = new object();
        IntPtr unk = Marshal.GetIUnknownForObject(test);
        try
        {
            IntPtr vtbl = Marshal.ReadIntPtr(unk);
            IntPtr releaseAddress = Marshal.ReadIntPtr(vtbl, 2 * IntPtr.Size);
            return (ReleaseDelegate)Marshal.GetDelegateForFunctionPointer(releaseAddress, typeof(ReleaseDelegate));
        }
        finally
        {
            Marshal.Release(unk);
        }
    }

    //Given an interface pointer, this will replace the address of Release in the vtable
    //with our own. Yes, I know.
    private static void HookReleaseForPtr(IntPtr ptr)
    {
        IntPtr vtbl = Marshal.ReadIntPtr(ptr);
        IntPtr releaseAddress = Marshal.ReadIntPtr(vtbl, 2 * IntPtr.Size);
        Marshal.WriteIntPtr(vtbl, 2 * IntPtr.Size, myReleaseAddress);
    }

    //Go and replace the address of CCW Release with the address of our Release
    //in all the COM visible vtables.
    private static void AddDisposeHandler(object o)
    {
        //Only bother if it is actually useful to hook Release to call Dispose
        if (Marshal.IsTypeVisibleFromCom(o.GetType()) && o is IDisposable)
        {
            //IUnknown has its very own vtable.
            IntPtr comInterface = Marshal.GetIUnknownForObject(o);
            try
            {
                HookReleaseForPtr(comInterface);
            }
            finally
            {
                Marshal.Release(comInterface);
            }
            //Walk the COM-Visible interfaces implemented
            //Note that while these have their own vtables, the function address of Release
            //is the same. At least in all observed cases it's the same, a check could be added here to
            //make sure the function pointer we're replacing is the one we read from GetIUnknownForObject(object)
            //during initialization
            foreach (Type intf in o.GetType().GetInterfaces())
            {
                if (Marshal.IsTypeVisibleFromCom(intf))
                {
                    comInterface = Marshal.GetComInterfaceForObject(o, intf);
                    try
                    {
                        HookReleaseForPtr(comInterface);
                    }
                    finally
                    {
                        Marshal.Release(comInterface);
                    }
                }
            }
        }
    }

    //Our own release. We will call the CCW Release, and then if our refCount hits 0 we will call Dispose.
    //Note that is really a method int IUnknown.Release. Our first parameter is our this pointer.
    private static int Release(IntPtr unk)
    {
        int refCount = unkRelease(unk);
        if (refCount == 0)
        {
            //This is us, so we know the interface is implemented
            ((IDisposable)Marshal.GetObjectForIUnknown(unk)).Dispose();
        }
        return refCount;
    }
    #endregion

    /// <summary>
    /// Creates a new <see cref="DisposableComObject"/>
    /// </summary>
    protected DisposableComObject()
    {
        AddDisposeHandler(this);
    }

    /// <summary>
    /// Calls <see cref="Dispose"/> with false.
    /// </summary>
    ~DisposableComObject()
    {
        Dispose(false);
    }

    /// <summary>
    /// Override to dispose the object, called when ref count hits or during GC.
    /// </summary>
    /// <param name="disposing"><b>true</b> if called because of a 0 refcount</param>
    protected virtual void Dispose(bool disposing)
    {

    }

    void IDisposable.Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

je n'ai pas vérifié cela, mais voici ce que je voudrais essayer:

tout d'Abord, voici un article du Blog CBrumme à propos de la mise en œuvre par défaut D'IMarshal par le clr. Si vos utilitaires sont utilisés dans tous les appartements COM, vous n'obtiendrez pas un comportement com correct d'un port direct de VB6 vers le CLR. Les objets Com mis en œuvre par le CLR agissent comme s'ils regroupaient le modèle de marshaller fileté libre plutôt que le modèle de VB6 fileté appartement exposé.

vous pouvez mettre en oeuvre IMarshal (sur la classe clr vous exposez comme un objet com). Ma compréhension est que vous permettra de contrôler la création du proxy COM (pas le proxy interop). Je pense que cela vous permettra de piéger les appels de libération dans l'objet que vous avez retourné depuis UnmarshalInterface et de renvoyer le signal à votre objet original. J'envelopperais le marshaller standard (par exemple pinvoke CoGetStandardMarshaler) et lui transmettre tous les appels. Je crois que cet objet aura une vie liée à la vie de la CCAC.

nouveau ... c'est ce que j'essaierais si je devais le résoudre en C#.

d'un autre côté, Est-ce que ce genre de solution serait vraiment plus facile à mettre en œuvre qu'en ATL? Ce n'est pas parce que la partie magique est écrite en C# que la solution est simple. Si ce que je propose ci-dessus résout le problème, vous aurez besoin d'écrire un très grand commentaire expliquant ce qui se passait.

j'ai eu du mal avec cela aussi, pour essayer d'obtenir la durée de vie du serveur correcte pour mon gestionnaire de prévisualisation, comme décrit ici: Afficher Les Données De Votre Chemin Avec Notre Géré Preview Handler

j'avais besoin de le mettre dans un serveur de processus, et soudainement j'ai eu des problèmes de contrôle à vie.

La façon d'entrer dans un processus serveur qui est décrit ici, pour toute personne intéressée: RegistrationSrvices.Type d'enregistrement pour la communauté des clients contenu ce qui implique que vous pouvez être capable de le faire en implorant IDispose, mais cela n'a pas fonctionné.

j'ai essayé d'implémenter un finaliseur, ce qui a finalement provoqué la libération de l'objet, mais à cause du modèle d'utilisation du serveur appelant mon objet, cela signifiait que mon serveur était resté pour toujours. J'ai aussi essayé d'enlever un objet au travail, et après une nuit de sommeil, forçant une collecte des ordures, mais c'était vraiment le bordel.

au lieu de cela, il est venu à la libération d'accrochage (et AddRef parce que la valeur de retour de Release ne pouvait pas être fiable).

(trouvé via ce post: http://blogs.msdn.com/b/oldnewthing/archive/2007/04/24/2252261.aspx#2269675)

voici ce que j'ai fait dans le constructeur de mon objet:

//  Get the CCW for the object
_myUnknown = Marshal.GetIUnknownForObject(this);
IntPtr _vtable = Marshal.ReadIntPtr(_myUnknown);

// read out the AddRef/Release implementation
_CCWAddRef = (OverrideAddRef)
    Marshal.GetDelegateForFunctionPointer(Marshal.ReadIntPtr(_vtable, 1 * IntPtr.Size), typeof(OverrideAddRef));

_CCWRelease = (OverrideRelease)
    Marshal.GetDelegateForFunctionPointer(Marshal.ReadIntPtr(_vtable, 2 * IntPtr.Size), typeof(OverrideRelease)); 
_MyRelease = new OverrideRelease(NewRelease);
_MyAddRef = new OverrideAddRef(NewAddRef);


Marshal.WriteIntPtr(_vtable, 1 * IntPtr.Size, Marshal.GetFunctionPointerForDelegate(_MyAddRef)); 
Marshal.WriteIntPtr(_vtable, 2 * IntPtr.Size, Marshal.GetFunctionPointerForDelegate(_MyRelease));

and the declarations:


int _refCount; 

delegate int OverrideAddRef(IntPtr pUnknown);
OverrideAddRef _CCWAddRef; 
OverrideAddRef _MyAddRef;


delegate int OverrideRelease(IntPtr pUnknown); 
OverrideRelease _CCWRelease;
OverrideRelease _MyRelease;

IntPtr _myUnknown;

protected int NewAddRef(IntPtr pUnknown) 
{
    Interlocked.Increment(ref _refCount);
    return _CCWAddRef(pUnknown); 
}


protected int NewRelease(IntPtr pUnknown) 
{
    int ret = _CCWRelease(pUnknown);

    if (Interlocked.Decrement(ref _refCount) == 0)
    {
        ret = _CCWRelease(pUnknown);
        ComServer.Unlock();
    }

    return ret; 
}

.Net framework fonctionne différemment, voir:

le .net Framework fournit des techniques de gestion de la mémoire qui diffèrent de la façon dont la gestion de la mémoire fonctionnait dans un monde basé sur COM. La gestion de la mémoire dans COM était par le comptage de référence. .NET fournit une technique de gestion automatique de la mémoire qui implique le traçage des références. Dans cet article, nous allons jeter un oeil à la technique de collecte des ordures utilisées par le langage commun Runtime CLR.

rien à faire

[ÉDITÉ] plus un rond...

jetez un coup d'oeil à cette alternative Importation d'une Bibliothèque de Type comme un Assemblage

Comme vous l'avez dit vous-même en utilisant CCW vous pouvez accéder référence-counte en COM traditionnel de la mode.

[ÉDITÉ] la Persévérance est une vertu

Vous savez WinAPIOverride32