我正在阅读“干净的代码”，无法弄清楚如何将我的某些函数（通常是构造函数）保持为3个参数的最大值。
通常，我的对象需要大量的信息才能工作-我是否应该制作一个小的构造函数，然后使用mutator函数将所有信息提供给它们？ 这似乎并不比仅使用大型构造函数更好。
例如，我有一个“ MovablePatch”类。 它使用户可以在窗口中拖动一个正方形。 它需要几个参数，包括Radius，Color，Renderer，InitialPosition和Visibility。 目前，我从GUI收集所有这些信息，然后致电：
MovablePatch(int radius, Renderer* renderer, Color color, Position initial, bool visibility)
这些只是我在课堂上需要的一些东西。 谁能建议我如何打包此信息以传递给构造函数？ 我看不到这里出现任何明显的“分解为小类”。
因此，我的任务是使用Parse在应用程序（iOS，Swift）中实现类似于“ retweet”的功能。
这是在此之前提出的，但这是a）相当高的层次，b）我手头的任务-我不一定要寻求有关体系结构决策的帮助，尽管如果我似乎显然缺少某些东西，我会 我很高兴接受反馈。
我的应用程序有每个由用户创建的原因。还有一个带有TO和FROM用户的FOLLOW表。首先，我只是查询CAUSES表，其约束是发布的USER应该与FOLLOW表中的TO用户（当前用户是FROM用户）的objectId相匹配。 更简洁地说：
let getFollowedUsersQuery = PFQuery(className: Constants.kParseClassFollowers)
getFollowedUsersQuery.whereKey(Constants.kParseFieldFromUser, equalTo: PFUser.currentUser()!)
let causesQuery = PFQuery(className: Constants.kParseClassCauses)
causesQuery.whereKey(Constants.kParseFieldFromUser, matchesKey: Constants.kParseFieldToUser, inQuery: getFollowedUsersQuery)
causesQuery.findObjectsInBackgroundWithBlock({ (objects, error) -> Void in
if let causes = objects {
for cause in causes {
// populate the tableview cells, etc.
}
}
})
现在，我有了引起我关注的所有用户原因……这都是相当标准的。
这就是棘手的地方。
每个原因还具有一个称为支持者的关系。现在，我需要设计一种方法来从我没有关注的人那里获取所有原因，但是在支持者列表中有我关注的用户。
尽管我正在接近一种“蛮力”解决方案，但我还没有找到一种优雅的解决方案，它是如此繁琐和冗长，以至于像Susan Powter一样，我的程序员大脑的一半都在向我尖叫...
这是一个示例：
let retweetQuery = PFQuery(className: Constants.kParseClassCauses)
retweetQuery.orderByDescending(Constants.kParseFieldCreatedAt)
retweetQuery.whereKey(Constants.kParseFieldFromUser, notEqualTo: PFUser.currentUser()!)
retweetQuery.whereKey(Constants.kParseFieldFromUser, doesNotMatchKey: Constants.kParseFieldToUser, inQuery: getFollowedUsersQuery)
retweetQuery.findObjectsInBackgroundWithBlock({ (objects, error) -> Void in
if let causes = objects {
for cause in causes {
let supporterRelations = cause.relationForKey(Constants.kParseClassSupporters)
let supporterQuery = supporterRelations.query()
supporterQuery.findObjectsInBackgroundWithBlock { (supporters, error) in
if(error == nil && supporters?.count > 0) {
for supporter in supporters! {
let user:PFUser = supporter as! PFUser
getFollowedUsersQuery.whereKey(Constants.kParseFieldToUser, equalTo: user)
getFollowedUsersQuery.whereKey(Constants.kParseFieldFromUser, equalTo: PFUser.currentUser()!)
getFollowedUsersQuery.findObjectsInBackgroundWithBlock({ (results, error) -> Void in
if(error == nil && results?.count > 0) {
for result in results! {
// do stuff
}
}
})
}
}
}
}
}
})
现在，这简直是疯狂，而且令人难以置信的浪费（特别是考虑到Parse如何计算免费套餐-我认为，如果将其投入生产，这确实会对我的API限制做出重大贡献）。
已经完成了两次查询，我将完全重做一次，然后针对SUPPORTER关系中的每个原因执行另一个查询，然后对该关系中的每个用户进行另一个查询，以查看是否遵循它们……一旦获得这些信息，我就可以 需要遍历该用户支持的原因（由于Parse查询的异步返回，我根本感觉不到可以回到父循环中）……我尚未实现，因为 要扔毛巾-必须有更好的方法！
我希望我在这里错过了一项策略...
几乎每个程序员一生都做一次：如果变量的值更改，则设置一些标志。 总是有很多属性，如果有更改，您想跟踪
除了在每次属性更改时更新标准对象范围的脏标志之外，我对以上情况下实现“脏标志”功能的其他方式也很感兴趣。 必须有比在每个设置器中都加上“脏=真”更好的东西：它看起来很丑，是一件乏味的工作。
我已经阅读了很多有关Singleton的内容，何时应该使用不应该使用它们，以及如何安全地实现它们。 我正在用C ++ 11编写，并且遇到了迈耶的单例的懒惰初始化实现。
该实现是：
static Singleton& instance()
{
static Singleton s;
return s;
}
我从SO上的其他问题中了解到线程安全性如何，但是我不明白的是这实际上是单例模式。 我已经用其他语言实现了单例，并且这些总是以类似于Wikipedia的示例的形式结束：
public class SingletonDemo {
private static volatile SingletonDemo instance = null;
private SingletonDemo() { }
public static SingletonDemo getInstance() {
if (instance == null) {
synchronized (SingletonDemo .class){
if (instance == null) {
instance = new SingletonDemo ();
}
}
}
return instance;
}
}
当我看第二个示例时，这是一个单例非常直观，因为该类持有对自身一个实例的引用，并且仅返回该实例。 但是，在第一个示例中，我不明白这如何防止对象存在两个实例。 所以我的问题是：
谢谢你的帮助，
我正在寻找一些有关C＃中流畅接口的好技巧。 我本人只是在学习它，但是渴望听到别人在我正在阅读的文章之外的想法。 我特别追求：
如果您可以发表一个小贴士或想法，或每篇文章发表任何内容。 我也想看看他们如何获得投票。
先感谢您。
我正在构建一个Android应用程序。 我注意到我在每个类中都创建了许多与此类似的代码重复：
Button buttonX = (Button)findViewById(R.id.buttonXName);
// Register the onClick listener with the implementation above
buttonX.setOnClickListener(new OnClickListener() {
public void onClick(View v)
{
//DO SOMETHING! {RUN SOME FUNCTION ... DO CHECKS... ETC}
}
});
我现在有十五个按钮，这使我的代码很难看。 有没有人有关于如何将所有这些代码转换为更有效的内容的类或示例，所以我可以：
{public void onClick(View v)}{public void onClick(View v)}{public void onClick(View v)}如果有人知道，我将不胜感激。
我开始研究Laravel，但我不了解Service Container的概念。
它是如何工作的，开发人员需要了解什么才能在Laravel中充分利用此概念？
（注意：我的问题与三个月前问这个问题的人非常相似，但从未得到回答。）
我最近开始使用MVC3 + Entity Framework，并且我一直在阅读，最佳实践是使用存储库模式来集中对DAL的访问。 这还附带了有关您要使DAL与域（尤其是视图层）分开的说明。 但是在示例中，我看到存储库只是（或似乎）返回了DAL实体，即，在我的情况下，存储库将返回EF实体。
所以我的问题是，如果存储库仅返回DAL实体，那么存储库有什么用？ 这是否增加了一层复杂性并不能消除在各层之间传递DAL实体的问题？ 如果存储库模式创建“进入DAL的单个入口点”，那么它与上下文对象有何不同？ 如果存储库提供了一种检索和持久保存DAL对象的机制，那么它与上下文对象有何不同？
另外，我至少读过一个地方，即工作单元模式集中了存储库访问权限，以便管理数据上下文对象，但是我也不理解为什么这很重要。
我98.8％肯定我在这里遗漏了一些东西，但是从我的阅读中我没有看到它。 当然，我可能只是没有阅读正确的资料...：\
我查看了Android中SensorManager的源代码，发现当您注册ListenerDelegate时，SensorManager将监听器的控制权传递给ListenerDelegate。
我仅以此为例。 我阅读了有关委托编程的Wikipedia文章，但仍不确定其目的。 为什么要使用“委托”？ 它如何帮助控制程序？ 使用（或不使用）一个的缺点是什么？ 最适合与听众一起使用吗？
编辑：ListenerDelegate在487行上，有问题的方法在1054行附近。
我从MSDN了解锁定关键字的主要功能
lock语句（C＃参考）
lock关键字标记一条语句 作为关键部分阻止 获取互斥锁 对于给定的对象，执行 语句，然后释放 锁。
什么时候应该使用锁？
例如，它对多线程应用程序有意义，因为它可以保护数据。 但是，当应用程序不剥离任何其他线程时是否有必要？
使用锁是否存在性能问题？
我刚刚继承了一个在所有地方都使用锁的应用程序，它是单线程的，我想知道是否应该保留它们，甚至有必要吗？
请注意，这更多是一个常识性的问题，应用速度很好，我想知道这是将来遵循的良好设计模式，还是除非绝对需要，否则应该避免这种情况。
我已经使用工厂方法创建模式已有一段时间了。 最近有人告诉我：
public static class ScheduleTypeFactory
{
public static IScheduleItem GetScheduleItem(ScheduleTypeEnum scheduleType)
{
IScheduleItem scheduleItem = null;
switch (scheduleType)
{
case ScheduleTypeEnum.CableOnDemandScheduleTypeID:
{
scheduleItem = new VODScheduleItem();
break;
}
case ScheduleTypeEnum.BroadbandScheduleTypeID:
{
scheduleItem = new VODScheduleItem();
break;
}
case ScheduleTypeEnum.LinearCableScheduleTypeID:
{
scheduleItem = new LinearScheduleItem();
break;
}
case ScheduleTypeEnum.MobileLinearScheduleTypeID:
{
scheduleItem = new LinearScheduleItem();
break;
}
}
return scheduleItem;
}
}
不是我的“技术”负责人提出的工厂方法创建模式，而没有告诉我原因或给我她的解释。 我恳求解释，她告诉我她没有时间。 有人告诉我要重命名它。 如果我错了，那么我无疑会接受我多年来错误地实施了这一做法。 这是实现工厂方法创建模式的方式吗？ 提前致谢。
假设我有一些Foo类，它具有两个依赖项：ISerializer<T>和IFileAccessHandler。
现在，此类还具有其他依赖关系，即功能依赖关系。 我不希望任何人在无效状态下实例化此类，因此我还需要在构造函数中传递一个域对象。
但是，当我实际上在创建类Foo的那一刻也知道要传递哪个域对象时，如何由IoC处理呢？
我将域对象设置为工厂设置的属性。 因此，Factory进行Service Locator调用，以获取具有其依赖关系的正确实例化的“ Foo”类，并进一步使用正确的域对象填充它并返回它。
但这是最好的方式吗？ 我希望将域对象作为构造函数的一部分，以使其看起来像实际需要使用“ Foo”一样。
有任何想法吗？我在这里想念什么吗？
设计模式的思想从何而来，谁决定了什么是模式，什么不是模式，并给它们起了名字？ 是否有一个定义它们的官方组织，或者它们是通过某种社区共识而存在的？
我正在做一些Objective-C / iOS开发，并且听说过一些有关Actor模式的参考。 在《大书呆子牧场》一书中，它说：
当您有长时间运行的任务并且有一些任务时，将使用actor对象 完成后需要执行的代码。 这种物体 获得执行任务所需的信息并回调 完成该任务后执行。 演员在自己的线程上运行 没有任何进一步的输入，并且在完成时被销毁。
这里的actor与网络呼叫结合使用。 这是Actor的主要用途吗？ 是互斥还是互赠？ Actor的定义似乎非常广泛，我正在尝试更好地理解它的含义。 另外，是否可以在非OO环境中使用Actor？
有很多不同的日志记录库可供选择，每种都有各自的独特之处和优势。 （.Net示例：log4net，System.Diagnostics.TraceSource，nLog等）
自然的倾向是抽象化那些怪癖并使用伐木外观。 （例如：Castle.Services.Logging，Common.Logging，Simple Logging Facade）这样，如果您正在使用的给定日志框架过时，或者其他框架变得流行，您可以换掉实现并退出 代码未修改。
但是，有多个伐木立面可供选择。 鉴于许多不同的日志记录实现的答案都是抽象，为什么不使用日志记录外观Facade？ 如果这听起来很荒谬，是什么让它比原始的伐木外观更荒谬？ 是什么使日志框架之上的抽象层增加了魔数？
我一直在讨论DRY（请勿重复自己）原理（也称为DIE（重复就是邪恶）），并且有投票意见，任何简单的代码重复总是有害的。 我想听听您对以下几点的意见：
上述情况是否是放弃抽象过程的充分理由，而只是保留重复的代码，以免将来有更改或可读性的风险？
众所周知，C ++中的内置枚举不是类型安全的。我想知道在那里使用哪些实现类型安全枚举的类...我本人使用以下“自行车”，但它有点冗长和有限：
typesafeenum.h：
struct TypesafeEnum
{
// Construction:
public:
TypesafeEnum(): id (next_id++), name("") {}
TypesafeEnum(const std::string& n): id(next_id++), name(n) {}
// Operations:
public:
bool operator == (const TypesafeEnum& right) const;
bool operator != (const TypesafeEnum& right) const;
bool operator < (const TypesafeEnum& right) const;
std::string to_string() const { return name; }
// Implementation:
private:
static int next_id;
int id;
std::string name;
};
typesafeenum.cpp：
int TypesafeEnum::next_id = 1;
bool TypesafeEnum::operator== (const TypesafeEnum& right) const
{ return id == right.id; }
bool TypesafeEnum::operator!= (const TypesafeEnum& right) const
{ return !operator== (right); }
bool TypesafeEnum::operator< (const TypesafeEnum& right) const
{ return id < right.id; }
用法：
class Dialog
{
...
struct Result: public TypesafeEnum
{
static const Result CANCEL("Cancel");
static const Result OK("Ok");
};
Result doModal();
...
};
const Dialog::Result Dialog::Result::OK;
const Dialog::Result Dialog::Result::CANCEL;
加成：我认为我应该更具体地说明这些要求。 我将尝试总结一下：
优先级1：毫无例外，将枚举变量设置为无效值应该是不可能的（编译时错误）。
优先级2：应该可以通过单个显式函数/方法调用将枚举值与int转换。
优先级3：尽可能紧凑，优雅，方便的声明和使用
优先级4：将枚举值与字符串进行相互转换。
优先级5 ：（很高兴）迭代枚举值的可能性。
关于这个主题有数百个类似的问题。 但是我仍然很困惑，我想为此寻求专家的建议。
我们正在使用ASP.NET MVC 4和EF5开发应用程序，而我们的方法是数据库优先方法。
我们在一个单独的项目中有一个数据层，该项目是一个类库，其中包含所有定义的实体。 然后，使用所有存储库和域模型定义业务层（这是要使用的正确术语）。 然后是表示层。
目前，我们尚未定义任何视图模型，我们正在使用BL中与视图模型相同的域模型。 在这种方法中，一个映射就足够了。
实体<=>域模型
但是对我来说，它看起来并不是一个好的设计。 我更喜欢在表示层中定义视图模型，并使用域模型在表示层和业务层之间进行通信。 在BL上，将域对象转换为数据实体并与DAL通信。 使用这种方法，我必须使用两次映射。
查看模型<=>域模型<=> ENTITY
我的域模型真的必要吗？ 我不能使用我的实体与Presentation层进行通信。 如果我在表示层中引用实体，会有什么影响？ 如果有什么样的影响？
我正在研究命令设计模式，并且对它的使用方式非常困惑。 我的示例与用于打开和关闭灯的远程控制类有关。
为什么不使用Light类的switchOn（）/ switchOff（）方法，而不使用单独的类和方法来最终调用switchOn / switchOff方法呢？
我知道我的例子很简单，但这就是重点。 我无法在Internet上的任何地方找到任何复杂的问题，以查看命令设计模式的确切用法。
如果您知道可以使用此设计模式解决的任何复杂现实问题，请与我分享。 它可以帮助我和本文的未来读者更好地了解这种设计模式的用法。 谢谢
//Command
public interface Command {
public void execute();
}
//Concrete Command
public class LightOnCommand implements Command {
//Reference to the light
Light light;
public LightOnCommand(Light light) {
this.light = light;
}
public void execute() {
light.switchOn(); //Explicit call of selected class's method
}
}
//Concrete Command
public class LightOffCommand implements Command {
//Reference to the light
Light light;
public LightOffCommand(Light light) {
this.light = light;
}
public void execute() {
light.switchOff();
}
}
//Receiver
public class Light {
private boolean on;
public void switchOn() {
on = true;
}
public void switchOff() {
on = false;
}
}
//Invoker
public class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
}
}
//Client
public class Client {
public static void main(String[] args) {
RemoteControl control = new RemoteControl();
Light light = new Light();
Command lightsOn = new LightsOnCommand(light);
Command lightsOff = new LightsOffCommand(light);
//Switch on
control.setCommand(lightsOn);
control.pressButton();
//Switch off
control.setCommand(lightsOff);
control.pressButton();
}
}
为什么我不应该轻易使用以下代码？
Light light = new Light();
switch(light.command) {
case 1:
light.switchOn();
break;
case 2:
light.switchOff();
break;
}
今天我顿悟了，那是我做错了所有事情。 历史：我继承了一个C＃应用程序，它实际上只是静态方法的集合，完全是C＃代码的程序混乱。 我重构了当时我所知道的最好的知识，从而带来了许多大学后OOP知识。 长话短说，代码中的许多实体原来都是Singletons。
今天，我意识到我需要3个新类，每个新类都将遵循相同的Singleton模式以匹配软件的其余部分。 如果我继续在这个光滑的斜坡上翻滚，最终我的应用程序中的每个类都将是Singleton，这在逻辑上与原始静态方法组实际上并没有什么不同。
我需要重新考虑这一点。 我知道依赖注入，这通常是打破Singleton诅咒的策略。 但是，我有一些与此重构有关的具体问题，以及有关这样做的最佳实践的所有问题。
使用静态变量封装配置信息的接受程度如何？ 我对使用静态方法有一定的头脑，我认为这是由于大学里的一门面向对象的早期课程，教授说静态方法不好。 但是，每次访问该类时，是否都必须重新配置该类？ 访问硬件时，可以保留指向所需地址和变量的静态指针，还是应该继续执行SerialPortWriter和DataFileWriter操作？
现在，我有一个方法充当控制器。 具体来说，我不断地（通过硬件驱动程序）轮询几种外部工具以获取数据。 应该使用这种类型的控制器，还是应该在程序启动时为每个仪器生成单独的线程？ 如果是后者，如何使该对象面向对象？ 我是否应该创建名为SerialPortWriter和DataFileWriter的类？ 还是有一些标准的方法来解决这个问题？
有更好的方法进行全局配置吗？ 现在，我只是在整个代码中随意洒了SerialPortWriter。 几乎每个类都使用它，因此将其保留为Singleton可能有意义。 有什么想法吗？
我的很多课程都像SerialPortWriter或DataFileWriter之类，它们必须坐在那里等待数据流进来。由于它们一直处于活动状态，因此我应该如何安排它们以便侦听数据传入时产生的事件？
任何其他有关如何摆脱Singleton和其他模式过度使用的资源，书籍或评论都将有所帮助。