mrousavy / jellyfish

🐟 An incredibly lightweight and type safe MVVM library for .NET WPF, Silverlight, Xamarin and UWP

Jellyfish

🐟

An incredibly light and type safe MVVM library for .NET WPF, Silverlight, Xamarin and UWP

Jellyfish is on NuGet:

PM> Install-Package Jellyfish

Make sure to also check out the Jellyfish Visual Studio Extension 📦!

Compared to other MVVM Frameworks like MVVM Light, Prism or Caliburn.Micro, this framework is

• as light as possible
• using modern best-practices
• using modern code style
• using little to no runtime reflection to be as fast as possible
• exactly fitting my needs

Usage

For description, documentation and usage, please view the Jellyfish wiki 📖 or the Getting Started guide 📖. For usage-example projects, please see Jellyfish.Demo or GameFinder.

📝 View Models

Every ViewModel needs to implement the ViewModel class:

public class LoginViewModel : ViewModel
{
    private User _user;
    public User User
    {
        get => _user;
        set => Set(ref _user, value);
    }
}

See View Models 📖

⚡ Commands

The RelayCommand is an ICommand implementation.

<Window ...>
    <Button Command="{Binding LoginCommand}" />
</Window>

Initialize the ICommand with a non-generic RelayCommand instance and the given action/callback:

ICommand LoginCommand = new RelayCommand(LoginAction, CanLogin);
// ...
void LoginAction(object parameter)
{ ... }
bool CanLogin(object parameter)
{ ... }

See Commands 📖

💉 Dependency Injection

Provide dependencies for types using the IInjector

At app startup:

Injector.Register<IUser>(() => new User("John", "Smith"));
Injector.Register<IDatabaseService>(() => OpenDatabaseService(username, password));

Some ViewModel:

class LoginViewModel : ViewModel
{
    IUser User { get; set; }
    IDatabaseService _service;

    LoginViewModel()
    {
        this.Inject();
    }
}

See Dependency Injection 📖

💾 Enums

The enum binding source extension allows for better binding support on enums.

Just use the EnumBindingSource extension to bind an enum to any ItemsSource:

<ComboBox ItemsSource="{Binding Source={jellyfish:EnumBindingSource {x:Type local:Status}}}"
	  SelectedItem="{Binding SelectedStatus}" />

See Enums 📖

⚙️ Preferences

An abstract class definition for any application Preferences.

public class DemoPreferences : Preferences
{
    public int SomeInt { get; set; } = 400;
    public string SomeString { get; set; } = "test string";
    public bool SomeBool { get; set; } = false;

    public object SomeObject { get; set; } = new
    {
        Name = "Marc",
        IsValid = true
    };
}

See Preferences 📖

🔔 Feeds

The IFeed<T> allows notifying any subscribers in this feed about sudden changes within the application domain in realtime.

class CustomViewModel : INode<NotifyReason>
{
    public CustomViewModel
    {
        this.Subscribe();
    }

    public void MessageReceived(NotifyReason reason)
    { ... }
}

Feed.Notify(NotifyReason.RefreshView);

See Feeds 📖

Results

With Jellyfish

public class LoginViewModel : ViewModel
{
    private User _user;
    public User User
    {
        get => _user;
        set => Set(ref _user, value);
    }
}

Without Jellyfish

public class LoginViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
          PropertyChangedEventHandler handler = PropertyChanged;
          if (handler != null)
          {
              handler(this, new PropertyChangedEventArgs(propertyName));
          }
    }

    private string _username;
    public string Username
    {
        get
	{
	    return _username;
	}
	set
	{
	    _username = value;
	    OnPropertyChanged("Username");
	}
    }
}

jellyfish's Issues

Dependency Injection/Auto-wiring

Implement Dependency Injection for interfaces or other properties.

Example:

class LoginModel : Model
{
    [Autowired]
    IDatabase Database { get; }
}

Jellyfish should automatically find the IDatabase implementation (or it is pre-configured before initialization), and initialize the Database { get; } property with that instance. The IDatabase instance is either already initialized somewhere (👍) or initialized by the default constructor (👎)

Example 2:

class LoginModel : Model
{
    IDatabase Database { get; }

    public LoginModel(IDatabase database)
    {
        Database = database;
    }
}

Re-eval CanExecute on RelayCommand

Automatically re-evaluate the RelayCommand::CanExecute(T t) function whenever the parameter t changes.

Before:

ICommand LoginCommand = new RelayCommand<MyObject>(LoginAction, CanExecute);
// ...
bool CanExecute(MyObject parameter)
{
    return parameter.SomeValue == true;
}
// ...
public T MyObject
{
    get => _myObject;
    set
    {
        Set(ref _myObject, value);
        LoginCommand.RaiseCanExecuteChanged(); // re-evaluate CanExecute(T)
    }
}

After:

ICommand LoginCommand = new RelayCommand<MyObject>(LoginAction, CanExecute);
// ...
bool CanExecute(MyObject parameter)
{
    return parameter.SomeValue == true;
}

Possible approaches:

• Hook PropertyChanged if it's implementing INotifyPropertyChanged
• Pass by reference

Allow easy DependencyProperty creation

Create Dependency Properties easily by either using Attributes or Wrapper classes:

Example:

[DependencyProperty]
public string Username { get; set; }

or

private string _username;
public string Username
{
    get => _username;
    set => SetDependencyProperty(ref _username, value);
}

Global message queue

Add a global message queue that will receive and foward messages from (view)-models to (view)-models.

Example:

LoginViewModel.cs

public class MainViewModel : Sender<T>, ...
{
    public void LoginAction()
    {
        // send message of type T to any other VM
        base.Send(new { User = this.User, Status = Status.LoggedIn });
    }
}

MainViewModel.cs

public class MainViewModel : Receiver<T>, ...
{
    public override void Receive(T message)
    {
        // received message of type T from another VM
    }
}

Receiver can optionally also handle whether the message gets removed from the global message queue or stays untouched.

This is especially useful for multi-view applications, where extra updates are needed upon some action.

Use case:

• Application has an all-users window and a create-new-user window.
• New user gets created
• All-Users window gets updated with the newly created user

Use [Property] Attribute

Use [Property] Attribute (PropertyAttribute.cs) for overriding a property's getter and setter methods instead of having backing fields and using the ObservableObject::Set<T>(ref T t, T value) function.

Before:

private string _username;
public string Username
{
    get => _username;
    set => Set(ref _username, value);
}

After:

[Property]
public string Username { get; set; }

Pro:

• Much cleaner code
• More maintainable code (less backing field or get & set pollution)

Con:

• Difficult to implement
• Probably having to use Fody (PropertyChanged Implementation)