Question

如果我在非泛型构建器类中使用隐式运算符，那么每件事都可以：

 public class ReligionBuilder
{
    private Religion _religion;

    public ReligionBuilder()
    {
        _religion = new Religion(){//some codes}

    }

    public ReligionBuilder AddToRepository()
    {
        Repository<Religion>.Add(_religion);
        return this;
    }
    public Religion Build()
    {
        return _religion;
    }

    public static implicit operator Religion(ReligionBuilder _builder)
    {
        return _builder.Build();

    }
}

我可以使用它：

 Religion religion=new ReligionBuilder().AddToRepository();

但如果此运算符属于泛型类，则表示错误：

 public abstract class DataTestBuilderBase<T> : IDataTestBuilder<T>
{
    protected T TestData { get; set; }

    public virtual T Build()
    {
        return TestData;
    }

    public abstract IDataTestBuilder<T> AddToRepository();
    public abstract IDataTestBuilder<T> WithDefault();

    public static implicit operator T(DataTestBuilderBase<T> builder)
    {
        return builder.Build();
    }
}


 public class PersonDataTestBuilder : DataTestBuilderBase<Person>
{
    private Person _person;

    public PersonDataTestBuilder()
    {
        //some codes
    }
    public override IDataTestBuilder<Person> AddToRepository()
    {
       //some codes
        return this;
    }
}

用法：

 PersonDataTestBuilder _testBuilder = new PersonDataTestBuilder();
        Person person = _testBuilder.AddToRepository();

错误是：无法将IDataTestBuilder转换为Person

问题是什么？

Answer 1

AddToRepository仅返回IDataTestBuilder<Person>（就编译时返回类型而言） - 并且没有从到Person的隐式转换。如果您将抽象方法的返回类型更改为DataTestBuilderBase<T>，那么它应该可以工作 - 尽管坦率地说我还是不想使用隐式转换。我通常对提供隐式转换非常谨慎 - 它们通常会使代码不那么清晰，因为我相信它们会在这里进行。

你真的应该在构建器上提供AddToRepository吗？对于建筑商而言，这感觉就像是不合适的行为 - 我希望：

Person person = new PersonBuilder { /* properties */ }
                     .Build()
                     .AddToRepository();

编辑：只是为了表明我对更改AddToRepository的返回类型的意思，这是一个简短而完整的程序来演示。它工作正常。

using System;

public abstract class BuilderBase<T>
{
    public abstract T Build();
    public abstract BuilderBase<T> AddToRepository();

    public static implicit operator T(BuilderBase<T> builder)
    {
        return builder.Build();
    }
}

public class TestBuilder : BuilderBase<string>
{
    public override string Build()
    {
        return "Built by Build()";
    }

    public override BuilderBase<string> AddToRepository()
    {
        return this;
    }
}

class Program
{
    static void Main(string[] args)
    {
        string x = new TestBuilder().AddToRepository();
        Console.WriteLine(x);
    }
}

使用泛型隐式运算符有什么问题？

1 个答案: