抽象类共享属性，是否可以将它们放在一个地方？

Question

我有两个具有几个相同属性的抽象类。 如何将它们放在一个普通的地方？

public abstract class ClassA
{
     public abstract string PropertyA {get; }
     public abstract string PropertyB {get; }          
     public string PropertyX {get; set;}
     public void MethodA()
     {
         // do something
     }          
}


public abstract class ClassB
{
     public abstract string PropertyA {get; }
     public abstract string PropertyB {get; }          
     public string PropertyY {get; set;}          
     public void MethodB()
     {
         // do something else
     }
}

public class ClassC1 : ClassA
{
     public string PropertyA {get {return "MyString";} }
     public string PropertyB {get{return "MyOtherString";} }          

}

public class ClassC2 : ClassA
{
     public string PropertyA {get {return "MyString2";} }
     public string PropertyB {get{return "MyOtherString2";} }          

}

public class ClassD1 : ClassB
{
     public string PropertyA {get {return "MyString";} }
     public string PropertyB {get{return "MyOtherString";} }          
}

public class ClassD2 : ClassB
{
     public string PropertyA {get {return "MyString2";} }
     public string PropertyB {get{return "MyOtherString2";} }          
}

这是我的情况。 现在，由于PropertyA和PropertyB为这两个类返回相同的值，所以我想知道是否有任何方法可以重构这些类，因此我没有在两个抽象/具体类中都放置相同的属性。

Answer 1

制作一个通用的抽象类，并从中继承其余部分

public abstract class ClassCommon
{
     public abstract string PropertyA {get; }
     public abstract string PropertyB {get; }          
}

public abstract class ClassA : ClassCommon
{              
     public string PropertyX {get; set;}          
}


public abstract class ClassB : ClassA
{     public string PropertyY {get; set;}          
}

您可以覆盖属性，而不是使用基类属性。

public class ClassC1 : ClassCommon
{
     public override string PropertyA {get {return "MyString";} }
     public override string PropertyB {get{return "MyOtherString";} }              
}

Answer 2

此解决方案不会从子类中删除字符串属性，但是会删除重复的字符串值。

现在，可以在“ CustomProperties”类中对其进行配置，然后重新使用。

见下文。

偏爱继承而不是继承

public class CustomProperties
{
    public string PropertyA { get; private set; }
    public string PropertyB { get; private set; }
}

public interface ICustomProperties
{
      string PropertyA { get; }
      string PropertyB { get; }
}

public abstract class ClassA : ICustomProperties
{
    private readonly CustomProperties properties;

    public ClassA(CustomProperties properties)
    {
        this.properties = properties;
    }

    public string PropertyA
    {
        get { return properties.PropertyA; }
    }

    public string PropertyB
    {
        get { return properties.PropertyB; }
    }

    public string PropertyX { get; set; }

    public void MethodA()
    {
        // do something
    }
}

Answer 3

除了Adil答案之外，您还可以将方法抽象或虚化，并在派生类中覆盖它们吗？

Answer 4

不知道ClassA和B是否可以从相同的基数派生，但是如果是，则可以这样：

public class CommonAB
{
    public string PropertyA { get; private set; }
    public string PropertyB { get; private set; }

    public CommonAB(string a, string b)
    {
        PropertyA = a;
        PropertyB = b;
    }
}

public class ClassA : CommonAB
{
    public ClassA(string a, string b)
        : base(a, b)
    {
    }

    public string PropertyX { get; set; }
    public void MethodA()
    {
        // do something
    }
}


public class ClassB : CommonAB
{
    public ClassB(string a, string b)
        : base(a, b)
    {
    }

    public string PropertyY { get; set; }
    public void MethodB()
    {
        // do something else
    }
}

public class ClassC1 : ClassA
{
    public ClassC1()
        : base("MyString", "MyOtherString")
    {
    }
}

public class ClassC2 : ClassA
{
    public ClassC2()
        : base("MyString2", "MyOtherString2")
    {
    }
}

public class ClassD1 : ClassB
{
    public ClassD1()
        : base("MyString", "MyOtherString")
    {
    }
}

public class ClassD2 : ClassB
{
    public ClassD2()
        : base("MyString2", "MyOtherString2")
    {
    }
}