रोल ऑब्जेक्ट पैटर्न प्रश्न

Question

मैं मार्टिन फाउलर द्वारा किए गए एक पेपर को देख रहा हूं जिसे Dealing With Roles कहा जाता है। इसमें, फाउलर किसी संगठन (यानी कर्मचारी, अभियंता, प्रबंधक, सेल्समैन) में किसी व्यक्ति के लिए भूमिकाओं से निपटने के लिए तीन मूलभूत रणनीतियों को तोड़ देता है जिसमें भूमिका सबटाइपिंग, रोल ऑब्जेक्ट और रोल रिलेशनशिप शामिल हैं।

1 99 7 में लिखा गया यह निश्चित रूप से पुराना है, और "काम करने का मसौदा" होने के कारण इसमें कुछ त्रुटियां भी हैं जो अन्यथा वहां नहीं होंगी। मैं रोल ऑब्जेक्ट के उदाहरण के बारे में उलझन में हूं, और नीचे दिए गए अपने कुछ जावा कोड की मेरी सी # व्याख्या शामिल है।

मैं तीन प्रश्न हैं:
(1) वहाँ प्रकार पहचान का एक बहुत तार की तरह यह जेनरिक के साथ बदली किया जाना चाहिए लगता है कि के साथ किया जा रहा है, लेकिन मैं कैसे इतना अभी तक ऐसा करने के लिए पर एक संभाल नहीं कर सकते। जेनेरिक का उपयोग करके आप इस कोड को कैसे कार्यान्वित करेंगे?
(2) जॉब रोल एक प्रकार के स्ट्रिंग नाम के रूप में कोड में है लेकिन इसे विशेष रूप से शेष कोड के साथ परिभाषित नहीं किया गया है। मैं नहीं बता सकता कि यह PersonRole के लिए आधार वर्ग है या नहीं। जॉब रोल की परिभाषा क्या है? क्या इकाई परीक्षण पैटर्न के उपयोग के सही उदाहरण की तरह दिखता है?
(3) क्या किसी के पास हालिया कार्यान्वयन और रोल ऑब्जेक्ट का उपयोग करने के उदाहरण के लिए कोई लिंक है?

चीयर्स,
Berryl

public class PersonWithRoles : Person 
{ 
    private readonly IList<PersonRole> _roles = new List<PersonRole>(); 

    public static PersonWithRoles CreatePersonWithRoles(string identifierName) { 
     ... 
    } 

    public void AddRole(PersonRole role) { _roles.Add(role); } 

    public PersonRole RoleOf(string typeName) { return _roles.FirstOrDefault(x => x.HasType(typeName)); } 
} 

public class PersonRole 
{ 
    public virtual bool HasType(string typeName) { return false; } 
} 

public class Salesman : PersonRole 
{ 
    public override bool HasType(string typeName) 
    { 
     if (typeName.Equals("Salesman", StringComparison.InvariantCultureIgnoreCase)) return true; 
     if (typeName.Equals("JobRole", StringComparison.InvariantCultureIgnoreCase)) return true; 

     return base.HasType(typeName); 
    } 

    public int NumberOfSales { get; set; } 

} 

[TestFixture] 
public class RoleUsageTests 
{ 
    [Test] 
    public void Test() { 
     var p = PersonWithRoles.CreatePersonWithRoles("Ted"); 
     var s = new Salesman(); 
     p.AddRole(s); 

     var tedSales = (Salesman) p.RoleOf("Salesman"); 
     tedSales.NumberOfSales = 50; 
    } 
} 

Answer 1

मैं विश्वास के तहत कर रहा हूँ कि एप्लीकेशन के लिए डेकोरेटर डिज़ाइन पैटर्न के उपयोग, जिसमें एक व्यक्ति आधार वर्ग है के लिए अच्छा उम्मीदवार हैं, और उसके बाद प्रत्येक भूमिका उस बेस क्लास को बढ़ाती है। बेस क्लास में अनुमतियों की कोई घोषणा नहीं है - केवल व्यक्तियों को विस्तारित करने वाली भूमिकाएं कक्षाएं होनी चाहिए।

अस्पष्ट होने के लिए खेद है, लेकिन मुझे उम्मीद है कि आप जो वर्णन करने की कोशिश कर रहे हैं उसे प्राप्त करें।

class programmer { 
name ... 
email ... 
seat location ... 
} 

class html_coder extends programmer { 
canCodeHTML ... 
} 

class script_coder extends programmer { 
canCodeHTML ... 
canCodeJavascript ... 
} 

class senior_developer extends programmer { 
canCodeHTML ... 
canCodeJavascript ... 
canAccessDatabase ... 
canEditProjectArchitectureFiles ... 
canWearTennisShoesToWork... 
} 

इन सभी प्रोग्रामर आधार वर्ग का विस्तार ... लगता है कि प्रोग्रामर वर्ग अधिकार की घोषणा नहीं करता ... बस गुण सी # में

Answer 2

1) जेनरिक मदद कर सकते हैं एक neater कार्यान्वयन
2 बनाने) जॉबरोले एक उप-प्रकार का पर्सनलोल है, और एक विशिष्ट नौकरियों के लिए एक सुपर-टाइप

मैं अभी भी उपयोग के उदाहरण देखना चाहता हूं, क्योंकि इस पैटर्न के बारे में फाउलर के बिंदुओं में से एक यह है कि टाइपिंग लचीलापन व्यय पर आता है एक दो कदम उपयोग पैटर्न के। एक सजावटी पैटर्न का उपयोग करके इसे कार्यान्वित करना इसे नहीं बदलता है। उदाहरण के लिए, सेल्समैन की भूमिका में किसी व्यक्ति के साथ काम करने के लिए, सबसे पहले आपको किसी व्यक्ति का उदाहरण प्राप्त करने की आवश्यकता होती है और फिर सेल्समैन की भूमिका मिलती है।

चीयर्स,
Berryl

public class Person 
{ 
    public FullName FullName { get; set; } 

    public Person(FullName fullName) { FullName = fullName; } 

    public IList<IRole> Roles { get; private set; } 

    public IRole GetRoleOf<T>() where T: IRole{return Roles.FirstOrDefault(x => x.HasType(typeof(T))); } 

    public void AddRole(IRole role) { Roles.Add(role); } 

    public bool RemoveRole(IRole role) { return Roles.Remove(role); } 

}

public interface IRole 
{ 
    bool HasType(Type type); 
} 

public abstract class Role : IRole 
{ 
    public virtual bool HasType(Type type) { return false; } 
} 

/// <summary> 
/// Base type for any type of role for a person. 
/// </summary> 
public class PersonRole : Role 
{ 
    public override bool HasType(Type type) { return type.Equals(typeof(PersonRole)); } 
} 

/// <summary> 
/// Base type for any type of role for a person. 
/// </summary> 
public class JobRole : Role 
{ 
    public override bool HasType(Type type) { 
     if(type.Equals(GetType())) return true; 
     return base.HasType(type); 
    } 
} 

/// <summary> 
/// Behavior specific to a salesman 
/// </summary> 
public class Salesman : JobRole, ISalesman 
{ 
    public override bool HasType(Type type) 
    { 
     if (type.Equals(GetType())) return true; 
     return base.HasType(type); 
    } 

    public int NumberOfSales { get; set; } 
} 

[TestFixture] 
public class JobRoleTests : BaseTestFixture 
{ 
    private PersonEx _person; 

    protected override void OnFixtureSetUp() { 
     _person = new PersonEx(new OneNameFullName("schmuck")); 
     // can be a Salesman 
     _person.AddRole(new Salesman()); 
    } 

    [Test] 
    public void Salesman_CanGet() { 
     var salesman = _person.GetRoleOf<Salesman>() as Salesman; 
     Assert.That(salesman, Is.Not.Null); 
     salesman.NumberOfSales = 50; 
     Assert.That(salesman.NumberOfSales, Is.EqualTo(50)); 
    } 
}