Fluent API Support

• Jan 22, 2025
• 4 minutes to read

Fluent APIs utilize method cascading to relay the instruction context of a subsequent call. By doing so, a Fluent API follows the same natural language rules as those utilized by people. As a result, a well-constructed Fluent API provides more human-friendly code that is easier to perceive and understand.

Tip

To get started with Fluent API concepts, refer to the following article: Code First Fluent API.

The DevExpress MVVM Framework provides extension methods to build Fluent API expressions for any task: from binding simple properties to relating MVVM behaviors with specific events.

Property Binding and UI Triggers

Related article: Data Bindings and Notifications

• Simple property binding.

  C#

  mvvmContext.ViewModelType = typeof(ViewModel);
  var fluentAPI = mvvmContext.OfType<ViewModel>();
  fluentAPI.SetBinding(editor, e => e.EditValue, x => x.Title);
  //ViewModel
  public virtual string Title { get; set; }
  

  VB.NET

  mvvmContext.ViewModelType = GetType(ViewModel)
  Dim fluentAPI = mvvmContext.OfType(Of ViewModel)()
  fluentAPI.SetBinding(editor, Function(e) e.EditValue, Function(x) x.Title)
  'ViewModel
  public virtual String Title {get;set;}
  

• Binding to nested properties.

  C#

  mvvmContext.ViewModelType = typeof(ViewModel);
  var fluent = mvvmContext.OfType<ViewModel>();
  fluent.SetBinding(editor, e => e.EditValue, x => x.Child.Title);
  //ViewModel
  public NestedViewModel Child { get; private set; }
  //NestedViewModel
  public virtual string Title { get; set; }
  

  VB.NET

  mvvmContext.ViewModelType = GetType(ViewModel)
  Dim fluent = mvvmContext.OfType(Of ViewModel)()
  fluent.SetBinding(editor, Function(e) e.EditValue, Function(x) x.Child.Title)
  'ViewModel
  public NestedViewModel Child {get;private set;}
  'NestedViewModel
  public virtual String Title {get;set;}
  

• UI Triggers.

  C#

  mvvmContext.ViewModelType = typeof(UIViewModel);
  var fluentAPI = mvvmContext.OfType<UIViewModel>();
  fluentAPI.SetTrigger(x => x.IsActive, (active) =>
  {
      label.Text = active ? "Active" : "Inactive";
  });
  //UIViewModel
  public virtual bool IsActive { get; set; }
  

  VB.NET

  mvvmContext.ViewModelType = GetType(UIViewModel)
  Dim fluentAPI = mvvmContext.OfType(Of UIViewModel)()
  fluentAPI.SetTrigger(Function(x) x.IsActive, Sub(active)
      label.Text = If(active, "Active", "Inactive"))
  'UIViewModel
  public virtual Boolean IsActive {get;set;}
  

Command Binding

Related article: Commands

• Parameterized commands with CanExecute conditions.

  C#

  mvvmContext.ViewModelType = typeof(ViewModel);
  int parameter = 4;
  var fluentAPI = mvvmContext.OfType<ViewModel>();
  fluentAPI.BindCommand(commandButton, (x, p) => x.DoSomething(p), x => parameter);
  
  //ViewModel
  public class ViewModel {
      public void DoSomething(int p) {
          //. . .
      }
  
      public bool CanDoSomething(int p) {
          return (2 + 2) == p;
      }
  }
  

  VB.NET

  mvvmContext.ViewModelType = GetType(ViewModel)
  Dim parameter As Integer = 4
  Dim fluentAPI = mvvmContext.OfType(Of ViewModel)()
  fluentAPI.BindCommand(commandButton, Function(x, p) x.DoSomething(p), Function(x) parameter)
  
  'ViewModel
  public class ViewModel
      public void DoSomething(Integer p)
          '. . .
  
      public Boolean CanDoSomething(Integer p)
          Return (2 + 2) = p
  

• Asynchronous commands.

  C#

  mvvmContext.ViewModelType = typeof(ViewModel);
  var fluentAPI = mvvmContext.OfType<ViewModel>();
  fluentAPI.BindCommand(commandButton, x => x.DoSomethingAsynchronously());
  fluentAPI.BindCancelCommand(cancelButton, x => x.DoSomethingAsynchronously());
  
  //ViewModel
  public class ViewModelWithAsyncCommandAndCancellation 
      public Task DoSomethingAsynchronously() {
          return Task.Factory.StartNew(() =>
          {
              var asyncCommand = this.GetAsyncCommand(x => x.DoSomethingAsynchronously());
              for(int i = 0; i <= 100; i++) {
                  if(asyncCommand.IsCancellationRequested) // cancellation check
                      break;
                  //. . .
              }
          });
      }
  }
  

  VB.NET

  mvvmContext.ViewModelType = GetType(ViewModel)
  Dim fluentAPI = mvvmContext.OfType(Of ViewModel)()
  fluentAPI.BindCommand(commandButton, Function(x) x.DoSomethingAsynchronously())
  fluentAPI.BindCancelCommand(cancelButton, Function(x) x.DoSomethingAsynchronously())
  
  'ViewModel
  public class ViewModelWithAsyncCommandAndCancellation public Task DoSomethingAsynchronously()
          Return Task.Factory.StartNew(Sub() ' cancellation check
                  '. . .
              Dim asyncCommand = Me.GetAsyncCommand(Function(x) x.DoSomethingAsynchronously())
              For i As Integer = 0 To 100
                  If asyncCommand.IsCancellationRequested Then
                      Exit For
                  End If
              Next i
          End Sub)
  }
  

• The WithCommand extension allows you to bind a command to one or multiple target UI elements.

  C#

  //binding to one UI element
  fluent.WithCommand(x => x.DoSomething())
         .Bind(btnDoSomething);
  //binding to multiple UI elements
  fluent.WithCommand(x => x.DoSomething())
         .Bind(btn1DoSomething)
         .Bind(btn2DoSomething);
  fluent.WithCommand(x => x.DoSomethingAsynchronously())
         .Bind(btnDo)
         .BindCancel(btnCancel);
  

  VB.NET

  'binding to one UI element
  fluent.WithCommand(Function(x) x.DoSomething()).
         Bind(btnDoSomething)
  'binding to multiple UI elements
  fluent.WithCommand(Function(x) x.DoSomething())
         .Bind(btn1DoSomething)
         .Bind(btn2DoSomething)
  fluent.WithCommand(Function(x) x.DoSomethingAsynchronously())
         .Bind(btnDo)
         .BindCancel(btnCancel)
  

• Command triggers allow you to automatically call specific methods before the target command is executed, after that, or when this command’s CanExecute condition changes.

  C#

  fluent.WithCommand(x => x.DoSomething())
         .After(() => AfterDoSomethingExecuted());
  fluent.WithCommand(x => x.DoSomething())
         .Before(() => BeforeDoSomethingExecuted());
  fluent.WithCommand(x => x.DoSomething())
         .OnCanExecuteChanged(() => WhenCanDoSomethingChanged());
  

  VB.NET

  fluent.WithCommand(Function(x) x.DoSomething())
         .After(Function() AfterDoSomethingExecuted())
  fluent.WithCommand(Function(x) x.DoSomething())
         .Before(Function() BeforeDoSomethingExecuted())
  fluent.WithCommand(Function(x) x.DoSomething())
         .OnCanExecuteChanged(Function() WhenCanDoSomethingChanged())
  

Attaching Behaviors

Related article: Behaviors

• Confirmation behavior.

  C#

  mvvmContext.WithEvent<ChangingEventArgs>(editor, "EditValueChanging")
      .Confirmation(behavior =>
      {
          behavior.Caption = "CheckEdit State changing";
          behavior.Text = "This checkEdit's checked-state is about to be changed. Are you sure?";
      });
  

  VB.NET

  mvvmContext.WithEvent(Of ChangingEventArgs)(editor, "EditValueChanging").Confirmation(Sub(behavior)
      behavior.Caption = "CheckEdit State changing"
      behavior.Text = "This checkEdit's checked-state is about to be changed. Are you sure?"
  End Sub)
  

• Event-To-Command Behaviors

  C#

  mvvmContext.ViewModelType = typeof(ViewModel);
  mvvmContext.WithEvent<ViewModel, EventArgs>(thirdPartyButton, "Click")
      .EventToCommand(x => x.DoSomething());
  
  //ViewModel
  public void DoSomething() {
      //. . .
  }
  

  VB.NET

  mvvmContext.ViewModelType = GetType(ViewModel)
  mvvmContext.WithEvent(Of ViewModel, EventArgs)(thirdPartyButton, "Click").EventToCommand(Function(x) x.DoSomething())
  
  'ViewModel
  Public Sub DoSomething()
      '. . .
  End Sub
  

• Key-To-Command and Keys-To-Command Behaviors

  C#

  mvvmContext.OfType<KeyAwareViewModel>()
          .WithKey(memo, Keys.A)
          .KeyToCommand(x => x.OnAKey());
  mvvmContext.OfType<KeyAwareViewModel>()
          .WithKeys(memo, new Keys[] { Keys.A, Keys.B, Keys.C })
          .KeysToCommand(x => x.OnKey(Keys.None), args => args.KeyCode);
  

  VB.NET

  mvvmContext.OfType(Of KeyAwareViewModel)().WithKey(memo, Keys.A).KeyToCommand(Function(x) x.OnAKey())
  mvvmContext.OfType(Of KeyAwareViewModel)().WithKeys(memo, New Keys() { Keys.A, Keys.B, Keys.C }).KeysToCommand(Function(x) x.OnKey(Keys.None), Function(args) args.KeyCode)