我创建了一个工厂和一组规范来创建和验证聚合根.目前我对工厂进行了一些测试,这些测试称工厂的产品规格,但我想知道这是否足够.从设计的角度来看,将工厂与其产品的规格相结合可能会更好,因为它们密切相关.
如果聚合根产品的规范用于验证而不是用于创建,那么从工厂内部调用它是否有意义？
或者单位测试是否足够好？
validation domain-driven-design aggregate specification-pattern factory-pattern
tl; wr:这是一个讨论.
我知道这个"问题"更多的是讨论,因此我将其标记为社区维基.但是,根据" 如何询问"页面,它可能属于此处,因为它具体与编程相关,经过一个小时的研究后无法在网络上讨论,具体而言,与大多数C#程序员和主题相关.而且,这个问题本身就是为了获得答案,不管我的偏见,我都会保持开放的态度:C#真的会从总体结构中受益吗？尽管有这一前言,但我知道这是关闭的,但如果有权限和意图关闭的用户将我重定向到Web上的适当讨论点,我将不胜感激.
结构是C#中的灵活但有争议的类型.它们提供堆栈分配的值类型组织范例,但不提供其他值类型的不变性.
有人说结构应该代表值,而值不会改变(例如int i = 5;,5是不可变的),而有些人认为它们是带有子字段的OOP布局.
上结构不变性(辩论1,2,3),为此,当前的解决方案似乎具有程序员执行不变性,也没有解决.
例如,当结构作为引用(本页底部)访问并限制赋值时,C#编译器将检测可能的数据丢失.此外,由于结构构造函数,属性和函数能够执行任何操作,在返回控件之前使用限制(对于构造函数)分配所有字段,结构不能声明为常量,如果它们仅限于数据表示.
聚合类(维基百科)是严格的数据结构,功能有限,注定会因缺乏灵活性而在对应方面提供语法糖.在C++中,它们"没有用户声明的构造函数,没有私有或受保护的非静态数据成员,没有基类,也没有虚函数".尽管核心概念保持不变,但C#中此类类别的理论细节仍可供讨论.
由于聚合结构是严格的带有标记访问器的数据持有者,因此它们的不变性(在可能的C#环境中)将被保险.除非?指定了null运算符(),否则聚合也无法为空,无其他纯值类型.出于这个原因,许多非法的结构操作将成为可能,以及一些语法糖.
从C++语法中我们可以想象出以下几点:(记住,这是一个社区维基,欢迎并鼓励改进)
aggregate Size
{
int Width;
int Height;
}
aggregate Vector
{
// Default values for constructor.
double X = 0, Y = 0, Z = 0;
}
aggregate Color
{
byte R, G, B, …我想使用R将具有非唯一rownames的表中的数值数据汇总到具有唯一行名的结果表,其中值使用自定义函数进行汇总.摘要逻辑是:如果最大值与最小值的比率<1.5,则使用值的均值,否则使用中值.因为表非常大,我试图在reshape2包中使用melt()和cast()函数.
# example table with non-unique row-names
tab <- data.frame(gene=rep(letters[1:3], each=3), s1=runif(9), s2=runif(9))
# melt
tab.melt <- melt(tab, id=1)
# function to summarize with logic: mean if max/min < 1.5, else median
summarize <- function(x){ifelse(max(x)/min(x)<1.5, mean(x), median(x))}
# cast with summarized values
dcast(tab.melt, gene~variable, summarize)
上面的最后一行代码会导致错误通知.
Error in vapply(indices, fun, .default) : values must be type 'logical', but FUN(X[[1]]) result is type 'double' In addition: Warning messages: 1: In max(x) : no non-missing arguments to max; returning -Inf …
我有一个对象集合,每个对象都有一个位字段枚举属性.我想要得到的是整个集合中位字段属性的逻辑OR.如何通过循环遍历集合(希望使用LINQ和lambda)来完成此操作？
这是我的意思的一个例子:
[Flags]
enum Attributes{ empty = 0, attrA = 1, attrB = 2, attrC = 4, attrD = 8}
class Foo {
Attributes MyAttributes { get; set; }
}
class Baz {
List<Foo> MyFoos { get; set; }
Attributes getAttributesOfMyFoos() {
return // What goes here?
}
}
我试过这样用.Aggregate:
return MyFoos.Aggregate<Foo>((runningAttributes, nextAttributes) =>
runningAttributes | nextAttribute);
但这不起作用,我无法弄清楚如何使用它来得到我想要的东西.有没有办法使用LINQ和一个简单的lambda表达式来计算这个,或者我只是在集合上使用循环？
注意:是的,这个示例案例很简单,基本foreach将是要走的路,因为它简单且不复杂,但这只是我实际使用的简化版本.
我有一个表,其中包含一系列与时间段相关的条目(具体来说,是为客户工作的时间):
task_time:
id | start_time | end_time | client (fk)
1 08/12/2011 14:48 08/12/2011 14:50 2
我试图从我的Django应用程序聚合给定客户端的所有工作时间:
time_worked_aggregate = models.TaskTime.objects.\
filter(client = some_client_id).\
extra(select = {'elapsed': 'SUM(task_time.end_time - task_time.start_time)'}).\
values('elapsed')
if len(time_worked_aggregate) > 0:
time_worked = time_worked_aggregate[0]['elapsed'].total_seconds()
else:
time_worked = 0
这似乎不优雅,但确实有效.或者至少我认为:事实证明它在PostgreSQL数据库上工作正常,但当我转移到SQLite时,一切都会消失.
一点挖掘表明,其原因是DateTimes不是SQLite中的一流数据.以下原始SQLite查询将完成我的工作:
SELECT SUM(strftime('%s', end_time) - strftime('%s', start_time)) FROM task_time WHERE ...;
我的问题如下:
我应该提一下,数据集是数千个条目; 以下不太实际:
sum([task_time.end_date - task_time.start_date for task_time in models.TaskTime.objects.filter(...)])
我试图使用嵌套聚合函数和分组来获得平均值.我想要做的是:
SELECT AVG(SUM(x) GROUP BY y) WHERE ... GROUP BY ...;
也就是说,对于返回的每一行,我希望其中一个字段是和的平均值,其中每个和是在y相同的行上.
如果可能的话,我想避免使用子选择.
我的SQL有点生疏,我遇到这个问题有点困难.假设我有一个带有Timestamp列和Number列的表.目标是返回包含某个任意选择的常规间隔的平均值的结果集.
因此,例如,如果我有以下初始数据,则间隔为5分钟的结果输出如下:
time value
------------------------------- -----
06-JUN-12 12.40.00.000000000 PM 2
06-JUN-12 12.41.35.000000000 PM 3
06-JUN-12 12.43.22.000000000 PM 4
06-JUN-12 12.47.55.000000000 PM 5
06-JUN-12 12.52.00.000000000 PM 2
06-JUN-12 12.54.59.000000000 PM 3
06-JUN-12 12.56.01.000000000 PM 4
OUTPUT:
start_time avg_value
------------------------------- ---------
06-JUN-12 12.40.00.000000000 PM 3
06-JUN-12 12.45.00.000000000 PM 5
06-JUN-12 12.50.00.000000000 PM 2.5
06-JUN-12 12.55.00.000000000 PM 4
请注意,这是一个Oracle数据库,因此特定于Oracle的解决方案可以正常工作.当然,这可以通过存储过程完成,但我希望在单个查询中完成任务.
分组时,ng-grid会创建与常规行不同的组行.特别是,组行不显示常规列,但显示由aggregateTemplate定义的单个合并行.我正在尝试做的是自定义组行以包括聚合列数据.例如:
列:
NAME | VALUE
数据:
name1 | 5
name1 | 5
name2 | 1
按NAME分组时显示的网格:
- name1 | 10(这是扩展的第一组行)
- name1 | 5(这些是实际的数据行)
- name1 | 5(这些是实际的数据行)
- name2 | 1(这是折叠的第二组行)
请注意,组行显示两列,其VALUE等于其子项的总和.
如果您熟悉ms excel数据透视表,那就是我正在尝试模拟的分组类型功能.
关于堆栈溢出的类似问题(如何使用ng-grid中的分组设置聚合)显示了如何进行子聚合计算的示例,但我仍然坚持如何让ng-grid像常规行一样显示输出有单独的列.看看ng-grid代码,它看起来不是一件容易的事.有人有这方面的经验吗？
谢谢!
使用Scala标准库时,我可以做这样的事情:
scala> val scalaList = List(1,2,3)
scalaList: List[Int] = List(1, 2, 3)
scala> scalaList.foldLeft(0)((acc,n)=>acc+n)
res0: Int = 6
从许多Int中取出一个Int.
我可以这样做:
scala> scalaList.foldLeft("")((acc,n)=>acc+n.toString)
res1: String = 123
从许多Int中制作一个String.
因此,foldLeft可以是同构的,也可以是异构的,无论我们想要什么,它都在一个API中.
在Spark中,如果我想要很多Int中的一个Int,我可以这样做:
scala> val rdd = sc.parallelize(List(1,2,3))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:12
scala> rdd.fold(0)((acc,n)=>acc+n)
res1: Int = 6
fold API类似于foldLeft,但它只是同类的,RDD [Int]只能生成带折叠的Int.
Spark中也有一个聚合API:
scala> rdd.aggregate("")((acc,n)=>acc+n.toString, (s1,s2)=>s1+s2)
res11: String = 132
它是异构的,RDD [Int]现在可以生成一个String.
那么,为什么fold和聚合在Spark中实现为两个不同的API？
为什么它们的设计不像foldLeft那样可以是同构的还是异构的？
(我对Spark很新,请原谅我这是一个愚蠢的问题.)
scala aggregate heterogeneous homogenous-transformation apache-spark
这些是Oracle docs的引文：
[可选]通过合并两个聚合上下文合并并返回单个上下文。此操作组合子集上的聚合结果，以获得整个集合上的聚合。在对集合进行串行或并行评估时，可能需要执行此额外步骤。如果需要，它在步骤4之前执行：
，
在此类汇总操作中，将调用ODCIAggregateMerge（）接口来计算超级聚合值。
我们有一个聚合函数，我们不想并行运行。
原因是上下文的合并将消耗资源，并且将迫使我们使用与现在使用的数据结构不同的数据结构，从而有效地抵消了并行执行带来的任何性能优势。
因此，我们没有将函数声明为parallel_enabled，而是以防万一的方式返回ODCIAggregateMerge中的ODCIconst.Error。
但是，第一个引用文档声称，即使在串行评估中也可能发生合并。
超级聚合（汇总，多维数据集）是明显的示例，但是还有其他示例吗？
我完全无法通过简单的分组依据来重现它，如果没有parallel_enabled，就永远不会调用merge，并且似乎在该分组中始终只创建一个上下文。
是否可以安全地假设没有parallel_enabled设置，合并将永远不会运行？
您见过该规则的反例吗？