避免只有几个不同属性的多个类

Question

我有两个接近相同的类，除了一个变量类型。
下面的例子应该说明这个问题。

class Customer
{
    byte Reputation;
    const byte MaximumReputation = 255;
    int Data;
    string MoreData;
    Briefcase EvenMoreData;

    public Customer(byte reputation, int data, string moreData, Briefcase evenMoreData)
    {
        Reputation = reputation;
        Data = data;
        MoreData = moreData;
        EvenMoreData = evenMoreData;
    }

    public float Level()
    {
        return Reputation / MaximumReputation;
    }

    public string Information()
    {
        return Data.ToString() + ", " + MoreData + EvenMoreData.Id;
    }
}
class CustomerDeluxe
{
    ushort Reputation;
    const byte MaximumReputation = 255;
    int Data;
    string MoreData;
    Briefcase EvenMoreData;

    public CustomerDeluxe(ushort reputation, int data, string moreData, Briefcase evenMoreData)
    {
        Reputation = reputation;
        Data = data;
        MoreData = moreData;
        EvenMoreData = evenMoreData;
    }

    public float Level()
    {
        return Reputation / MaximumReputation;
    }

    public string Information()
    {
        return Data.ToString() + ", " + MoreData + EvenMoreData.Id;
    }
}

由于Customers 的声望不会超过 255，我可以存储在一个字节中。在我的应用程序中，这个字段是一个大数组。这就是为什么我想选择尽可能小的类型。但是对于字段可以超过一个字节的少数情况，必须有另一个类。

如何“合并”这两个类？

Answer 1

使用泛型：

public class BaseCustomer<TRep>
{
    protected TRep Reputation;
}

public class CustomerDeluxe : BaseCustomer<ushort>
{
}

public class Customer : BaseCustomer<byte>
{
}

对于泛型，您基本上是在说：“我不确定 TRep 的类型是什么，但它会表现出来。”当一个泛型像上面BaseCustomer<TRep> 一样时，它被称为open。我们需要先关闭它，然后才能使用它。当我们继承它时，然后我们用特定的类型关闭它：在一个实例中我们指定它为ushort，在另一个实例中我们指定它为byte。

通过一些重构，您可以将大部分代码推送到BaseCustomer<T>：

public abstract class BaseCustomer<TRep>
{
    protected TRep Reputation;
    protected const byte MaximumReputation = 255;
    int Data;
    string MoreData;
    Briefcase EvenMoreData;

    public BaseCustomer(TRep reputation, int data, string moreData, Briefcase evenMoreData)
    {
        Reputation = reputation;
        Data = data;
        MoreData = moreData;
        EvenMoreData = evenMoreData;
    }

    public abstract float Level();


    public string Information()
    {
        return Data.ToString() + ", " + MoreData + EvenMoreData.Id;
    }
}

public class CustomerDeluxe : BaseCustomer<ushort>
{
    public CustomerDeluxe(ushort reputation, int data, string moreData, Briefcase evenMoreData) 
        : base(reputation, data, moreData, evenMoreData)
    {
    }

    public override float Level()
    {
        return Reputation / MaximumReputation;
    }
}

public class Customer : BaseCustomer<byte>
{
    public Customer(byte reputation, int data, string moreData, Briefcase evenMoreData) 
        : base(reputation, data, moreData, evenMoreData)
    {
    }

    public override float Level()
    {
        return Reputation / MaximumReputation;
    }
}

Answer 2

class CustomerDeluxe : CustomerBase
{
    ushort Reputation;

    public override ushort GetReputation()
    {
        return Reputation;
    }
}

class Customer : CustomerBase
{
    byte Reputation;
    public override ushort GetReputation()
    {
        return Reputation;
    }
}

abstract class CustomerBase
{
    const byte MaximumReputation = 255;
    public abstract ushort GetReputation();

    public float Level()
    {
        return GetReputation()/MaximumReputation;
    }
}