在查看从WCF库反映的一些代码时,我看到了用于创建异常的模式:
if(argument == null)
{
throw Error.ArgumentNull("argument");
}
空参数是最简单的示例,其他类型的异常可通过静态错误类获得.
这种工厂模式的价值是多少？为什么不使用new运算符并简单地调用ArgumentNullException构造函数？
当我尝试在Ninject中使用ToFactory时,我得到Ninject.ActivationException
var test = new StandardKernel();
test.Bind<IFoo>().To<Foo>();
test.Bind<IFooFactory>().ToFactory();
var factory = test.Get<IFooFactory>();
var foo = factory.GetFoo(); //<--Ninject.ActivationException
工厂:
public interface IFooFactory
{
IFoo GetFoo();
}
例外:
Ninject.ActivationException was unhandled
Message=Error activating IFoo
No matching bindings are available, and the type is not self-bindable.
Activation path:
1) Request for IFoo
Suggestions:
1) Ensure that you have defined a binding for IFoo.
2) If the binding was defined in a module, ensure that the module has been loaded into the kernel.
3) …在我当前的项目中，我越来越多地采用 DDD/洋葱架构。我仍然不清楚的许多事情之一是应该有多少封装。用一个具体的例子更容易解释。
例子
namespace MyProject.Model
{
public class ComplexEntity
{
private int _id;
public int Id { get {return _id;} }
public ValueObjectA ValueA {get; set;}
public bool IsBool {get; set;}
public ComplexEntity(ValueObjectA a, bool isBool)
{
// Do some validation first
ValueA = a;
ValueB = b;
IsBool = isBool;
}
}
public class ValueObjectA
{
public bool IsBoolA {get; private set;}
public bool IsBoolB {get; private set;}
public ValueObjectA(bool a, bool b)
{
IsBoolA = a;
IsBoolB = …Java 和 Javascript 都允许以不同的方式执行静态代码。Java 允许您在类的主体中包含静态代码，而 JS 允许您在类定义之外执行静态代码。例子：
爪哇：
public class MyClass {
private static Map<String,String> someMap = new HashMap<String,String();
static {
someMap.put("key1","value");
someMap.put("key2","value");
SomeOtherClass.someOtherStaticMethod();
System.out.println(someMap);
}
}
JS（基本上是类之外的任何 JS 代码）：
var myint = 5;
callSomeMethod();
$(document).ready(function () {
$("#hiddenelement").hide();
});
但是，Dart 似乎支持两种方式中的任何一种。支持声明全局变量和方法，但不支持像在 JS 中那样调用方法和执行代码。这只能在一个main()方法中完成。此外，类中的静态代码也是不允许的。
我知道 Dart 有其他方法可以像我的第一个示例一样静态填充 Map，但是我可以想到另一种情况需要这样做。
让我们考虑以下CarRegistry实现，它允许您将汽车模型的字符串映射到相应类的实例。从 JSON 数据中获取汽车模型时的 Fe：
class CarRegistry {
static Map<String, Function> _factoryMethods = new HashMap<String, Function>();
static void registerFactory(String key, Car factory()) {
_factoryMethods[key] = factory;
}
static Car …我的 Laravel 5.2 应用程序具有以下结构：
用户： id 姓名...
帖子：id 标题正文 user_id (fk)
评论：id body user_id (fk) post_id (fk)
我想创建几个用户（20），为每个用户创建随机数量的帖子，并为每个帖子创建随机数量的评论（即使是固定数量也可以）。
我可以创建用户并为每个用户分配帖子，但我无法为每个帖子分配评论：我有这个：
factory(App\User::class, 20)->create()->each(function($u) {
$u->posts()->saveMany(factory(App\Post::class, 5)->make();
});
我发现了一些东西但没有用：
factory(App\Comment::class, 100)->create()->each(function($u) {
$u->user()->sync(
App\User::all()->random(3)
);
});
注意：我在模型之间建立了这样的关系：用户有很多帖子，用户有很多评论，帖子有很多评论，评论属于帖子，评论属于用户
我试图将Enum样式的工厂模式实现为内部枚举,但它不起作用.有没有将内部枚举分离成新文件的解决方案？换句话说,内部Enum风格的工厂模式是否可能？
代码如下.
public class SampleParent {
private class InnerChild { }
private class InnerChildA extends InnerChild { }
private class InnerChildB extends InnerChild { }
private class InnerChildC extends InnerChild { }
enum InnerChildEnum {
CHILD_A {
@Override
public InnerChild getInstance() {
return new InnerChildA(); // compile error
}
},
CHILD_B {
@Override
public InnerChild getInstance() {
return new SampleParent.InnerChildB(); // compile error
}
},
CHILD_C {
@Override
public InnerChild getInstance() {
return SampleParent.new InnerChildC(); // compile error
}
}, …我有两种在我的应用程序中保存数据的方法：保存到数据库和保存到文件。由于我不希望客户端代码处理对象的构造，因此我创建了一个类（据我所知）是带有工厂方法的简单工厂。代码如下：
public static DataPersister createDataPersister(Boolean saveToDb, Session session, String filename) {
if (saveToDb) {
return new DatabaseDataPersister(session);
} else {
return new FileDataPersister(filename);
}
}
使用此设置，客户端代码不必处理构建任何内容或决定是否保存到数据库或文件 - 它只需调用save()工厂返回的对象上的方法，如下所示：
DataPersister dataPersister = DataPersisterSimpleFactory.createDataPersister(this.savetoDb, this.session, this.filename);
dataPersister.save(this.data);
我的问题是 - 这个解决方案是否违反了 SOLID 原则？例如，为了创建一个DatabaseDataPersister客户端代码需要传递一个filename参数，并且这个实现DataPersister不会使用它。我觉得它与类似于接口隔离原则的东西并不相符，但并非如此。
如果解决方案确实是代码异味 - 我该如何清理它？
我为帖子和类别编写了工厂，工作非常完美。但我找不到一种方法来填充category_post 表来测试它们之间的ManyToMany 关系。
我怎样才能做到这一点？
注意：我将尝试用简化的场景来解释用例（这对您来说可能看起来很奇怪）。
我有 2 个模型（相关但没有外键）：
# models.py
class User(models.Model):
name = models.CharField()
age = models.IntegerField()
weight = models.IntegerField()
# there are a lot more properties ...
class Group(models.Model):
name = models.CharField()
summary = JSONField()
def save(self, *args, **kwargs):
self.summary = _update_summary()
super().save(*args, **kwargs)
def _update_summary(self):
return calculate_group_summary(self.summary)
# this helper function is located in a helper file
def calculate_group_summary(group_summary):
"""calculates group.summary data based on group.users"""
# retrieve users, iterate over them, calculate data and store results in group_summary object
return group_summary …我遇到过一个面试问题，是这样的：
某个地区有一些工厂会产生污染气体，每个工厂都要安装过滤器以减少污染。每安装一个过滤器就会使该工厂的污染减少一半。每个工厂可以有多个过滤器。有一个包含 N 个整数的列表，代表该地区 N 个工厂中每个工厂的污染程度。求出将总体污染减半所需的最少过滤器数量。
例如 - 让 [3, 5, 6, 1, 18] 成为 5 个工厂的污染级别列表
总体污染=3+5+6+1+18=33（目标是33/2=16.5）
在工厂安装一个过滤器，索引=4 --> 污染级别将为 [3, 5, 6, 1, 9]
在工厂安装一个过滤器，索引=4 --> 污染级别将为 [3, 5, 6, 1, 4.5]
在工厂安装一个过滤器，索引=2 --> 污染级别将为 [3, 5, 3, 1, 4.5]
至少需要 3 个过滤器才能将总体污染减少一半。
N 是 [1...30,000] 范围内的整数。列表中的每个元素都是 [0....70,000] 范围内的整数
我为此想出的解决方案很简单：每次查找列表中的最大值和一半，直到总和<=目标
def solution(A):
total = sum(A)
target = total/2
count = 0
while total>target:
count+=1
max_p = max(A)
total-= max_p/2
A.remove(max_p)
A.append(max_p/2)
return count
这很有效，只是时间复杂度似乎是 O(N^2)。有人可以建议一种时间复杂度较低（最好是 O(N)）的方法来解决这个问题吗？