Reactive Applications with Akka.NET
Anthony Brown
  • MEAP began January 2016
  • Publication in Spring 2017 (estimated)
  • ISBN 9781617292989
  • 375 pages (estimated)
  • printed in black & white

Developing applications in a reactive style ensures that the experience is always responsive. Akka.NET is a framework for building distributed, message-driven applications which are able to stay responsive for the user even in the face of failure or when faced with more users. It makes it easy for .NET developers to write applications which are able to react to changes in their environment.

Reactive Applications with Akka.NET begins with an overview of reactive and a sample application written in the reactive style. You'll learn concepts of the actor model and what these mean in a real-world reactive context. This hands-on book builds on fundamental concepts to teach you how to create reliable and resilient applications. You'll also learn useful Akka.NET features for building real-world applications. By the end of the book, you'll be able to look at a problem domain and understand how to create applications which are able to withstand the demands of a modern day application.

Table of Contents detailed table of contents

Part 1: The road to reactive

1. Why Reactive?

1.1. Why the need for reactive systems

1.1.1. Requirements for users

1.1.2. Requirements for businesses

1.2. The reactive methodology

1.3. The routes to reactive

1.3.1. Akka.Net— Actor based concurrency

1.3.2. Reactive Extensions — Event based concurrency

1.4. What this book will teach you

1.5. Summary

2. Reactive Application Design

2.1. Designing an Application with Reactive traits

2.1.1. Representing entities in our reactive system

2.1.2. The flow of data

2.1.3. Processing complex tasks

2.1.4. Reading data

2.1.5. The application so far

2.2. Handling failure

2.2.1. Sensors break

2.2.2. Sensor data connection fails

2.2.3. Data ingestion node fails

2.2.4. A sensor actor fails

2.2.5. A room actor fails

2.2.6. View fails

2.2.7. Failure recovery summary

2.3. Summary

Part 2: Digging in

3. Your First Akka.Net Application

3.1. Setting up an application

3.2. Actors

3.2.1. What does an actor embody?

3.2.2. What can an actor do?

3.2.3. Defining an actor

3.2.4. Summary

3.3. Spawning an actor

3.3.1. The actor system

3.3.2. Spawning an actor

3.3.3. Summary

3.4. Communicating with actors

3.4.1. Actor addresses and references

3.4.2. Sending a message

3.4.3. Summary

3.5. Summary

4. State, behavior and actors

4.1. Preparing for the next message

4.2. Setting appropriate receive behaviour in Akka.Net

4.2.1. Switchable behaviours

4.2.2. Become and Unbecome

4.2.3. Switchable behaviour summary

4.3. Finite State Machines

4.3.1. Understanding Finite State Machines

4.3.2. The use in a concurrency model

4.3.3. Converting a finite state machine to an actor

4.3.4. Using the Finite State Machine actor

4.3.5. Finite state machines summary

4.4. Summary

5. Configuration, Dependency Injection and Logging

5.1. Why do we need configuration?

5.2. Configuring an actor deployment

5.2.1. Understanding Props

5.2.2. Actor configuration summary

5.3. Dependency Injection

5.3.1. Introducing dependency injection[2]

5.3.2. Configuring an Inversion of Control container

5.3.3. Dependency injection summary

5.4. Hocon — A human readable configuration file format

5.4.1. What is HOCON?

5.4.2. Loading configuration into an actor system

5.4.3. HOCON Summary

5.5. Logging

5.5.1. Why do we need logging?

5.5.2. Writing to the log

5.5.3. Customising a logger deployment

5.5.4. Logging summary

5.6. Configuration, Dependency Injection and Logging Summary

6. Failure Handling

6.1. Understanding failures

6.2. Handling application level failures

6.2.1. Responding to application errors

6.2.2. The Akka.Net supervision tree

6.2.3. Failing fast

6.2.4. The actor lifecycle

6.2.5. Watching for the deaths of other actors

6.2.6. Interface level failures

6.2.7. Application level failures summary

6.3. Understanding transport level failures

6.3.1. Writing applications which handle message loss

6.3.2. Transport level failure summary

6.4. Handling failures summary

7. Scaling in reactive systems

7.1. Scaling up and scaling out

7.2. Distributing work

7.2.1. Routers

7.2.2. Pools and groups

7.2.3. Distributing work summary

7.3. Routing strategies within Akka.Net

7.3.1. Random routing

7.3.2. Round robin routing

7.3.3. Shortest mailbox queue

7.3.4. Consistent hashing

7.3.5. Scatter gather first completed

7.3.6. Tail chopping router

7.3.7. Routing strategies summary

7.4. Scaling reactive systems summary

8. Composing actor systems

8.1. Introducing Akka.Net Remoting

8.2. Preparing to use remoting

8.3. Communicating with remote actors

8.3.1. Remote actor system addresses

8.3.2. Sending messages to remote actors

8.3.3. Remote deployment of actors

8.3.4. Remote actor communication summary

8.4. Elastic scale across machines

8.4.1. Configuring a router to use multiple machines

8.5. Failure handling across machines

8.5.1. Supervisor strategies across a network

8.5.2. Remoting deathwatch

8.5.3. Failure handling across machines summary

8.6. Akka.Remote security

8.6.1. Limiting messages able to be sent over the network

8.6.2. Restricting available remote actor targets

8.6.3. Akka.Remote security summary

8.7. Composing actor systems summary

Part 3: Real-life usage

9. Testing Akka.Net actors

9.1. Introducing Akka.TestKit

9.2. Unit testing actors

9.2.1. Spawning test actors

9.2.2. Validating internal data

9.2.3. Testing FSMs

9.2.4. Unit Testing Actors summary

9.3. Integration testing actors

9.3.1. Creating test specifications

9.3.2. Asserting message responses

9.3.3. Time based testing

9.3.4. Test probes

9.3.5. Integration testing actors summary

9.4. Testing distributed applications with the MultiNodeTestKit

9.4.1. Multinode specs

9.4.2. Running code on individual actor systems

9.4.3. Barriers

9.4.4. Testing for network failure

9.4.5. Multinodetestkit summary

9.5. Akka.TestKit Summary

10. Integrating Akka.Net

10.1. Integrating with ASP.Net

10.2. Integrating with SignalR

10.2.1. Communicating through an actor

10.2.2. Connecting to the user's web browser

10.2.3. Integrating with SignalR summary

10.3. Custom integrations with Akka.IO

10.3.1. Creating a listen server

10.3.2. Sending data through Akka.IO

10.3.3. Akka.IO Summary

10.4. Integrating Akka.Net summary

11. Persisting data

12. Clustering capabilities

What's inside

  • Real-world applications of Akka.NET and reactive applications
  • Designing an Internet of Things architecture with reactive in mind
  • Building applications to handle the demands of the modern era of software
  • Integrating Akka.NET with your existing .NET stack
  • Deploying Akka.NET applications to the cloud

About the reader

Readers should be comfortable with C# or F# and the .NET framework. No previous reactive experience needed.

About the author

Anthony Brown has been developing software for several years, primarily using the .NET framework. He's a regular speaker at conferences on tools and techniques to rapidly build systems that work.

Manning Early Access Program (MEAP) Read chapters as they are written, get the finished eBook as soon as it’s ready, and receive the pBook long before it's in bookstores.
Buy
  • MEAP combo $44.99 pBook + eBook
  • MEAP eBook $35.99 pdf + ePub + kindle

FREE domestic shipping on three or more pBooks