Question

我有多个继承自基类的类，我需要检查这个类的值，我想避免为继承的基类的相同属性编写相同的检查

class baseClass
{
    public int Firstname;
    public string LastName;
    public string ID;
}

class TypeOneAditionalInformation: baseClass
{
   public string x1;
   public string x2;
}

class TypeTwoAditionalInformation: baseClass
{
   public int x3;
   public string x4;
}

public List<ErrorGet> TypeOneTest(TypeOneAditionalInformation _type)
{
  if(_type.Firstname!=null) ...
  if(_type.LastName!=null) ...
  if(_type.ID!=null) ...
  if(_type.x1!=null) ...
  if(_type.x2!=null) ...
}

public List<ErrorGet> TypeTwoTest(TypeTwoAditionalInformation _type)
{
  if(_type.Firstname!=null) ...
  if(_type.LastName!=null) ...
  if(_type.ID!=null) ...
  if(_type.x3!=null) ...
  if(_type.x4!=null) ...

}

我想避免对相同的基本类型属性进行两次相同的检查：

if(_type.Firstname!=null) ...
if(_type.LastName!=null) ...
if(_type.ID!=null) ...

它的最佳做法是什么？

Answer 1

创建一个函数来检查基类型错误，并在其他两种类型中调用该函数。

类似的东西：

const

然后从其他两个人那里打电话......

  public List<ErrorGet> BaseClassTest(baseClass _type)
  {
     if(_type.Firstname!=null) ...
     if(_type.LastName!=null) ...
     if(_type.ID!=null) ...
  }

Answer 2

考虑一个验证框架来做这些事情，你会节省很多时间。

例如，ASP.NET MVC和ASP.NET Web API中使用的模型验证可用作独立验证器。

想象一下，有一个A类的Text属性，你希望它为 not null ：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

public class A
{
    [Required]
    public string Text{get;set;}    
}

public class Program
{
    public static void Main()
    {
        List<ValidationResult> errors = new List<ValidationResult>();

        if(Validator.TryValidateObject(new A(), null, errors))
        {
            // Do stuff if object validates
        }
    }
}

在您的情况下，您的基类可以运行this的验证程序：

public class baseClass
{
    // Note I've switched your class fields to auto-properties
    [Required]
    public int Firstname { get; set; }

    [Required]
    public string LastName { get; set; }

    [Required]
    public string ID { get; set; }

    protected virtual bool Validate()
    {
          List<ValidationResult> results = new List<ValidationResult>();

          // Running it for "this" executes the validator for the most derived
          // class, so this includes ALL properties (from the base class to 
          // the most derived one!
          return Validator.TryValidateObject(this, null, results);
    }
}

这样，您可以在派生类中调用Validate，并且将自动检查所有属性以填充某些值，甚至来自派生类的属性（您可以获得一体化解决方案）。

除了可以应用于您的媒体资源(check them in MSDN System.ComponentModel.DataAnnotations namespace documentation)之外，还有许多其他验证属性。

Answer 3

在这种情况下，使用参数化构造函数使用构造函数初始化程序初始化基类中的成员。应该如下

class baseClass
{
    public string Firstname;
    public string LastName;
    public string ID;

  public baseClass(string fn, string ln, string id)
{
  this.Firstname = fn;
  this.LastName = ln;
  this.ID = id; 
}
}

class TypeOneAditionalInformation: baseClass
{
   public string x1;
   public string x2;

 public TypeOneAditionalInformation(string fn, string ln,
             string id, string x1, string x2) : base(fn, ln, id)
{
  this.x1 = x1;
  this.x2 = x2;
}
}

Answer 4

这就是多态性真的变得很棒的地方！

您应该在基类中做什么，将TypeTest声明为虚拟。然后，您应该在每个继承的类中覆盖它，添加其他功能。这是一个例子：

class BaseClass
{
    public virtual string FirstName { get; set; }
    public virtual string LastName { get; set; }

    public virtual void TypeTest()
    {
        Console.WriteLine(FirstName != null ? "FirstName is NOT NULL!" : "FirstName IS NULL!");
        Console.WriteLine(LastName != null ? "LastName is NOT NULL!" : "LastName IS NULL!");
    }
}

class TypeOneAditionalInformation : BaseClass
{
    public string X1 { get; set; }
    public string X2 { get; set; }

    public override void TypeTest()
    {
        base.TypeTest();

        Console.WriteLine(X1 != null ? "X1 is NOT NULL!" : "X1 IS NULL!");
        Console.WriteLine(X2 != null ? "X2 is NOT NULL!" : "X2 IS NULL!");
    }
}

class TypeTwoAditionalInformation : BaseClass
{
    public string X3 { get; set; }
    public string X4 { get; set; }

    public override void TypeTest()
    {
        base.TypeTest();

        Console.WriteLine(X3 != null ? "X3 is NOT NULL!" : "X3 IS NULL!");
        Console.WriteLine(X4 != null ? "X4 is NOT NULL!" : "X4 IS NULL!");
    }
}

这将允许您执行的只是执行TypeTest而无需担心类型或属性。这是一个例子：

var baseClass = new BaseClass();
var type1 = new TypeOneAditionalInformation();
var type2 = new TypeTwoAditionalInformation();

baseClass.FirstName = "Joe";
baseClass.LastName = "Miller";

type1.FirstName = "Rachel";
type1.LastName = "Miller";
type1.X1 = "72";

type2.FirstName = null;
type2.LastName = "Miller";
type2.X4 = "99";

var list = new List<BaseClass> {baseClass, type1, type2};
foreach (BaseClass obj in list)
{
    Console.WriteLine();
    // Here is where polymorphism is magic!
    obj.TypeTest();
    Console.WriteLine();
}

这里发生的是您的程序在运行时动态调用适当的TypeTest函数。如果obj是BaseClass类型，那么您的程序将自动知道在TypeTest内调用BaseClass方法。同样，如果obj是TypeOneAditionalInformation类，那么您的程序将知道在该类中调用TypeTest。

避免对基类属性执行重复操作

4 个答案: