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

本文关键字：什么 问题 运算符 泛型 | 更新日期: 2023-09-27 18:20:36

如果我在非泛型生成器类中使用隐式运算符，一切都可以：

 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

问题出在哪里？

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

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);
    }
}
相关文章：