c#为泛型返回类型方法返回此值_C#

c#为泛型返回类型方法返回此值
c#为泛型返回类型方法返回此值,c#,C#,我的类中的许多方法都会返回这个以便我可以在一行内调用多个函数。类似于a.method1（）.method2（）.method3（）当我尝试创建基类时出现问题。如果我在基类中创建了一个返回typeT的方法，那么我就不能再返回这个
我的类中的许多方法都会
返回这个以便我可以在一行内调用多个函数。类似于a.method1（）.method2（）.method3（）当我尝试创建基类时出现问题。如果我在基类中创建了一个返回typeT
的方法，那么我就不能再返回这个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;
    }
}

公共类基类
{
公共T方法1（）
{
//做事
返回此；//不起作用
}
}
公共类继承类：基类
{
公共继承类方法2（）
{
//做事
归还这个；
}
}
基类的返回类型应该是基类本身，而不仅仅是T
public class baseClass<T>
{
    public baseClass<T> method1()
    {
        //Do stuffs
        return this;
    }
}

公共类基类
{
公共基类method1（）
{
//做事
归还这个；
}
}
基类的返回类型应该是基类本身，而不仅仅是T
public class baseClass<T>
{
    public baseClass<T> method1()
    {
        //Do stuffs
        return this;
    }
}

公共类基类
{
公共基类method1（）
{
//做事
归还这个；
}
}
基类的返回类型应该是基类本身，而不仅仅是T
public class baseClass<T>
{
    public baseClass<T> method1()
    {
        //Do stuffs
        return this;
    }
}

公共类基类
{
公共基类method1（）
{
//做事
归还这个；
}
}
基类的返回类型应该是基类本身，而不仅仅是T
public class baseClass<T>
{
    public baseClass<T> method1()
    {
        //Do stuffs
        return this;
    }
}

公共类基类
{
公共基类method1（）
{
//做事
归还这个；
}
}
在基类示例中，“this”不是“T”的类型，而是“基类{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 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;
  }
}

在基类示例中，“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 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;
  }
}

在基类示例中，“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 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;
  }
}

在基类示例中，“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 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 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;
    }
}

公共抽象类基类，其中T:BaseClass
{
公共T方法1（）
{
//做事
//我们确信这个类的任何实例都是T:BaseClass。
//唯一的例外可能是基类的直接实例，这就是我们将基类抽象化的原因。
返回（T）这个；
}
}  
公共类继承类：基类
{
公共继承类方法2（）
{
//做事
归还这个；
}
}

两件事改变了。首先，我们仍然在铸造，但在基类这样做。其次，我们保证此强制转换在约束和抽象的地方工作。
可能是这样
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;
    }
}

公共抽象类基类，其中T:BaseClass
{
公共T方法1（）
{
//做事
//我们确信这个类的任何实例都是T:BaseClass。
//唯一的例外可能是基类的直接实例，这就是我们将基类抽象化的原因。
返回（T）这个；
}
}  
公共类继承类：基类
{
公共继承类方法2（）
{
//做事
归还这个；
}
}

两件事改变了。首先，我们仍然在铸造，但在基类这样做。其次，我们保证此强制转换在约束和抽象的地方工作。
可能是这样
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;
    }
}

公共抽象类基类，其中T:BaseClass
{
公共T方法1（）
{
//做事
//我们确信这个类的任何实例都是T:BaseClass。
//唯一的例外可能是基类的直接实例，这就是我们将基类抽象化的原因。
返回（T）这个；
}
}  
公共类继承类：基类
{
公共继承类方法2（）
{
//做事
归还这个；
}
}

两件事改变了。首先，我们仍然在铸造，但在基类这样做。其次，我们保证此强制转换在约束和抽象的地方工作。
可能是这样
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;
    }
}

公共抽象类基类，其中T:BaseClass
{
公共T方法1（）
{
//做事
//我们确信这个类的任何实例都是T:BaseClass。
//唯一的例外可能是基类的直接实例，这就是我们将基类抽象化的原因。
返回（T）这个；
}
}  
公共类继承类：基类
{
公共继承类方法2（）
{
//做事
归还这个；
}
}

两件事改变了。首先，我们仍然在铸造，但在基类这样做。其次，我们保证此强制转换与where约束和抽象一起工作。
什么？？发布代码。@HighCore示例代码发布了什么？？发布代码。@HighCore示例代码发布了什么？？发布代码。@HighCore示例代码发布了什么？？发布代码。@HighCore示例代码发布后，我无法