标签: composition

我将尝试在一个简单的例子中提出我的问题......

假设我有一个抽象的基类Car.Car有一个基本的Engine对象.我在抽象Car类中有一个方法StartEngine(),它将引擎的起始委托给Engine对象.

如何允许Car的子类(如法拉利)将Engine对象声明为特定类型的引擎(例如,TurboEngine)？我需要另一个Car class(TurboCar)吗？

我正在继承一个普通的旧Engine对象,我不能在我的Car子类中重新声明(或覆盖)它作为TurboEngine.

编辑: 我知道我可以在我的法拉利课程中将任何Engine的子类插入myEngine参考中...但是我怎样才能调用只有TurboEngine暴露的方法？因为myEngine是作为基础引擎继承的,所以没有包含任何turbo内容.

谢谢!

当我阅读有关Ruby元编程的更多信息时,大多数时候我们发现至少有两种解决方案来解决问题.请看下面两个例子:

class Base
  def self.has_many(*args)
    # ...
  end
end

class Student < Base
  has_many :books
end

另一种风格:

module Base
  def self.included(klass)
    klass.extend ClassMethods
  end

  module ClassMethods
    def has_many(*args)
      # ...
    end
  end
end

class Student
  include Base

  has_many :books
end

但是当我们设计api时,我们必须决定使用哪一个,但我想问一下大多数人已经在他们的库中实现的想法和一些最佳实践.

我正在考虑使用MEF来解决插件管理要求.在模糊中它表示"没有硬依赖",但据我所知,导入/导出界面存在严重依赖.

我担心的是这个.我的可扩展应用程序是由我编写的.插件由第三方编写.所以我们都说从V1开始.我的应用程序定义了IPlugin插件"部件"需要实现的接口.我们部署应用程序,用户安装了一堆第三方插件.一切都很好.

现在我升级了我的应用程序,我想在插件界面中添加一个新方法.我看到它的方式我有两个选择:

1. 编辑界面 - 可能不好,这会破坏现有插件,因为它们将不再正确实现界面.

2. 创建一个新的'V2'接口,继承自原始接口

   公共接口IPluginV2:IPlugin {}

现在我有一个问题.我的用户都有一堆第三方插件实现IPlugin,但我现在要求他们实现IPluginV2.我认为这些第三方插件将不再有效,直到开发人员实现新界面.

MEF有办法处理这种情况吗？我真的在寻找一种让我可以改进我的应用程序的方法,同时让旧的插件继续工作而不必重建.什么是最好的处理方式？

我理解mixin看起来像继承,但更像是组合.
(编辑:我倾向于giving additional functionality/attributes通过mixin 思考而不是giving another is-a relationship.)在
心理上,当我使用mixin时,我说的是这样的东西:我给你这个你缺少的mixin,而不是你实际上也是这个mixin-type. (IS-A)

我读了几遍,你应该更喜欢作文而不是继承.

我们可以使用直接的成分而不是mixins,什么是mixin？

如果我不得不猜测,那是因为my_instance.foo()比my_instance.another_instance.foo()更容易吗？
(如果mixin有foo(),你可以使用my_instance.foo(),当你将another_instance复合为my_instance的属性时,你需要my_instance.another_instance.foo()

还有其他原因吗？

编辑:

所以即使我觉得它有一个-a,但mixin仍然是一种关系.当你使用is-a时,你得到的好处是更清洁的界面.那就是我如何理解德尔南的答案.

我想撰写成员指针.基本上我有一个不同成员的主类.如何为主类创建一个指向该类成员的成员指针.我希望下面的代码解释我正在尝试做什么:

  struct SubUnit
  {
    int   value;
  };
  struct Unit
  {
    SubUnit sub_unit;
  };

  void Test()
  {
    SubUnit Unit::* ptr1 = &Unit::sub_unit; // WORKING
    int Unit::* ptr2 = &Unit::sub_unit::value; // NOT WORKING !
  }

请考虑以下有关函数组合的Python代码段:

from functools import reduce
def compose(*funcs):
    # compose a group of functions into a single composite (f(g(h(..(x)..)))
    return reduce(lambda f, g: lambda *args, **kwargs: f(g(*args, **kwargs)), funcs)


### --- usage example:
from math import sin, cos, sqrt
mycompositefunc = compose(sin,cos,sqrt)
mycompositefunc(2)

我有两个问题:

1. 有人可以解释一下compose"操作逻辑"吗？(这个怎么运作？)
2. 是否可以(以及如何？)在不使用reduce的情况下获得相同的东西？

我已经看过这里,这里和这里,我的问题是不明白是什么lambda意思或reduce做(例如,我认为我2在使用示例中将有点是funcs要编写的第一个元素).我发现更难理解的是两者如何lambda组合/嵌套并在*args, **kwargs这里作为reduce第一个参数混合的复杂性......

编辑:

首先,@ Martijn和@Borealid,感谢您的努力和答案以及您献给我的时间.(抱歉延误,我在业余时间这样做,并不总是有很多......)

好的,现在来看看事实......

关于我的问题的第1点: …

考虑以下Haskell定义,取自YouTube上优秀的Haskell视频:

import Data.List
greeting = "Hello"
swedish = intersperse 'f'
very f x = f (f (f x))

如果我们将它们加载到GHCi中,我们会看到以下结果:

ghci> swedish greeting
"Hfeflflfo"
ghci> very swedish greeting
"Hfffffffeffffffflffffffflfffffffo"
ghci> very very swedish greeting
"Hffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
fffffffffffffffffffffffffffff... (536,870,913 chars total)

前两个输出我完全理解.A swedish greeting出现穿插fs,a very swedish greeting只是a swedish (swedish (swedish greeting)),穿出三次.

但究竟在第三个输入线上发生了什么？我对Haskell语法的理解(相当不完整)表明,以空格分隔的表达式序列被解释为函数调用,其中第一个表达式是函数,其余表达式是参数.在这种情况下,如何在最外层very被称为三个参数(very,swedish,和greeting)时,它只能定义为接受两个？

如果它有帮助,似乎a very very swedish greeting等同于a swedish $ swedish $ swedish $ swedish $ …

如何将效果应用于ListView,其中前30px从完全透明变为完全不透明？我们的想法是,当您向下滚动时,顶部项目逐渐消失.

我正在构建一个UWP应用程序,其中设计要求ListView的前30px从不透明度0开始并转换为不透明度1.从概念上讲,我想象一个不透明蒙版将应用于SpriteVisual的顶部但我无法工作如何实现这一目标.

我正在尝试使用Windows 10,Composition和Win2D的周年纪念版.

编辑:一张图片可能会刷1000字:

如果查看此图像,左下角和右下角有两个内容元素.虽然背景看起来是黑色的,但它实际上是一个渐变.如果您检查两个元素的顶部,它们会变得更加透明,通过背景显示.这就是我想要达到的效果.

编辑2:为了显示我正在寻找的效果的结果,这里有一个GIF,如果我使用重叠的位图,它会显示效果:

标题背景图片是:

较低的30px具有alpha渐变并且出现在网格视图上方,使得网格视图项目的明显效果逐渐淡出并在背景下滑动.

XAML布局如下所示:

<Page
x:Class="App14.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:App14"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">
<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="150" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>

    <Image Source="/Assets/background.png"
           Grid.Row="0"
           Grid.RowSpan="2"
           VerticalAlignment="Top"
           Stretch="None" />

    <GridView Grid.Row="1"
              Margin="96,-30,96,96">
        <GridView.Resources>
            <Style TargetType="Image">
                <Setter Property="Height" Value="400" />
                <Setter Property="Width" Value="300" />
                <Setter Property="Margin" Value="30" />
            </Style>
        </GridView.Resources>
        <Image Source="Assets/1.jpg" />
        <Image Source="Assets/2.jpg" />
        <Image Source="Assets/3.jpg" />
        <Image Source="Assets/4.jpg" />
        <Image Source="Assets/5.jpg" />
        <Image Source="Assets/6.jpg" />
        <Image Source="Assets/7.jpg" />
        <Image Source="Assets/8.jpg" />
        <Image Source="Assets/9.jpg" …

对于简单的函数组合,是否有"do notation"语法糖？

(即(.) :: (b -> c) -> (a -> b) -> a -> c)

我希望能够存储一些成分的结果供以后使用(同时仍然继续链.

如果可能的话,我宁愿不使用RebindableSyntax扩展.

我正在寻找这样的东西:

composed :: [String] -> [String]
composed = do
    fmap (++ "!!!")
    maxLength <- maximum . fmap length
    filter ((== maxLength) . length)

composed ["alice", "bob", "david"]
-- outputs: ["alice!!!", "david!!!"]

我不确定这样的事情是否可能,因为早期函数的结果基本上必须通过"通过"maxLength的绑定,但我愿意听到任何其他类似的表达选项.基本上我需要收集信息,因为我通过合成以便以后使用它.

也许我可以用状态monad做这样的事情？

谢谢你的帮助!

编辑

这种事情有点起作用:

split :: (a -> b) -> (b -> a -> c) -> a -> c
split ab bac a = bac (ab a) a

composed …

我正在尝试重新创建一个过程，以创建一个对象列表，该对象列表是使用Java 8 Streams的另一个对象列表的集合。

例如，我有一个如下所述的类，它是通过数据库调用或类似方法提供的

public class Order {

    private String orderNumber;        
    private String customerNumber;
    private String customerGroup;
    private Date deliveryDate;
    private double orderValue;
    private double orderQty;
}

在我的应用程序的其他地方，我有一个OrderTotal类，该类代表和汇总按客户编号和组分组的Order分组，并汇总orderValue和orderQty的总数。（在customerGroup和customerNumber上使用等于和哈希码）

public class OrderTotal {

    private String customerGroup;
    private String customerNumber;
    private double totalValue;
    private double totalQty;
}

我们在Java 8之前实现这一目标的“长手”方法如下

public Collection<OrderTotal> getTotals(List<Order> orders) {
    ///map created for quick access to the order total for each order 
    Map<OrderTotal, OrderTotal> map = new HashMap<>();
    ///loop through all orders adding to the relevaent order total …