Implementing Actor Mannequin in Azure Service Cloth

Introduction

On this article, we’re going to study a very new programming paradigm known as Actors. First I provides you with a quick intro to Actor Mannequin concept after which we are going to begin implementing Actor Mannequin utilizing Service Cloth. We will even see how we will handle the state within the Actor Mannequin.

Highway Map

1. A quick intro to Actor Mannequin concept
2. Service Cloth Actors Implementation
3. Making a Consumer Service
4. Calling to Actors
5. Check Utilizing Postman
6. Use Circumstances

*Pre-requisite* This text makes use of base code from the earlier article “Creating Companies With Azure Service Cloth”

Temporary Intro to Actor Mannequin Principle

There are numerous issues concerning multithreading together with sharing of information between totally different threads. Since then, there have been many makes an attempt to simplify multithreaded programming, and the Actor mannequin is likely one of the hottest ones as of late. And what precisely is an actor? An actor is an remoted entity and is outlined as a elementary unit of computation, which embodies three important elements.

• Processing,
• Storage,
• Communications

The actor mannequin says that every thing is an actor, that means that you just mannequin the system as a set of actors. However what’s an actor? An actor is an summary entity that accommodates.

• Code to execute.
• A persistent state. The state can solely be accessed by the actor and nobody else.
• A mailbox, which implies it is discoverable by different actors or totally different elements of the applying like companies.

The primary factor it’s best to bear in mind is that a number of actors can run in parallel, however one actor processes messages sequentially. The underlying actor runtime implementation makes positive it executes actors as successfully as doable so you do not have to fret about parallelism.

Service Cloth Actors Implementation

a. Let’s create an actor venture in Visual Studio. As standard, we’ll right-click the ECommerce venture, select Add, New Service Cloth Service

b. Now choose Actor Service, and let’s name it UserActor.

A person service within the type of an actor. After that is performed, you may see that Visual Studio generates two new tasks, UserActor and UserActor.Interfaces.

Now let’s take a look on the class generated within the UserActor venture UserActor.cs, which is an entry level to the actor occasion. The very first thing value noticing is that it derives from the Actor class. It additionally implements the IUserActor interface, which itself comes from the interface’s venture.

The Code beneath is routinely generated by the venture, you don’t have to write down it.

After we open it, we will see it implements the IActor interface, which accommodates just a few strategies Visual Studio generated for us for instance. These are strategies seen to public callers in actor’s shoppers.

The Code beneath is routinely generated by the venture, you don’t have to write down it.

There can be an actor implementation class, in our case UserActor.cs, which implements frameworks Actor class, and likewise a public interface seen to actor’s shoppers, in our case IUserActor.cs, which itself is contained in a separate venture. And the very last thing I might like to indicate you earlier than we transfer on is UserActor’s constructor. It passes two parameters which can be of use to us. The primary one, ActorService, simply gives context data like actor settings and the way it’s configured by the system, however the second, ActorId, is of utter significance and desires extra clarification.

The Code beneath is routinely generated by the venture, you don’t have to write down it.

In Service Cloth, actor tasks are known as actor-type tasks. That is merely a option to map concept to code, and here’s what it means. The actor Sort accommodates code that implements actor conduct. For instance, UserActor can have performance to retailer person profiles and handle person baskets. Nevertheless, there are tens of millions of customers present on the system, and in accordance with the actor concept, every person must be represented as a separate actor.

Constructing a Consumer Service

Now we have to determine what our actor goes to do, proper? For this, we are going to modify the IUserActor interface. The primary methodology is designated so as to add a product to the basket the place we specify productId and amount. Word that we’re not going to retailer the product data as there is no such thing as a want for this. ID is sufficient. The second methodology to get the basket, a technique to delete all merchandise from the basket. We’ll delete the older generated strategies and feedback as a result of we do not want them.

a. However earlier than that, create a brand new class BasketItem in UserActor.Interfaces venture.

public class BasketItem
{
    public Guid ProductId { get; set; }
    public int Amount { get; set; }
}

b. Now outline the next strategies within the IUserActor interface.

public interface IUserActor : IActor
{
    Process AddToBasket(Guid productId, int amount);
    Process<BasketItem[]> GetBasket();
    Process ClearBasket();
}

All you need to know for now’s that actor state administration may be very accessible and developer-friendly. The way in which to entry the actor state is by way of the actor’s base property known as StateManager. StateManager is a dictionary-like construction that permits you to add values by keys, and take away, or replace them. Subsequently, so as to add a product to the basket, I’ll write the next code. It makes use of StateManager’s methodology AddOrUpdateStateAsync, which accepts three parameters: Key, which we set to productId. Worth, and for the worth, we are going to use the product amount. And since this methodology provides a brand new worth or updates it, we have to present a technique to resolve conflicts if the important thing already exists.

c. Implement the strategy AddToBasket as follows.

public async Process AddToBasket(Guid productId, int amount)
{
    await StateManager.AddOrUpdateAsync(productId.ToString(), amount, (id, oldQuantity) => oldQuantity + amount);
}

ClearBasket methodology will merely clear all of the keys from the actor. So first it enumerates the keys, or typically they’re known as states in Service Cloth terminology, and removes every key’s state.

d. Implement ClearBasket as follows,

public async Process ClearBasket()
{
    IEnumerable<string> productIDs = await StateManager.GetStateNamesAsync();
    foreach (string productId in productIDs)
    {
        await StateManager.RemoveStateAsync(productId);
    }
}

GetBasket, just like ClearBasket, enumerates all of the states, then will get the worth for every state or key and places it in a consequence BasketItem checklist, so simple as that.

e. Lastly implement the GetBasket methodology.

public async Process<BasketItem[]> GetBasket()
{
    var consequence = new Record<BasketItem>();
    IEnumerable<string> productIDs = await StateManager.GetStateNameAsync();
    foreach (string productId in productIDs)
    {
        int amount = await StateManager.GetStateAsync<int>(productId);
        consequence.Add(new BasketItem { ProductId = new Guid(productId), Amount = amount });
    }
    return consequence.ToArray();
}

Calling to Actors

We have created the actor and carried out the basket strategies, nevertheless it’s all non-public to our cluster up to now. It is not that helpful to have non-public, inaccessible, and untested code that serves no goal for customers; subsequently, the pure subsequent step can be to reveal the basket API by way of our net server REST API.

a. To start with right-click the Controllers folder and add a brand new class known as BasketController.

The Code beneath is routinely generated by the venture, you don’t have to write down it.

Now, I might prefer to have a technique to get the person basket. Okay, our UserActor does return the basket; nonetheless, a map of GUI to integer shouldn’t be that good trying in a JSON world; subsequently, I am going to create a specifically crafted entity. We are going to return to the callers of our API within the Mannequin folder as we did earlier than and name it ApiBasket.

b. Create a category ApiBasket within the Mannequin folder of Api and add the next code.

public class ApiBasket
{
    [JsonProperty("userid")]
    public string UserId { get; set; }
    [JsonProperty("item")]
    public ApiBasketItem[] Objects { get; set; }
}

public class ApiBasketItem
{
    [JsonProperty("productid")]
    public string ProductId { get; set; }
    [JsonProperty("quantity")]
    public int Amount { get; set; }
}

Again to our controller class, BasketController, I might prefer to have a technique that returns this basket. It permits me to fetch the basket object by the next URI.

http://host:port/api/basket/userid

c. Create a Get Methodology within the BasketController class, we are going to add the code later.

public async Process<ApiBasket> GetAsync(string userId)
{
}

ApiBasketAddRequest is one other class I’ve declared that accommodates productId and amount, which permits me to bind it to the physique of the request.

d. Create a category ApiBasketAddRequest within the Mannequin folder of API with this code.

public class ApiBasketAddRequest {
    [JsonProperty("productid")]
    public Guid ProductId { get; set; }
    [JsonProperty("quantity")]
    public int Amount { get; set; }
}

I might prefer to declare a nice-looking REST POST request so as to add product amount to the person’s basket. Will probably be accessible by way of the identical URL containing the product ID and amount within the physique.

e. Declare a Put up methodology as follows.

[HttpPost("{userId}")]
public async Process AddAsync(string userId, [FromBody] ApiBasketAddRequest request)
{
}

And the delete methodology is admittedly easy. All we’d like is userId, and the strategy can be callable with the Delete HTTP methodology with the identical URL as earlier than.

f. Declare Delete Methodology as Follows.

[HttpDelete("{userId}")]
public async Process DeleteAsync(string userId)
{
}

The strategies are in place. They nonetheless do not name our actor, and that is what we’ll do now. Identical to with companies, so as to name an actor, we have to create an actor proxy; subsequently, I am going to add a helper methodology to get our UserActor interface to our controller, which accepts userId as a parameter as a result of we selected to bind person ID to actor ID, so this parameter is certainly helpful.

g. Add a helper methodology GetActor in BasketController as follows.

non-public IUserActor getActor(string userId)
{
    return ActorProxy.Create<IUserActor>(
        new ActorId(userId), new Uri("material:/Ecommerce/UserActorService"));
}

Shifting on. Having this in place, it is simple to ahead API calls to the actor.

h. Change the HttpPost and HttpDelete strategies as follows.

[HttpPost("{userId}")]
public async Process AddAsync(string userId, [FromBody] ApiBasketAddRequest request)
{
    IUserActor actor = getActor(userId);
    await actor.AddToBasket(request.ProductId, request.Amount);
}

[HttpDelete("{userId}")]
public async Process DeleteAsync(string userId)
{
    IUserActor actor = getActor(userId);
    await actor.ClearBasket();
}

i. Add the next code to the HttpGet methodology.

public async Process<ApiBasket> GetAsync(string userId)
{
    IUserActor actor = GetActor(userId);
    BasketItem[] merchandise = await actor.GetBasket();
    return new ApiBasket()
    {
        UserId = userId,
        Objects = merchandise.Choose(p => new ApiBasketItem
        {
            ProductId = p.ProductId.ToString(),
            Amount = p.Amount
        }).ToArray()
    };
}

Check with Postman

We are actually able to launch this software and make the decision.

And it is profitable, so downside solved.

Ought to attempt to get again the basket for the person, right here we go, and we get it again.

All our APIs are working simply completely. Congratulations! You’ve got made it.

Use Circumstances

• The complicated system that entails dependencies and coordinating shared state
• Whenever you need to keep away from utilizing express locks to guard shared state
• Basic synchronization issues like eating philosophers and the sleeping barber’s downside
• Extremely accessible companies
• Scalable companies