Events 在F中实现委托接口#

我想在F中实现以下C#接口#

接口
{  
作废处理（foo输入）；
事件行动结果；
} 

但是，我在活动/代表部分失败：

type doSomething() =
    let result = new Event<System.Action<bar>>()    
    interface IDoSomeThing with
        [<CLIEvent>]
        member x.Result = result.Publish 
          // This expression was expected to have type
          // Handler<System.Action<foobar>>    
          //  but here has type
          // System.Action<foobar>  

类型doSomething（）=
让结果=新事件（）
接口
[]
成员x.Result=Result.Publish
//此表达式应具有类型
//处理者
//但这里有一种类型
//系统.行动

你知道怎么做吗

解决方案

type doSomething() =
    let e =  DelegateEvent<_>()  
    let result s = e.Trigger ([| box s |]) 

    let calc input = 
        input 
        |> (...) // The real processing happens here 
        |> result

    interface IDoSomething with
        member x.Process input = calc input
        [<CLIEvent>]
        member x.Result = e.Publish

类型doSomething（）=
设e=DelegateEvent（）
让结果s=e.触发器（[|框s |]）
让计算输入=
输入
|>（…）//真正的处理发生在这里
|>结果
接口
成员x.过程输入=计算输入
[]
成员x.结果=e.发布

由于您的界面定义了非标准事件类型，因此您必须使用

DelegateEvent

而不是（更常见的）

事件

类型DoSomething（）=
let result=DelegateEvent（）
接口
成员x.Process（输入：Foo）=（）
[]
成员x.Result=Result.Publish
由于您的界面定义了非标准事件类型，因此您必须使用
DelegateEvent
而不是（更常见的）
事件

类型DoSomething（）=
let result=DelegateEvent（）
接口
成员x.Process（输入：Foo）=（）
[]
成员x.Result=Result.Publish
由于您的界面定义了非标准事件类型，因此您必须使用
DelegateEvent
而不是（更常见的）
事件

类型DoSomething（）=
let result=DelegateEvent（）
接口
成员x.Process（输入：Foo）=（）
[]
成员x.Result=Result.Publish
由于您的界面定义了非标准事件类型，因此您必须使用
DelegateEvent
而不是（更常见的）
事件

类型DoSomething（）=
let result=DelegateEvent（）
接口
成员x.Process（输入：Foo）=（）
[]
成员x.Result=Result.Publish
请参见此处的“实现接口事件”部分：注意，在这种情况下，您可以直接与
[]
一起使用-只需注意，您必须像
操作（趣味栏->…）一样包装操作。
请参见此处的“实现接口事件”部分：注意，在这种情况下，您可以与
[]一起使用
直接-只需注意，您必须像
操作（乐趣栏->…）那样包装操作。
请参阅此处“实现接口事件”一节：注意，在这种情况下，您可以直接与
[]
一起使用-只需注意，您必须像
操作（乐趣栏->…）那样包装操作。
请参阅此处的“实现接口事件”：请注意，在这种情况下，您可以直接与
[]
一起使用-只需注意，您必须像
操作（趣味栏->…）那样包装操作。
type doSomething() =
    let e =  DelegateEvent<_>()  
    let result s = e.Trigger ([| box s |]) 

    let calc input = 
        input 
        |> (...) // The real processing happens here 
        |> result

    interface IDoSomething with
        member x.Process input = calc input
        [<CLIEvent>]
        member x.Result = e.Publish

type DoSomething() =
    let result = DelegateEvent<_>()
    interface IDoSomething with
        member x.Process(input: Foo) = ()
        [<CLIEvent>]
        member x.Result = result.Publish