Unknown Recipes

Recursively Traversing IEnumerable

Mon, 21 Mar 2011 12:13:55 GMT

Most of the samples I saw about traversing an IEnumerable<T> use recursion, this can cause some overload in the stack depending on the hierarchy depth. The version I propose use a Queue<T> to achieve the same; note that this is I a common algorithm named Breadth-first search, and note that you can use a Stack<T> instead to turn to Depth-first search algorithm. Here you have the extension method:

public static IEnumerable<T> Traverse<T>(
    this IEnumerable<T> items,
    Func<T, IEnumerable<T>> itemsEnumerator)
{
    var queue = new Queue<T>(items);
    while (queue.Count > 0)
    {
        var item = queue.Dequeue();
        yield return item;
 
        foreach (var child in itemsEnumerator(item))
        {
            queue.Enqueue(child);
        }
    }
}

The use of this extension method is really simple, for example, if we have the following class:

public class Node
{
    public Node()
    {
        this.Nodes = new List<Node>();
    } 
           
    public string Name { get; set; }
            
    public List<Node> Nodes { get; private set; }
}

We can use the extension method above to traverse the hierarchy in the following way:

node.Nodes.Traverse(n => n.Nodes);

Getting the default value for a Type

Thu, 10 Feb 2011 02:30:35 GMT

Sometimes we need to get a default value for an specific type but we only know the type in runtime, then we can not use default(T). One way to do this is to use a simple extension method:

public static object DefaultValue(this Type type)
{
    return Expression.Lambda(Expression.Default(type)).Compile().DynamicInvoke();
}

As you can see it is a simple Expression tree that returns the default value for the type.

How to implement Property Changed notification in WPF with a base ViewModel

Thu, 28 Oct 2010 15:08:46 GMT

Implement property changed notifications is tedious, there are some posts about how to implement it in a strongly-typed way. I decided combine that technique with a way to simplify the implementation of the setter.

The first what you need is a base class to inherit all your view models from, this class will have the necessary methods to raise the PropertyChanged event and to set the value of the property. Here is the base class that I use:

public abstract class ObservableObject : INotifyPropertyChanged

{

protected ObservableObject()

{

}

public event PropertyChangedEventHandler PropertyChanged;

protected void OnPropertyChanged<T>(Expression<Func<T>> propertyExpresion)

{

var property = (MemberExpression)propertyExpresion.Body;

VerifyPropertyExpression<T>(propertyExpresion, property);

this.OnPropertyChanged(property.Member.Name);

}

protected void OnPropertyChanged(string propertyName)

{

if (this.PropertyChanged != null)

{

this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

}

protected void SetValue<T>(ref T refValue, T newValue, Expression<Func<T>> propertyExpresion)

{

if (!object.Equals(refValue, newValue))

{

refValue = newValue;

this.OnPropertyChanged(propertyExpresion);

}

protected void SetValue<T>(ref T refValue, T newValue, Action valueChanged)

{

if (!object.Equals(refValue, newValue))

{

refValue = newValue;

valueChanged();

}

[Conditional("DEBUG")]

private void VerifyPropertyExpression<T>(

Expression<Func<T>> propertyExpresion,

MemberExpression property)

{

if (property.Member.GetType().IsAssignableFrom(typeof(PropertyInfo)))

{

throw new ArgumentException(string.Format(

CultureInfo.CurrentCulture,

"Invalid Property Expression {0}",

propertyExpresion));

}

var instance = property.Expression as ConstantExpression;

if (instance.Value != this)

{

throw new ArgumentException(string.Format(

CultureInfo.CurrentCulture,

"Invalid Property Expression {0}",

propertyExpresion));

}

Basically when you implement a property that need property changed notification, all you need to do is the following:

private string notificable;

public string Notificable

{

get { return this.notificable; }

set { this.SetValue(ref this.notificable, value, () => this.Notificable); }

}

As you can see the implementation of the setter is very simple. There are some other cases when you need execute some logic if the value of the property is changed, but you do not really need property changed notification, for that reason there is a second overload of the SetValue method:

private string notificable;

public string Notificable

{

get { return this.notificable; }

private set { this.SetValue(ref this.notificable, value, this.OnNotificableChanged); }

}

private void OnNotificableChanged()

{

// TODO seome logic here

}

As you can see is really easy to manage the notifications in this way.

Add Service Reference from SO-Aware

Tue, 07 Sep 2010 15:46:00 GMT

We have recently included a very cool feature to automatically create WCF service references (or service proxies) within Visual Studio 2010 from the SO-Aware repository. After running the installer, you will be able to find a "TellagoStudios.VisualStudio.Editors.SOAware.vsix" extension within "C:\Program Files (x86)\Tellago Studios\SO-Aware\SDK\Visual Studio\" to register this plugin in your Visual Studio instance.

In order to create a new service reference you can do right click on the project and hit “Add Service Reference from SO-Aware”:

Once you click on that menu option, a new screen for searching services will appear. In this screen you can select the SO-Aware repository to browse, and select the service and version for which you want to generate the proxy

Finally, you will get a proxy generated just like any other “Service Reference” that you generate with Visual Studio. The magic here is that this proxy file does not require any configuration as everything is automatically resolved from the SO-Aware Repository. In fact, if you take a look at the generated code, you will notice that the base proxy class for this new proxy is "ConfigurableClientBase", which is a SO-Aware specific proxy class that knows how to retrieve endpoint and binding configurations from the repository.

[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
public partial class ProxyGeneratorServiceClient :
    Tellago.ServiceModel.Governance.ServiceConfiguration.ConfigurableClientBase<
        ServiceProxySample.Sample.IProxyGeneratorService>,
    ServiceProxySample.Sample.IProxyGeneratorService
{
    public ProxyGeneratorServiceClient() :
        base(
            new System.Uri("http://localhost/SoAware/ServiceRepository.svc"),
            "ProxyGeneratorService(1.0)",
            "Sample")
    {
    }
 
    public ProxyGeneratorServiceClient(System.Uri serviceRepositoryUri) :
        base(serviceRepositoryUri, "ProxyGeneratorService(1.0)", "Sample")
    {
    }
 
    public ProxyGeneratorServiceClient(
        System.Uri serviceRepositoryUri,
        string category,
        string endpointName) :
        base(serviceRepositoryUri, "ProxyGeneratorService(1.0)", category, endpointName)
    {
    }

This class also contains a SetClientBehavior in case you want to resolve and inject "Endpoint" behavior from the repository into the proxy. For instance, this becomes handy for cases where you have credentials like certificates already configured in a behavior.

You can download the SDK here.

SO-Aware released – WCF Repository

Thu, 29 Jul 2010 12:35:21 GMT

Tellago Studios, the company where I am working on, released a great new product called SO-Aware. This is basically a WCF Service Repository that keeps all the configuration centralized.

The repository can be accessed through OData feeds, which makes the product easily manipulated using standard http.

You can get a description of this product here.

MOQ 4.0 Beta 3 Released

Mon, 31 May 2010 19:25:07 GMT

We released MOQ 4.0 Beta 3. It was compiled for .NET Framework 3.5 & 4.0 and Silverlight 3 & 4.

You can get the binaries here.

Sorting a ListView in WPF – Part II

Mon, 10 May 2010 16:12:00 GMT

Some time ago I wrote a post about how to sort a ListView by clicking on the header of the column. The problem with that solution was that you needed to implement it each time and you have to define an explicit header for each column.

As a more general solution I use attached properties to extend the ListView and GridViewColumn. The first attached property is tied to the ListView itself, and it indicates that the control supports sorting. This property attach or detach to the Click event of the GridViewColumnHeader depending on its value. In order to enable sorting, this property should be true:

<ListView ItemsSource="{Binding Notes}" l:SortBehavior.CanUserSortColumns="true">
  ...
</ListView>

If you simply need to allow sorting for every column in your ListView and you are not applying data templates to the columns it is all that you need.

The rest of the attached properties are applicable to GridViewColum and are intended to be used in some special cases. For example, if you do not want to allow sorting in a specific column, you can disable this behavior using the CanUseSort property:

<GridViewColumn
    Width="50"
    Header="Id"
    DisplayMemberBinding="{Binding Id}"
    l:SortBehavior.CanUseSort="false" />

The value of this property indicates that you can not sort the column containing the Id.

The second property (SortExpression) is useful in cases where you are using a DataTemplate. The sorting property is extracted from the binding that you are using automatically, in the case of the DataTemplate this automatic behavior is simply not possible. In that case you will need to indicate the sorting property explicitly:

<GridViewColumn Width="210" Header="Title" l:SortBehavior.SortExpression="Title">
    <GridViewColumn.CellTemplate>
        <DataTemplate>
            <TextBlock>
                <Run Text="{Binding Title}" FontWeight="Bold" />
                <LineBreak />
                <Run Text="{Binding Text}" />
            </TextBlock>
        </DataTemplate>
    </GridViewColumn.CellTemplate>
</GridViewColumn>

The last property (SortDirection) is used internally to track the current sort direction of each column, its values are based on ListSortDirection enum, also it can be null in case this column is not sorted. You can set this property in any column in order to define the initial sorting of the items:

<GridViewColumn
    Width="130"
    DisplayMemberBinding="{Binding Written}"
    Header="Date"
    l:SortBehavior.SortDirection="Ascending" />

Finally, you can define a DataTemplate that applies to every column to display some visual indicator that shows the user that this column is sorted.

<DataTemplate x:Key="SortHeader">
    <Grid Margin="3,0" Grid.IsSharedSizeScope="True">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="15" SharedSizeGroup="ArrowHolder" />
            <ColumnDefinition Width="*" />
            <ColumnDefinition Width="15" SharedSizeGroup="ArrowHolder" />
        </Grid.ColumnDefinitions>
        <TextBlock Text="{Binding}" Grid.Column="1" HorizontalAlignment="Center" />
        <Path x:Name="arrow" StrokeThickness="1" Fill="DarkGray" Visibility="Hidden" Grid.Column="2" />
    </Grid>
    <DataTemplate.Triggers>
        <MultiDataTrigger>
            <MultiDataTrigger.Conditions>
                <Condition Binding="{Binding Path=Column.(l:SortBehavior.CanUseSort),
                    RelativeSource={RelativeSource FindAncestor,
                    AncestorType={x:Type GridViewColumnHeader}}}" Value="true" />
                <Condition Binding="{Binding Path=Column.(l:SortBehavior.SortDirection),
                    RelativeSource={RelativeSource FindAncestor,
                    AncestorType={x:Type GridViewColumnHeader}}}" Value="Ascending" />
            </MultiDataTrigger.Conditions>
            <MultiDataTrigger.Setters>
                <Setter TargetName="arrow" Property="Data" Value="M 5,10 L 15,10 L 10,5" />
                <Setter TargetName="arrow" Property="Visibility" Value="Visible" />
            </MultiDataTrigger.Setters>
        </MultiDataTrigger>
        <MultiDataTrigger>
            <MultiDataTrigger.Conditions>
                <Condition Binding="{Binding Path=Column.(l:SortBehavior.CanUseSort),
                    RelativeSource={RelativeSource FindAncestor,
                    AncestorType={x:Type GridViewColumnHeader}}}" Value="true" />
                <Condition Binding="{Binding Path=Column.(l:SortBehavior.SortDirection),
                    RelativeSource={RelativeSource FindAncestor,
                    AncestorType={x:Type GridViewColumnHeader}}}" Value="Descending" />
            </MultiDataTrigger.Conditions>
            <MultiDataTrigger.Setters>
                <Setter TargetName="arrow" Property="Data" Value="M 5,5 L 10,10 L 15,5" />
                <Setter TargetName="arrow" Property="Visibility" Value="Visible" />
            </MultiDataTrigger.Setters>
        </MultiDataTrigger>
    </DataTemplate.Triggers>
</DataTemplate>

You can download the sample here.

MOQ 4.0 Beta 2 released

Sun, 02 May 2010 01:59:00 GMT

We released MOQ 4.0 Beta 2, it includes some fixes over the previous version and the update to DynamicProxy 2.2. It was compiled for .NET Framework 3.5 & 4.0 and Silverlight 3 & 4.

You can get the binaries here.

Disabling Minimize and Maximize buttons in a WPF Window

Mon, 22 Mar 2010 20:06:00 GMT

In WPF there is no possibility to control when the Minimize and Maximize buttons are disabled when the WindowStyle is SingleBorderWindow or ThreeDBorderWindow. In Windows Forms there are some properties like ControlBox, MinimizeBox and MaximizeBox that allow to do that.

Because the WPF window internally has a hWnd we can do this using Windows API (GetWindowLong and SetWindowLong will do the trick). I did three attached properties applicable to Window that use the internal API, in order to disable/hide the minimize and maximize buttons. You can use the two following attached properties:

<Window
   l:ControlBox.HasMinimizeButton="false"
   l:ControlBox.HasMaximizeButton="false">

The third attached property is to enable the context help button. This button is added only if the minimize and maximize buttons are not present, then the right configuration to use the context help button is:

<Window
   l:ControlBox.HasMinimizeButton="false"
   l:ControlBox.HasMaximizeButton="false"
   l:ControlBox.HasHelpButton="true">

You can download the code here.

C# Code Snippets for properties raising PropertyChanged event

Mon, 17 Aug 2009 13:07:00 GMT

I decided to publish the snippets I use to implement properties that raise the PropertyChanged event. There are two code snippets, one generates a property raising the event, it is called by typing propnpc in the code editor, and generates the following code:

private int myField;
 
public int MyProperty
{
    get
    {
        return this.myField;
    }
    set
    {
        if (this.myField != value)
        {
            this.myField = value;
            this.OnPropertyChanged("MyProperty");
        }
    }
}

The other generates the call to the event by typing onpc:

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

Both snippets work in Visual Studio 2008 and 2010 beta. You will need copy the two files to %USERPROFILE%\Documents\Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets or %USERPROFILE%\Documents\Visual Studio 2010\Code Snippets\Visual C#\My Code Snippets folder depending of your version of Visual Studio. You can download here.

MOQ 3.5 Beta released

Fri, 17 Jul 2009 01:08:13 GMT

MOQ 3.5 Beta was released, it includes a lot of fixes of the previous version. You can get the binaries here. If you are using Visual Studio 2010 you should download the version called: Moq 3.5 Beta Binaries and Help (with Castle Assemblies).

How to get notifications in attached properties

Mon, 13 Jul 2009 17:41:22 GMT

Sometime we need to know when an attached property change its value for a specific FrameworkElement. For example consider the following:

<Canvas>
  <Button x:Name="move" Content="Move" Canvas.Left="10" Canvas.Top="10"/>
</Canvas>

If in a part of the code we have something like:

Canvas.SetLeft(this.move, 20);

And we need listen when the Left attached property changed for the button, we can use a DependencyPropertyDescriptor to do it. This class provides the FromProperty static method, which gives as an instance of itself receiving the DependencyProperty:

var descriptor = DependencyPropertyDescriptor.FromProperty(

    Canvas.LeftProperty,

    typeof(Button));

Once we have the instance of the DependencyPropertyDescriptor we can use it to get the notifications using AddValueChanged method:

    descriptor.AddValueChanged(this.move, this.OnValueChanged);
  

Finally we need to implement the event handler:

private void OnValueChanged(object sender, EventArgs e)

    var button = (Button)sender;

...

How to force a binding to update

Thu, 04 Jun 2009 14:24:18 GMT

It is really very simple, all that we need is the FrameworkElement and the DependencyProperty that we need refresh. I did some extensions method to update the target or the source of the binding:

public static class BindingExtensions
{
    public static void UpdateTarget(
        this FrameworkElement element,
        DependencyProperty property)
    {
        BindingExpression expression = element.GetBindingExpression(property);
        if (expression != null)
        {
            expression.UpdateTarget();
        }
    }
 
    public static void UpdateSource(
        this FrameworkElement element,
        DependencyProperty property)
    {
        BindingExpression expression = element.GetBindingExpression(property);
        if (expression != null)
        {
            expression.UpdateSource();
        }
    }
}

For example if we want to refresh the Text property in a bound TextBox we can do:

textBox.UpdateTarget(TextBox.TextProperty);

Publish a Clickonce deploy with assemblies not referenced in Visual Studio 2008 SP1

Fri, 01 May 2009 13:29:00 GMT

Some time ago I wrote a post about this subject, but that post only apply to Visual Studio 2005. The targets used in that post where changed. Basically this post is an update to Visual Studio 2008 SP1. Note that this post does not apply to Visual Studio 2008 without SP1, there were some changes between the two versions of the used target.

In this version we need replace only one target which is _DeploymentComputeClickOnceManifestInfo. This target is executed before the beginning of the publishing. You will need copy this target to a file, for example AssembliesCopy.targets, and add the logic to get the not referenced assemblies from the Modules folder. Take a look to the following target:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Target
  Name="_DeploymentComputeClickOnceManifestInfo"
  Condition="'$(GenerateClickOnceManifests)'=='true'"
  DependsOnTargets="_DeploymentGenerateTrustInfo">
 
  <!-- Grab just the serialization assemblies for a referenced assembly.  There may also be a symbols file in ReferenceRelatedPaths -->
  <ItemGroup>
   <_SGenDllsRelatedToCurrentDll
    Include="@(_ReferenceSerializationAssemblyPaths->'%(FullPath)')"
    Condition="'%(Extension)' == '.dll'"/>
   <_SGenDllsRelatedToCurrentDll
    Include="@(SerializationAssembly->'%(FullPath)')"
    Condition="'%(Extension)' == '.dll'"/>
  </ItemGroup>
 
  <!-- Flag primary dependencies-certain warnings emitted during application manifest generation apply only to them. -->
  <ItemGroup>
   <_DeploymentReferencePaths Include="@(ReferencePath)">
    <IsPrimary>true</IsPrimary>
   </_DeploymentReferencePaths>
  </ItemGroup>
 
  <!-- Create list of items for manifest generation -->
  <ResolveManifestFiles
   TargetFrameworkVersion="$(TargetFrameworkVersion)"
   SigningManifests="$(SignManifests)"
   EntryPoint="@(_DeploymentManifestEntryPoint)"
   ExtraFiles="@(_DebugSymbolsIntermediatePath);$(IntermediateOutputPath)$(TargetName).xml;@(_ReferenceRelatedPaths)"
   Files="@(ContentWithTargetPath);@(_DeploymentManifestIconFile);@(AppConfigWithTargetPath)"
   ManagedAssemblies="@(_DeploymentReferencePaths);@(ReferenceDependencyPaths);@(_SGenDllsRelatedToCurrentDll);@(SerializationAssembly)"
   NativeAssemblies="@(NativeReferenceFile);@(_DeploymentNativePrerequisite)"
   PublishFiles="@(PublishFile)"
   SatelliteAssemblies="@(IntermediateSatelliteAssembliesWithTargetPath);@(ReferenceSatellitePaths)"
   TargetCulture="$(TargetCulture)">
   <Output TaskParameter="OutputAssemblies" ItemName="_DeploymentManifestDependencies"/>
   <Output TaskParameter="OutputFiles" ItemName="_DeploymentManifestFiles"/>
   <Output TaskParameter="OutputEntryPoint" ItemName="_DeploymentResolvedManifestEntryPoint"/>
  </ResolveManifestFiles>
 
  <!-- Begin custom fragments - Generate all managed assemblies inside modules -->
  <CreateItem Include="$(OutputPath)Modules\**\*.dll">
   <Output TaskParameter="Include" ItemName="ManagedAssemblies" />
  </CreateItem>
  <CreateItem
   Include="@(ManagedAssemblies)"
   AdditionalMetadata="TargetPath=Modules\%(RecursiveDir)%(Filename)%(Extension);DependencyType=Install;">
   <Output ItemName="_DeploymentManifestDependencies" TaskParameter="Include" />
  </CreateItem>
  <!-- End custom fragments -->
 
  <PropertyGroup>
   <_DeploymentManifestType>ClickOnce</_DeploymentManifestType>
  </PropertyGroup>
 
  <!-- Obtain manifest version from ApplicationVersion and ApplicationRevision properties -->
  <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)">
   <Output TaskParameter="OutputVersion" PropertyName="_DeploymentManifestVersion"/>
  </FormatVersion>
  <FormatUrl InputUrl="$(_DeploymentUrl)">
   <Output TaskParameter="OutputUrl" PropertyName="_DeploymentFormattedDeploymentUrl"/>
  </FormatUrl>
  <FormatUrl InputUrl="$(SupportUrl)">
   <Output TaskParameter="OutputUrl" PropertyName="_DeploymentFormattedSupportUrl"/>
  </FormatUrl>
  <FormatUrl InputUrl="$(ErrorReportUrl)">
   <Output TaskParameter="OutputUrl" PropertyName="_DeploymentFormattedErrorReportUrl"/>
  </FormatUrl>
</Target>
</Project>

Note that most of the lines came from the original target delivered from Microsoft; the lines added are in Italic.

Finally you need include the new target in your project; open your csproj file with a text editor and include the following line before the </Project> end tag.

<Import Project="AssembliesCopy.targets" />

After that, when you publish the project again the assemblies from the folder Modules will be copied in your Published folder.

You can download a sample project here.

How to disable Copy and Paste for a control in WPF

Tue, 28 Apr 2009 19:40:00 GMT

By default all the TextBox’s (an other controls) in WPF have a default ContextMenu that allows copy, paste and cut. You can disable this menu by setting this property as “{x:Null}”, but the keys associated with the menu options still work. In order to disable this commands we can use the DataObject class, which have handlers to attach any DepencencyObject in case on Copy or Paste:

DataObject.AddPastingHandler(control, this.OnCancelCommand);
DataObject.AddCopyingHandler(control, this.OnCancelCommand);

Finally in the event handler we need to cancel the current command:

private void OnCancelCommand(object sender, DataObjectEventArgs e)
{
    e.CancelCommand();
}

The CancelCommand method will cancel any ApplicationCommand.Copy, ApplicationCommand.Paste and ApplicationCommand.Cut sent over the control.

WPF Validation with Attributes and IDataErrorInfo interface in MVVM

Fri, 17 Apr 2009 13:49:00 GMT

WPF provides validation infrastructure for binding scenarios through IDataErrorInfo interface. Basically you have to implement the Item[columnName] property putting the validation logic for each property in your Model (or ModelView) requiring validation. From XAML you need to set ValidatesOnDataErrors to true and decide when you want the binding invoke the validation logic (through UpdateSourceTrigger).

The idea of this post is try to generalize the validation logic in IDataErrorInfo.Item[] using the validation attributes in System.ComponentModel.DataAnnotations assembly.

First, we decorate each property needing validation with one or more validation attributes (An explanation of each validation attribute is out of the scope of this post) depending on the validation rules. For example if we have a property named Range we can add RangeAttribute to validate that the property value is between the boundaries:

[Required(ErrorMessage = "Field 'Range' is required.")]
[Range(1, 10, ErrorMessage = "Field 'Range' is out of range.")]
public int Range
{
    get
    {
        return this.range;
    }
    set
    {
        if (this.range != value)
        {
            this.range = value;
            this.OnPropertyChanged("Range");
        }
    }
}

Now, we need a few code to get the validation attributes and the value getters for each property requiring validation, just a couple of simple LINQ queries:

private static readonly Dictionary<string, Func<ValidationModelView, object>>
    propertyGetters = typeof(ValidationModelView).GetProperties()
                      .Where(p => GetValidations(p).Length != 0)
                      .ToDictionary(p => p.Name, p => GetValueGetter(p));
 
private static readonly Dictionary<string, ValidationAttribute[]> validators =
    typeof(ValidationModelView).GetProperties()
    .Where(p => GetValidations(p).Length != 0)
    .ToDictionary(p => p.Name, p => GetValidations(p));
 
private static ValidationAttribute[] GetValidations(PropertyInfo property)
{
    return (ValidationAttribute[])property
        .GetCustomAttributes(typeof(ValidationAttribute), true);
}
 
private static Func<ValidationModelView, object> GetValueGetter(PropertyInfo property)
{
    var instance = Expression.Parameter(typeof(ValidationModelView), "i");
    var cast = Expression.TypeAs(
        Expression.Property(instance, property),
        typeof(object));
    return (Func<ValidationModelView, object>)Expression
        .Lambda(cast, instance).Compile();
}

It is important emphasize that in order to improve the performance in the validation we use static dictionaries and Lamda expressions to generate the value getters. The validation attributes are cached in other dictionary in order to improve the performance too.

Finally we need implement the Item[columnName] property which is the part of code that really do the validation. It is very simple, WPF send the name of the property in the columnName argument, then all you have to do is get the value of the property using the propertyGetters dictionary and test this value against the validation attributes in the validators dictionary.

public string this[string columnName]
{
    get
    {
        if (propertyGetters.ContainsKey(columnName))
        {
            var value = propertyGetters[columnName](this);
            var errors = validators[columnName].Where(v => !v.IsValid(value))
                .Select(v => v.ErrorMessage).ToArray();
            return string.Join(Environment.NewLine, errors);
        }
 
        return string.Empty;
    }
}

All of this returns the list of message errors that will be shown in the UI.

You can do download a complete sample here.

MOQ 3.1 released

Thu, 16 Apr 2009 23:11:21 GMT

Finally MOQ 3.1 was released, it includes a lot of fixes of the previous version (3.0). You can get the binaries here.

Using expression trees to get property getter and setters

Fri, 10 Apr 2009 15:55:00 GMT

There are times when you need get and set property values and you do not know the type of the properties. One option is use reflection through GetValue and SetValue from PropertyInfo class, but this wears to poor performance in our code.

In order to do that we can use an Expression Tree to generate delegates that allow to get and set the value of the required property, for example building a couple of extensions methods applying to PropertyInfo:

public static class PropertyInfoExtensions
{
    public static Func<T, object> GetValueGetter<T>(this PropertyInfo propertyInfo)
    {
        if (typeof(T) != propertyInfo.DeclaringType)
        {
            throw new ArgumentException();
        }
 
        var instance = Expression.Parameter(propertyInfo.DeclaringType, "i");
        var property = Expression.Property(instance, propertyInfo);
        var convert = Expression.TypeAs(property, typeof(object));
        return (Func<T, object>)Expression.Lambda(convert, instance).Compile();
    }
 
    public static Action<T, object> GetValueSetter<T>(this PropertyInfo propertyInfo)
    {
        if (typeof(T) != propertyInfo.DeclaringType)
        {
            throw new ArgumentException();
        }
 
        var instance = Expression.Parameter(propertyInfo.DeclaringType, "i");
        var argument = Expression.Parameter(typeof(object), "a");
        var setterCall = Expression.Call(
            instance,
            propertyInfo.GetSetMethod(),
            Expression.Convert(argument, propertyInfo.PropertyType));
        return (Action<T, object>)Expression.Lambda(setterCall, instance, argument)
                                            .Compile();
    }
}

Now, we can use this extensions methods to retrieve the delegates for get or set a value, assuming that we have a class called ReflectedType and we have a valid PropertyInfo for this class:

var getter = property.GetValueGetter<ReflectedType>();
var setter = property.GetValueSetter<ReflectedType>();

Finally we can get or set the value, assuming that we have a valid instance of the ReflectedType type:

setter(reflectedType, 0);
var value = getter(reflectedType));

You can get the code here.

Moq 3.0 Final

Fri, 06 Mar 2009 23:23:39 GMT

Finally the new version of Moq is released, check the new improvements and fixes here.

You can get the binaries from http://moq.me/get.

Enjoy It !!!

Sticky notes add-in for Visual Studio

Wed, 07 Jan 2009 19:53:00 GMT

My coworker Pablo has released a nice Visual Studio add-in called Sticky Notes. Basically this add-in allows to write sticky notes in your code, that can be private notes or team notes.