/// <summary>
/// Invokes the specified method for the actor with provided request.
/// </summary>
/// <param name="interfaceId">Interface ID.</param>
/// <param name="methodId">Method ID.</param>
/// <param name="methodName">Method Name.</param>
/// <param name="requestMsgBodyValue">Request Message Body Value.</param>
/// <param name="cancellationToken">Cancellation Token.</param>
/// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns>
protected async Task <IActorResponseMessageBody> InvokeMethodAsync(
int interfaceId,
int methodId,
string methodName,
IActorRequestMessageBody requestMsgBodyValue,
CancellationToken cancellationToken)
{
var headers = new ActorRequestMessageHeader
{
ActorId = this.ActorId,
ActorType = this.ActorType,
InterfaceId = interfaceId,
MethodId = methodId,
CallContext = Actors.Helper.GetCallContext(),
MethodName = methodName,
};
var responseMsg = await this.actorRemotingClient.InvokeAsync(
new ActorRequestMessage(
headers,
requestMsgBodyValue),
cancellationToken);
return(responseMsg?.GetBody());
}
/// Internal - used by remoting
/// <summary>
/// This checks if we are wrapping actor message body or not.
/// </summary>
/// <param name="requestMessageBody">Actor Request Message Body.</param>
/// <returns>true or false.</returns>
protected bool CheckIfItsWrappedRequest(IActorRequestMessageBody requestMessageBody)
{
if (requestMessageBody is WrappedMessage)
{
return(true);
}
return(false);
}
byte[] IActorRequestMessageBodySerializer.Serialize(IActorRequestMessageBody actorRequestMessageBody)
{
if (actorRequestMessageBody == null)
{
return(null);
}
using var stream = new MemoryStream();
using var writer = this.CreateXmlDictionaryWriter(stream);
this.serializer.WriteObject(writer, actorRequestMessageBody);
writer.Flush();
return(stream.ToArray());
}
/// <summary>
/// Why we pass IMessageBodyFactory to this function instead of
/// setting at class level?. Since we cache MethodDispatcher for each interface,
/// we can't set IMessageBodyFactory at class level.
/// These can be cases where multiple IMessageBodyFactory implmenetation but single dispatcher class.
/// This method is used to dispatch request to the specified methodId of the
/// interface implemented by the remoted object.
/// </summary>
/// <param name="objectImplementation">The object impplemented the remoted interface.</param>
/// <param name="methodId">Id of the method to which to dispatch the request to.</param>
/// <param name="requestBody">The body of the request object that needs to be dispatched to the object.</param>
/// <param name="remotingMessageBodyFactory">IMessageBodyFactory implementaion.</param>
/// <param name="cancellationToken">The cancellation token that will be signaled if this operation is cancelled.</param>
/// <returns>A task that represents the outstanding asynchronous call to the implementation object.
/// The return value of the task contains the returned value from the invoked method.</returns>
public Task <IActorResponseMessageBody> DispatchAsync(
object objectImplementation,
int methodId,
IActorRequestMessageBody requestBody,
IActorMessageBodyFactory remotingMessageBodyFactory,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var dispatchTask = this.OnDispatchAsync(
methodId,
objectImplementation,
requestBody,
remotingMessageBodyFactory,
cancellationToken);
return(dispatchTask);
}
/// <summary> /// This method is implemented by the generated method dispatcher to dispatch one way messages to the specified methodId of the /// interface implemented by the remoted object. /// </summary> /// <param name="methodId">Id of the method.</param> /// <param name="remotedObject">The remoted object instance.</param> /// <param name="requestBody">Request body.</param> protected abstract void OnDispatch(int methodId, object remotedObject, IActorRequestMessageBody requestBody);
/// <summary>
/// This method is implemented by the generated method dispatcher to dispatch request to the specified methodId of the
/// interface implemented by the remoted object.
/// </summary>
/// <param name="methodId">Id of the method.</param>
/// <param name="remotedObject">The remoted object instance.</param>
/// <param name="requestBody">Request body.</param>
/// <param name="remotingMessageBodyFactory">Remoting Message Body Factory implementation needed for creating response object.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation.
/// The result of the task is the return value from the method.
/// </returns>
protected abstract Task <IActorResponseMessageBody> OnDispatchAsync(
int methodId,
object remotedObject,
IActorRequestMessageBody requestBody,
IActorMessageBodyFactory remotingMessageBodyFactory,
CancellationToken cancellationToken);
public ActorRequestMessage(IActorRequestMessageHeader header, IActorRequestMessageBody msgBody)
{
this.header = header;
this.msgBody = msgBody;
}