I would like to present here a little argument verification library that does not require you to type any string for specifying the name of the parameter you are checking. This lets the library faster to use, not intrusive in the actual method code, and refactor friendly. As a bonus you can use it by just embedding a single file. We can see below an example, just to get immediately to the point:

As we can see, there is no magic string at all. All the argument name are guessed thanks to the metadata contained in the linq Expression we use. For example the method at line 14 if called with a null value will report:

Value cannot be null.
Parameter name: arg1

The same happens to the more complex check we do at line 46, when we write:

Contract.Expect(() => array).Meet(a => a.Length > 0 && a.First() == 0);

We have a complex predicate do meet, described by a lambda, standing that the input array should have first element zero, and non zero length. Notice that the name of the parameter is array, but we need to use another name for the argument of the lambda ( in this case I used ‘a’ ), the library is smart enough to understand that ‘a’ actually refers to array, and the error message will report it correctly if the condition does not meet. Just to clarify, the message in case of failure would be:

Precondition not verified:((array.First() == 0) AndAlso (ArrayLength(array) > 1))
Parameter name: array

Well it is not supposed to be a message to an end real user, it is a programmer friendly message, but such validation error are supposed to be reported to a developer ( an end user should not see method validation errors at all, should he ? )

Well Meet is a cutting edge function we can use for complex validations. Out of the box, for simpler cases we have some functions too, as we can see on the IContract interface definition:

An interesting portion of the codebase proposed is the one renaming the parameter on the lambda expression, to achieve the reported message reflect the correct offending parameter. It is not so easy because plain string replacement would not work:we can have a parameter named ‘a’, seen in any place in the expression string representation and a plain replacement would resolve in a big mess, furthermore Expressions are immutable. So I found help on StackOverflow, and a reply to this question solved the problem, let see the “Renamer” at work ( Thanks to Phil ):

Basically is a reusable class that take the new name of the parameter and returns a copy of the input expression with the (single) argument changed.

To improve the library or just use it, please follow/check out the project on Bitbucket, suggestions and comments are always welcome.

Sometimes happens that we need to roll over all the combinations of elements in multiple arrays. This operation is called Cartesian Product and is defined as:

Definition (Cartesian product): Let A₁, ..., A_n be n sets.

Then the set of all ordered n-tuples <x₁, ..., x_n> , where x_iA_i for all i, 1in ,

is called the Cartesian product of A₁, ..., A_n, and is denoted by A₁ ... A_n .

Achieving this is possible by some linq tricks, or by an helper class I propose in this post. But just for clarify let’s start from the example:

We have three array as below:

 { "JUICY", "SWEET" }

{ "GREEN", "YELLOW" }

{ "APPLE", "BANANA", "MANGO" }

we want to obtain all the possible tuples, ie:

This can be achieved by the following code ( helper class ):

          public class 
          CartesianProduct<T>
{ int[] lengths; T[][] arrays; public CartesianProduct(params T[][]
arrays) { lengths = arrays.Select(k => k.Length).ToArray(); if (lengths.Any(l
=> l == 0)) throw new ArgumentException("Zero
lenght array unhandled."); this.arrays = arrays;
} public IEnumerable<T[]>
Get() { int[] walk = new
int[arrays.Length]; int x = 0; yield
return walk.Select(k => arrays[x++][k]).ToArray(); while (Next(walk))
{ x = 0; yield return walk.Select(k => arrays[x++][k]).ToArray();
} } private bool Next(int[]
walk) { int whoIncrement = 0; while (whoIncrement
< walk.Length) { if (walk[whoIncrement] < lengths[whoIncrement]
- 1) { walk[whoIncrement]++; return true; } else {
walk[whoIncrement] = 0; whoIncrement++; } } return false;
} } 

And, just for completeness, the example application:

          static void Main(string[]
args) { var cross = new CartesianProduct<string>( new
string[] { "JUICY", "SWEET" }
, new string[] { "GREEN", "YELLOW" }
, new string[] { "APPLE", "BANANA", "MANGO" }
); Console.WriteLine("========================================================="); foreach (var item in cross.Get())
{ Console.WriteLine("{0}\t{1}\t{2}",
item[0], item[1], item[2]); } Console.WriteLine("=========================================================");
} 

Sometimes we want to use some shortcut key for special commands in our application, but the KeyBinding objects works with just routed commands, and so it is not directly usable with Caliburn Micro ( or with many other MVVM strategies ).
In similar situation CM rely on System.Windows.Interactivity.dll, for example when we need to map an event on a Caliburn action we can write:

          <
          Button 
          x
          :
          Name
          ="Save"
> <
          i
          :
          Interaction.Triggers
          >
<
          i
          :
          EventTrigger 
          EventName
          ="Click">
<
          cl
          :
          ActionMessage 
          MethodName
          ="Save"
></
          cl
          :
          ActionMessage
          >
</
          i
          :
          EventTrigger
          >
</
          i
          :
          Interaction.Triggers
          > 
          </
          Button
          > 
        

With the code above, we explicitly link the "Click" event from the button to the action calling the metod Save. We can act in a similar way by creating a custom trigger, lets see how.
First look at what we can do it in XAML:

          <
          i
          :
          Interaction.Triggers
          >
<
          local
          :
          InputBindingTrigger
          >
<
          local
          :
          InputBindingTrigger.InputBinding
          >
<
          KeyBinding 
          Modifiers
          ="Ctrl" 
          Key
          ="S"/>
</
          local
          :
          InputBindingTrigger.InputBinding
          >
<
          cl
          :
          ActionMessage 
          MethodName
          ="Save"/>
</
          local
          :
          InputBindingTrigger
          >
</
          i
          :
          Interaction.Triggers
          > 
        

We need to declare a class, deriving from TriggerBase in System.Windows.Interactivity in order to fire the action(s) in place of executing a routed command when the user press the proper key gesture. Here the code:

          class 
          InputBindingTrigger:TriggerBase<FrameworkElement>,ICommand { public InputBindingTrigger()
{ } public InputBinding InputBinding
{ get { return (InputBinding)GetValue(InputBindingProperty);
} set { SetValue(InputBindingProperty, value);
} } public static readonly DependencyProperty InputBindingProperty
= DependencyProperty.Register("InputBinding", typeof(InputBinding)
, typeof(InputBindingTrigger)
, new UIPropertyMetadata(null)); protected
override void OnAttached() { if (InputBinding
!= null) { InputBinding.Command = this;
AssociatedObject.InputBindings.Add(InputBinding); } base.OnAttached();
} #region ICommand Members public
bool CanExecute(object parameter) { //
action is anyway blocked by Caliburn at the invoke level return
true; } public event EventHandler CanExecuteChanged
= delegate { }; public
void Execute(object parameter) { InvokeActions(parameter);
} #endregion } 

Very easily we add the InputBinding to the bindings list on the object, and we attach the trigger as a command handler. In the execute function we fire the InvokeActions and it done. Please not the command on the KeyBinding is not required in the markup, since there is virtually any routed command.