Class LoggedActionRenderer<T>
Decorates an IActionRenderer<T> so that all event messages are logged. In other words, this is an IActionRenderer<T> version of LoggedRenderer<T>.
Every single event message causes two log messages: one is logged before
rendering, and other one is logged after rendering. If any exception is thrown
it is also logged with the log level
Inherited Members
Namespace: Libplanet.Blockchain.Renderers
Assembly: Libplanet.dll
Syntax
public class LoggedActionRenderer<T> : LoggedRenderer<T>, IActionRenderer<T>, IRenderer<T> where T : IAction, new()
Type Parameters
Name | Description |
---|---|
T | An IAction type. It should match to BlockChain<T>'s type parameter. |
Examples
IActionRenderer<ExampleAction> actionRenderer = new SomeActionRenderer();
// Wraps the action renderer with LoggedActionRenderer:
actionRenderer = new LoggedActionRenderer<ExampleAction>(
actionRenderer,
Log.Logger,
LogEventLevel.Information,
);
Constructors
| Improve this Doc View SourceLoggedActionRenderer(IActionRenderer<T>, ILogger, LogEventLevel)
Creates a new LoggedActionRenderer<T> instance which decorates the given
action renderer
.
Declaration
public LoggedActionRenderer(IActionRenderer<T> renderer, ILogger logger, LogEventLevel level = null)
Parameters
Type | Name | Description |
---|---|---|
IAction |
renderer | The actual action renderer to forward all event messages to and actually render things. |
ILogger | logger | The logger to write log messages to. Note that all log messages
this decorator writes become in the context of the |
Log |
level | The log event level. All log messages become this level. |
Properties
| Improve this Doc View SourceActionRenderer
The inner action renderer to forward all event messages to and actually render things.
Declaration
public IActionRenderer<T> ActionRenderer { get; }
Property Value
Type | Description |
---|---|
IAction |
Methods
| Improve this Doc View SourceRenderAction(IAction, IActionContext, IAccountStateDelta)
Does things that should be done right after an action
is executed and applied to the blockchain.
Declaration
public void RenderAction(IAction action, IActionContext context, IAccountStateDelta nextStates)
Parameters
Type | Name | Description |
---|---|---|
IAction | action | An executed action. |
IAction |
context | The equivalent context object to an object passed to
the |
IAccount |
nextStates | The states right after this action executed,
which means it is equivalent to the states |
Remarks
It is guaranteed to be called only once for an action
,
and only after applied to the blockchain, unless an exception is thrown during executing
the action
(in that case Renderaction
has been unrendered.
Also note that this method is invoked after RenderBlock(Block<T>, Block<T>) method is called
(where its second parameter newTip
contains a transaction the action
belongs to).
The reason why the parameter action
takes
IAction instead of T
is because it can take
block actions (Block
RenderActionError(IAction, IActionContext, Exception)
Does the similar things to Renderaction
has terminated with an exception.
Declaration
public void RenderActionError(IAction action, IActionContext context, Exception exception)
Parameters
Type | Name | Description |
---|---|---|
IAction | action | An action which threw an exception during execution. |
IAction |
context | The equivalent context object to an object passed to
the |
Exception | exception | The exception thrown during executing the |
Remarks
Also note that this method is invoked after RenderBlock(Block<T>, Block<T>) method is called
(where its second parameter newTip
contains a transaction the action
belongs to).
The reason why the parameter action
takes
IAction instead of T
is because it can take
block actions (Block
RenderBlockEnd(Block<T>, Block<T>)
Does things that should be done right all actions in a new Block<T> are rendered.
Declaration
public void RenderBlockEnd(Block<T> oldTip, Block<T> newTip)
Parameters
Remarks
It is guaranteed to be called only once for a block.
UnrenderAction(IAction, IActionContext, IAccountStateDelta)
Does things that should be undone right after the given action
is
invalidated (mostly due to reorg, i.e., a block which the action has belonged to becomes
considered stale).
This method takes the equivalent arguments to Render
Declaration
public void UnrenderAction(IAction action, IActionContext context, IAccountStateDelta nextStates)
Parameters
Type | Name | Description |
---|---|---|
IAction | action | A stale action. |
IAction |
context | The equivalent context object to an object passed to
the |
IAccount |
nextStates | The states right after this action executed,
which means it is equivalent to the states |
Remarks
As a rule of thumb, this should be the inverse of
Render
UnrenderActionError(IAction, IActionContext, Exception)
Does the similar things to Unrenderaction
has terminated with an exception.
This method takes the equivalent arguments to Render
Declaration
public void UnrenderActionError(IAction action, IActionContext context, Exception exception)
Parameters
Type | Name | Description |
---|---|---|
IAction | action | An action which threw an exception during execution. |
IAction |
context | The equivalent context object to an object passed to
the |
Exception | exception | The exception thrown during executing the |
Remarks
The reason why the parameter action
takes
IAction instead of T
is because it can take
block actions (Block