Programação reativa e o actor model

Programação Reativa e o
Actor Model
Elemar Júnior
@elemarjr
elemarjr@ravendb.net
elemarjr@gmail.com
elemarjr.com

Antes de entender o que é
Programação Reativa, vamos
entender o que não é!

public static string[] GetNamesFromEmployees(Employee[] employees)
{
var result = new string[employees.Length];
for (var i = 0; i < employees.Length; i++)
{
result[i] = employees[i].Name;
}
return result;
}

public static List<string> GetNamesFromEmployees(List<Employee> employees)
{
var result = new List<string>(employees.Count);
foreach (var employee in employees)
{
result.Add(employee.Name);
}
return result;
}

public static IList<string> GetNamesFromEmployees(IList<Employee> employees)
{
var result = new List<string>(employees.Count);
{
}
return result;
}

public static IEnumerable<string> GetNamesFromEmployees(IEnumerable<Employee> employees)
{
var result = new List<string>();
{
}
return result;
}

public static IEnumerable<string> GetNamesFromEmployees(IEnumerable<Employee> employees)
{
{
yield return employee.Name;
}
}

using System.Collections.Generic;
using static System.Console;
public class Program
{
public static void Main()
{
WriteLine("Before calling Get4");
var elements = Get4();
WriteLine("After calling Get4");
foreach (var e in elements)
{
WriteLine(e);
}
}
public static IEnumerable<int> Get4()
{
for (var i = 1; i <= 4; i++)
{
WriteLine($"Before Yield {i}");
yield return i;
WriteLine($"After Yield {i}");
}
}
}

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4
After calling Get4

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4
After calling Get4
Before Yield 1

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4
After calling Get4
Before Yield 1
1

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4
After calling Get4
Before Yield 1
1
After Yield 1

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4
After calling Get4
Before Yield 1
1
After Yield 1
Before Yield 2

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
Before calling Get4
After calling Get4
Before Yield 1
1
After Yield 1
Before Yield 2
...

public static class EnumerableOfEmployees
{
public static IEnumerable<string> GetNames(IEnumerable<Employee> employees)
{
{
}
}
}
EnumerableOfEmployees.GetNames(someListOfEmployees);

{
public static IEnumerable<string> GetNames(
this IEnumerable<Employee> employees
)
{
{
}
}
}
var names = someListOfEmployees.GetNames();
var names = EnumerableOfEmployees.GetNames(someListOfEmployees);

{
public static IEnumerable<string> GetNames(
)
{
{
}
}
public static IEnumerable<string> GetSocialSecurityNumbers(
)
{
{
yield return employee.SocialSecurityNumber;
}
}
}

{
public static IEnumerable<TResult> Get<TResult>(
this IEnumerable<Employee> employees,
Func<Employee, TResult> selector
)
{
{
yield return selector(employee);
}
}
}
var names = someListOfEmployees.Get(e => e.Name);
var ssn = someListOfEmployees.Get(e => e.SocialSecurityNumber);

{
public static IEnumerable<TResult> Get<TResult>(
this IEnumerable<Employee> employees,
Func<Employee, TResult> selector
)
{
{
yield return selector(employee);
}
}
}

public static class Enumerable
{
public static IEnumerable<TResult> Get<T, TResult>(
this IEnumerable<T> elements,
Func<T, TResult> selector
)
{
foreach (var element in elements)
{
yield return selector(element);
}
}
}

{
public static IEnumerable<TResult> Select<T, TResult>(
)
{
{
}
}
}

{
)
{
{
}
}
}
var names = someListOfEmployees.Select(e => e.Name);
var ssn = someListOfEmployees.Select(e => e.SocialSecurityNumber);

public static IEnumerable<T> Where<T>(
Func<T, bool> filter
)
{
{
if (filter(element))
{
yield return element;
}
}
}

public static IEnumerable<T> Take<T>(
int count
)
{
var i = 0;
{
if (i >= count) yield break;
yield return element;
i++;
}
}

{
)
{
{
}
}
}
public interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}

{
)
{
{
}
}
}
{
}
public interface IEnumerator<out T> : IDisposable, IEnumerator
{
T Current { get; }
}

{
)
{
{
}
}
}
{
}
{
T Current { get; }
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}

)
{
using (var enumerator = elements.GetEnumerator())
{
while (enumerator.MoveNext())
{
yield return selector(enumerator.Current);
}
}
}

)
{
{
{
yield return selector(enumerator.Current);
}
}
}
{
}
{
T Current { get; }
}
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}

) => new SelectEnumerable<T, TResult>(elements, selector);
class SelectEnumerable<T, TResult> : IEnumerable<TResult>
{
private readonly IEnumerable<T> _elements;
private readonly Func<T, TResult> _selector;
public SelectEnumerable(
IEnumerable<T> elements,
)
{
_elements = elements;
_selector = selector;
}
public IEnumerator<TResult> GetEnumerator()
=> new SelectEnumerator(_elements.GetEnumerator(), _selector);
IEnumerator IEnumerable.GetEnumerator()
=> GetEnumerator();
}

class SelectEnumerable<T, TResult> : IEnumerable<TResult>
{
)
{
}
=> new SelectEnumerator(_elements.GetEnumerator, _selector);
=> GetEnumerator();
}
class SelectEnumerator<T, TResult> : IEnumerator<TResult>
{
private readonly IEnumerator<T> _source;
public SelectEnumerator(
IEnumerator<T> source,
)
{
_source = source;
}
public void Dispose() => _source.Dispose();
public bool MoveNext() => _source.MoveNext();
public void Reset() => _source.Dispose();
public TResult Current => _selector(_source.Current);
object IEnumerator.Current => Current;
}

var names = someEmployees.Select(e => e.Name);
foreach (var name in names)
{
Console.WriteLine(name);
}
using (var enumerator = names.GetEnumerator())
{
{
Console.WriteLine(enumerator.Current);
}
}

{
{
}
}

{
{
}
} class SelectEnumerable<T, TResult> : IEnumerable<TResult>
{
)
{
}
=> new SelectEnumerator(_elements.GetEnumerator, _selector);
=> GetEnumerator();
}

{
{
}
}
{
)
{
_source = source;
}
}

class WhereEnumerator<T> : IEnumerator<T>
{
private readonly Func<T, bool> _filter;
public WhereEnumerator(
)
{
_source = source;
_filter = filter;
}
public bool MoveNext()
{
while (_source.MoveNext())
if (_filter(_source.Current))
return true;
return false;
}
public void Reset() => _source.Reset();
public T Current => _source.Current;
}

class WhereEnumerator<T> : IEnumerator<T>
{
private readonly Func<T, bool> _filter;
public WhereEnumerator(
)
{
_source = source;
_filter = filter;
}
public bool MoveNext()
{
while (_source.MoveNext())
if (_filter(_source.Current))
return true;
return false;
}
public void Reset() => _source.Reset();
public T Current => _source.Current;
}
{
)
{
_source = source;
}
}

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
=> new Get4Enumerable();

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
{
{
WriteLine(enumerator.Current);
}
}

{
{
{
WriteLine(e);
}
}
{
for (var i = 1; i <= 4; i++)
{
yield return i;
}
}
}
class Get4Enumerator : IEnumerator<int>
{
private int _state;
private int _current;
public void Dispose() { }
bool IEnumerator.MoveNext()
{
if (_state == 1) WriteLine($"After Yield {_current}");
if (_current >= 4)
{
_state = 2;
return false;
}
_current++;
WriteLine($"Before Yield {_current}");
_state = 1;
return true;
}
public void Reset() { _current = 0; }
public int Current => _current;
}

Where Select ConsumerProducer
GetEnumerator()
{
{
}
}

GetEnumerator()GetEnumerator()
{
{
}
}

GetEnumerator()GetEnumerator()GetEnumerator()
{
{
}
}

MoveNext()
{
{
}
}

MoveNext()MoveNext()
{
{
}
}

MoveNext()MoveNext()MoveNext()
{
{
}
}
Consumidor Comanda

Estamos habituados a desenvolver
código “pró-ativo”

Mas por que se fala tanto em
programação “reativa”?

Usuários esperam resultados em
real-time

Eventos são cidadãos de primeira
grandeza.

grandeza
User Interface

grandeza
Domain Events

grandeza
Infrastructure Events

grandeza
Integration Events (Bus)

IEnumerableIEnumerableIEnumerable

IObservableIObservableIObservable

public interface IObservable<out T>
{
IDisposable Subscribe(IObserver<T> observer);
}

public interface IObservable<out T>
{
IDisposable Subscribe(IObserver<T> observer);
}
IObserver
IObserverIObserver
public interface IObserver<in T>
{
void OnCompleted();
void OnError(Exception error);
void OnNext(T value);
}

Subscribe()

Subscribe()Subscribe()

Subscribe()Subscribe()Subscribe()

OnNext/OnError/OnCompleted OnNext/OnError/OnCompleted OnNext/OnError/OnCompleted

OnNext/OnError/OnCompleted OnNext/OnError/OnCompleted OnNext/OnError/OnCompleted
Produtor Comanda

Exemplo 1: Abstrações para APIs
primitivas

public class Bytes : IObservable<byte>
{
private readonly NetworkStream _stream;
private readonly Subject<byte> _subject;
private Bytes(NetworkStream stream)
{
_stream = stream;
_subject = new Subject<byte>();
}
private bool _running;
private async void Run()
{
_running = true;
var buffer = new byte[8192];
try
{
int bytesRead;
while ((bytesRead = await _stream.ReadAsync(buffer, 0, buffer.Length)) != 0)
for (var i = 0; i < bytesRead; i++) _subject.OnNext(buffer[i]);
}
catch (Exception e)
{
_subject.OnError(e);
}
_subject.OnCompleted();
}
private readonly object _guard = new object();
public IDisposable Subscribe(IObserver<byte> observer)
{
lock (_guard)
{
var result = _subject.Subscribe(observer);
if (!_running) Run();
return result;
}
}
public static Bytes From(NetworkStream stream)
=> new Bytes(stream);
}
{
{
_stream = stream;
}

{
{
_stream = stream;
}
{
_running = true;
try
{
int bytesRead;
}
catch (Exception e)
{
}
}
{
lock (_guard)
{
return result;
}
}
}
{
lock (_guard)
{
return result;
}
}

{
{
_stream = stream;
}
{
_running = true;
try
{
int bytesRead;
}
catch (Exception e)
{
}
}
{
lock (_guard)
{
return result;
}
}
}
{
_running = true;
try
{
int bytesRead;
{
}
}
catch (Exception e)
{
}
}

public class FramedMessages : IObservable<string>
{
enum States {Expecting254, Expecting255 };
private readonly Subject<string> _subject;
private FramedMessages(IObservable<byte> bytes)
{
_subject = new Subject<string>();
var buffer = new MemoryStream();
var currentState = States.Expecting254;
bytes.Subscribe(new AnonymousObserver<byte>(
onNext: b =>
{
if (currentState == States.Expecting254)
{
if (b == 254) currentState = States.Expecting255; else buffer.WriteByte(b);
}
else
{
if (b == 255)
{
currentState = States.Expecting254;
var message = Encoding.UTF8.GetString(buffer.ToArray());
_subject.OnNext(message);
buffer = new MemoryStream();
}
else
{
buffer.WriteByte(254);
}
}
},
onCompleted: () =>
{
var a = buffer.ToArray();
if (a.Length != 0)
{
}
}
));
}
public IDisposable Subscribe(IObserver<string> observer)
=> _subject.Subscribe(observer);
public static FramedMessages From(IObservable<byte> bytes)
=> new FramedMessages(bytes);
}
{
enum States { Expecting254, Expecting255 };
{

{
{
onNext: b =>
{
{
}
else
{
if (b == 255)
{
}
else
{
}
}
},
onCompleted: () =>
{
if (a.Length != 0)
{
}
}
));
}
}
onNext: b =>
{
{
}
else
{
if (b == 255)
{
}
else
{
}
}
},

{
{
onNext: b =>
{
{
}
else
{
if (b == 255)
{
}
else
{
}
}
},
onCompleted: () =>
{
if (a.Length != 0)
{
}
}
));
}
}
onCompleted: () =>
{
if (a.Length != 0)
{
}
}

Exemplo 2: Tratamento inteligente
de eventos de UI (JavaScript)

Exemplo 3: Gerenciando fluxo de
dados de API externa

var framesGrabbed =
Observable.FromEventPattern(
h => _capturer.ImageGrabbed += h,
h => _capturer.ImageGrabbed -= h
)
.Sample(TimeSpan.FromSeconds(1));

// frame to bitmap
var bitmaps = framesGrabbed.Select(
args => ((Capture)args.Sender).QueryFrame().Bitmap
);

Exemplo 4: Combinando eventos I

var form = this;
var mouseDown = Observable.FromEventPattern<MouseEventHandler, MouseEventArgs>(
h => form.MouseDown += h,
h => form.MouseDown -= h
);
var mouseUp = Observable.FromEventPattern<MouseEventHandler, MouseEventArgs>(
h => form.MouseUp += h,
h => form.MouseUp -= h
);
var mouseMove = Observable.FromEventPattern<MouseEventHandler, MouseEventArgs>(
h => form.MouseMove += h,
h => form.MouseMove -= h
);

var dragging =
from down in mouseDown
from move in mouseMove.TakeUntil(mouseUp)
select new
{
Start = down.EventArgs.Location,
Finish = move.EventArgs.Location
};

var subscription = dragging.Subscribe(info =>
{
using (Graphics g = form.CreateGraphics())
g.DrawLine(Pens.Red, info.Start, info.Finish);
});

Exemplo 5: Reconhecendo
sequências

var keyUp = Observable.FromEventPattern<KeyEventHandler, KeyEventArgs>(
h => form.KeyUp += h,
h => form.KeyUp -= h
)
.Select(key => key.EventArgs.KeyCode);

Func<Keys, IObservable<Keys>> WherePressedIs =
(searchedKey) => keyUp.Where(k => k == searchedKey);
Func<Keys, IObservable<Keys>> WherePressedIsNot =
(searchedKey) => keyUp.Where(k => k != searchedKey);

var abcPressed =
from fst in WherePressedIs(Keys.A)
from snd in WherePressedIs(Keys.B).Take(1).TakeUntil(WherePressedIsNot(Keys.B))
from thd in WherePressedIs(Keys.C).Take(1).TakeUntil(WherePressedIsNot(Keys.C))
select new Unit();

Ele foi definido em 1973 por Carl
Hewitt

Define uma abstração para Sistemas
Distribuídos e Concorrentes

Foi popularizado na linguagem
ERLANG

class CapturerActor : ReceiveActor
{
private readonly IActorRef _recognizer;
public CapturerActor(IActorRef recognizer)
{
_recognizer = recognizer;
Waiting();
}
private void Waiting()
{
Receive<Messages.StartCapturingMessage>(m =>
{
Execute();
Become(Running);
});
}
private void Running()
{
Receive<Messages.StopCapturingMessage>(m =>
{
_handler.Dispose();
_capturer.Dispose();
Become(Stopped);
});
}
private void Stopped() { }
private Capture _capturer;
private IDisposable _handler;
public void Execute()
{
_capturer = new Capture();
WriteLine();
// get a frame per second
var framesGrabbed =
)
// frame to bitmap
);
_handler = bitmaps.Subscribe(bitmap => _recognizer.Tell(bitmap));
_capturer.Start();
}
}
{
{
Waiting();
}
{
{
Execute();
Become(Running);
});
}

{
{
Waiting();
}
{
{
Execute();
Become(Running);
});
}
{
{
_handler.Dispose();
Become(Stopped);
});
}
{
WriteLine();
var framesGrabbed =
)
// frame to bitmap
);
_capturer.Start();
}
}
{
{
_handler.Dispose();
Become(Stopped);
});
}

{
{
Waiting();
}
{
{
Execute();
Become(Running);
});
}
{
{
_handler.Dispose();
Become(Stopped);
});
}
{
WriteLine();
var framesGrabbed =
)
// frame to bitmap
);
_capturer.Start();
}
}
{
// configuring the camera
var framesGrabbed =
)
// frame to bitmap
);
_capturer.Start();
}

_myActorSystem = ActorSystem.Create(“MyActorSystem");
var props = Props.Create(() => new RecognizerActor())
.WithRouter(new RoundRobinPool(10));
var recognizer = _myActorSystem
.ActorOf(props, "recognizer");
var capturer = _myActorSystem
.ActorOf(Props.Create(() => new CapturerActor(recognizer)), "capturer");
capturer.Tell(Messages.StartCapturing());

elemarjr.com
@elemarjr
linkedin.com/in/elemarjr
elemarjr@ravendb.net
elemarjr@gmail.com
Mantenha contato!

Programação reativa e o actor model

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Programação reativa e o actor model

Semelhante a Programação reativa e o actor model (20)

Mais de Fabrício Rissetto

Mais de Fabrício Rissetto (8)

Último

Último (20)

Programação reativa e o actor model