7

我已经完成了 OOP 课程作业，我在其中设计和编写了一个复数类。为了获得额外的信用，我可以执行以下操作：

  1. 添加两个复数。该函数将一个复数对象作为参数并返回一个复数对象。将两个复数相加时，调用对象的实部与作为参数传递的复数对象的实部相加，调用对象的虚部与作为参数传递的复数对象的虚部相加一个参数。

  2. 减去两个复数。该函数将一个复数对象作为参数并返回一个复数对象。当两个复数相减时，作为参数传递的复数对象的实部从调用对象的实部中减去，作为参数传递的复数对象的虚部从调用对象的虚部中减去调用对象。

我已经对此进行了编码，我使用 this 关键字来表示类的当前实例，我的 add 方法的代码如下，我的减法方法看起来相似：

 public ComplexNumber Add(ComplexNumber c)
{
    double realPartAdder = c.GetRealPart();
    double complexPartAdder = c.GetComplexPart();

    double realPartCaller = this.GetRealPart();
    double complexPartCaller = this.GetComplexPart();

    double finalRealPart = realPartCaller + realPartAdder;
    double finalComplexPart = complexPartCaller + complexPartAdder;

    ComplexNumber summedComplex = new ComplexNumber(finalRealPart, finalComplexPart);

    return summedComplex;
}

我的问题是：我这样做是否正确且风格良好？（使用 this 关键字）？

4

11 回答 11

19

可以讨论关键字的使用this，但通常归结为个人品味。在这种情况下，虽然从技术角度来看是多余的，但我个人认为它增加了清晰度，所以我也会使用它。

于 2009-12-04T08:20:09.100 回答
6

this. 包含在StyleCop工具中的 Microsoft 编码标准鼓励使用冗余。

于 2009-12-04T08:24:52.663 回答
6

您还可以重载数学运算符，就像：

public static ComplexNumber operator +(ComplexNumber c1, ComplexNumber c2)
于 2009-12-04T08:26:59.050 回答
3

由于您现在正在学习 C# 并询问样式，因此我将向您展示您发布的代码中的几处错误以及原因。

编辑：我只回复了这个，因为看起来你真的在努力解决这个问题。由于我更喜欢​​与这种人一起工作，所以我更挑剔只是因为我希望它可以帮助你获得更好的结果。:)

结构名称

  1. ComplexNumber不必要的长。请注意，名称中没有Single, Double, Int32,Int64等Number。这表明这Complex是一个更合适的名称。
  2. Complex匹配已在 .NET Framework 中建立的命名。

实部和虚部

  1. GetRealPart()并且GetComplexPart()应该是只获取属性而不是方法。
  2. GetComplexPart()命名错误，因为它实际上是在返回虚部。
  3. 由于 .NET 框架已经有了一个Complex结构，所以您不应该重新命名。因此，除非您能够重新定义框架约定，否则必须将属性命名为Real和Imaginary。

运营

如果您查看现有示例System.Windows.Vector，您会发现数学运算是通过提供静态方法和运算符来实现的：

public static Point Add(Vector vector, Point point);
public static Point operator+(Vector vector, Point point);

毫不奇怪，这种约定延续到了System.Numerics.Complex结构中：

public static Complex Add(Complex left, Complex right);
public static Complex operator +(Complex left, Complex right);

概括

结果是干净的、易于验证的，并且行为符合每个人的预期。this关键字不会/不能出现，因为方法是静态的。

public static Complex Add(Complex left, Complex right)
{
    return new Complex(left.Real + right.Real, left.Imaginary + right.Imaginary);
}

public static Complex operator +(Complex left, Complex right)
{
    return new Complex(left.Real + right.Real, left.Imaginary + right.Imaginary);
}
于 2010-04-03T17:17:36.000 回答
1

我只对变量使用这个关键字，并且当有一个与私有变量同名的参数时。IE

private String firstname;
public SetName(String firstname)
{
    this.firstname = firstname;
}
于 2009-12-04T08:37:48.440 回答
0

如果您遵循命名约定，则需要使用它：

class MyClass 
{ 
    public int _variableA; 
    public string _variableB; 

    public MyClass(int variableA, string variableB) 
    { 
        _variableA = variableA; 
        _variableB = variableB; 
    } 
}
于 2010-04-03T16:50:28.683 回答
0

只是为了增加答案的完整性 - 有一种情况是this关键字是强制性的。那时你有一个与类成员同名的局部变量（或方法参数）。在这种情况下，写它 withoutthis将访问局部变量，而 withthis将设置类成员。为了显示：

class MyClass
{
    public int SomeVariable;

    public void SomeMethod()
    {
        int SomeVariable;

        SomeVariable = 4; // This assigns the local variable.
        this.SomeVariable = 6; // This assigns the class member.
    }
}

随之而来的几件事：

  • 始终避免给局部变量赋予与类成员相同的名称（我承认，我自己并不总是遵循这一点）；
  • 在所有成员访问之前写入this就像一种保护措施。如果您编写一段没有它的代码，然后稍后引入一个与类成员具有相同名称和类型的局部变量，您的代码仍然可以正常编译，但会做一些完全不同的事情（并且可能是错误的）。

虽然我对方法参数使用与类成员相同的名称的一个实例是在构造函数中。我经常这样写：

class MyClass
{
    public int VariableA;
    public string VariableB;

    public MyClass(int VariableA, string VariableB)
    {
        this.VariableA = VariableA;
        this.VariableB = VariableB;
    }
}

在我看来，这使构造函数更清晰，因为您立即了解哪个参数设置了哪个类成员。

于 2009-12-04T09:06:55.880 回答
0

我会说是的，它看起来正确且易于阅读。但这不是你的TA应该回答的吗？

于 2009-12-04T08:20:20.543 回答
0

这个关键字的使用似乎很好。

尽管我相信对于像 Complex 这样的类，您应该将实数和复数部分存储为 int 属性并在方法中使用它们，而不是使用 GetRealPart() 和 GetComplexPart() 方法

我会这样做：

    class ComplexNumber
    {
        public int RealPart { get; set; }
        public int ComplexPart { get; set; }

        public ComplexNumber(int real, int complex)
        {
            this.RealPart = real;
            this.ComplexPart = complex;
        }

        public ComplexNumber Add(ComplexNumber c)
        {
            return new ComplexNumber(this.RealPart + c.RealPart, this.ComplexPart + c.ComplexPart);
        }
    }

以下是必须使用它的场景，否则，对于分配的 LHS 和 RHS，将考虑参数而不是类成员。

public ComplexNumber(int RealPart, int ComplexPart)
        {
            RealPart = RealPart; // class member will not be assigned value of RealPart
            ComplexPart = ComplexPart;
        }
于 2009-12-04T08:21:21.523 回答
0 
double realPartCaller = this.GetRealPart();

即使你省略this 它GetRealPart()应该仍然可以。但是在this维护者方面，使用 使得它很容易阅读和理解。

double realPartCaller = this.GetRealPart(); ==> bit more readable IMHO
double realPartCaller = GetRealPart();
于 2009-12-04T08:22:35.033 回答
0

我发现自己越来越多地将this关键字用于当前实例的方法和属性，因为我觉得它增加了可读性和可维护性。如果您的类也有静态方法和/或属性，这尤其有用，您当然不能在其上使用this关键字，因为它们与当前实例无关。通过使用this，您可以清楚地看到差异。

为了更进一步，您应该考虑使用类名作为静态方法和属性的限定符，即使在类本身中也是如此。

于 2009-12-04T08:41:03.737 回答