C#类-过于泛化导致不必要的开销？

使用Webforms构建

我有很多类，它们包含各种属性：

public String Fullname {
  get {
    return Forename + " " + LastName;
  }
}

让我们说：

USER:
Forename,
Surname,
EyeColour,
FavouriteIceCream

在我的网站的不同部分，我需要显示一个用户列表，因此：

Bob Jones,
Fred Smith,
Susan Gifford

而在其他部分，我需要一份清单：

GIFFORD, Susan
JONES, Bob
SMITH, Fred

像怀斯一样，我可能需要把他们的名字缩写成

BJo
FSm
SGi

在我看来，在我的类中有额外的属性是明智的，称为：

Fullname (forename + ' ' + surname)
Reverse (ToUpper(surname) +', ' + forename)
Intials

它们在创建用户对象时填充，因此当我想显示Bob时，可以调用

ThisUser.FullName

而不是

ThisUser.Forename + " " + ThisUser.Surname

如果我不打算经常使用这些属性，那么在创建时创建额外属性是否是一种不好的做法

显然，我已经在这里进行了简化，但是每次我引用一个用户时，即使我只在一个不常浏览的页面上使用他们最喜欢的口味，

FavoriteIcecream

字段被证实，这是不是很糟糕

对我来说，这似乎是保持一致性的一个好方法，如果页面是由团队中忘记了所需格式的人编写的，那么任何想要使用名称的反向格式的页面总是

JONES，Bob

，而不是有时

JONES，Bob

另一方面，我想我们有一个简单的最小用户类，只有当我们需要知道他们的偏好时，我们才会引入额外的字段

//另外,， 如果有区别的话，内部基于intranet的webform只有200个用户

在创建用户对象时填充的字段[…]在每次我引用用户时都会对字段进行验证

您正在谈论创建要填充的静态属性吗？为什么不创建动态属性呢？大概是这样的：

public string Fullname { get { return $"{Forename} {Surname}"; } }
public string Reverse { get { return $"{Surname.ToUpper()}, {Forename}"; } }
// etc.

string Forename;
string Surname;

// set value for the private properties as usual
public User(string fn, string sn)
{
    Forename = fn;
    Surname = sn;
}

// getters
public string DefaultName
{
    get { return Forname + “ “ + Surname; }
}

public string ReversedName
{
    get { return Surname + “ “ + Forename; }
}

不需要两次填充相同的数据，并且在调用它们之前不会使用这些数据

基本上，这不是复制数据与将逻辑放在整个应用程序之间的选择，而是将逻辑放在整个应用程序或对象上的选择。把逻辑放在物体上

在创建用户对象时填充的字段[…]在每次我引用用户时都会对字段进行验证

您正在谈论创建要填充的静态属性吗？为什么不创建动态属性呢？大概是这样的：

public string Fullname { get { return $"{Forename} {Surname}"; } }
public string Reverse { get { return $"{Surname.ToUpper()}, {Forename}"; } }
// etc.

string Forename;
string Surname;

// set value for the private properties as usual
public User(string fn, string sn)
{
    Forename = fn;
    Surname = sn;
}

// getters
public string DefaultName
{
    get { return Forname + “ “ + Surname; }
}

public string ReversedName
{
    get { return Surname + “ “ + Forename; }
}

不需要两次填充相同的数据，并且在调用它们之前不会使用这些数据

基本上，这不是复制数据与将逻辑放在整个应用程序之间的选择，而是将逻辑放在整个应用程序或对象上的选择。把逻辑放在物体上

如果我不打算经常使用这些属性，那么在创建时创建额外属性是否是一种不好的做法

对。使用只读计算属性：

public String Fullname {
  get {
    return Forename + " " + LastName;
  }
}

如果我不打算经常使用这些属性，那么在创建时创建额外属性是否是一种不好的做法

对。使用只读计算属性：

public String Fullname {
  get {
    return Forename + " " + LastName;
  }
}

---

我认为在创建实例时存储这些属性的值是个坏主意。但您仍然可以使用如下属性获取程序：

public string Fullname { get { return $"{Forename} {Surname}"; } }
public string Reverse { get { return $"{Surname.ToUpper()}, {Forename}"; } }
// etc.

string Forename;
string Surname;

// set value for the private properties as usual
public User(string fn, string sn)
{
    Forename = fn;
    Surname = sn;
}

// getters
public string DefaultName
{
    get { return Forname + “ “ + Surname; }
}

public string ReversedName
{
    get { return Surname + “ “ + Forename; }
}

---

无需占用内存中的额外空间来存储运行时可以操作的数据。否则，正如另一个答案所建议的那样，您可以创建用于获取操纵名称的方法。无论如何，永远不要存储冗余数据总是最好的

我认为在创建实例时存储这些属性的值是个坏主意。但您仍然可以使用如下属性获取程序：

public string Fullname { get { return $"{Forename} {Surname}"; } }
public string Reverse { get { return $"{Surname.ToUpper()}, {Forename}"; } }
// etc.

string Forename;
string Surname;

// set value for the private properties as usual
public User(string fn, string sn)
{
    Forename = fn;
    Surname = sn;
}

// getters
public string DefaultName
{
    get { return Forname + “ “ + Surname; }
}

public string ReversedName
{
    get { return Surname + “ “ + Forename; }
}

无需占用内存中的额外空间来存储运行时可以操作的数据。否则，正如另一个答案所建议的那样，您可以创建用于获取操纵名称的方法。无论如何，永远不要存储冗余数据总是最好的

，这取决于情况

填充一个类的一组属性来保存相同信息的不同版本并不是最好的主意

根据创建的复杂程度和使用的位置，这可能只是一个扩展方法、视图中需要特定类型视图的私有方法，也可能是类本身的直接属性

通过使用类本身的属性，您至少有四种可能性：

• 创建对象时填充（如果不可变）

• 调用依赖setter时填充它（如果它是可变的）

• 无论何时调用该值，都可以动态创建该值（如果多次调用，则多次创建）

• 在调用时创建一次值，并返回此结果，直到更改依赖值为止

  public class Person
  {
      private string _firstName;
      private string _lastName;
      private Lazy<string> _fullName;
  
      public string FirstName
      {
          get => _firstName;
          set
          {
              _firstName = value;
              UpdateFullName();
          }
      }
      public string LastName
      {
          get => _lastName;
          set
          {
              _lastName = value;
              UpdateFullName();
          }
      }
      public string FullName => _fullName.Value;
  
      private void UpdateFullName()
      {
          _fullName = new Lazy<string>(()=> $"{FirstName} {LastName}");
      }
  }
  

  公共类人物
  {
  私有字符串_firstName；
  私有字符串_lastName；
  私人懒惰(fullName);；
  公共字符串名
  {
  get=>\u firstName；
  设置
  {
  _firstName=值；
  updatealName（）；
  }
  }
  公共字符串姓氏
  {
  get=>\u lastName；
  设置
  {
  _lastName=值；
  updatealName（）；
  }
  }
  公共字符串FullName=>\u FullName.Value；
  私有void updatealName（）
  {
  _fullName=newlazy（（）=>$“{FirstName}{LastName}”）；
  }
  }
  

特别是在只在某些地方使用的复杂创建的情况下，使用

Lazy

会有所帮助。它将在第一次调用时计算一次值，然后在所有连续调用时返回计算结果。如果该值需要重新计算（在下次调用时），只需实例化一个新版本的

Lazy

实例即可

如果您将

惰性

方法与不变性相结合，您也可以得到类似的结果（如果约束允许，这将是我的选择）：

公共类人物
{
私人懒惰(fullname);；
公众人物（字符串firstName，字符串lastN）