如何使用两个相同的类名称和具有不同返回类型的相同辅助方法来重构此代码？

Question

我有下面的两个类别：

public async A GernerateStuff(int expireDays = 15)
{
    using var randomNumberGenerator = RandomNumberGenerator.Create();
    var randomBytes = new byte[64];
    var now = DateTime.UtcNow;
    randomNumberGenerator.GetBytes(randomBytes);
    return new A
    {
        Stuff = Convert.ToBase64String(randomBytes),
        Created = now,
        Expires = now.AddDays(expireDays)
    };
}

public async B GernerateStuff(int expireDays = 10)
{
    using var randomNumberGenerator = RandomNumberGenerator.Create();
    var randomBytes = new byte[64];
    var now = DateTime.UtcNow;
    randomNumberGenerator.GetBytes(randomBytes);

    return new B
    {
        Stuff = Convert.ToBase64String(randomBytes),
        Created = now,
        Expires = now.AddDays(expireDays)
    };
}

public class A
{
    public string Stuff{ get; set; }
    public DateTime Created { get; set; }
    public DateTime Expires { get; set; }
}

public class B
{
    public string Stuff{ get; set; }
    public DateTime Created { get; set; }
    public DateTime Expires { get; set; }
}

约束是：我不能仅创建一个类，而不是两个单独的A和B类，因为它们在使用方面有显着差异。

现在，我的问题是：如何同时使用A和B类清洁此代码，而是一种用于gernerateStuff的一种方法？

我可以创建一个这样的接口：

public class A : IInterface
{
}

public class B : IInterface
{

}

public interface IInterface
{
    public string Stuff{ get; set; }
    public DateTime Created { get; set; }
    public DateTime Expires { get; set; }
}

然后，问题是public async iinterface gernerateStuff（int expiredays = 15）签名如何处理A和B类？

Answer 1

TOT实现这一目标有几种方法。在其他答案中已经提到了一个，这是关于使用仿制药的。但是，这假设您的类型a和b确实有任何共同点，您可以用作常见的通用约束，例如一个常见的基本接口。然后，您可以做到这一点：

public async T GernerateStuff<T>(int expireDays = 15) where T: new(), MyInterface
{
    using var randomNumberGenerator = RandomNumberGenerator.Create();
    var randomBytes = new byte[64];
    var now = DateTime.UtcNow;
    randomNumberGenerator.GetBytes(randomBytes);
    return new T
    {
        Stuff = Convert.ToBase64String(randomBytes),
        Created = now,
        Expires = now.AddDays(expireDays)
    };
}

您还可以创建一个工厂，该工厂创建a或b的实例，具体取决于某种条件 - 例如某些配置。但是，您还需要一个常见的基础接口：

public async MyInterface GernerateStuff(int expireDays = 15)
{
    using var randomNumberGenerator = RandomNumberGenerator.Create();
    var randomBytes = new byte[64];
    var now = DateTime.UtcNow;
    randomNumberGenerator.GetBytes(randomBytes);
    return CreateTheThing(Convert.ToBase64String(randomBytes), now, now.AddDays(expireDays));
}

MyInterface CreateTheThing(string stuff, DateTime created, DateTime expires)
{
    if(...)
        return new A { ... }
    else if(...)
        return new B { ... }
    return new C { ... }
}

此解决方案具有优势，当您向工厂添加新类型时，您无需更改客户端逻辑。您需要更改的只是通过引入新的C {...}来更改工厂本身。此外，客户无法提供任何实际不起作用的类型，因为它们根本不提供任何类型的信息。

顺便说一句，您的方法不会等待任何东西，因此没有理由将其制作async。

Answer 2

创建静态出厂方法并将其注入参数：

public static A CreateA(byte[] stuff, DateTime now, DateTime expires)
    => new A{  Stuff = stuff,   Created = now,  Expires = expires  }

...
public static T GernerateStuff<T>(Func<byte[], DateTime, DateTime, T> ctor, int expireDays = 15)
{
    using var randomNumberGenerator = RandomNumberGenerator.Create();
    var randomBytes = new byte[64];
    var now = DateTime.UtcNow;
    randomNumberGenerator.GetBytes(randomBytes);
    return ctor(    
        Convert.ToBase64String(randomBytes),
        now,
        now.AddDays(expireDays)
    ;
}
...
var a = GernerateStuff(CreateA);

但是，如果A类和B类是相同的，为什么不使用同一类呢？这是一种确定的代码气味，您可能应该考虑如何对问题进行建模。另外，async在没有等待的情况下不会有任何意义，因此请摆脱它。

Answer 3

我在聚会上有点迟了，但是您可以将词典与代表使用可以提供懒惰初始化的代表。

让我举个例子。首先，我们需要进行枚举以避免在创建类实例时else语句：

public enum FooType
{
    A, B
}

然后，我们需要拥有所有派生类具有相同行为的抽象基类：

public abstract class FooBase
{
    public string? Stuff { get; set; }
    public DateTime Created { get; set; }
    public DateTime Expires { get; set; }
}

而派生的类看起来像这样。 ：

public class A : FooBase
{
    public A(int expireDays)
    {
    }

    public override string ToString() => $"I am A class";
    
}

public class B : FooBase
{
    public B(int expireDays)
    {
    }

    public override string ToString() => $"I am B class";
}

然后，工厂看起来像这样，您可以根据需要自定义任何属性或方法：

public class FooFactory
{
    Dictionary<FooType, Func<FooBase>> _fooBaseByType;

    public Func<FooBase> GetInstance(FooType fooType, int expireDays) 
    {
        _fooBaseByType = new Dictionary<FooType, Func<FooBase>>
        {
            { 
                FooType.A, () => new A(expireDays) 
                { 
                    Created = SomeCustomDateTime(), 
                    Stuff = SomeCustomString()
                } 
            },
            {   
                FooType.B, () => new B(expireDays) 
                { 
                    Created = SomeCustomDateTime()
                } 
            }
        };

        return _fooBaseByType[fooType];
    }

    private DateTime SomeCustomDateTime() => DateTime.Now;
    private string SomeCustomString() => "My custom string";
}

您可以这样使用：

FooFactory factory = new FooFactory();
A a = (A)factory.GetInstance(FooType.A, 11)();