Question

我创建了一个这样的类。

public class SimpleClass
{
    public string myProp { get; set; }

    public SimpleClass()
    {
        this.myProp = "";
    }

    public SimpleClass Method1()
    {
        this.myProp += "Method1";
        return this;
    }

    public SimpleClass Method2()
    {
        this.myProp += "Method2";
        return this;
    }

    public string GetProp()
    {
        return this.myProp;
    }
}

我正在使用它。

public class Worker
{
    public Worker()
    {
        string Output = new SimpleClass().Method1().Method2().GetProp();
    }
}

所有函数返回容器类，last方法返回结果。

我对这种表现感到好奇，使用性能或好的方法是不是很糟糕？

我应该这样使用它还是你可以用另一种方式建议。

由于

Answer 1

一些建议：用户应该如何知道First Call method1然后Method2以及最后GetProp()？

最好封装你的方法并隐藏所有复杂性。例如，用户只需拨打GetProp()，然后在GetProp()中就可以执行您想要的操作。你的例子可以改变如下：

 public class SimpleClass
{
    public string myProp { get; set; }

    public SimpleClass()
    {
        this.myProp = "";
    }

    private string Method1()
    {
        this.myProp += "Method1";
        return Method2();

    }

    private string Method2()
    {
      return  this.myProp += "Method2";

    }

    public string GetProp()
    {
        Method1();
        return this.myProp;
    }
}

最后调用你的Prop（）方法，如：

        SimpleClass simple = new SimpleClass();
    string Output = simple.GetProp();

另一个有更好设计的建议是将Mathod1和Method2设为Private。

Answer 2

我认为你是以错误的方式重新发明轮子。你可能正在寻找完全相同的StringBuilder。

var builder = new StringBuilder();
var result = builder.Append("something").Append("something else").ToString();

但是如果你仍然希望有专门的类来提供有意义的方法而不仅仅是Append，并且还提供了对传递的参数的一些抽象，你可以这样做。

public class SimpleClass
{
    private readonly StringBuilder _builder = new StringBuilder();

    public SimpleClass Method1()
    {
        _builder.Append("Method1");
        return this;
    }

    public SimpleClass Method2()
    {
        _builder.Append("Method2");
        return this;
    }

    public string GetProp()
    {
        return _builder.ToString();
    }
}

请注意，使用StringBuilder是将字符串附加到一起的有效方法。对于少量的追加，它可能没有显示出差异，但是对于大量的追加，它会更快并且产生更少的垃圾。

C＃类函数返回类（性能）

2 个答案: