你遇到的问题核心是F#和C#对protected嵌套类型的访问规则差异：C#允许派生类直接引用基类的protected嵌套属性，但F#的访问限制更严格，无法在派生类的属性标注中直接访问基类的protected嵌套属性（比如Actor类内部定义的OnEventDoActionAttribute）。

不过不用担心，有两种可靠的解决方案：

方案1：手动注册事件处理器（推荐，纯F#实现） #

Coyote的Actor类提供了RegisterEventHandler方法，允许你在代码中手动绑定事件和处理函数，完全不需要依赖那个protected属性。这是更符合F#惯用风格的做法。

修改后的完整代码如下：

open System
open Microsoft.Coyote.Actors
open Microsoft.Coyote.Testing

type SetupEvent(serverId : ActorId) = 
    inherit Event() 
    member this.ServerId = serverId

type PingEvent(callerId : ActorId) = 
    inherit Event() 
    member this.Caller = callerId

type PongEvent() = inherit Event()

type Server() = 
    inherit Actor()
    
    override this.OnInitializeAsync(initialEvent: Event) =
        // 手动注册PingEvent的处理器
        this.RegisterEventHandler(typeof<PingEvent>, fun e -> this.HandlePing(e))
        base.OnInitializeAsync(initialEvent)

    member private this.HandlePing(e : Event) =
        let ping = e :?> PingEvent
        printfn "Server handling ping"
        printfn "Server sending pong back to caller"
        this.SendEvent(ping.Caller, PongEvent())

type Client() = 
    inherit Actor()
    let mutable serverId : ActorId = null

    override this.OnInitializeAsync(initialEvent : Event) : System.Threading.Tasks.Task =
        // 手动注册PongEvent的处理器
        this.RegisterEventHandler(typeof<PongEvent>, fun _ -> this.HandlePong())
        printfn "%A initializing" this.Id
        serverId <- (initialEvent :?> SetupEvent).ServerId
        printfn "%A sending ping event to server" this.Id
        this.SendEvent(serverId, PingEvent(this.Id))
        base.OnInitializeAsync(initialEvent)

    member private this.HandlePong() =
        printfn "%A received pong event" this.Id

[<Test>]
let Execute (runtime : IActorRuntime) =
    let serverId = runtime.CreateActor(typeof<Server>)
    runtime.CreateActor(typeof<Client>, SetupEvent(serverId)) |> ignore
    runtime.CreateActor(typeof<Client>, SetupEvent(serverId)) |> ignore
    runtime.CreateActor(typeof<Client>, SetupEvent(serverId)) |> ignore

let runtime = RuntimeFactory.Create()
Execute(runtime) |> ignore
Console.ReadLine() |> ignore

方案2：用C#做中间基类（兼容属性方式） #

如果你更倾向于保留属性标注的方式，可以创建一个C#的抽象基类，在C#中应用OnEventDoActionAttribute，然后让F#类继承这个基类：

第一步：创建C#基类 #

using Microsoft.Coyote.Actors;

public abstract class ServerBase : Actor
{
    [OnEventDoAction(typeof(PingEvent), "HandlePing")]
    protected ServerBase() {}
}

public abstract class ClientBase : Actor
{
    [OnEventDoAction(typeof(PongEvent), "HandlePong")]
    protected ClientBase() {}
}

第二步：F#类继承这些基类 #

// ... 事件类型定义和之前一致 ...

type Server() = 
    inherit ServerBase()
    
    member this.HandlePing(e : Event) =
        let ping = e :?> PingEvent
        printfn "Server handling ping"
        printfn "Server sending pong back to caller"
        this.SendEvent(ping.Caller, PongEvent())

type Client() = 
    inherit ClientBase()
    let mutable serverId : ActorId = null

    override this.OnInitializeAsync(initialEvent : Event) : System.Threading.Tasks.Task =
        printfn "%A initializing" this.Id
        serverId <- (initialEvent :?> SetupEvent).ServerId
        printfn "%A sending ping event to server" this.Id
        this.SendEvent(serverId, PingEvent(this.Id))
        base.OnInitializeAsync(initialEvent)

    member this.HandlePong() =
        printfn "%A received pong event" this.Id

// ... 测试代码和之前一致 ...

为什么会出现这个问题？ #

简单来说：

• 在C#中，派生类可以直接访问基类的protected嵌套类型（包括属性），所以[OnEventDoAction(...)]可以正常工作。
• 在F#中，protected成员的可见性被限制在派生类的成员内部，而属性标注是在类的定义上下文（不属于成员内部），所以无法直接引用基类的protected嵌套属性。

内容的提问来源于stack exchange，提问作者Bent Rasmussen