MvvmBlazor 1.1.0

MvvmBlazor

BlazorMVVM is a small framework for building Blazor and BlazorServerside apps. With it's simple to use MVVM pattern you can boost up your development speed while minimizing the hazzle to just make it work.

Get started

MvvmBlazor is available on NuGet. You will need .NET Core 3.0 or later to use this library.

Usage

Startup

The library needs to be initialized in order to use it. This is done in your Startup class.

BlazorServerside:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvvm();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseMvvm();
    }
}

Blazor:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvvm();
    }

    public void Configure(IComponentsApplicationBuilder app)
    {
        app.UseMvvm();
    }
}

Components

Components need to inherit the base class MvvmBlazor.Components.MvvmComponentBase if you want to inject your view model manually. You can set a binding on any view model you like to.

If you want full support use MvvmBlazor.Components.MvvmComponentBase<T> and specify your view model type as a generic argument. Your view model will get auto injected into the component and set as a binding context.

BindingSource

The binding source is the default source object a binding will be made to. It is set automatically when using the base class MvvmBlazor.Components.MvvmComponentBase<T> where T is your view model type. You can access it via the BindingContext property in your component.

Bindings

Bindings are achieved via the Bind method in the component. If the value of the bound property has changed the component will be told to rerender automatically. In this example we assume that the class ClockViewModel has a property called DateTime.

@inherits MvvmComponentBase<ClockViewModel>

Current time: @Bind(x => x.DateTime)

Bindings can also be done by specifying the binding source explicitly:

@inherits MvvmComponentBase
@inject ClockViewModel ClockViewModel

Current time: @Bind(ClockViewModel, x => x.DateTime)

Bindings also handle background updating automatically. No need to invoke the main thread.

EventHandlers

Event handles work just the way they work in blazor. When you use the non generic base class you can bind any injected object on them.

@inherits MvvmComponentBase
@inject CounterViewModel CounterViewModel

<button @onclick="@CounterViewModel.IncrementCount">Click me</button>

When using the generic base class you can directly bind them to your binding context.

@inherits MvvmComponentBase<CounterViewModel>

<button @onclick="@BindingContext.IncrementCount">Click me</button>

ViewModel

View models need to inherit the base class MvvmBlazor.ViewModel.ViewModelBase.

Property implementation

Bindable properties need to raise the PropertyChanged event on the ViewModel.

The Set-Method is performing an equality check and is raising this event if needed. An example implementation could look like this:

private int _currentCount;
public int CurrentCount
{
    get => _currentCount;
    set => Set(ref _currentCount, value);
}

Lifecycle methods

View models have access to the same lifecycle methods as a component when they are set as a binding context. They are documented here.

Dispose

View models are implementing the IDisposable pattern of Blazor. Inside ViewModels, Disposing is achieved by overriding the Dispose(bool disposing) method.

Examples

Examples for Blazor and Serverside Blazor can be found here.