SeeSharp

Mindscape WinRT Controls

Thu, 20 Dec 2012 14:34:05 GMT

As a part of my adventures on porting my suite of Calendar controls to Windows 8 and WinRT, I set to see how other companies are doing in providing components for Windows 8 development. Considering WinRT is a new market for component providers there are not so many companies with WinRT controls around. Mindscape is among very few others providing a promising suite of controls. Although still in Beta the controls have great feature set, astonishing look and feel and more importantly a good time to market which is a key factor at this stage if you're working on a Windows 8 application.

The controls are currently in Beta version and I also went an extra mile and downloaded their nightly build. The only issue I had was that I had to fix some references in the sample project to get it running (could be an issue with the nightly build I downloaded). Other than that the sample app ran just fine.

There are not so many user controls available in the suite yet. There is a Calendar and a DateTime Picker and a few text boxes with Autocomplete, Numeric, Integer, Up/Down support. I would have liked to see just one textbox control with all these features instead of having completely separate controls. Among other controls there is a Transition Control that you can use to have nifty animations when changing a content of a ContentControl, without going through the trouble of creating any complex animation. The Coverflow and Book controls would also provide similar functionality, but I don't see myself using them that much.

On the other hand wide range of Chart controls are available for you to pick from: Bar, Area, Pie, Line, Stock and a few more are all there and they look great. There's even a "Pallette" feature that allows you select a set of color that would match your corporate / application profile without having to style the chart control.

Even though I expected to see more controls, this is still in beta and I'm happy with where this is headed to. If you're into Windows 8 development, I recommend you grab the trial version and take a look for yourself.

Android Development for .NET Programmers

Sun, 18 Nov 2012 18:57:09 GMT

When it comes to mobile programming, Android is one of the vastly spread mobile OSes around, so how would you as a .NET programmer write android applications? It turns out there is a Monodroid project (currently in beta) which you can use to write android applications in C# and managed .NET environment and you can reuse your existing knowledge. Pretty cool, except it is a commercial framework once released. The alternative is to use freely available android tools and SDK, but the catch is that you need to be familiar with Java language instead of C#. But how different is that? Should it matter for a programmer at all? Let's find out.

Java Language
For a C# programmer, the language should be very similar as they are more similar and different. There are some differences in Generics, Iterators, etc. but those are easy to master. Of course you don't have C# 3.0 syntactic sugar luxuries in Java world. One thing that may seem odd for a .NET developer is the notion of inline classes which are non existing in .NET world. This construct allows you to specify an interface implementation inline, instead of creating a full blown class. This comes in handy for example, when you implement click listener interfaces on your class. Here's an example:

public class MyActivity extends Activity {
    protected void wireEventHandlers() {
        this.mybutton.setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                showMessage();
            }
        });
    }
}

In above example, "OnClickListener" is actually an interface where implementation (merely a method) is implemented inline. A .NET developer also may write the above snippet as this, which of course does the same job:

public class MyActivity extends Activity 
                            implements View.OnClickListener {
    
    protected void wireEventHandlers() {
        this.mybutton.setOnClickListener(this);
    }

    public void onClick(View view) {
        showMessage();
    }
}

The C# goodies I missed when developing in Java were mostly delegates and inability to use them as functional blocks of code, and also the most argued "var" keyword.

Tools of the Trade
There are two choices when you start developing Android applications. What most people use is the Eclipse IDE which is one of the worst IDEs I have ever worked with. Eclipse allows development for different platforms and languages: C/C++, Java, PHP and now Android. The good thing about it is that it is free and has a lot of plugins but that's about it.

It caused a lot of pain for me during the development and the IDE seems immature at best when compared with other IDEs or probably in your case, comparing to Visual Studio with all its bells and whistles.

Is there a better alternative? Fortunately, yes. Good guys at JetBrains have added Android development support to their Java IDE called IntelliJ Idea and if you have happened to use their Resharper plugin for Visual Studio, specially with IntelliJ Keyboard shortcuts, you'll feel right at home. IntelliJ Idea has a Community Edition that is free and open-source.

Other than an IDE you need to get Android SDK and emulator. You can download the SDK manager from this google web page and once downloaded you need to download a specific version of SDK for the android platform you plan to develop your application on, from within the SDK Manager.

Now that you have an IDE and downloaded the necessary SDK you're all set. In next post we'll start to write a small app that works with a REST API so that we see how things are easily done and how a regular .NET developer is able to write full blown Android application in no time.

Cracking .NET Assemblies

Sun, 09 Sep 2012 05:42:17 GMT

As a part of working in a Licensing component codebase, I'm checking commercial components to see how they implement licensing and the result, as you guess, is that mostly in-house (read dumb) lousy solutions are used for licensing and trial versioning. So if you see the key-gen for your application spread on the internet a couple of days after releasing a new version, maybe this post is meant for you.

If you've been a .NET developer for long enough, you probably know that your high level .NET Language (C# / VB.NET, etc.) is converted to Common Intermediate Language (CIL). That is true for all languages converting to Intermediate Langauge so the discussion here is not limited to .NET, nor it is a weakness of .NET languages per se.

So what's the big deal? The problem is that your assembly, can be converted BACK to IL, modified and saved, so malicious crackers can remove your copy protection pretty easily, so you need to take extra precautions to make it harder for cracker to do that.

You may think changing the IL code needs extensive amount of IL knowledge, but that is not true. To have better idea what to do, you need to put yourself in the cracker's shoe. Let's see a real world component and see how it can easily be cracked (I've removed/changed the names/namespaces to protect the innocent).

Disclaimer: This is to show software vendors and providers how to protected (or not protect) their intellectual property. Author is not responsible or liable for any misuse of the information provided here.

Chances are, when a cracker wants to remove the copy protection, he opens your assembly in Reflector to find out how the internals are working.

As you can see, this is the worst case scenario because the cracker can isolate the protection mechanism instantly just by looking at namespaces! It helps to put that code somewhere that is not so obvious, or even better, spread the protection code to a couple of places! Upon further investivation, he will find out that a simple Date object is used to track compilation date of the assembly and make it stop working after a predefined days are passed:

internal static class TrialSystem
{
    public static DateTime CompilationDate
    {
        get { return new DateTime(2011, 1, 1); }
    }
}

The easiest crack would be to change the CompilationDate to return DateTime.Now everytime accessed, so the application would never expire! But how'd you do that? Supposing the cracker has
limited knowledge of IL, he fires up the VisualStudio, writes the replacing code in C# / VB.NET and opens the output assembly in Reflector in IL language!

All needed is to replace this code with the one inside the assembly. Believe it or not, the tools needed are accompanied in .NET SDK! Open the VisualStudio 2010 Command Prompt and type the following on the same folder the assembly resides in:

ILDASM /OUT=SourceCode.il TheAssemblyName.dll

This dumps the IL code into SourceCode.il file and places the rest of the resources at the same folder so later all these files can be stitched back together. Cracker can now open the IL file in any text editor, replace old IL code with the one shown above and save the IL code back to disk. Now time to convert the IL back to regular assembly. The following command creates a .NET Assembly from the IL code:

ILASM /DLL SourceCode.il /OUT=NewAssembly.dll

Now he can use the new assembly without any limitation. If you think signing the assembly will prevent crackers, you're completely wrong. It may make it a little bit more laborious but the assembly is still vulnerable.

In next post, I'll show you some techniques to make this process a little harder for crackers, but remember, as a general rule of thumb if your application is worth more than couple of hundred dollars or has more than hundred users, chances are it WILL get cracked at some point.

DevExpress Scheduler and Hijri Shamsi Calendar

Wed, 11 Jul 2012 04:19:24 GMT

The level of customization that Silverlight comes with - even when you don't have access to the source code of the control you are using - is simply amazing. Those who experienced WinForms control customization or control centric web frameworks like ASP.NET already know how much trouble they face when customizing a 3rd party control, if there is any customization support at all. In fact people have been asking DevExpress to add RightToLeft support to their WinForms suite of controls, which is not going to happen for the same reason: it is hard to modify how a control looks without touching the other behavioral logics inside because those two are mixed together. Since in Silverlight and WPF the logic is completely kept separate from the presentation, you could twist the look and feel and make the control look how you want it to look.

A good example would be adding Hijri Shamsi calendar support to DevExpress scheduler controls. This now can be done by retemplating the whole Scheduler control and using date calculation support of my FarsiLibrary project. The best part is that unlike WinForms, the source code is not needed at all and you can apply this to the out of the box control directly.

Microsoft abandoning Silverlight platform in favour of HTML 5 makes my heart ache. Will there be that level of customization support in HTML 5 applications (and controls, maybe someday) is left to be seen.

Deferred Message Processing in NServiceBus

Wed, 27 Jun 2012 15:54:25 GMT

When working on a project using NServiceBus, we came up with an interesting requirement. The messages in the queue should be processed only in certain time frames. The reason is that message handler is making a webservice call and the other party is only available at certain times and system is not even allowed to make a call during the outage window. You can easily achieve this using Bus.Defer feature in version 3.0 of NServiceBus, but that would put the message at the back of the queue and would change the order of the messages which was very important from business perspective in our case. So we had to roll up our sleeves and dig a bit deeper. It turned out NServiceBus is using an ITransport interface to process the messages in the queue. The implementation that comes with NServiceBus is named TransactionalTransport. This is the class that handles the processing threads under the hood, so what if we set the number of processing threads to zero for a while, and when we need to resume processing, set it back to the default value (one or more threads)?

Udi suggests that you shouldn't actually use this, if possible. Instead send the message to the remote queue and let the other end worry about how and when to process it, but this may not work if you're working in a locked down environment or your customer would simply play it by their rules.

Okay here's the code snippet if you're interested.

public abstract class BaseCommandHandler<T> : IHandleMessages<T>
{
    private TimeSpan _wait = TimeSpan.FromSeconds(30);

    public TimeSpan DefaultWait
    {
        get { return _wait; }
        set { _wait = value; }
    }

    public virtual IBus Bus { get; set; }

    public virtual ITransport Transport { get; set; }

    public virtual void Handle(T message)
    {
        if (CanProcessMessage())
        {
            ProcessMessage(message);
        }
        else
        {
            PauseProcessing(DefaultWait);
        }
    }

    protected abstract void ProcessMessage(T message);

    protected virtual bool CanProcessMessage()
    {
        return true;
    }

    private void PauseProcessing(double interval)
    {
        Transport.PauseProcessing();
        Spin(interval);
    }

    private void Spin(double interval)
    {
        var timer = new Timer(interval) { Enabled = true };
        timer.Elapsed += OnSpinnigFinished;
        timer.Start();
    }

    private void OnSpinnigFinished(object sender, ElapsedEventArgs elapsedEventArgs)
    {
        var timer = (Timer) sender;
        timer.Enabled = false;
        timer.Dispose();
        Transport.ResumeProcessing();
    }
}

public static class TransportExtensions
{
    public static void PauseProcessing(this ITransport transport)
    {
        transport.AbortHandlingCurrentMessage();
        transport.ChangeNumberOfWorkerThreads(0);
    }

    public static void ResumeProcessing(this ITransport transport)
    {
        transport.ChangeNumberOfWorkerThreads(1);
    }
}

Distributed Transactions Tweaks in NServiceBus

Tue, 29 May 2012 02:00:10 GMT

While using NServiceBus on the first engagement at Readify, we had an interesting configuration. Development environment has a shared database which runs on a server but when creating the backend application, we're running NServiceBus on our local developer machines. When handling messages, NServiceBus creates an ambient transaction using MSDTC which spans multiple resources/machines and is of course a valuable feature because if an exception is thrown somewhere in your code when a message is being processed, database transactions (or any other DTC enlisted transactions for that matter) will automatically rollback so you won't have to write boilerplate code. This was problematic for us because DTC was not enabled on the database server so we couldn't test the application at all. We needed to tell NServiceBus not to use DTC around message consumers. You gotta love open-source projects because just by looking at the code we found out there is a property on TransactionalTransport named SuppressDTC which exactly does that, but how to set that?

You see, NServiceBus uses IoC containers to find its components, so in this case TransactionalTransport (an ITransport implementation) is created by the container, so we'd have limited access to where it is created or how it is being registered in the container and have no elegant way to set this property, but luckily we were using Castle Windsor container we could do much better with its extensibility model.

In case you don't know, Castle Windsor allows you to tap into creation of an object using ICommissionConcern (and a similar thing for when destroying an object). So all you needed to do to get called when an object of a certain type is created is to create a class implementing ICommissionConcern, which has only one method to implement. You also need to plug this class in and let the container know which component type is bound to this commission concern. This is done by implementing IContributeComponentModelConstruction interface and checking the interface or concrete type of the component that is being created. Too much said, you can see it all in one piece of code.

public class TransportTransactionConfig : IContributeComponentModelConstruction
{
    public void ProcessModel(IKernel kernel, ComponentModel model)
    {
        if (model.Implementation != typeof(TransactionalTransport))
            return;
	
        var concern = new TransactionSuppressConcern();
        model.Lifecycle.Add(concern);
    }
	
    private class TransactionSuppressConcern : ICommissionConcern
    {
        public void Apply(ComponentModel model, object component)
        {
            ((TransactionalTransport)component).SupressDTC = ShouldSuppressDTC;
        }

        private bool ShouldSuppressDTC
        {
            get { return bool.Parse(ConfigurationManager.AppSettings["SuppressDTC"]); }
        }
    }
}

Fun with Expression Trees

Mon, 21 May 2012 07:00:21 GMT

Logging is easy. We've all been there and done that, but when how do you log a request/response object of a webservice, specially when the WSDLs are being changed constantly? The requirements were easy, just log all the property names along with their values. The first obvious approach is the good old fashioned style:

public static string GetRequestLog(this ServiceRequest request)
{
    var sb = new StringBuilder();
    sb.AppendFormat("FirstProperty:{0}", request.FirstProperty);
    sb.AppendFormat("SecondProperty:{0}", request.FirstProperty);
    ... 
    sb.AppendFormat("LastProperty:{0}", request.LastProperty);
    return sb.ToString();
}

The problem is you code includes name and value of the property in two separate places and when you get an updated WSDL with most of the property names changed, you have to update two places, one of them being the property name in a string which makes it just harder to refactor and rename, but what can you do? You can shrug and say so be it, that is the problem at hand, until the next day you'll be handled the newer version of the WSDL, or you can do something about it.

If performance is not an issue (well you should know better to turn the debugging on in production), you can get away by passing in an expression of the property. This was you're passing in the property as well as it's value!

public static string GetRequestLog(this ServiceRequest request) 
{
    var sb = new StringBuilder();
    sb.AppendProperty(() => request.FirstProperty);
    sb.AppendProperty(() => request.SecondProperty);
    ...
    sb.AppendProperty(() => request.HundredthProperty);
    return sb.ToString();
}
    
public static class StringBuilderExtension
{
    public static void AppendProperty<T>(this StringBuilder sb, Expression<Func<T>> property)
    {
        var memberInfo = GetMemberInfo(property);
        sb.AppendFormat("{0}: {1}", memberInfo.Name, SafeToString(property.Compile().Invoke()));
    }

    private static MemberInfo GetMemberInfo(Expression expression)
    {
        var lambda = (LambdaExpression)expression;
        MemberExpression memberExpression;
        if (lambda.Body is UnaryExpression)
        {
            var unaryExpression = (UnaryExpression)lambda.Body;
            memberExpression = (MemberExpression)unaryExpression.Operand;
        }
        else
        {
            memberExpression = (MemberExpression)lambda.Body;
        }
        return memberExpression.Member;
    }

    private static string SafeToString(object obj)
    {
        return obj == null ? ("null") : obj.ToString();
    }
}

This of course is no magic these days, you probably have seen this when raising NotifyPropertyChange event in Caliburn or reading my blog post back in September 2008.

God Class and Helpers

Tue, 31 Jan 2012 14:29:24 GMT

While code reviewing a client's code base I found this gem.

Enough has been said about God Classes and Separation of Concerns but I still wonder how putting everything in one place and call it "Helper" can help you. Their argument? It is easier to find the function we are looking for if everything is in one class.

My Geek Origin Story

Thu, 19 Jan 2012 20:16:50 GMT

While spending my last days at my country and not working on an interesting project to blog about, I thought a post about how I happen to be what I am today is in order. While reading a blog post by Richard Banks, I was inspired to write my Geek Origin Story, a movement initially started by Michael Kordahi.

My dad used to work in department of power as an engineer as far as I can remember. I used to go with him to all power stations all around the country so eating out with other engineers and playing around gas turbines was something I was used to. Later when personal computers were taking off they grabbed one of the Siemens computers - they already had a lot of contracts with Siemens - and it was sitting there collecting dust in an office at the same floor as my dad's. The curious geek in me was getting itchy.

When I was only nine years old, on his visit to Italy my father brought home the best gift ever! A Casio PB-700 computer with four 4 KB memory modules, and it was attachable to an extension unit with a tape drive and a printer. With BASIC programming language built-in opportunities seemed endless. Ain't that a beaut?

Unfortunately the manual was in Italian, but I started pushing the program samples into it and somehow deciphered how it worked. Soon I was heading to my cousin's computer bookshop - almost one and the only bookshop dedicate to selling computer books in the capital city - to borrow or read a book or two. Around that time ZX-Spectrum were becoming more common and it supported another variation of Basic language. I had very hard time adjusting the samples for ZX-Spectrum books to run on my Casio computer but I managed to do it to some good extent and did a lot of PEEK / POKE in the making.

My next big computer was an Amiga 500. This one had a lot more juice in it and you could program it with C/C++, various Basic dialects, Pascal or other languages such as Oberon and Fortran - I barely knew any of them - but it also had a giant GPU so it suited very good for graphic applications. You see, personal computers back then mostly had a monochrome display and a command base OS while Amiga 500 had Graphical User Interface (GUI), a very rich music channels and a decent full-color monitor, so I was in for a good ride. This meant lots of Games, Music and Graphics, and did I mention games?

Once I was in high school my father ordered a 80-386 PC computer, with a 5 ¼” and 3 ½” floppy drives and 10 MB of hard disk! No it didn’t even have a mouse and no UI based OS. It ran MS-DOS 3.0 and it looked archaic comparing to my Amiga 500, but from the looks of how things were moving forward it seemed to be the future so I started reading more books and my cousin’s bookstore was a more common place. One of the best professional books I read was Dennis Ritchie's C programming language that put some sense into my brain.

By the time I was finishing high school, I helped the school's network administrator in removing the viruses or setup networking. After high school, being so fond of languages, I decided to study English language at university and learned French and Spanish - although not as good as I intended - in the process. Now although some find it strange and some other find it flat unacceptable, I see studying [real] languages has helped me lean computer languages and achieving my principal goal, which would have been next to impossible otherwise.

Well that was my geek story…what is yours?

Caliburn Meets TPL / Async

Tue, 18 Oct 2011 06:35:56 GMT

With C# and Async integration in the language, you'll wonder how this fits in your current application infrastructure. I have started porting an old application into Silverlight 5.0 which comes with new C# 5.0 and Async features and I needed a way to integrate this with the Calibrun framework I had in place.

Caliburn Async Abstractions

In Caliburn you could expose your ViewModel actions as IResult / IEnumerable<IResult>. I have blogged about this before, but in short, it is a good way to abstract away the whole async stuff you have in your ViewModel and it made testing async actions in the view model much easier. Here's a typical action I had on a ViewModel:

public IEnumerable<IResult> LoadEmployee()
{
    yield return Show.Busy();

    yield return new ServiceResult().Invoke(new EmployeeServiceClient().GetEmployeeAsync, SelectedEmployee.Id);

    yield return Show.NotBusy();
}

By using IResult we have modified the whole async and continuation into coroutines which is much cleaner to read and easier to follow.

Hello Async

Now with async stuff in the horizon, how would async / await fit this scenario? Let's suppose we have the following async method in our View Model:

private void LoadEmployeeAsync()
{
    var service = new EmployeeServiceClient();
    service.GetEmployeeCompleted += (s, e) => { CurrentEmployee = e.Result };
    var employee = service.GetEmployee(SelectedEmployee.Id);
}

At first we should convert this service call into the new async pattern:

private async Task<Employee> LoadEmployeeAsync()
{
    IEmployeeSevice service = new EmployeeServiceClient();

    return await Task.Factory.FromAsync<Employee>(client.BeginGetEmployee(SelectedEmployee.Id, null, null), ar => client.EndGetEmployee(ar));
}

A couple of things to notice: We are now using the interface of the generated service, which exposes IAsyncResult and we're returning the method call with a Task<TResult>. With the new async pattern, your method should either return void or Task / Task<T> before you can use the async keyword.

There's an IResult for that

Now the question is how to call the async method in a sequence of IResults. This would be the first attempt:

public IEnumerable<IResult> LoadEmployee()
{
    yield return Show.Busy();

    yield return new ActionResult(() => LoadEmployeeAsync());

    yield return Show.NotBusy();
} 

public class ActionResult : IResult
{
        public ActionResult(Action action)
        {
            ToExecute = action;
        }

        public Action ToExecute { get; set; }

        public override void Execute(ResultExecutionContext context)
        {
            ToExecute.Invoke();
            RaiseCompleted();
        }
}

Apparently this won't work as expected because as soon as we call the async method it will return and we'll fire the Completed event on IResult which will move to execution of the next IResult in the sequence. What we want to do is to wait for the completion of the Task and then raise the Completed event, so I came up with this implementation:

public class TaskResult : IResult
{
    public TaskResult(Func<Task> task)
    {
        ToExecute = task;
    }

    public Func<Task> ToExecute { get; set; }

    public override void Execute(ResultExecutionContext context)
    {
        ToExecute.Invoke().ContinueWith(task => 
         {
             Execute.OnUIThread(() => RaiseCompleted(task.IsCanceled, task.Exception));
         });
    }
}

This is just the same API that is available today on TPL, so nothing fancy, the only thing worth mentioning here is that we're raising the Completed event on the UI thread using Execute class of Caliburn. The Execute class uses IDispatcher interface that wraps Silverlight / WPF dispatcher object. The final version of the TaskResult can be used like this:

public IEnumerable<IResult> LoadEmployee()
{
    yield return Show.Busy();

    yield return new TaskResult<Employee>().Invoke(LoadEmployeeAsync).ContinueWith(task => CurrentEmployee = task.Result);

    yield return Show.NotBusy();
}

This now fully supports calling Task or Task<T> methods and also has its own continuation support. This works right alongside other IResult implementations. Ideas?

Introduction to WF Designer Rehosting - Part Three

Mon, 26 Sep 2011 18:06:04 GMT

In previous posts we saw how to bind our designer properties to our activity and use VB.NET syntax for more complex values. In this post let's see how to show variables and work with namespaces.

Importing Namespaces
If you want to use certain types in your Xaml, you need to import necessary namespaces, as an example our List<T> type is in Sysem.Collections.Generic namespace which needs to be imported for a valid WF Xaml. Let's see how this is done. When creating the WorkflowDesigner control, you initially need to create an empty workflow, like an empty Sequence or Flowchart and feed it to the Load method of the WorkflowDesigner:

private void CreateDesigner()
{
    designer = new WorkflowDesigner();
    designer.Load(CreateDefaultSequence());
    designer.Flush();
}

public Sequence CreateDefaultSequence()
{
    var seq = new Sequence {DisplayName = "Empty Sequence"};
    var settings = new VisualBasicSettings();
    var references = new VisualBasicImportReference {Assembly = "System", Import = "System.Collections.Generic"};
	
    settings.ImportReferences.Add(x));
    VisualBasic.SetSettings(seq, settings);

    return seq;
}

Although user can import necessary namespaces using the designer, it'd be ideal to automatically import mostly used namespaces upon designer startup.

Note: Load method of designer accepts "Object" which is ambiguous as the only type of objects I managed to feed it was ActivityBuilder, Sequence and Flowchart.

Displaying Variables
Sometimes you need to allow user to select an existing variable name and bind it to a property of your Activity. How do you do that? Remember the ModelItem property on your designer? The ModelItem property is hierarchical so traversing this you can gain access to the root element of your workflow (here we use a SequenceActivity) where defined variables can be found. ModelItem also has information about the type of the property so you can just select properties of certain type. The following extension method finds all available variables, regardless of their types:

public static IEnumerable<ModelItem> FindAllVariables(this ModelItem selectedItem)
{
    var variables = new List<ModelItem>();
    while (selectedItem.Parent != null)
    {
        Type parentType = selectedItem.Parent.ItemType;
        if (typeof(System.Activities.Activity).IsAssignableFrom(parentType))
        {
            var mp = selectedItem.Parent.Properties["Variables"];
            if (mp != null && mp.Collection != null && mp.PropertyType == typeof(Collection<Variable>))
            {
                mp.Collection.ToList().ForEach(variables.Add);
            }
        }
		
        var dels = selectedItem.Properties.Where(p => typeof(ActivityDelegate).IsAssignableFrom(p.PropertyType));
        foreach (var actdel in dels)
        {
            if (actdel.Value != null)
            {
                foreach (var innerProp in actdel.Value.Properties)
                {
                    if (typeof(DelegateArgument).IsAssignableFrom(innerProp.PropertyType) && null != innerProp.Value)
                    {
                        variables.Add(innerProp.Value);
                    }
                }
            }
        }
        selectedItem = selectedItem.Parent;
    }

    return variables;
}

Now to make this easier, let's think what is it that we want to select? We need the name of the variable, along with related ModelItem information, so let's create a Model class to contain this information:

public class VariableItem : Observable
{
    public VariableItem(string name, ModelItem variable)
    {
        Name = name;
        Variable = variable;
    }

    public string Name { get; set; }

    public ModelItem Variable { get; set; }
}

It is easier now to bind a ComboBox to a list of VariableItem instances. All we need to do is to get all the variable of certain types (or all the variables, regardless of their types) as a list of VariableItems and bind it in the designer. This extension method will do the trick for you and has both generic and non-generic flavors:

public static IEnumerable<VariableItem> FindVariableOfType(this ModelItem selectedItem, Type typeToFind)
{
	var variables = FindAllVariables(selectedItem);
	var found = new Dictionary<string, ModelItem>();

	variables.ForEach(x =>
	{
		var name = x.Properties.GetValue<string>("Name");
		var type = x.Properties.GetValue<Type>("Type");

		if (type == typeToFind)
		{
			found.Add(name, x);
		}
	});

	return found.Select(x => new VariableItem(x.Key, x.Value));
}

public static IEnumerable<VariableItem> FindVariableOfType<T>(this ModelItem selectedItem)
{
	return FindVariableOfType(selectedItem, typeof (T));
}

Notice ModelItem has information about the variable, like name of the variable and the underlying type of the variable. In next post we'll see how to use complex objects in our activities and how to fill and serialize them to / from xaml from our custom designers.

Introduction to WF Designer Rehosting - Part Two

Mon, 26 Sep 2011 18:05:53 GMT

In first part of this serie we saw how to bind our designer properties to activity properties and create a custom designer for our activity. Let's see how to bind to activity properties through the designer and allow user to enter values in the designer.

If you have some experience with WF Activities you know that input properties are of type InArgument<T> so how do we convert and bind our regular types to a InArgument<T>?

Let's go with simple types like String, supposing our SendTo activity has an Enabled property of type InArgument<bool> and we have a CheckBox on our designer. First approach would be to bind directly through ModelItem property of the designer, inherited from the base class by using a ValueConverter:

<CheckBox IsChecked="{Binding Path=ModelItem.IsEnabled, Mode=TwoWay, Converter={StaticResource ValueToInArgumentLiteralConverter}}" />

public class ValueToInArgumentLiteralConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value != null)
        {
            var modelItem = value as ModelItem;
            if (modelItem != null)
            {
                var expr = modelItem.Properties["Expression"];
                if(expr != null)
                {
                    return expr.Value;
                }
            }
        }

        return null;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null) return null;

        var type = typeof (InArgument<>);
        var genericArgument = type.MakeGenericType(value.GetType());
        var argument = Activator.CreateInstance(genericArgument, value);
			
        return argument;
    }
}

This approach works fine but only for simple scenarios. If you want more control on selected properties, changing values, having dependent properties or if your designer UI is complex, I advise using a ViewModel instead. You can access current ModelItem from your view:

public interface ISendToDesigner
{
    ModelItem ModelItem { get; }
}

public class SendToViewModel 
{
    public virtual dynamic SelectedModelItem
    {
        get { return View != null ? View.ModelItem : null; }
    }

    public virtual bool IsEnabled
    {
        get { return isEnabled; }
        set
        {
            isEnabled = value;
            RaisePropertyChanged(() => IsEnabled);
            UpdateModelProperties();
        }
    }

    private void UpdateModelProperties()
    {
        SelectedModelItem.IsEnabled = IsEnabled.ToInArgument();
    }
}

Did you see SelectedModelItem is of dynamic type? Exposing underlying ModelItem as dynamic allows us to directly assign properties without going through indexers. This trick results in much cleaner and better maintainable code, supposing you have unit tests for your view models! Also I'm using an extension method named ToInArgument which converts the primitive values to InArgument. Here's the extension method:

public static InArgument<T> ToInArgument<T>(this T value)
{
    return new InArgument<T>(value);
}

This works for primitive values but what if you have Enums, Guids, Lists or Dictionary properties on your Activity? Unfortunately though this seem to work, it won't and designer shows an error. The alternative would be to use VisualBasicValue<T> instead. If you are a C# developer, welcome yourself to the world of VB.NET!

Seems VisualBasicValue<T> can be assigned as InArgument<T> so you just need to convert your values to a VisualBasicValue. This approach works file with Enums as well, too bad you can not create an extension method with Enum constraint. Here's an extension method that converts your enum to VisualBasicValue:

public static InArgument<T> ToExpression<T>(this T value)
{
    return new VisualBasicValue<T>(string.Format("{0}.{1}", typeof(T).Name, value));
}

Now List and Dictionaries are a little bit different. Let's see how I convert List<Guid> to a VisualBasicValue and you can use the same approach to make it work for all generic types:

public static InArgument<List<Guid>> ToExpression(this List<Guid> list)
{
    var expr = "New List(Of Guid) From {{{0}}}";
    var item = list.Select(i => string.Format("New Guid(\"{0}\")", i));
    var items = string.Join(",", item);

    return new VisualBasicValue<List<Guid>>(string.Format(expr, items));
}

On the next part of this post, we'll see how to allow user to select existing variables (of a specific types) and import needed namespaces into our workflow xaml.

Introduction to WF Designer Rehosting - Part One

Mon, 15 Aug 2011 17:32:53 GMT

I've recently been creating custom designer for Workflow Activities and hosting the whole WF designer in a web application. As there is very limited documentation and guide other than Microsoft Forums, here I'll try to shed some lights to some of the problems I have encountered.

WF 4.0 designer is a set of WPF controls and classes designed with re-hosting in mind, so hosting the designer in an XBAP application works to some extent without any pain. To start create a WPF (either browser or desktop) application that will be used as your WF Designer. There are a couple of controls you can add to your main window that make it look like out of the box designer:

Toolbox Control: Is the toolbox control that contains your activities. You can create Categories and place your own and system activities into separate categories.

Workflow Designer: Is the control that does all the heavy lifting like hosting the activities, generating xaml, loading and saving, etc.

Property Editor: Workflow designer has a UIElement that is the property editor you can use to edit properties of the workflow/activity.

Let's say you have a Send activity that sends out an email to selected recipients. You need to create a custom designer for the activity. The good thing is you don't need to anything to the source code of the activity, thanks to IRegisterMetadata interface, you can add attributes to your activities from the outside. For those familiar with WPF Design Time integrations, this is the same thing. To add necessary designer attribute to your Activity, you should do something like this:

public class SendToRegisterer : IRegisterMetadata
{
    [SecurityCritical]
    public void Register()
    {
        var builder = new AttributeTableBuilder();

        builder.AddCustomAttributes(typeof(SendTo), new DesignerAttribute(typeof(SendToDesigner)));
        builder.AddCustomAttributes(typeof(SendTo), "Receiver", new BrowsableAttribute(false));
        builder.AddCustomAttributes(typeof(SendTo), "Subject", new BrowsableAttribute(false));
			
        MetadataStore.AddAttributeTable(builder.CreateTable());
    }
}

There are two things happening here: First we set the designer of SendTo activity to SendToDesigner, then we set BrowsableAttribute with False value to the properties of SendTo. This makes the properties hidden on the property editor so you can make sure user can only interact with your activity through the designer.

To create the designer class you need to create a WPF UserControl and make it derive from ActivityDesigner in http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation namespace. Among many things, this base class has a ModelItem property that allows interacting with the activity that is being displayed. You can bind activity properties to your designer directly using this property or alternatively bind the designer UI to your ViewModel and update the ModelItem property when you want to replicate the changes to the Model Item and update / generate WF Xaml.

On the next post, we'll see how to bind designer UI to our activity properties.

Installing Microsoft Dynamics on a XP machine

Wed, 06 Jul 2011 09:10:42 GMT

The other day, I was starting a new gig to integrate an in-house sales system with Microsft Dynamics and naturally I needed to install MSDynamics on my machine. The best option was to install it on a VM so that I get rid of it after the project is done. I decided to install it on a Windows XP machine that needs less resource to run, but I bumped into something interesting:

It seems Micorosft Dynamics only installs on your machine if you have connected to a domain controller. But I don't have any domain controller, now what?

The first solution is to download and install a [trial] version of Windows Server 2003/2008, add your XP machine to the domain, install, and then you are free to kill the domain controller altogether, but all these efforts just to install an application seems ridiculous.

A better solution was to modify registery keys to fool your OS and make it think you are connected to a domain controller, but the server is not reachable at the moment! To do this, go to this registery key:

HKLM\System\CurrentControlSet\Control\ComputerName\ActiveComputerName

Enter any new name e.g. "VM" into this registery key. Now you also need to set an environment variable. You can do this using command prompt or by going to Control Panel, System, System Properties, Environment Variables. Add a new environment variable under System variables. The variable key is "UserDnsDomain" and you need to enter the same value you have entered in the registery key. You are all set. Run the installation and it will work this time. Remember to revert the registery key back to its original value when you are finished installing.

One day in Kanban Land (Farsi)

Mon, 20 Jun 2011 08:39:12 GMT

If you are into agile methodologies, you probably have seen the comic strips "One Day In Kanban Land" by Henrik Kniberg. He discussed it in mode depth with us in his Scrum Master course a while ago. This is the Farsi translated version. If you have seen the original one, or don't speak Farsi, you may skip this post.

WPF Application with Caliburn - Part Four

Mon, 06 Jun 2011 05:27:30 GMT

This is the next serie in the Caliburn tutorials. You can find previous post: Part One, Part Two, Part Three

One of the best features of Caliburn framework that I haven't seen in other MVVM frameworks, is a feature called Coroutines. Coroutines are according to Wikipedia:

In computer science, coroutines are program components that generalize subroutines to allow multiple entry points for suspending and resuming execution at certain locations. Coroutines are well-suited for implementing more familiar program components such as cooperative tasks, iterators,infinite lists and pipes.

This feature is extremely useful if you do async programming like accessing data over a webservice or execution of long running tasks on the background thread. Let's take a closer look on how to use this feature and how it helps us developing better applications and results in more maintainable code.

Note: This post will work equally on Caliburn 1.1 and 2.0.

A Recap on Actions
If you have seen other parts of Caliburn posts, Caliburn facilitates implementing MVVM by eliminating usage of ICommands. Forget about implementing ICommand interface or using RelayCommands. You can not directly bind your events to public actions on your ViewModel class. You no longer are limited by controls having commands, you can bind any arbitrary event to any public method on your ViewModel. Caliburn also checks for any existing preconditions based on the convention. The precondition, called Filters, are properties name the same as your action, but with a "Can" prefix. Here's how it looks to bind:

<Button cal:Message.Attach="[Event Click] = [Action ShowCustomers]">

public virtual bool CanShowOrders 
{
    get { return _canShowOrders; }
    set 
    {
        _canShowOrders = value;
        NotifyOfPropertyChanged(() => CanShowOrders);    
    }
}

public virtual void ShowOrders()
{
    CurrentPresenter = ViewModelFactory.Create<IOrderViewModel>();
}

Using Coroutines
Your action that used to return void can return a special return type that will be handeld by Caliburn upon execution. If your method returns an instance of IResult interface it will be treated differently. First let us look at IResult interface:

public interface IResult  
{  
    void Execute(ActionExecutionContext context);  
    event EventHandler<ResultCompletionEventArgs> Completed;  
}

Very simple to implement! Basically, Execute method is called by Caliburn and this is where you implement the execution logic of this action. Caliburn then pauses unitl your action fires "Completed" event at which point it understands that action has compeleted and is finished. Where's the power, you may ask? Well you can send multiple IResults instanced from your action method by returning an IEnumerable<IResult> and since Caliburn waits for each action to fire its Completed event, all IResult instances are processed sequentially. An example is displaying a progress window, firing up a background worker to do a long running process data and stop progress window when the background worker is finished, let's see how:

public IEnumerable<IResult> LoadOrders()
{
    yield return ProgressResult.Show("Loading Orders");
    yield return new ServiceFetchResult(...);
    yield return ProgressResult.Hide();
}

And the outcome is that the progress window is still showing until ServiceFetchResult has finished the long running procedure.

Remember how specially IResults are treated. In the above example, enumerable items are only processed if the previous one's Completed event is fired. This helps a lot when you do async style programming, specially in Silverlight which almost every outgoing request should run asynchronously.

Testability
If you have used an async service, you know how painful it is when it comes down to testing. The problem is how the Async model works, and the easiest way is the same way you connect to webservices in Silverlight: First you subscribe to the event that is called when operation is completed, then you call the async method and wait for it to call you back on the callback handler. If you want to abstract it in an interface, it'd be something like this:

public class FetchOrdersCompletedEventArgs : AsyncCompletedEventArgs
{
    public FetchOrdersCompletedEventArgs(Exception error, bool cancelled, object userState) 
        : base(error, cancelled, userState)
    {
    }
}

public class OrdersDataClient
{
    public void FetchOrdersAsync()
    {
        //some stuff
    }

    public event EventHandler<FetchOrdersCompletedEventArgs> FetchOrdersCompleted;
}

The problem with this code which makes it unsuitable for testing is that you usually generate proxies for your services and this piece of generated code has numerous problems: there's no clean interface and even generated methods are not virtual, making the whole thing unreplaceable in testing (at least by conventional tools). Notice that this implemnentation of async pattern which uses events is much cleaner than the one using IAsyncResult and callbacks, but still not much good in unit testing.

Now lets sit back and see what is it that we want to test? Let's suppose we want to test that LoadOrders will load orders from the correct service operation, how would we do that?

[Test]
public void Orders_Are_Loaded_From_Service()
{
    var mockService = Mock<OrdersServiceClient>();

    var vm = new OrderViewModel(mockService);

    vm.LoadOrders();

    mockService.AssertWasCalled(x => x.FetchOrdersAsync());
}

This code would have worked unless you can't mocked out the service that easily, remember? Now here's how using IResult would help you test the same thing, but with a changed mindset:

[Test]
public void Orders_Are_Loaded_From_Service()
{
    var vm = new OrderViewModel();

    var results = vm.LoadOrders().ToList();
    var fetchRequest = results[1] as ServiceFetchResult;
            
    Assert.NotNull(fetchRequest);
    Assert.That(fetchRequest.Action.Method.Name, Is.EqualTo("FetchOrdersAsync"));
}

Conclusion

If you need to go through this in more detail, feel free to grab the source code of this part from here. This one uses the latest Caliburn 2.x version. We'll cover how to migrate from version 1.5 in the next post.

Farsi Library - Version 2.0 now available

Fri, 27 May 2011 12:08:12 GMT

Version 2.0 of FarsiLibrary is now available. The following changes are made in this release :

Modified : Migrated to Visual Studio .NET 2008. Still using .NET Framework 2.0, so you just need the new IDE to compile. Might affect clients using old .NET Framework 2.0 (without the new SP Installed).
Modified : IComparer and IComparer are converted to explicit implementation in PersianDate class.
Modified : ICloneable interface implementation is converted to explicit implementation in PersianDate class.
Modified : Assign method of PersianDate to internal.
Modified : Changed the Day/Month/Year change eventhandler type to EventHandler. You can use the New/Old value properties to access the underlying values.
Modified : FALocalizeManager now is a singleton class. Use the Instance property instead of static methods.
Modified : FAMessageBoxManager.Delete method now returns boolean value based on whether the delete operation was successful or not.
Added : Implementation of IsLeapMonth method in PersianCalendar.
Added : Solution Items folder.
Added : Partial Office 2007 Blue theme. Drawing of dropdown buttons of FADatePicker control need a better visualization.
Added : PainterFactory to create painters based on the state of BaseStyledControl.
Added : FAMessageBox now implementes IDisposable interface explicitly. Dispose method is made internal.
Fixed : When changing the culture, Year value didn't change, e.g. when in Farsi culture in year 1385 culture is set to english, the year remain 1385 (which was a valid year in English calendar).
Fixed : When changing the DefaultCulture property, Day and Month properties did not return the culture-specific values.

Fixed : A bug when accessing Now property of PersianDate class.

Please report any bug you might encounter. You can download the source code from here and the binary (including test project executables) from here.

More information about this project can be found on my Code Project article at here.

Resharper 4.0 Released

Fri, 27 May 2011 11:57:18 GMT

You need to wait no longer! Resharper 4.0 is here.

Besides Support for C# 3.0, LINQ and XAML, which is great, there are lots of other enhancements in this release which makes it a "Must Have". Did I mention my little favorite feature, CamelHumps is also there? To get your hands dirty and know what's new in this release, check the Product's overview page here.

NHibernate 2.0 Released

Fri, 27 May 2011 11:56:43 GMT

The good news, after not-so-good news about Reflector, is that NHibernate 2.0 is finally released. This version's feature is comparable with Java Hibernate 3.2 so, this might be a giant step forward. If you're new to NHibernate, you definitely want to check out the http://www.summerofnhibernate.com web site, which contains screencasts that will minimize your learning curve. There'll be some sessions regarding new features of NHibernate 2.0, so keep an eye out.

Enhanced INotifyPropertyChanged - Revisited

Fri, 27 May 2011 11:55:02 GMT

A while a go, I had a post regarding how to implement the INotifyPropertyChanged event in a more proper fashion. You didn't have to hard-code the property name, and could instead use a linq expression, which with a help of an extension method, the name of the property is easily extracted, and passed to raise the PropertyChanged event. Simple, right?

public static class EventExtension
{
  public static void Notify<T, TValue>(this T instance, PropertyChangedEventHandler handler, Expression<Func<T, TValue>> selector)
     where T : INotifyPropertyChanged
  {
      if (handler != null)
      {
          var memberExpression = selector.Body as MemberExpression;
          if (memberExpression == null)
              throw new InvalidOperationException("selector should be a MemberExpression.");

          handler(instance, new PropertyChangedEventArgs(memberExpression.Member.Name));
      }
  }
}

public abstract class NotificationAwareBase : INotifyPropertyChanged
{
  public event PropertyChangedEventHandler PropertyChanged;
}

public class Customer : NotificationAwareBase
{
  private string _Name;

  public string Name
  {
      get { return _Name; }
      set
      {
          _Name = value;
          this.Notify(base.PropertyChanged, o => o.Name);
      }
  }
}

Should work like a charm, right? WRONG! you'll end up with a compile time error. It is like the extension method does not like my inherited PropertyChanged event. The drawback to the latter method was that you could not use it in inheritance context.

I need to implement INotifyPropertyChanged only once (Layer Supertype, anyone?). I had to come up with something to be able to work in inheritance context. Finally, here's it :

public abstract class NotificationAware : INotifyPropertyChanged
{
  private event PropertyChangedEventHandler propertyChangedEvent;

  public event PropertyChangedEventHandler PropertyChanged
  {
      add
      {
          propertyChangedEvent += value;
      }
      remove
      {
          propertyChangedEvent -= value;
      }
  }

   protected void Notify<T>(T obj, Expression<Func<T, object>> selector)
  {
      if (propertyChangedEvent != null)
      {
          MemberExpression memberExpression = selector.Body as MemberExpression;
          if (memberExpression == null)
          {
              UnaryExpression unary = selector.Body as UnaryExpression;
              if (unary != null)
              {
                  memberExpression = unary.Operand as MemberExpression;
              }
          }

          if(memberExpression == null)
              throw new ArgumentException("member should be of MemberExpression type", "selector");
        

          propertyChangedEvent(this, new PropertyChangedEventArgs(memberExpression.Member.Name));
      }
  }
}

public class Customer : NotificationAware
{
  private string _Name;
  public string Name
  {
      get { return _Name; }
      set
      {
          _Name = value;
          Notify(this, o => o.Name);
      }
  }
}

Happy coding!