Any good implementation of Actors for C#? [closed]

Answer 1

One might also look at Project Orleans Microsofts approach on actors.(which was released last week)

This is the projects website: http://research.microsoft.com/en-us/projects/orleans/

Here is also a good talk from build 2014 as introduction

Using Orleans to Build Halo 4’s Distributed Cloud Services in Azure http://channel9.msdn.com/Events/Build/2014/3-641

Please note that the bits for download as posted today are CTP.

Introduction to Orleans: http://felixnotes.com/orleans-microsofts-take-on-the-actor-pattern-in-net/

And yes, it was also open sourced: https://github.com/dotnet/orleans

Answer 2

NAct is an actors framework for .NET which takes a really easy-to-use approach. (Disclaimer: I wrote it)

The message passing between two actors is just a method call between two objects. You have to make sure that all method arguments are immutable, and it will be thread-safe.

It works by wrapping your objects in a proxy that deals with the thread switching. All the normal .NET features, particularly events, are dealt with correctly, so you can write normal code and thread marshalling will happen on its own.

There's even a branch with support for C# 5 async/await.

Answer 3

FSharp.Actor

An actor framework for F#.

From an example:

let rec schizoPing =
    (fun (actor:IActor<_>) ->
        let log = (actor :?> Actor.T<_>).Log
        let rec ping() =
            async {
                let! (msg,_) = actor.Receive()
                log.Info(sprintf "(%A): %A ping" actor msg, None)
                return! pong()
            }
        and pong() =
            async {
                let! (msg,_) = actor.Receive()
                log.Info(sprintf "(%A): %A pong" actor msg, None)
                return! ping()
            }
        ping()
    )

Sending two messages to the 'schizo' actor results in

let schizo = Actor.spawn (Actor.Options.Create("schizo")) schizoPing

!!"schizo" <-- "Hello"
!!"schizo" <-- "Hello"

Output:

(schizo): "Hello" ping
(schizo): "Hello" pong

Find it at github and at docs

Answer 4

Just noticed this question, and thought to add a newer data point. Microsoft currently has a semi-official project for this, called ActorFX. It's open source and still evolving, but worth keeping an eye on...

Answer 5

.NET Actor Model frameworks:

Proto.Actor

• Actors
• Virtual Actors

https://github.com/AsynkronIT/protoactor-dotnet

Akka.NET

• Actors

https://github.com/akkadotnet/akka.net

Microsoft Orleans

• Virtual Actors

https://github.com/dotnet/orleans

Answer 6

Remact.Net is my current project. It uses WebSockets and Json for the remote actor messaging. It has typesafety for C# actors but also supports dynamic types for browser based actors written in Java script.

My previous project was AsyncWcfLib. This is a C# library for actors communicating in a process or between different applications. The remote message passing uses WCF.
An actor catalog service enables actor discovery on several hosts.The hosts may run Windows or Linux.