Quelle est la meilleure pratique pour utiliser le verrou dans les classes héritées?

Question

Je veux savoir si une classe hérite d'une autre, vaut-il mieux que les classes partagent un objet verrou défini dans la classe de base ou un objet verrou défini à chaque niveau d'héritage.

Un exemple très simple d'un objet de verrouillage à chaque niveau de la classe

public class Foo { 
    private object thisLock = new object(); 
    private int ivalue; 

    public int Value { 
    get { 
     lock(thisLock) { 
     return ivalue; 
     } 
    } 
    set { 
     lock(thisLock) { 
     ivalue= value; 
     } 
    } 
    } 
} 

public class Foo2: Foo { 
    private object thisLock2 = new object(); 

    public int DoubleValue { 
    get { 
     lock(thisLock2) { 
     return base.Value * 2; 
     } 
    } 
    set { 
     lock(thisLock2) { 
     base.Value = value/2; 
     } 
    } 
    } 
} 

public class Foo6: Foo2 { 
    private object thisLock6 = new object(); 

    public int TripleDoubleValue { 
    get { 
     lock(thisLock6) { 
     return base.DoubleValue * 3; 
     } 
    } 
    set { 
     lock(thisLock6) { 
     base.DoubleValue = value/3; 
     } 
    } 
    } 
} 

Un exemple très simple d'un objet verrou partagé

public class Foo { 
    protected object thisLock = new object(); 
    private int ivalue; 

    public int Value { 
    get { 
     lock(thisLock) { 
     return ivalue; 
     } 
    } 
    set { 
     lock(thisLock) { 
     ivalue= value; 
     } 
    } 
    } 
} 

public class Foo2: Foo {  
    public int DoubleValue { 
    get { 
     lock(thisLock) { 
     return base.Value * 2; 
     } 
    } 
    set { 
     lock(thisLock) { 
     base.Value = value/2; 
     } 
    } 
    } 
} 
public class Foo6: Foo2 {  
    public int TripleDoubleValue { 
    get { 
     lock(thisLock) { 
     return base.DoubleValue * 3; 
     } 
    } 
    set { 
     lock(thisLock) { 
     base.DoubleValue = value/3; 
     } 
    } 
    } 
} 

Quel exemple est le meilleur moyen de gérer le verrouillage dans une classe héritée?

Answer 1

Vous pouvez trouver votre deuxième option dans le .NET Framework assez souvent, en utilisant une propriété au lieu d'un champ bien (par exemple, le CommunicationObject.ThisLock Property):

public class Foo { 
    private readonly object thisLock = new object(); 
    private int ivalue; 

    protected object ThisLock { 
    get { 
     return thisLock; 
    } 
    } 

    public int Value { 
    get { 
     lock(ThisLock) { 
     return ivalue; 
     } 
    } 
    set { 
     lock(ThisLock) { 
     ivalue= value; 
     } 
    } 
    } 
} 

et

public class Foo2: Foo {  
    public int DoubleValue { 
    get { 
     lock(ThisLock) { 
     return base.Value * 2; 
     } 
    } 
    set { 
     lock(ThisLock) { 
     base.Value = value/2; 
     } 
    } 
    } 
} 

Answer 2

Combien les instances d'un objet verrou que vous avez doivent égaler le nombre de choses auxquelles vous essayez de contrôler l'accès. Si toutes les sous-classes partagent la même ressource, il devrait y avoir un seul objet lock, par exemple un champ/propriété dans la classe de base.