c#为泛型返回类型方法返回this

本文关键字：返回 this 方法 返回类型 泛型 | 更新日期: 2023-09-27 18:28:55

类中的许多方法都是return this;，这样我就可以在一行中调用多个函数。当我试图创建基类时，会出现类似a.method1().method2().method3();的问题。如果我在基类内创建一个返回类型T的方法，那么我就不能再返回return this;，因为基类类型不是T。我不能只把返回类型作为基类，因为在继承的类上还有很多不在基类中的方法可用。我该如何解决这个问题？

样本代码：

public class baseClass<T>
{
    public T method1()
    {
        //Do stuffs
        return this;//doesnt work
    }
}
public class inheritedClass:baseClass<inheritedClass>
{
    public inheritedClass method2()
    {
        //Do stuffs
        return this;
    }
}

c#为泛型返回类型方法返回this

可能是这个

public abstract class BaseClass<T> where T : BaseClass<T>
{
    public T Method1()
    {
        //Do stuffs
        // We are sure any instance of this class is T : BaseClass<T>. 
        // Only exception might be direct instance of BaseClass<T> and that's why we made BaseClass abstract.
        return (T)this;
    }
}  
public class InheritedClass : BaseClass<InheritedClass>
{
    public InheritedClass Method2()
    {
        //Do stuffs
        return this;
    }
}

有两件事发生了变化。首先，我们仍然在选角，但在基类中这样做。第二，我们保证这个演员阵容可以使用where约束和抽象。

基类的返回类型应该是基类本身，而不仅仅是T.

public class baseClass<T>
{
    public baseClass<T> method1()
    {
        //Do stuffs
        return this;
    }
}

在基类示例中，"this"不是"T"的类型，而是"baseClass｛T｝"的类型。这就是为什么它不起作用。我不确定你想在这里完成什么，但这可能会编译。。。

public class baseClass<T>
{
  public baseClass<T> method1()
  {
    return this;
  }
}
public class inheritedClass : baseClass<inheritedClass>
{
  public baseClass<inheritedClass> method2()
  {
    return this.method1();
  }
}

编辑：我现在明白你的问题了。这可能是比使用继承更好的整体方法。如果需要，可以将接口转换为通用接口。。。

public interface FluentStuff
{
  FluentStuff method1();
  FluentStuff method2();
}
public class MyClass : FluentStuff
{
  public FluentStuff method1()
  {
    return this;
  }
  public FluentStuff method2()
  {
    return this;
  }
}

但如果你坚持使用继承。。。

public interface FluentStuff
{
  FluentStuff method1();
  FluentStuff method2();
}
public abstract class BaseClass : FluentStuff
{
  public virtual FluentStuff method1()
  {
    return this;
  }
  public abstract FluentStuff method2();
}
public class MyClass : BaseClass, FluentStuff
{
  public override FluentStuff method2()
  {
    return this;
  }
}

我强烈鼓励组合而非继承

带有泛型的示例。。。

public interface FluentStuff<T>
{
  FluentStuff<T> method1();
  FluentStuff<T> method2();
}
public abstract class BaseClass<T> : FluentStuff<T>
{
  public virtual FluentStuff<T> method1()
  {
    return this;
  }
  public abstract FluentStuff<T> method2();
}
public class MyClass : BaseClass<MyClass>, FluentStuff<MyClass>
{
  public override FluentStuff<MyClass> method2()
  {
    return this;
  }
}

你发布的另一个问题/关注的最后一个例子。。。

public class SharedFunctionality
{
  public void DoStuff1()
  {
    // common implementation for do stuff 1
  }
  public void DoStuff2()
  {
    // common implementation for do stuff 2
  }
}
public class MyClass1
{
  private readonly SharedFunctionality sharedFunctionality;
  public MyClass1()
  {
    this.sharedFunctionality = new SharedFunctionality();
  }
  public MyClass1 Method1()
  {
    this.sharedFunctionality.DoStuff1();
    return this;
  }
  public MyClass1 Method2()
  {
    this.sharedFunctionality.DoStuff2();
    return this;
  }
}
public class MyClass2
{
  private readonly SharedFunctionality sharedFunctionality;
  public MyClass2()
  {
    this.sharedFunctionality = new SharedFunctionality();
  }
  public MyClass2 Method1()
  {
    this.sharedFunctionality.DoStuff1();
    return this;
  }
  public MyClass2 Method2()
  {
    this.sharedFunctionality.DoStuff2();
    return this;
  }
  public MyClass2 Method3()
  {
    // do something only this class does
    return this;
  }
}
class Program
{
  static void Main(string[] args)
  {
    MyClass1 c1 = new MyClass1();
    c1.Method1().Method2();
    MyClass2 c2 = new MyClass2();
    c2.Method1().Method2().Method3();
  }
}
相关文章：