javascript

git

python

java

git-remote

github

django

c#

reactjs

c++

undefined

scrum

kubernetes

ruby-on-rails

.net

.net-framework-version

operators

git-fetch

typescript

user-experience

设计模式-IObservable vs普通事件,或者为什么应该使用IObservable?

微软通过.NET Framework 4向BCL引入了IObservable<T>接口,我想:“太好了,最后,我必须使用它!” 因此,我深入研究并阅读了帖子和文档,甚至实现了该模式。

这样做之后,我意识到基本实现实际上将所有T事件发送给所有订阅者,而没有对其进行任何过滤。 即纯广播。 我在某处读到Observable模式是用于普通广播的。 我觉得这是不正确的,我缺少了一些东西。

我的问题:

  1. 如果添加过滤机制,则使用Observable模式与仅使用普通CLR事件有什么区别?

  2. 什么时候应该使用这种模式,什么时候应该选择使用普通的CLR事件?

  3. 可观察模式的主要优点是什么?

trans by 2020-08-12T10:28:49Z

设计模式-工厂,抽象工厂和工厂方法

我对这三个术语感到非常困惑。

我的理解是:

  • 在工厂模式下,没有混凝土工厂。 工厂根据参数构建新对象。

  • 在抽象工厂模式中,有多个混凝土工厂。 客户必须显式创建不同的具体工厂。

那正确吗?

其他区别是什么?

此外,什么是工厂方法模式? 与工厂模式相同吗?

trans by 2020-08-11T20:40:36Z

Python观察者模式:示例,提示?

是否有用Python实现的GoF Observer的示例示例? 我有一个位代码,当前有一些调试代码通过键类附加(如果设置了魔术环境,当前会向stderr生成消息)。 另外,该类还具有一个接口,用于递增地返回结果以及将其存储在内存中以进行后期处理。 (该类本身是一个作业管理器,用于通过ssh在远程计算机上并发执行命令)。

当前,该类的用法类似于:

job = SSHJobMan(hostlist, cmd)
job.start()
while not job.done():
    for each in job.poll():
        incrementally_process(job.results[each])
        time.sleep(0.2) # or other more useful work
post_process(job.results)

另一种用法是:

job = SSHJobMan(hostlist, cmd)
job.wait()  # implicitly performs a start()
process(job.results)

这对于当前的实用程序来说一切正常。 但是,它确实缺乏灵活性。 例如,我目前支持简短的输出格式或进度条作为增量结果,我也支持post_process()功能的简要,完整和“合并的消息”输出。

但是,我想支持多个结果/输出流(到终端的进度条,对日志文件的调试和警告,从成功作业到一个文件/目录的输出,错误消息以及从不成功作业到其他结果的其他结果) 等)。

这听起来像是一种情况,要求Observer ...让我的类的实例接受其他对象的注册,并在事件发生时使用特定类型的事件进行回调。

我正在查看PyPubSub,因为我在SO相关问题中看到了一些引用。 我不确定是否准备将外部依赖项添加到我的实用程序中,但是如果这样做可以使其他人更容易使用,那么我可以看到将其接口用作我的模型的价值。 (该项目既可以用作独立的命令行实用程序,也可以用作编写其他脚本/实用程序的类)。

简而言之,我知道该怎么做...但是有很多方法可以实现它。 从长远来看,我想对最可能对其他代码用户起作用的建议。

代码本身位于:classh。

trans by 2020-08-10T21:09:13Z

设计模式-依赖反转原理(SOLID)与封装(OOP的支柱)

最近,我在关于依赖性反转原理,控制反转和依赖性注入的辩论中。 关于这个话题,我们正在讨论这些原则是否违反了OOP的支柱之一,即封装。

我对这些事情的理解是:

  • 依赖倒置原则意味着对象应该依赖于抽象而不是依赖-这是实现控制模式倒置和依赖注入的基本原理。
  • 控制反转是依赖反转原理的一种模式实现,其中抽象依赖替换了具体的依赖,从而允许在对象外部指定依赖的具体形式。
  • 依赖注入是一种实现控制反转并提供依赖解决方案的设计模式。 当依赖项传递到依赖项组件时,将发生注入。 本质上,依赖注入模式提供了一种将依赖抽象与具体实现耦合的机制。
  • 封装是将高级对象所需的数据和功能隔离开并且不可访问的过程,因此,程序员不知道对象是如何实现的。

辩论的焦点在于以下陈述:

IoC不是OOP,因为它破坏了封装

就我个人而言,我认为所有OOP开发人员都应认真遵守依赖关系倒置原则和控制倒置模式-我的引用如下:

如果(可能)有多种方法可以给猫剥皮,则不要 表现得只有一个。

范例1:

class Program {
    void Main() {
        SkinCatWithKnife skinner = new SkinCatWithKnife ();
        skinner.SkinTheCat();
    }
}

在这里,我们看到一个封装的例子。 程序员只需致电.SkinTheCat();,猫就会被剥皮,但是如果他想用一组剃刀般锋利的牙齿给猫剥皮怎么办?

范例2:

class Program {
    // Encapsulation
    ICatSkinner skinner;

    public Program(ICatSkinner skinner) {
        // Inversion of control
        this.skinner = skinner;
    }

    void Main() {
        this.skinner.SkinTheCat();
    }
}

... new Program(new SkinCatWithTeeth());
    // Dependency Injection

由于提供了摘要(.SkinTheCat();),以便允许程序员传递具体的依赖关系,因此在这里我们观察到了依赖关系反转原理和控制反转。 最后,有多种方法可以给猫皮!

这里的争吵是: 这会破坏封装吗? 从技术上讲,人们可能会认为.SkinTheCat();仍封装在Main()方法调用内,因此程序员并不了解此方法的行为,因此我认为这不会破坏封装。

深入研究,我认为IoC容器会因为使用反射而使OOP中断,但是我不相信IoC会破坏OOP,也不相信IoC会破坏封装。 实际上,我什至可以这么说:

控制的封装和反转相互一致 高兴地是,允许程序员仅传入一个 依赖,同时通过隐藏了整体实现 封装。

问题:

  • IoC是否直接实现了依赖倒置原则?
  • IoC是否总是破坏封装并因此破坏OOP?
  • 是否应谨慎,虔诚或适当地使用IoC?
  • IoC和IoC容器有什么区别?
trans by 2020-08-10T00:26:10Z

设计模式-什么是C ++中的代理类

什么是C ++中的代理类? 为什么创建它以及在哪里有用?

trans by 2020-08-08T14:26:31Z

oop-减少构造函数的参数数量

我正在阅读“干净的代码”,无法弄清楚如何将我的某些函数(通常是构造函数)保持为3个参数的最大值。

通常,我的对象需要大量的信息才能工作-我是否应该制作一个小的构造函数,然后使用mutator函数将所有信息提供给它们? 这似乎并不比仅使用大型构造函数更好。

例如,我有一个“ MovablePatch”类。 它使用户可以在窗口中拖动一个正方形。 它需要几个参数,包括Radius,Color,Renderer,InitialPosition和Visibility。 目前,我从GUI收集所有这些信息,然后致电:

MovablePatch(int radius, Renderer* renderer, Color color,  Position initial, bool visibility)

这些只是我在课堂上需要的一些东西。 谁能建议我如何打包此信息以传递给构造函数? 我看不到这里出现任何明显的“分解为小类”。

trans by 2020-08-06T17:18:17Z

iOS-parse.com“转发”模式太冗长

因此,我的任务是使用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查询的异步返回,我根本感觉不到可以回到父循环中)……我尚未实现,因为 要扔毛巾-必须有更好的方法!

我希望我在这里错过了一项策略...

trans by 2020-08-06T12:20:02Z

设计模式-实现“脏”标志功能的不同方法

几乎每个程序员一生都做一次:如果变量的值更改,则设置一些标志。 总是有很多属性,如果有更改,您想跟踪

  1. 在任何财产
  2. 在特定的属性中
  3. 或某些属性中

除了在每次属性更改时更新标准对象范围的脏标志之外,我对以上情况下实现“脏标志”功能的其他方式也很感兴趣。 必须有比在每个设置器中都加上“脏=真”更好的东西:它看起来很丑,是一件乏味的工作。

trans by 2020-08-02T18:07:02Z

c ++-Meyers如何实现Singleton实际上是Singleton

我已经阅读了很多有关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;
        }
}

当我看第二个示例时,这是一个单例非常直观,因为该类持有对自身一个实例的引用,并且仅返回该实例。 但是,在第一个示例中,我不明白这如何防止对象存在两个实例。 所以我的问题是:

  1. 第一个实现如何执行单例模式? 我认为它与static关键字有关,但我希望有人可以向我深入说明幕后情况。
  2. 在这两种实现方式之间,是否有一种比另一种更好? 优缺点都有什么?

谢谢你的帮助,

trans by 2020-08-01T18:35:44Z

设计模式-用C#3编写流畅接口的技巧

我正在寻找一些有关C#中流畅接口的好技巧。 我本人只是在学习它,但是渴望听到别人在我正在阅读的文章之外的想法。 我特别追求:

  1. 什么时候流利太多?
  2. 是否有流利的模式?
  3. C#中的什么使流利的界面更流利(例如扩展方法)
  4. 复杂的流利界面仍然是流利的吗?
  5. 重构以达到流畅的界面或重构现有的流畅界面
  6. 您曾经合作过或可以推荐的好例子吗?

如果您可以发表一个小贴士或想法,或每篇文章发表任何内容。 我也想看看他们如何获得投票。

先感谢您。

trans by 2020-08-01T15:52:20Z

Android Button setOnClickListener设计

我正在构建一个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}
    } 
});

我现在有十五个按钮,这使我的代码很难看。 有没有人有关于如何将所有这些代码转换为更有效的内容的类或示例,所以我可以:

  1. 创建按钮对象{public void onClick(View v)}
  2. 设置监听器{public void onClick(View v)}
  3. 确定是否单击了{public void onClick(View v)}
  4. 然后为每个按钮运行特定的代码?

如果有人知道,我将不胜感激。

trans by 2020-08-01T08:23:17Z

php-Laravel中服务容器的概念是什么?

我开始研究Laravel,但我不了解Service Container的概念。

它是如何工作的,开发人员需要了解什么才能在Laravel中充分利用此概念?

trans by 2020-07-30T08:23:37Z

实体框架-存储库模式可以解决哪些特定问题?

(注意:我的问题与三个月前问这个问题的人非常相似,但从未得到回答。)

我最近开始使用MVC3 + Entity Framework,并且我一直在阅读,最佳实践是使用存储库模式来集中对DAL的访问。 这还附带了有关您要使DAL与域(尤其是视图层)分开的说明。 但是在示例中,我看到存储库只是(或似乎)返回了DAL实体,即,在我的情况下,存储库将返回EF实体。

所以我的问题是,如果存储库仅返回DAL实体,那么存储库有什么用? 这是否增加了一层复杂性并不能消除在各层之间传递DAL实体的问题? 如果存储库模式创建“进入DAL的单个入口点”,那么它与上下文对象有何不同? 如果存储库提供了一种检索和持久保存DAL对象的机制,那么它与上下文对象有何不同?

另外,我至少读过一个地方,即工作单元模式集中了存储库访问权限,以便管理数据上下文对象,但是我也不理解为什么这很重要。

我98.8%肯定我在这里遗漏了一些东西,但是从我的阅读中我没有看到它。 当然,我可能只是没有阅读正确的资料...:\

trans by 2020-07-29T01:01:04Z

java-委托模式的目的是什么?

我查看了Android中SensorManager的源代码,发现当您注册ListenerDelegate时,SensorManager将监听器的控制权传递给ListenerDelegate

我仅以此为例。 我阅读了有关委托编程的Wikipedia文章,但仍不确定其目的。 为什么要使用“委托”? 它如何帮助控制程序? 使用(或不使用)一个的缺点是什么? 最适合与听众一起使用吗?

编辑:ListenerDelegate在487行上,有问题的方法在1054行附近。

trans by 2020-07-28T17:17:21Z

多线程-C#中的lock关键字

我从MSDN了解锁定关键字的主要功能

lock语句(C#参考)

lock关键字标记一条语句 作为关键部分阻止 获取互斥锁 对于给定的对象,执行 语句,然后释放 锁。

什么时候应该使用锁?

例如,它对多线程应用程序有意义,因为它可以保护数据。 但是,当应用程序不剥离任何其他线程时是否有必要?

使用锁是否存在性能问题?

我刚刚继承了一个在所有地方都使用锁的应用程序,它是单线程的,我想知道是否应该保留它们,甚至有必要吗?

请注意,这更多是一个常识性的问题,应用速度很好,我想知道这是将来遵循的良好设计模式,还是除非绝对需要,否则应该避免这种情况。

trans by 2020-07-27T12:52:34Z

c#-这是工厂方法创建模式吗?

我已经使用工厂方法创建模式已有一段时间了。 最近有人告诉我:

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;
    }
}

不是我的“技术”负责人提出的工厂方法创建模式,而没有告诉我原因或给我她的解释。 我恳求解释,她告诉我她没有时间。 有人告诉我要重命名它。 如果我错了,那么我无疑会接受我多年来错误地实施了这一做法。 这是实现工厂方法创建模式的方式吗? 提前致谢。

trans by 2020-07-27T07:05:33Z

设计模式-无法结合Factory / DI

假设我有一些Foo类,它具有两个依赖项:ISerializer<T>IFileAccessHandler

现在,此类还具有其他依赖关系,即功能依赖关系。 我不希望任何人在无效状态下实例化此类,因此我还需要在构造函数中传递一个域对象。

但是,当我实际上在创建类Foo的那一刻也知道要传递哪个域对象时,如何由IoC处理呢?

我将域对象设置为工厂设置的属性。 因此,Factory进行Service Locator调用,以获取具有其依赖关系的正确实例化的“ Foo”类,并进一步使用正确的域对象填充它并返回它。

但这是最好的方式吗? 我希望将域对象作为构造函数的一部分,以使其看起来像实际需要使用“ Foo”一样。

有任何想法吗?我在这里想念什么吗?

trans by 2020-07-26T13:52:33Z

是否存在确定的设计模式列表?

设计模式的思想从何而来,谁决定了什么是模式,什么不是模式,并给它们起了名字? 是否有一个定义它们的官方组织,或者它们是通过某种社区共识而存在的?

trans by 2020-07-26T12:05:01Z

演员模式-究竟是什么构成

我正在做一些Objective-C / iOS开发,并且听说过一些有关Actor模式的参考。 在《大书呆子牧场》一书中,它说:

当您有长时间运行的任务并且有一些任务时,将使用actor对象 完成后需要执行的代码。 这种物体 获得执行任务所需的信息并回调 完成该任务后执行。 演员在自己的线程上运行 没有任何进一步的输入,并且在完成时被销毁。

这里的actor与网络呼叫结合使用。 这是Actor的主要用途吗? 是互斥还是互赠? Actor的定义似乎非常广泛,我正在尝试更好地理解它的含义。 另外,是否可以在非OO环境中使用Actor?

trans by 2020-07-22T23:46:47Z

设计模式-伐木立面的目的是什么?

有很多不同的日志记录库可供选择,每种都有各自的独特之处和优势。 (.Net示例:log4net,System.Diagnostics.TraceSource,nLog等)

自然的倾向是抽象化那些怪癖并使用伐木外观。 (例如:Castle.Services.Logging,Common.Logging,Simple Logging Facade)这样,如果您正在使用的给定日志框架过时,或者其他框架变得流行,您可以换掉实现并退出 代码未修改。

但是,有多个伐木立面可供选择。 鉴于许多不同的日志记录实现的答案都是抽象,为什么不使用日志记录外观Facade? 如果这听起来很荒谬,是什么让它比原始的伐木外观更荒谬? 是什么使日志框架之上的抽象层增加了魔数?

trans by 2020-07-22T17:13:03Z

1 2 3 4 5 6 7 8 9 10 11 12 13 14 下一页 共14页