Creating Advanced Blazor Components
Exploring Binding
By utilizing bindings, you can link variables either
inside a component (allowing for automatic updates) or by assigning a component
attribute. In Blazor, we can bind values to components and there are two
different ways to do this:
One-way binding 
Two-way binding
Through the use of binding, we can transmit
information between components and ensure that we can modify a value whenever
we choose.
Adding Actions and EventCallback
To relay changes, we can utilize EventCallback.
EventCallback<T> has some differences compared to what we might
recognize in .NET. It is a class specifically designed for Blazor, allowing the
event callback to be made available as a parameter for the component. In .NET
as a whole, it is possible to attach several listeners to an event
(multi-cast), whereas with EventCallback<T>, you can only attach a
single listener (single-cast).
It's important to note that you can utilize events in
Blazor similarly to how you do in .NET. However, you may prefer to employ EventCallback<T>
due to the numerous advantages it offers compared to conventional .NET events.
.NET events are based on classes, while EventCallback is built on
structs. This implies that in Blazor, we are not required to execute a null
check prior to invoking EventCallback, since a struct cannot be null.
EventCallback functions
asynchronously and can be awaited. Once EventCallback is invoked, Blazor
will automatically perform StateHasChanged on the component that
consumes it to ensure that the component updates whenever it requires updating.
So, if you need several
listeners, you can utilize Action<T>; if not, you should opt for EventCallback<T>.
Using RenderFragment
To enhance the
reusability of our components, we can provide them with a snippet of Razor
syntax. In Blazor, you have the option to define a RenderFragment, which
is a segment of Razor syntax that can be executed and displayed.
There are two categories
of render elements- RenderFragment and RenderFragment<T>. RenderFragment
is essentially a Razor fragment that does not have any input parameters, while RenderFragment<T>
includes an input parameter that can be accessed within the Razor fragment code
using the context keyword.
ChildContent
By labeling the render
fragment as ChildContent, Blazor will automatically utilize the content
found between the alert tags. This feature only applies when there is a single
render fragment. If multiple fragments are present, you will need to also
define the ChildComponent tag.
Conclusion
Some basics of creating a
component are discussed.
Comments
Post a Comment