Fluent API Support

• Mar 12, 2021
• 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.

Note

To get started with Fluent API concepts, refer to the following articles.

• A Look at Fluent APIs

  A Code Project blog post by Sacha Barber that describes what Fluent API is and why you should use it.

• Code First Fluent API

  The MSDN documentation section that describes Fluent API in the scope of the Entity Framework.

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)