Some of you might have ran into this situation where you try to evaluate a property or a method
during debug time, and get this message in the value cell of the watch:        

There is a quick “workaround” to this issue.
If you look carefully, you will see a small round icon after the message:        

Pressing on this icon will force the evaluation to continue,
which most likely will give you the result you were after:        

Now, let’s dive into the technical details… Why is this happening?

By default, we tell Visual Studio debugger to try and evaluate properties implicitly.
This of course requires running code while we are braked, and not only display memory content.
Running code, might potentially change the state of the system, which is not always what we want.
For example, I might be increasing a counter every time the property is accessed,
which means that when the debugger will try to evaluate the property, my code will run,
the counter will be incremented, and my system state is changed, even though I am braked.

As the default is to implicitly evaluate, the debugger will always try to do that,
risking a system state change.
If you want to disable the implicit evaluation, remove the checkbox from the settings:
    
Without the checkbox, by default, properties will not be evaluated, and you will have to manually request evaluation each time:

Getting back to our initial error message… where does it come from?
We just said that by default the debugger will try to evaluate implicitly, so what’s stopping it?

When we break the debugger and try to evaluate a property which requires running code,
we can only run code in the current thread. All other threads are frozen to minimize the system state impact…
But, what if my property requires another thread to run in order to complete evaluation?
For example, if I am doing a remote call, I will most likely need the ThreadPool threads for that...
But all other threads are frozen… which will result in a “deadlock”.
The debugger has a protection measure against that, which gives a max of 5 seconds to the evaluation code to run.
If the code did not finish to run within the time limit,
For example, when we are blocked due to a frozen thread,
the watch will be “hanged” for 5 seconds, and after that evaluation will be aborted.
We will get this message to notify us of the problem:


This of course is not a comfortable user experience…
For this reason, the .Net Framework gives us the method:

System.Diagnostics.Debugger.NotifyOfCrossThreadDependency()

This method should be used by the code developer who wrote the property we are trying to evaluate.
If this property (or method…) knows that in order to complete evaluation,
we need to do a cross thread operation, we can call this method inside the property code.

The method will have effect only if a debugger is attached, and the code is running
for evaluation purposes, in which case the code will immediately abort
and notify the debugger via exception that we need other threads to evaluate.

The debugger will not allow it automatically, to avoid state changes, and instead,
will give the user the “The function evaluation requires all threads to run” message.
If the user decides it’s OK to let all threads run, he can push the icon next to the message,
which will cause the debugger to run the property code a second time,
this time with all threads running, and not aborting on the NotifyOfCrossThreadDependency method.

On next evaluation, if the code is getting to NotifyOfCrossThreadDependency again,
we will need to do this again.

Important note:
Since each evaluation attempt will run the code, it means that all the code that was running up
to the NotifyOfCrossThreadDependency method call will be running as well until aborted, so we need to make sure
we avoid making state changes up to this method, as we might not be able to complete the code
beyond this method call!

What if you see this message although you never called this method yourself???
This could happen, and it means you called 3rd code
(that could be part of the framework for example), that in turn called this method.


You can even run into situations where it only happens in specific breakpoints,
or you might need to approve the cross dependency only once during the debug session.
This could happen if the 3rd code is not calling the NotifyOfCrossThreadDependency method every time,
but only in specific cases, usually in initialization code…

One of the popular examples for this are classes that use the Lazy<T>
initialization, and then use the Value property to get the instance.
This is because the Value property of Lazy is calling the notify method!



One of the ways to work around that is to make sure your code “warms up” these classes
before it’s time to evaluate them via the debugger.

The usage of Lazy might be common on Web scenarios and more..

Another common scenario is Task.Wait() which will also call the notify method
internally.         
       
If you are writing your own custom watch visualizer and run into a similar state,  you will get an exception
and can only notify the user that you can’t evaluate without the threads running…        

Currently I have not found a way to work around this issue (besides code warm-up).


Eli.

Personally I like using Morfix to translate text to Hebrew
But could not find a proper translation accelerator for Morfix just yet…

So I decided to check what does it take to built one for myself.

by nigelpepper

Searching the web quickly popped up this nice guide.

It turns out that it’s pretty simple and hardly needs “developer skills”.
All you need is 2 simple files.
1. An XML file for the accelerator definitions.
2. An html file for the installation phase.

In my case, I created Morfix.xml this way:

    1 <?xml version="1.0" encoding="UTF-8"?>

All I needed to change in the “basic template” are the highlighted values:
1. Morfix homepage URL.
2. The name of the accelerator that will appear on the context menu.
3. Morfix icon for the context menu. I just used the one on their one site, I think it’s nice.
4. The category under which to install the accelerator.
    It would normally be “Translate” but you can have only one default on each category,
    and I didn’t want to lose my current default, so I added it as “Translation”.
5. This is the most important value. this is the Query string form Morfix query.
    You can simply get it by running a translation on the site:

5. The last value is just the query string variable, which normally can be extracted from the previous values
     between the ? and the = chars.

Now we should create the HTML file for the installation. In my case I called it AddMorfix.htm :

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
    <title>Add Morfix Accelerator</title>
    <meta content="text/html; charset=windows-1255" http-equiv="Content-Type"/>
    <meta name="GENERATOR" content="MSHTML 8.00.6001.18372"/>
</head>
<body>
    <button id="myButton"
   onclick="window.external.AddService('https://www.ofeks.info/Download/Accelerators/Morfix/Morfix.xml')"> 
                        Press to add Morfix IE8 Accelerator Add-On</button>
</body>
</html>

Again, all I needed to change in the “basic template” are the highlighted values:
1. A nice title for the page.
2. The location of the previous xml file hosted on any web server…
3. Nice text for the installation button.

Now, simply host this html file on any web server, and browse to it.

This is how it looks like:

You can mark the accelerator as default in IE’s  “Manage Add-ons” Dialog.

This would be the final result:

You can test drive the accelerator by installing it from here:
https://www.ofeks.info/Download/Accelerators/Morfix/AddMorfix.htm

Have fun,

Eli.

My name is Eli Ofek, and I am an Application Development Consultant (ADC)
At Microsoft Israel Services. 
 
If you would like to learn more about my history,
you can check out my profile here.

 Guy Burstein suggested that I should open this blog.

by Sir Mervs

I intend to mainly post about interesting technical  experiences I had during my work,
Hopefully it will be interesting and beneficial to some of you.

Have fun,

Eli.