But luckily there are people in this world who are more ingenious than me… it is possible. You must write a little bit of code on the Object-prototype but it is quite self explaining. The code is found here: Eli Grey’s Gist.

I copy/pasted the code here below (changed some formatting). But again… All credits go to Eli Grey.

// object.watch
if (!Object.prototype.watch)
{
    Object.prototype.watch = function (prop, handler)
    {
        var val = this[prop],
        getter = function ()
        {
            return val;
        },
        setter = function (newval) {
            return val = handler.call(this, prop, val, newval);
        };
        if (delete this[prop]) { // can't watch constants
            if (Object.defineProperty) { // ECMAScript 5
                Object.defineProperty(this, prop, {
                   get: getter,
                   set: setter
                });
            }
            else if (Object.prototype.__defineGetter__ &&
                     Object.prototype.__defineSetter__) //legacy
            {
                Object.prototype.__defineGetter__.call(this, prop, getter);
                Object.prototype.__defineSetter__.call(this, prop, setter);
            }
        }
    };
}

// object.unwatch
if (!Object.prototype.unwatch)
{
    Object.prototype.unwatch = function (prop) {
        var val = this[prop];
        delete this[prop]; // remove accessors
        this[prop] = val;
    };
}

That’s it… works great…

Happy Coding…

While doing some refactoring I ran into the following code which was intended to convert a negative integer to a string with leading zeros.

int value = GetValue();
string val = "-" + (value * -1).ToString().PadLeft(2, '0');

This can be done much easier. And it works for positive and negative integers. Check the improved code below.

int value = GetValue();
string val = value.ToString("D2");

For a complete list of the possibilities for converting a integer into an string check the MSDN website for Standard Numeric Format Strings:

Happy coding…

The problem described above emerged when I was working with OpenLayers. We have made a lot of changes to OpenLayers and therefore I do not use the merged OpenLayers file but the separate source files. OpenLayers comes with a Python build script which orders the sourcefiles (based on it’s hierarchy) and compresses it to one file. Due to some circumstances the standard OpenLayers build script had to be changed significantly. The changes where bigger than my knowledge of Python and therefore I decided to make a .NET builder which will do the same thing as the Python script but with my changes in it.  And then I ran into the problem with the correct order of files.

OpenLayers files has a ‘@ reguires’ commentline in it’s files which determines the dependency between the files. I started to create a class which represents the OpenLayers file:

internal class OpenLayersFile: IComparable<OpenLayersFile>
{
    public OpenLayersFile(string filename)
    { ... }

    public string Name { get; set; }
    public List<string> DependsOn { get; set; }
    public int CompareTo(OpenLayersFile otherFile)
    { ... }
}

The class was simple. It has a Name – property which is the concatenated name of the file (e.g. OpenLayers/Layer/WMS.js). and a DependsOn – property which is a list of “Names” of the files it depends on. The CompareTo method just does a check if DependsOn contains the Name of the file it’s compared to. The logic is omitted because it will clutter up the code snippet and doesn’t add value to this post.

Because List<T>.Sort() didn’t work as described expected as described above I created my own Dependency Walker which runs down all the files and orders them correctly. This dependency walker also keeps in mind to order correct when we have a baseclass with a baseclass which has a baseclass (and so on). Here is the code:

private static class DependencyWalker
{
     public static void Walk(List<OpenLayersFile> files)
     {
          for (int index = 0; index < files.Count; index++)
          {
              OpenLayersFile fileToCompare = files[index];
              for (int i = 0; i < index; i++)
              {
                  OpenLayersFile otherFile = files[i];
                  if (fileToCompare.CompareTo(otherFile) == -1)
                  {
                      files.Remove(fileToCompare);
                      files.Insert(i, fileToCompare);
                      index = 0;
                      break;
                   }
                }
           }
      }
}

This worked perfectly for me and I hope that it will help you too. I am also interested if you have a different solution to the problem. If so, please contact me.

Happy coding!

While using this code I ran into a problem myself. The Form which was made ComVisible had a baseclass which was not ComVisible. When I ran my code I had this great exception when calling the C# code from JavaScript:

The simplest solution  is to make the baseclass ComVisible just as well. But in my case it was not an option to expose the baseclass to Com-components. So what can we do to make this work without having to make the baseclass ComVisible.  There are three easy steps to take to accomplish this.

Step 1 – Define a interface with the methods you’d like to call from JavaScript

First we define a Interface and put all the methods we want to reach through JavaScript in there. We make the interface ComVisible. I took the test-project of my previous post and added a IMapControlInteractable interface which contains just one method.

    [ComVisible(true)]
    public interface IMapControlInteractable
    {
        void ActivateControls();
    }

Step 2 – Give the ComVisible class the ClassInterfaceAttribute

To use the Interface in combination with the ComVisible attribute and effectivly let the JavaScript communicate with the C# code we give the class the ClassInterfaceAttribute and specify the type at ‘none’.

    [ClassInterface(ClassInterfaceType.None)]

Step 3 – Implement the Interface

The last thing we must do is implement the Interface. If we do so the code my look something like this.

    //Make class visible for COM so we can set the ObjectForScripting
    //Specify ClassInterfaceType.None to use the ComVisible Interface
    [ComVisible(true)]
    [ClassInterface(ClassInterfaceType.None)]
    public partial class GeekBrowser : GeekBasePage, IMapControlInteractable
    {

That’s all there is to it. Now our exception at runtime disappears and our code works. And our baseclass is not ComVisible.

Download this code in the adjusted test project.

For comments, questions  or suggestions contact me or leave a comment below.

In this post I will explain the basics of how to work and communicate with a WebBrowserControl in a Winforms application. I have made a test project which you can download so you can see the magic in action. Because I want to show you the basics of the ObjectForScripting I kept the project as simple as possible. No fancy code-patterns… just straightforward coding.

The idea of the project is:

• The Winform has several input fields for personal information which are all disabled
• A button on a webpage in the WebBrowserControl activates the input fields of the Winform
• The Winform contains a button which transfers the values of the input fields on the Winform to the input fields of a webpage

By implementing this in my project I can demonstrate the communication from Webpage to Winform (activating the controls on the Winform) as well as the communication from Winform to the Webpage (filling the input fields). Download the project and examine it carefully.

So now look at the code
The communication between the WebBrowser and the Winform works through JavaScript. You can call methods of the JavaScript in your C# code like this:

  this.webBrowser.Document.InvokeScript("alert", new object[] { "Hello World" });

and you can call your C# methods in your JavaScript like this:

  window.external.ActivateControls();

But before you can do so you must enable the communication by setting the ObjectForScripting on the WebBrowserControl.

  this.webBrowser.ObjectForScripting = this;

The above line of code sets the object for scripting. In this case it is set to ‘this’ which is the Winform in this project. The object set here is available in the JavaScript through window.external. So the methods of that object are available in the JavaScript.
If you set this line of code and compile the project you will get an Error. This is because the JavaScript has got to have access to the C# code and so we must mark the C# code visible for COM. We do this by setting the ComVisibleAttribute on the object we passed as the ObjectForScripting.

  [ComVisible(true)]
  public partial class GeekBrowser : Form

There is one small difference in calling the C# code from JavaScript and vice versa. When you call C# code from JavaScript you can send in the parameters directly. When you want to send parameters from C# to JavaScript methods you must send it as an Array of Objects. In our test project the JavaScript method takes 5 parameters and therefore I have to create an Array of Objects and give it the 5 parameters and send that array to the method:

  [ComVisible(true)]
  object[] args = new object[5];
  args[0] = this.firstNameTextBox.Text;
  args[1] = this.lastNameTextBox.Text;
  args[2] = this.addressTextBox.Text;
  args[3] = this.phoneTextBox.Text;
  args[4] = this.emailTextBox.Text;

  this.webBrowser.Document.InvokeScript("fillFields", args);

And that is, in a nutshell, how you can make the Winform communicate with the contents of the WebBrowser.

Read more about the test project on page 2.

Well, Yes… …I am happy with the result and me passing the test. But it left me with some mixed feelings. Let me explain.
I started learning for this exam at the beginning of  January. Studied the Self Paced Training Kit. Made the examples (well most of them) and took the test per chapter. Some subjects where difficult for me to understand (like Code Access Security CAS) and so I read several chapters in reference books. The Training Kit came with a CD with test exams and I took those as well.  I gave up a lot of free evenings in the past two months and was proud to have learned a lot more then I thought I would learn. Oh… and just two days before the exam I decided to download some TestKings and look at them as well.

So eventually I was taking the exam with some nervousness but in the back of my mind was confidence. I did my best and I should be able to pass the exam. I had to answer 40 questions. From this 40 there where at least 25 questions that where almost identical to the questions of the TestKings. I am convinced that if I only studied the TestKings and did nothing more than that, I would have passed the exam just as well. Probably not with 930 but that doesn’t matter does it? It matters that you pass the exam. No one looks at the grades when you show the certificate.

I think it is time for Microsoft to redefine their exams. At this moment anyone can pass their exams and it takes away the status of the certificate. I am proud of what I have achieved in the past months and will continue studying at the same way for the next exams.

But I did not passed the exam with 930… I did the Microsoft Trick and got 930 points out of it.

for (int i = 0; i < arr.Length; i++)
{
     object arrayItem = arr[i];
     //do something with arrayItem
}

Even though this is a perfectly legal example of a for-loop there is room for improvement.
Each iteration of the for-loop the Length property of the array will be retrieved. The performance penalty on this is minimal but when your array consists of thousands of objects the performance penalty can be noticeable. The answer is:  ‘caching’.

The for-loop can be changed to cache the Length-value in a variable and then use that variable instead of the length property. Example:

for (int i = 0, len = arr.Length; i < len; i++)
{
     object arrayItem = arr[i];
     //do something with arrayItem
}

Caching the value of the Length-property is always a good thing to do even if you expect your array yo be minimal in length. There is no penalty for doing this on small arrays, only a benefit when used on large arrays. Therefore I recommend to always use caching in your array.

It works in C# as well as in Javascript and probably on a lot of more languages.

Happy coding.

Martin Fowler called for the retirement of the MVP Pattern in July 2006 and suggested to separate the pattern into two new patterns, namely ‘Supervising Controller‘ and ‘Passive View‘. This blog-posting is not intended to explain the basics of the MVP-pattern. That being said, I even expect the reader to have a certain level of familiarity with the pattern.

The ‘Passive View’ is a pattern in which the User Interface has as less logic as possible. I prefer the ‘Passive View’ above the ‘Supervising Controller’ because lesser logic makes it easier to substitute the user interface with a new one. I use the Passive View as the pattern of choice and when I talk here about the MVP pattern I am referring to the Passive View approach.

As said above, classic MVP models the interface which describes the GUI (view) with Strings, Booleans and perhaps some domainobjects. When you want a grid in your GUI you will specify a List<object> in your view interface. Then in your implementation of the view you will have to write some logic to put the list of objects into the grid.
This approach has two major downfalls. The first is the amount of logic you have to put in your implementation. I am a big fan of the Passive View because the lack of logic in the implementation of the view makes the view easy to replace. The second downfall is that the logic you write in the implementation has to be written over and over again in the different forms and applications you create.

To avoid this two downfalls I am suggesting a different way of modeling the view using contracts of controls. I would like to call it the ‘Passive View Control Model’. Instead of specifying that the view should have a string to get the username given by a user in a textbox I tell the view to have a ITextbox for the username, which could be a WinForms Textbox or a ASP.NET Textbox.

Let me clarify myself in an example on the next page.

var text = tempText || “No Text Given”;

With this phrase we assign the value of tempText to the variable text. If tempText is null we assign “No Text Given” to the text variable.

To do the same trick in C# I was using the Conditional Operator:

string text = tempText != null ? tempText :  “No Text Given”;

In my opinion this isn’t very nice code. So I started searching and I found the nice Null-Coalescing Operator. It goes like this:

string text = tempText ?? “No Text Given”;

This looks much better.
For all you javascript-geeks. The javascript notation also checks for empty string. The Null-Coalescing Operator does not.

Happy coding!!

In my previous post I was thinking about some way to convert the C# code to JavaScript code. I figured out that the skeleton functions must remain and return null or 0. But my opinion has changed, because there is a difference between compilationtime and runtime.

When I write code to add a Panel only if the current user is in a certain role then this must be checked at runtime and not at compilation. To accomplish this the skeleton code still must return null or 0 but also must write a line of JavaScript code at the time they are called, runtime.

So what to do at compilation time. On compilation we must check the written code for functions which should be in a handler. We must create the handlers with two partial classes (just like your aspx.cs and aspx.designer.cs) and put the necessary code in it. This will ease the job of the developer because they don’t have to worry about writing handlers. This will be handled by ExtAppBuilder in a generic way

This might seem a bit cryptic and I write this down mostly as a reminder for myself. But in my next post, when I am back from holiday and when I understand the way of writing code blocks with WP (duh), I will explain my theory with code examples.