Une bonne implémentation des acteurs pour C #?
Existe-t-il une bonne implémentation de modèle de concurrence des acteurs pour .net/c #?
Je dois optimiser une routine c # et je pense que le modèle des acteurs convient parfaitement comme solution à mon problème. Malheureusement, je n'ai d'expérience qu'avec l'implémentation scala.
Vous devriez jeter un œil à MS Concurrency & Coordination Runtime (CCR) , et Decentralized Software Services (DSS) , partie de Robotic Studio .
Ces cadres vous permettraient de développer des services faiblement couplés qui répondent à la plupart des exigences d'approche des acteurs.
Axum serait le meilleur ajustement, malheureusement, il est toujours dans une sorte de phase alpha/bêta (MISE À JOUR, il a été tué en février 2011). Je l'utilise pour mes recherches et je dois dire que la direction générale est grande et elle a un énorme potentiel.
Pas C # mais C++ est Microsoft Asynchronous Agents Library qui vous donne toutes les fonctionnalités dont vous avez besoin.
Jetez un bon coup d'œil à Fonctionnalités connexes en parallèle de .NET 4.
J'espère que cela aide!
Cadres du modèle d'acteur .NET:
Proto.Actor
- Acteurs
- Acteurs virtuels
https://github.com/AsynkronIT/protoactor-dotnet
Akka.NET
- Acteurs
https://github.com/akkadotnet/akka.net
Microsoft Orléans
- Acteurs virtuels
On pourrait également regarder l'approche du Projet Orleans Microsofts sur les acteurs (qui a été publiée la semaine dernière)
Il s'agit du site Web des projets: http://research.Microsoft.com/en-us/projects/orleans/
Voici également une bonne présentation de Build 2014 comme introduction
Utilisation d'Orléans pour créer les services cloud distribués de Halo 4 dans Azure http://channel9.msdn.com/Events/Build/2014/3-641
Veuillez noter que les bits à télécharger tels que publiés aujourd'hui sont CTP.
Introduction à Orléans: http://felixnotes.com/orleans-microsofts-take-on-the-actor-pattern-in-net/
Et oui, il était également open source: https://github.com/dotnet/orleans
Stact
Un acteur-lib sur .Net. Assez compétent et bien testé. La fondation de TopShelf, MassTransit et NServiceBus.Host.
https://github.com/phatboyg/stact
Contient les abstractions:
- Workflow, permettant de définir et d'exécuter des protocoles complexes pilotés par l'état
- Canaux, pour prendre en charge le passage de messages entre les objets
- Acteurs, dactylographiés et anonymes
- Les fibres, un modèle de filetage coopératif
- Acheminement
- Demande/réponse
- Planificateurs
A venir:
- Hiérarchies appropriées des superviseurs
Être activement développé au moment de la rédaction de Chris.
Aperçu:
Le développement d'applications simultanées nécessite une approche qui s'écarte des méthodes de développement logiciel actuelles, une approche qui met l'accent sur la concurrence et la communication entre les composants du système autonome. Le modèle d'acteur définit un système de composants logiciels appelés acteurs qui interagissent les uns avec les autres en échangeant des messages (au lieu d'appeler des méthodes sur des interfaces dans une conception orientée objet), produisant un système dans lequel les données (au lieu du contrôle) traversent les composants pour se rencontrer les exigences fonctionnelles du système.
Stact est une bibliothèque de création d'applications utilisant le modèle d'acteur dans .NET. L'assembly principal, Stact.dll, est la bibliothèque d'acteurs et comprend tout le nécessaire pour utiliser le modèle d'acteur dans tout type d'application. Il existe également des cadres de prise en charge supplémentaires, tels que Stact.ServerFramework, qui peuvent être utilisés pour exposer des acteurs via des sockets ou HTTP, permettant aux services d'être créés à l'aide d'acteurs.
NAct est un framework d'acteurs pour .NET qui adopte une approche vraiment facile à utiliser. (Avertissement: je l'ai écrit)
Le message qui passe entre deux acteurs n'est qu'un appel de méthode entre deux objets. Vous devez vous assurer que tous les arguments de méthode sont immuables, et ils seront thread-safe.
Il fonctionne en enveloppant vos objets dans un proxy qui traite de la commutation des threads. Toutes les fonctionnalités normales de .NET, en particulier les événements, sont traitées correctement, vous pouvez donc écrire du code normal et le regroupement des threads se fera de lui-même.
Il y a même une branche avec le support de C # 5 async/wait.
Aujourd'hui, Microsoft a annoncé Azure Service Fabric qui, selon cette image, implémente un modèle de programmation d'acteur:
Voir l'annonce: http://Azure.Microsoft.com/blog/2015/04/20/announcing-Azure-service-fabric-reducing-complexity-in-a-hyper-scale-world/ =
Mise à jour: le SDK est maintenant disponible et il y a aussi un tutoriel vidéo .
Je ne connais aucune implémentation pour C #, mais il existe un tout nouveau langage de programmation basé sur le modèle Actor de Microsoft. Cela s'appelle Axum :
Axum(anciennement appeléMaestro) est un langage de programmation simultanée spécifique à un domaine, basé sur le modèle Actor, développé par Microsoft. Il s'agit d'un langage orienté objet basé sur le .NET Common Language Runtime utilisant une syntaxe de type C qui, étant un langage spécifique au domaine, est destiné au développement de portions d'une application logicielle bien adaptée à la concurrence. Mais il contient suffisamment de constructions à usage général pour qu'il ne soit pas nécessaire de passer à un langage de programmation à usage général (comme C #) pour les parties séquentielles des composants simultanés.
Vous devriez également considérer PostSharp Actors
Avez-vous pensé à MailboxProcessor of T, fourni avec F #?
Remact.Net est mon projet actuel. Il utilise WebSockets et Json pour la messagerie des acteurs distants. Il a une sécurité de type pour les acteurs C # mais prend également en charge les types dynamiques pour les acteurs basés sur un navigateur écrits en Java.
Mon projet précédent était AsyncWcfLib . Il s'agit d'une bibliothèque C # pour les acteurs communiquant dans un processus ou entre différentes applications. Le message distant transmis utilise WCF.
Un service de catalogue d'acteurs permet la découverte d'acteurs sur plusieurs hôtes. Les hôtes peuvent exécuter Windows ou Linux.
Comme déjà mentionné, la classe MailboxProcessor de F # offre une implémentation simple et directe du modèle d'acteur. Une fantastique introduction sur la façon de l'utiliser est disponible ici . F # interagit très bien avec C # et vous pouvez encapsuler l'agent dans une classe avec des méthodes qui affichent différents messages. Pour les cas où l'agent répondra par une réponse asynchrone, consultez la méthode PostAndAsyncRhness . Cela renvoie un flux de travail Async que vous pouvez transformer en une tâche qui peut être attendue en C # en utilisant la méthode Async.StartAsTask .
Enfin, si vous devez distribuer vos acteurs à distance, je vous recommande de consulter Akka.NET qui propose à la fois des API C # et F #.
Je viens de remarquer cette question et j'ai pensé ajouter un nouveau point de données. Microsoft a actuellement un projet semi-officiel pour cela, appelé ActorFX . Il est open source et continue d'évoluer, mais mérite d'être surveillé ...
FSharp.Actor
Un framework d'acteur pour F #.
À partir d'un exemple:
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()
)
L'envoi de deux messages à l'acteur "schizo" entraîne
let schizo = Actor.spawn (Actor.Options.Create("schizo")) schizoPing
!!"schizo" <-- "Hello"
!!"schizo" <-- "Hello"
Production:
(schizo): "Hello" ping
(schizo): "Hello" pong