Classe C# héritée Perdant "Référence"

Question

J'ai une classe partielle utilisant une interface car je ne peux pas hériter de ce qui était une classe abstraite originale en raison de l'auto-génération de l'autre classe partielle d'Entity Framework 4 et donc déjà d'ObjectContext.

Je donne les résultats suivants pour ma classe partielle:

namespace Model 
{ 
    using Microsoft.Practices.EnterpriseLibrary.Validation; 
    using Microsoft.Practices.EnterpriseLibrary.Validation.Validators; 
    using Utilities.BusinessRules; 
    using Utilities.BusinessRules.Rules; 

    [HasSelfValidation] 
    public partial class MyObject : IBusinessObject 
    { 
     private readonly IBusinessObject businessObject = new BusinessObject(); 

     private IBusinessObject BusinessObject 
     { 
      get 
      { 
       return businessObject; 
      } 
     } 

     public Comment() 
     { 
      AddRule(new ValidateRequired("Title")); 
     } 

     public void AddRule(BusinessRule rule) 
     { 
      BusinessObject.AddRule(rule); 
     } 

     [SelfValidation] 
     public void Validate(ValidationResults results) 
     { 
      BusinessObject.Validate(results); 
     } 
    } 
} 

est ici l'interface:

namespace Utilities.BusinessRules 
{ 
    using Microsoft.Practices.EnterpriseLibrary.Validation; 

    public interface IBusinessObject 
    { 
     void AddRule(BusinessRule rule); 

     void Validate(ValidationResults results); 
    } 
} 

Et la mise en œuvre:

namespace Utilities.BusinessRules 
{ 
    using System.Collections.Generic; 
    using System.Linq; 
    using Microsoft.Practices.EnterpriseLibrary.Validation; 
    using Microsoft.Practices.EnterpriseLibrary.Validation.Validators; 

    public class BusinessObject : IBusinessObject 
    { 
     private readonly IList<BusinessRule> businessRules = new List<BusinessRule>(); 

     public void AddRule(BusinessRule rule) 
     { 
      this.businessRules.Add(rule); 
     } 

     [SelfValidation] 
     public void Validate(ValidationResults results) 
     { 
      foreach (var rule in this.businessRules) 
      { 
       if (!rule.Validate(this)) 
       { 
        results.AddResult(new ValidationResult(rule.ErrorMessage, this, rule.Key, rule.Tag, null)); 
       } 
      } 
     } 
    } 
} 

Ne vous inquiétez pas les règles, ils travaillent. Le problème est que si j'utilise une classe abstraite dans un projet de test, la méthode Validate() dans BusinessObject va correctement identifier (this) comme n'importe quelle classe héritée de la classe abstraite (dans cet exemple, je m'attendrais à être MyObject). Malheureusement, en passant à une interface, (this) perd la classe héritée et l'identifie à la place comme BusinessObject.

Comment puis-je faire en sorte que la classe héritière soit correctement identifiée?

est ici la classe console appelant:

namespace ModelConsumer 
{ 
    using Model; 
    using System; 
    using Microsoft.Practices.EnterpriseLibrary.Validation; 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      using (var myEntities = new MyEntities()) 
      { 
       var myObject= new MyObject(); 

       myObject.Title = "Credo"; 

       var validationResults = Validation.Validate(myObject); 

       if (validationResults.IsValid) 
       { 
        myEntities.MyObjects.AddObject(myObject); 
        //myEntities.SaveChanges(); 

        Console.WriteLine("Valid."); 
       } 
       else 
       { 
        foreach (var validationResult in validationResults) 
        { 
         Console.WriteLine(validationResult.Message); 
        } 
       } 

       Console.Read(); 
      } 
     } 
    } 
} 

Cela devrait être valide, mais sera plutôt invalide parce que (cela) est identifié comme étant de type BusinessObject au lieu de MyObject.

Argh! Je suis si proche, c'est assez vexant.

Richard

Answer 1

Je crois que votre mise en œuvre de BusinessObject est écrit en supposant qu'il serait hérité. Cependant, maintenant que vous r l'utiliser comme un objet composé, vous devez faire quelques changements:

public interface IBusinessObjectValidator 
{ 
    void AddRule(BusinessRule rule); 

    void Validate(IBusinessObject target, ValidationResults results); 
} 


Public class BusinessObject: IBusinessObjectValidator 
{ 
... 

    public void Validate(IBusinssObject target, ValidationResults results) 
    { 
     foreach (var rule in this.businessRules) 
     { 
      if (!rule.Validate(target)) 
      { 
      results.AddResult(new ValidationResult(rule.ErrorMessage, target, rule.Key, rule.Tag, null)); 
      } 
     } 
    } 
} 

Et vous utiliserez comme suit:

[HasSelfValidation] 
    public partial class MyObject : IBusinessObject 
    { 
     private readonly IBusinessObjectValidator validator = new BusinessObject(); 

     private IBusinessObjectValidator BusinessObjectValidator 
     { 
      get 
      { 
       return validator ; 
      } 
     } 
    public Comment() 
    { 
     AddRule(new ValidateRequired("Title")); 
    } 

    public void AddRule(BusinessRule rule) 
    { 
     validator .AddRule(rule); 
    } 

    [SelfValidation] 
    public void Validate(ValidationResults results) 
    { 
     validator.Validate(this, results); 
    } 
} 

Essentiellement, nous disons que nous allons avoir une implémentation de validateur externe et par conséquent, nous devons avoir l'objet cible (en cours de validation) passé à la méthode validate. Je suggère également de renommer BusinessObject en BusinessObjectValidtor.