标签: class-design

我有兴趣听一些关于Python中类属性的讨论.例如,类属性的一个很好的用例是什么？在大多数情况下,我无法想出一个类属性比使用模块级属性更可取的情况.如果这是真的,那么为什么要将它们放在一边？

我遇到的问题是,错误地破坏类属性值几乎太容易了,然后你的"全局"值变成了本地实例属性.

请随意评论您将如何处理以下情况:

1. 类和/或子类使用的常量值.这可能包括永不改变的"幻数"字典键或列表索引,但可能需要一次性初始化.
2. 默认类属性,在极少数情况下为类的特殊实例更新.
3. 全局数据结构用于表示在所有实例之间共享的类的内部状态.
4. 初始化许多默认属性的类,不受构造函数参数的影响.

一些相关帖子:
类和实例属性之间的差异

我刚刚重构了一个同事的代码,粗略地看起来像这样......

public class Utility
  public void AddHistoryEntry(int userID, HistoryType Historytype, int companyID)
  {
    // Do something...
  }
  public void AddHistoryEntry(int userID, HistoryType historyType, int companyID, string notes)
  {
    // Do something...
  }
}

对此......

public class HistoryEntry
{
  public long UserID { get; private set; }
  public HistoryType HistoryType { get; private set; }
  public long CompanyID { get; set; }
  public string Notes { get; set; }

  public HistoryEntry(long userID, HistoryType historyType)
  {
    this.UserID = userID;
    this.HistoryType = historyType; …

我有一个案例,我需要为不同的公司执行一套验证规则.针对一家公司将有多个验证规则.

所以我有以下表格结构

公司

ID      CompanyName  
1       ABC   
2       DEF  

有效性规则

RuleID      Name  
1           Rule1   
2           Rule2 

CompanyValidationRuleMapping

MappingID      CompanyId    RuleID
1              1             1
2              1             2
3              2             2

我为每个验证规则都有单独的存储过程.

因此,从我的c#代码中,我将找到与公司相对应的所有验证规则,并且需要执行与该规则关联的验证存储过程.

所以我打算保留一个具有不同验证方法的接口'IValidation'.

要么

我是否必须为实现接口的每个验证创建不同的类

任何人都可以建议一个更好的方法.

我想知道将算法封装到类中是多么(不)常见？更具体地说,不是使用许多单独的函数来转发彼此之间的公共参数:

void f(int common1, int param1, int *out1);
void g(int common1, int common2, int param1, int *out2)
{
  f(common1, param1, ..);
}

将公共参数封装到类中并完成构造函数中的所有工作:

struct Algo
{
  int common1;
  int common2;

  Algo(int common1, int common2, int param)
  { // do most of the work }

  void f(int param1, int *out1);
  void g(int param1, int *out2);
};

看起来非常实用,不必通过函数参数转发常见参数和中间结果.但我还没有看到这种"模式"被广泛使用..有什么可能的缺点？

假设我有一个如下所示的类:

internal class SomeClass
{
    IDependency _someDependency;

    ...


    internal string SomeFunctionality_MakesUseofIDependency()
    {
    ...
    }
}

然后我想添加相关的功能,但是使用不同的依赖来实现其目的.也许类似如下:

internal class SomeClass
{
    IDependency _someDependency;

    IDependency2 _someDependency2;

    ...


    internal string SomeFunctionality_MakesUseofIDependency()
    {
    ...
    }

    internal string OtherFunctionality_MakesUseOfIDependency2()
    {
    ...
    }
}

当我为这个新功能编写单元测试(或者更新我对现有功能的单元测试)时,我发现自己创建了SomeClass(SUT)的新实例,同时传入null以获取我不需要的依赖项对于我想要测试的特定功能.

这对我来说似乎是一种难闻的气味,但我发现自己走这条路的原因是因为我发现自己正在为我介绍的每一项新功能创建新的类.这似乎也是一件坏事,所以我开始尝试将类似功能组合在一起.

我的问题:如果一个类的所有依赖关系都被它的所有功能所消耗,即如果不同的功能位使用不同的依赖关系,那么它们是否应该存在于不同的类中？

给定包含原始数据集的类A和包含该数据的重新组织版本(GUI就绪)的类B,我想使A中的原始数据在B中可见.

显然,A类中的原始数据包含在私有成员中.我想通过使用类似于C++的朋友类方法的东西,在B中看到这些数据.

我怎么处理这个？

谢谢.

或者更具体地说,不依赖于制定者和吸气者是否"好"？

我正在处理一个检查房间可用性的课程,并设置有十几个公共房产.事情如:

• unitNumber
• roomTypes(数组)
• codeCorporate
• 代码组
• numberKids
• numberAdults
• numberRooms
• 货币
• minRate
• MAXRATE
• SoapServer的
• 单位(数组)
• hotelId

在实例化对象之后,$this->在各种方法中设置这些属性.但是,处理对象的代码通常直接设置公共属性,而不是使用getter/setter方法:

$object->something = 3;

foreach ($object->things as $thing ) { }

如果我有时间重构这个课程..

• 我应该将所有这些属性都放在一个私有属性的数据数组中,以及定义__set和__get方法吗？
• 我应该为每个属性制作一个getter方法吗？

我正在使用不可变对象构建整个应用程序,以便更容易实现多线程和撤消.我正在使用Google Collections Library,它提供了Map,List和Set的不可变版本.

我的应用程序模型看起来像一棵树:

• Scene是一个顶级对象,包含对根节点的引用.
• 每个节点都可以包含子节点和端口.

对象图可能如下所示:

Scene
 |
 +-- Node
      |
      +-- Node 
           |
           +- Port
      +-- Node
           |
           +- Port
           +- Port

如果所有这些对象都是不可变的,则由顶级SceneController对象控制:

• 构建此层次结构的最佳方法是什么？
• 如何替换对象树中任意深度的对象？
• 有没有办法支持反向链接,例如具有"父"属性的节点？

更一般地说:

• 是否出现了处理此类数据的模式？
• 有关于这个主题的(学术)文献吗？
• 这是一个好主意吗？

我一直在努力防止用户使用没有智能指针的类.因此,强制它们使对象被智能指针分配和管理.为了得到这样的结果,我尝试了以下方法:

#include <memory>
class A
{
private :
    ~A {}
    // To force use of A only with std::unique_ptr
    friend std::default_delete<A>;
};

如果您只希望您的类用户能够通过操作类的实例,那么这项工作非常好std::unique_ptr.但它不起作用std::shared_ptr.所以我想知道你是否有任何想法来获得这样的行为.我发现的唯一解决方案是执行以下操作(使用friend std::allocator_traits<A>;效率不高):

#include <memory>
class A
{
private :
    ~A {}
    // For std::shared_ptr use with g++
    friend __gnu_cxx::new_allocator<A>;
};

但这种解决方案不可移植.也许我做错了.

我一直在开发一些手机游戏,其中那些游戏从服务器数据库中获取数据.

我习惯将"type"值存储为整数标识符,并在客户端中使用枚举来标识来自服务器的数据.

举个例子:在数据库表上:

怪物表:MonsterId(int),名称(字符串),MonsterType(int)

在客户端代码上:

typedef enum {
    MonsterTypeGround = 1,
    MonsterTypeAquatic = 2,
    MonsterTypeAmphibious = 3,
    MonsterTypeAerial = 4
}MonsterType;

请注意,上面的代码是Objective-C,我可以在其中指定整数值.但我也在使用C#和C++.

但是,我们的数据库人说,枚举是一个编译技巧,没有枚举数据类型.他认为整数类型标识符使得人们(其他开发人员)很难理解值的含义,并且他们不可能在不查看客户端代码的情况下知道等价物并且枚举不好因为你需要确保枚举与服务器端ID同步,并且最好使用字符串.

我的问题是:在这个问题上是否有客观正确的答案？

除了在客户端代码上使用枚举之外还有其他选择,但仍然会使用整数作为服务器数据库吗？