Dispose : quelles ressources sont concernées ?

Bonjour ou bonsoir,

Je crée une classe MaClasse implémentant l'interface IDisposable.
Vous trouverez (sans entrer dans le détail) l'allure de mon code à la fin de
mon message.
Je me pose quelques questions au sujet du contenu de la méthode public void
Dispose( bool disposing )

1) Ma classe contient quelques variables private de type string. Est-ce
qu'il y a un intéret à faire un this.maVariableString = null; ?

2) D'une manière générale, j'envisage de mettre à null tous les objets,
managés ou non, et d'appeller au préalable la methode .Dispose() si et
seulement si l'objet a été crée par la classe ( et bien entendu si l'objet à
"nullifier" propose la méthode Dispose() (*) ).

3) MaClasse travaille avec une base de données et possède une donnée private
de type IDbConnection. Cet objet de type IDbConnection est un argument d'un
constructeur; il est aussi accessible en lecture/écriture (get/set) via une
propriété. J'envisage donc, dans mon Dispose, de faire un simple
this.MonIdbConnection = null;. Je n'envisage rien d'autre, en particulier
aucun appel à un .Close() ou un .Dispose() car la connexion est partagée :
l'orsque mon objet de type MaClasse est créé, il existe déjà un autre objet
MaConnexion (de type IDbConenction, ou OleDbConnecttion ou...) et cet autre
objet "pointe" déjà une base et est "ouvert". Je passe donc MaConnexion au
constructeur de MaClasse, afin de profiter d'une connexion ouverte et donc
de faire l'économie d'une connexion supplémentaire... Est-ce là une bonne
pratique ? Je pose la question car j'ai lu, içi ou là dans quelques posts,
qu'il existerait un mécanisme de "pool de connexion" (**) ? Si ce mécanisme
est efficace et général, je pourrais alors passer plutôt par une chaine de
connexion, et créer une nouvelle connexion réellement propre à MaClasse,
puis fermer la conenxion dans le Dispose(), et par exemple ne pas supposer
ou vérifer que MaConnexion est ou non ouverte lorsque j'en ai besoin dans
MaClasse...

4) Accessoirement, je suppose qu'il y a un moyen (simple) de vérifier si un
objet implémente une interface (réflexion) ?

Merci à tous

Johnny

(*) Même chose pour le "Close()" si "Open()" réalisé dans la classe
(**) Avez-vous un (bon) lien à ce sujet ?

//---------------------------------------
//--------------------------------------- Portion de code
//---------------------------------------

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

public void Dispose( bool disposing )
{
if( disposing )
{
// Suppression des objets managés
}
// Suppression des objets non managés
}

~MaClasse()
{
this.Dispose( false );
}