INotifyPropertyChange – notifying about change of all properties at once

2014-08-242016-01-30 TPodolakINotifyPropertyChanged, MVVM, Silverlight, WPF1 Comment

Today, working on a new feature for my pet project, I realized that I have to notify the view, that all properties in view model have changed. The most obvious way to achieve that would, of course be to rise PropertyChange event a bunch of times.

protected virtual void OnPropertyChanged(Expression<Func<object>> propertyExpression)
{
   //..
   //implementation
   //..
}

protected virtual void OnPropertyChanged(string propertyName)
{
   //..
   //implementation
   //..
}

public void Refresh()
{
   OnPropertyChanged(() => FirstProperty);
   OnPropertyChanged(() => SecondProperty);
   OnPropertyChanged(() => ThirdProperty);
   //and so on ...
}

protected virtual void OnPropertyChanged(Expression<Func<object>> propertyExpression)

{

//..

//implementation

//..

}

protected virtual void OnPropertyChanged(string propertyName)

{

//..

//implementation

//..

}

public void Refresh()

{

OnPropertyChanged(() => FirstProperty);

OnPropertyChanged(() => SecondProperty);

OnPropertyChanged(() => ThirdProperty);

//and so on ...

}

This is good solution for one time usage, however I was interested in something more general, something which could be extracted to base view model. Fortunately, it turns out that there is a simple trick to do that. All You have to do is use an empty string or null as a property name. So in my case this comes down to this one-liner

public void Refresh()
{
   OnPropertyChanged(string.Empty);
}

public void Refresh()

{

OnPropertyChanged(string.Empty);

}

NHibernate – generating WHERE IN … OR … queries

2014-08-182016-01-30 TPodolak.NET, c#, Disjunction, Nhibernate, QueryOver, Restrictions

Let’s assume that we have a simple table GL_Task which looks like this

I was asked to rewrite simple SQL query

SELECT Id,Name,IdProject FROM GL_Task WHERE Name = 'First task' OR Id IN (3,4 /*more id's to come*/)

1	SELECT Id,Name,IdProject FROM GL_Task WHERE Name = 'First task' OR Id IN (3,4 /more id's to come/)

using NHibernate’s QueryOver API. As simple as it may seem, solution for this particular problem is not straightforward. My first (not so clever) attempt was simply combining WhereRestrictionOn and Where clause

var result = session.QueryOver<Task>().Where(val=> val.Name == "First task")
                                      .WhereRestrictionOn(val=> val.Id)
                                      .IsIn(new []{3,4})
                                      .List();

var result = session.QueryOver<Task>().Where(val=> val.Name == "First task")

.WhereRestrictionOn(val=> val.Id)

.IsIn(new []{3,4})

.List();

Of course this query returns wrong data because of the fact, that NHiberante by default “joins” queries using AND operator. So above query will result in generating something like that

SELECT Id,Name,IdProject FROM GL_Task WHERE Name = 'First task' AND Id IN (3,4 /*more id's to come*/)

1	SELECT Id,Name,IdProject FROM GL_Task WHERE Name = 'First task' AND Id IN (3,4 /more id's to come/)

After a little digging I managed to write appropriate query

var orRestriction = Restrictions.Or(
                         Restrictions.Where<Task>(val => val.Name == "First task"),
                         Restrictions.On<Task>(val => val.Id).IsIn(new[] { 3,4 }));

var result = session.QueryOver<Task>()
                    .Where(orRestriction)
                    .List();

var orRestriction = Restrictions.Or(

Restrictions.Where<Task>(val => val.Name == "First task"),

Restrictions.On<Task>(val => val.Id).IsIn(new[] { 3,4 }));

var result = session.QueryOver<Task>()

.Where(orRestriction)

.List();

Although this code generates correct SQL, it is hard to use it in case of many OR statements. For example, adding one more OR force us to write

var orRestriction = Restrictions.Or(
      Restrictions.Or(
            Restrictions.Where<Task>(val => val.Name == "First task"),
            Restrictions.On<Task>(val => val.Id).IsIn(new[] {3, 4}) 
       ),
       Restrictions.On<Task>(val => val.Name).IsIn(new[] {"FirstTask", "SecondTask"})
);

var result = session.QueryOver<Task>()
                    .Where(orRestriction)
                    .List();

var orRestriction = Restrictions.Or(

Restrictions.Or(

Restrictions.Where<Task>(val => val.Name == "First task"),

Restrictions.On<Task>(val => val.Id).IsIn(new[] {3, 4})

Restrictions.On<Task>(val => val.Name).IsIn(new[] {"FirstTask", "SecondTask"})

);

var result = session.QueryOver<Task>()

.Where(orRestriction)

.List();

In my opinion this is a little bit hard to read, so I continued my searching to find more elegant solution. My third attempt was based on Restrictions.Disjunction

var disjunctinos = Restrictions.Disjunction()
                           .Add(Restrictions.Where<Task>(val => val.Name == "First task"))
                           .Add(Restrictions.On<Task>(val => val.Id).IsIn(new[] { 3,4 }));
                           
var result = session.QueryOver<Task>()                    
                    .Where(disjunctinos)                    
                    .List();

var disjunctinos = Restrictions.Disjunction()

.Add(Restrictions.Where<Task>(val => val.Name == "First task"))

.Add(Restrictions.On<Task>(val => val.Id).IsIn(new[] { 3,4 }));

var result = session.QueryOver<Task>()

.Where(disjunctinos)

.List();

This was almost perfect solution. Adding new OR statements do not require us to do function nesting

var disjunctinos = Restrictions.Disjunction()
                          .Add(Restrictions.Where<Task>(val => val.Name == "First task"))
                          .Add(Restrictions.On<Task>(val => val.Id).IsIn(new[] { 3,4 }))
                          .Add(Restrictions.On<Task>(val => val.Name).IsIn(new[] { "FirstTask", "SecondTask" }));

var result = session.QueryOver<Task>()
                    .Where(disjunctinos)
                    .List();

var disjunctinos = Restrictions.Disjunction()

.Add(Restrictions.Where<Task>(val => val.Name == "First task"))

.Add(Restrictions.On<Task>(val => val.Id).IsIn(new[] { 3,4 }))

.Add(Restrictions.On<Task>(val => val.Name).IsIn(new[] { "FirstTask", "SecondTask" }));

var result = session.QueryOver<Task>()

.Where(disjunctinos)

.List();

However the ultimate solution is to just add NHibernate.Criterion namespace and use IsIn extension method. This operation simplify our query into single lambda expression

var result = session.QueryOver<Task>()
                    .Where(val => val.Name == "First task" || val.Id.IsIn(new[] { 3,4 }))
                    .List();

var result = session.QueryOver<Task>()

.Where(val => val.Name == "First task" || val.Id.IsIn(new[] { 3,4 }))

.List();

Source code for this post can be found here

Resharper – localizable string literals

2014-08-172016-01-30 TPodolakGlobalization, Localization, R#, Resharper

Everyone who has ever tried to create multilingual application knows, that this is very tedious task. The most repetitive work is usually moving hard-coded strings to resource files. Fortunately with Resharper this is definitelly less painfull than usuall.
In order to point out localizable parts of application , it is necessary to decorate classes with System.ComponentModel.LocalizableAttribute. However, usually we want to localize an entire program, so more universal solution is to set appropriate project configuration in properties window. To bring up this window, select project file and then press F4 button.

From now on, Resharper shows warnings indicating that our hard-coded strings might be moved to resource file. Pressing ALT+ENTER on these strings will bring up the context menu action, where new option – “Move to resource” is available.

Choosing this option will bring up the “Move to Resource” window. However if we do not have any resource files in our project, we will get this message.

In order to create these files, right click on project and choose Add->New Item. Now, select Resource.resx file and name it for example LocalizableStrings.resx.

In this resource file we will store values for our “default language”. Supporting more languages require us to create additional LocalizableString files with appropriate LETF tags suffixes.

Now, we are able to move our hard-coded string to resource files.

By default Resharper adds hard-coded strings to default resource file, so we have to specify values for localizable string for other languages. In order to do that, first navigate to resource entry in LocalizableStrings.resx file by holding CTRL and clicking property “Program_Main_This_is_localizable_string”

and then press ALT+ENTER and choose “Override ‘PropertyName…'”. This operation brings up “Edit Resource” window where You can easily navigate between resource files and update given resource property

Resharper not only is able to move strings to resource files but also can use existing ones. This basically means that if we use hard-coded string which already has been added to resource file, Resharper will suggest to use predefined resource