1. In the Clouds with Windows Phone 7

2. Visual Studio LightSwitch

BTW: Slides are in English so anyone can take advantage of it. Demos will follow

Installation guide

This is a two step procedure in which we’ll change the skin of emulator and Visual Studio designer. Make sure you backup all files before overwriting!!!

In ZIP file you’ll find two folders. Each one contains corresponding skin.

• Visual Studio Designer
• Windows Phone Emulator

1. To install skin for Visual Studio designer, extract content from “Visual Studio Designer” folder to “C:\Program Files\Microsoft SDKs\Windows Phone\v7.0\Emulation”. On 64-bit machines is the corresponding folder “C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v7.0\Emulation”.

2. To install skin for emulator, extract content from “Windows Phone Emulator” folder to “C:\Program Files\Microsoft XDE\1.0”. On 64-bit machines is the corresponding folder “C:\Program Files (x86)\Microsoft XDE\1.0”.

That’s it. Happy coding.

Download Skin

Here’s a description and a few screenshots:

• Create a new keyboard schemes (blank or from an existing one)
• Remove current keyboard scheme (unless it’s a default one)
• Filter commands for easier access
• Assign or remove shortcuts to a command
• Display a list of shortcuts for a selected command
• Display a list of commands used by a current shortcut

If you’re familiar with Visual Studio, then you won’t have problems in using it, as it’s nearly the same

Before I publish it (that should happen in very close future), I have to fix some bugs and get around some “nasty features” of Expression Blend. However, I’d be glad to receive some feedback prior to official publication.

1. Hit Pause/Break to toggle the use of a computer keyboard. Alternatively you can use PageUp and PageDown keys. After keyboard is activated, you can notice an icon with keyboard language in the top right corner.
2. Hit Alt to switch among character options. A menu shows up at the bottom of the screen with all possibilities for a character located before the caret. The menu is automatically closed unless you hold the key for a while.

Recently WordPress introduced another great addition to their WordPress application family named WordPress for Windows Phone 7. Trough the application you can manage your blog, add new posts, moderate comments and more.

Application is available for download under the following link: http://windowsphone.wordpress.org/download/

I found a video on YouTube which demonstrates some feature of the application. I hope you’ll enjoy it!

If you’re a developer, then you probably hate one thing the most, especially if your solution is quite big…and that’s an “Error List” window. I believe we all would be much happier if we’d see it before we’ve waited a minute or two to get error report from a compiler. Thanks to a few code inspection tools, we can save a lot of precious time. Let’s see what’s got ReSharper to say.

Table of Contents

• Enhanced IDE & Code Editor
• Solution Analysis
• Other Code Inspections
• Inspection Options

Enhanced IDE & Code Editor

When we open a file in a Visual Studio, we can notice a new bar (Analysis Bar) on the right side of the code editor. Top of the bar is conquered with a small square which represents the state of our file. Each state is indicated by a color, and we have 3 possible states:

• red – file contains errors
• orange – file contains warnings
• green – buddy you rocks!

Under the square are stacked tiny colored lines which stands for errors, warnings, suggestions and hints. Clicking on each line will take you to a location where an issue has been found. All issues in file are displayed on-the-fly while you’re coding, as well as Solution Errors. By default is Solution Analysis turned off, but you can easily turn it on by double clicking a gray circle in the bottom right corner or if you check the “Analyze errors in whole solution” under Options\Code Inspection\Setting. More about that latter in section Solution Analysis.

A quick look at Visual Studio with Code Inspection turned on.

Ok, we learned how to operate with issues in our code and now we’re moving to a Code Editor. We all know that Visual Studio issues detection is quite poor and sometimes it even underlines text where’s no error. Well ReSharper does it’s job very well. Each issues is colored in a different color and style. On a picture bellow you can see all possible issues in action.

Issues are defined this way:

• Text underlined with green dashed line stands for hints
• Text underlined with green waved line stands for suggestions 
• Text underlined with blue waved line stands for warnings
• Text underlined with red waved line or in red color stands for errors
• Text in gray color stands for redundant or unused code.

ReSharper visualizes issues in a very efficient and helpful way, so we can easily fix them. But do we really need to fix them on our own? With ReSharper that’s not the case. Trough a “Quick Fixes” (if you forgot what that is, you can read a “Coding Assistance” post) you can fix a lot of issues just by hitting Alt+Return shortcut.

Solution Analysis

As I mentioned before, ReSharper also provides analysis for a whole solution. All errors are displayed in a tool window named “Errors in Solution” (shown on a first picture). To open it, go to ReSharper\Windows and click Solution Errors Window. Unfortunately it doesn’t have a preset shortcut, but you can specify your own trough Keyboard settings of Visual Studio. There’s another tool window that I really appreciate, because it shows me all the other non-error issues for a current project or for a whole solution.

And the last thing before I end this section is a circle in the bottom right corner. It indicates the state of the solution. However here you can see only two states:

• green – solution doesn’t contain errors. Don’t get carried away with this statement. Your solution can still contain other non-error issues, but they’re not relevant for solution to build.
• red – solution contains errors…and you how many files have error (the first picture of the post).

Other Code Inspections

The list of features from this sections doesn’t end here, tough it is exciting so far. ReSharper gives you an ability to quickly look at hierarchy of a class or a project, incoming and outgoing calls, or find value’s origin and destination.

An example of type hierarchy.

Inspection Options

The last thing that’s worth a mention in this post is that inspections are customizable. You can turn them on/off or just change severity level. To do that you have two options. The most handy solution is to open inspection options trough the Quick Action like shown on the picture bellow.

This way you control exactly the inspection you want, and you don’t have to look after a right option. However, if you want to manage more inspections at once, then you can do that trough the options dialog.

Other posts in the series

Part 1 – Installation & First-time Configuration
Part 2 – Coding Assistance & Templates
Part 3 – Refactoring
Part 4 – Navigation
Part 5 – Code Inspection
Part 6 – Unit Tests
Part 7 – Performance & Memory Consumption
Part 8 – Ease of Use
Part 9 – Extensibility
Part 10 – Other Cool Features
Part 11 – Final Thoughts

The series continues with Navigation section, which is IMHO quiet brilliant. Abilities to navigate to Type, File, Symbol, Member, Declaration, Implementation, Base and Derived Symbols, and many others, will satisfy your needs in almost every respect. Besides that, ReSharper provides an improved “Find reference” dialog, which is my personal favorite.

What might prove as a winning combination is a “Navigate To” menu which contains all possible options to navigate from caret location. R# also provides some “Find” possibilities and I think this is the best place to put them along.

By the way: if you’ve missed my previous post from this series, you can navigate to any of them using links bellow.

Part 1 – Installation & First-time Configuration
Part 2 – Coding Assistance & Templates
Part 3 – Refactoring
Part 4 – Navigation
Part 5 – Code Inspection
Part 6 – Unit Tests
Part 7 – Performance & Memory Consumption
Part 8 – Ease of Use
Part 9 – Extensibility
Part 10 – Other Cool Features
Part 11 – Final Thoughts

Navigation Actions

• Go to Type… – navigates you to any type within a solution or referenced assemblies.
• Go to File… - navigates you to any file within a solution.
• Go to Symbol… - navigates you to any symbol (method, property, …) within a solution or referenced assembly.
• Go to File Member… - navigates you to any member within the type (class).
• Go to Declaration… - same as Visual Studio command.
• Go to Implementation… - navigates you to a member implementation – great to navigate trough interfaces.
• Base Symbols – navigates you to base members (classes, interfaces,…).
• Derived Symbols - navigates you to members (classes,interfaces…) that derive from this class/interface.
• Type of Symbol - navigates you an implementation of type regarding the member you performed action on. For example: You have defined a string property name "Title" in your class. When you execute this action, ReSharper will jump to string implementation (in our case to metadata file).
• Next / Previous Member - navigates among members (classes, interfaces, methods, regions) in the currently opened file.
• Containing Declaration - navigates to a method, that declares the statement where you execute the command.
• Navigate To… - provides you a list of all possible navigations regarding the member under the caret.
• Recent Files… – provides you a list of all recently opened files.
• Recent Edits… – provides you a list of all recently edited members (classes, interfaces, methods,…) and locations where the code was edited.
• Previous Edit – very similar functionality to Visual Studio’s Navigate Backward, unless it saves only position where code was edited and not all.
• Related Files… – provides you a list of files with the same or related name excluding the file extension. For example: if you execute the command in Form1.cs file, you’ll be given Form1.Designer.cs file as an option.
• Previous / Next Location – very similar functionality to Visual Studio’s Navigate Backward / Forward.

Find Actions

• Find Usages – provides you a list of  usages for specific member. In case there’s only one usage, it will take you to that location.
• Find Usages Advanced… – allows to define what are you looking for and where you want to look at. All the rest is pretty much the same to previous command.
• Highlight Usages in File… – highlights specific members’ background with SkyBlue color. Useful for Visual Studio 2005/2008 users.
• Find Code Dependent on Module… –
• Find symbols External to Scope… – provides you a list of assemblies/namespaces where for all members used within the file.
• Search with Pattern… –
• Previous / Next Item – navigates you to next “usage” in Find Results window.

erR# brings another dimension into the world of refactoring. A wide range of powerful refactorings satisfies even the most demanding users – like me. With abilities like “Move To”, “Introduce…”, “Extract…” and many others, you will quickly reshape the code.

Table of Contents

• Time for Some Action
  • Move
  • Introduce
  • Extract & Inline
  • Other
  • Convert
• Conclusion

Time for Some Action

I’m going to cover nearly all refactorings R# provides and I feel they boosts developers performance. Before I start, let me mention that all refactorings are accessible trough the main and context menu. Most of them are also willing to respond to shortcuts/keystrokes. However, like in Coding Assistance we have a “one to rule them all” shortcut Ctrl+Shift+R, which opens a context menu with all possible refactorings under the caret.

As you can see, we have many available options to choose¹, so I’ll start from top to bottom and try to cover them in details.

^{1 to avoid misunderstanding, keep in mind that this are only refactorings, that belong to current member.}

Refactoring dialogs are designer very clear, so even beginners can get a picture of what is going to happen, once they press “Next” button.

Move

In this section I’m going to describe all refactorings related with “moving” of types and members.

• Move To Another File – moves the type into a new file. If type is the only one in the old file, R# gives you an option to delete it once the type is moved to the new file.

  

• Move To Folder – major goal of this dialog is to move types into a new folder in the solution. You can specify the target folder by selecting it from dropdown tree or by entering the text. The dialog also gives you ability to put classes into separate files, ensure that types belong to correct namespace (with respect to solution‘s structure), and change types visibility. Of course you can specify which types to move and which not. In my opinion very useful dialog.

  

• Move Type To Another Namespace – moves type into specified namespace. Namespace can be chosen from a dropdown tree or by entering the text.

  

• Move Types Into Matching Files – in case you have a lot of types in a few files you want to move into matching files, you’ll reach for this refactoring very quickly. The best is that it works on a whole project, so you don’t need to run it on each file. Simply awesome.

  

• Move To Another Type – when you want to move some members into a different type, copy/paste is usually the best practice, which takes some time, but it gives you more control. This refactoring saves you tons of time, especially if you’re doing that frequently. It allows you to specify members you want to move, and move them to any type within the solution. Along the way you can also change members’ access rights. Simple, efficient and nothing to worry about.

  

Introduce

This section is related to introduction of new members like field, parameters, variables and properties.

• Introduce Variable – introduces variable from a selected code.

  

• Introduce Filed – promotes a local variable to field. It also allows you to define how field is initialized and it’s visibility.

  

• Introduce Parameter – promotes a local value or variable to parameter.

  

• Encapsulate Field – promotes field to property. Sometimes I wish I could directly promote local variable to property instead of using “Introduce Field” and “Encapsulate Field” combination. Anyway, I think this refactoring is very useful.

  

Extract & Inline

• Extract Method – extracts method from code selection. This refactoring allows you also to declare method as static, manage parameters and set methods visibility. A bit more advanced refactoring in comparison to Visual Studio.

  

• Extract Interface – extracts the interface from a class. This functionality is also provided by Visual Studio, but ReSharper’s one gives you more edge. You can decide whether to move interface in a new file or to keep it beside, and easily select only public members to extract.

  

• Extract Superclass – extracts base class from current class with selected members. Dialog also provides you with abilities to place base class in a new file and select all public or dependent members (options doesn’t exclude each other).

  

• Pull Members Up/Down – allows you to easily move members to base or derived classes. Very similar dialog to previous ones.

  

• Inline Method – copies method’s code into each location where method was used (with respect to parameters). Besides that it gives you an option to remove unused method as well.

  

Other

The next section is going to cover all the other refactorings that don’t belong to neither of sections above, but are also very very usable.

• Rename – I’m not completely sure if this dialog actually exploits Visual Studio’s “Rename” or is genuine replacement, but it does it’s job very fast.

  

• Adjust Namespaces – another cutting edge refactoring. Sometimes it happens that your classes doesn’t suit correct namespace. What are you going to do? Renaming namespaces and fixing dependent files is pain in the ass, right? Not anymore. This dialog will do the job for you within a few seconds. Bravo!

  

• Copy Type – creates a copy of a type with a new name. I didn’t find this refactoring very useful, but maybe some of you will.
• Safe Delete – tries to delete member. This refactoring is very useful to delete unused base types.

  

• Use Base Type where Possible – allows you to use base type instead of current type. It also provides you abilities to replace it in “is” and “typeof” operators.

  

• Change Signature – changes signature of current member. This refactoring covers everything possible to change for each member. Here’s an example what’s possible to change for methods.

  

• Make Method Static/Non-Static – I guess no further explanation is needed.
• Extract Class from Parameters – extracts a class or structure from parameters. Extracted class is passed as a new parameter (with previous parameters’ values) and selected parameters are removed. This method does much more as it seems at first sight and might be quite useful sometimes.

  

• Replace Constructor with Factory Method – picture tells 1000 words.

  

Convert

Ok, we’re getting close to the end. The only refactorings left are those that allows you to do some conversion among type members. I don’t think this refactorings needs any special treatment, so I’ll just explain them quickly:

• Property to Methods – Converts property to “get” and “set” methods. Conversion in opposite direction is also available.
• Method to Indexer – converts method to indexer. Conversion in opposite direction is also available.
• Abstract Class to Interface – simply changes class to interface. No dialog is shown, just code modification. Conversion in opposite direction is also available.
• Static to Extension Method – adds “this” in front of the first parameter. Conversion in opposite direction is also available.
• Property to Auto Property – coverts property with back fields into auto property. Conversion in opposite direction is also available.
• Anonymous to Named Type – I couldn’t find out why and how this is used.

Conclusion

In response to what I’ve seen so far, I can say just WOW. Guys from JetBrains put some great effort into designing powerful refactorings. Some of them are really indispensible.

BTW, I forgot to mention that nearly every refactoring is equipped with error prevention mechanism that warns you before you make something stupid.

Other posts in the series

Part 1 – Installation & First-time Configuration
Part 2 – Coding Assistance & Templates
Part 3 – Refactoring
Part 4 – Navigation
Part 5 – Code Inspection
Part 6 – Unit Tests
Part 7 – Performance & Memory Consumption
Part 8 – Ease of Use
Part 9 – Extensibility
Part 10 – Other Cool Features
Part 11 – Final Thoughts

Have you ever wondered how to backup your Search Providers or Accelerators from Internet Explorer 8? I didn’t until I realized I have a lot of great Accelerators and Search Providers installed and it would take a while to get them back. So I “binged” and “googled” the web in hope to find a resolution to my problem. I found one good topic about Search Providers, but a question about Accelerators remained open. So how I managed to solve this problem?

Note: If you’re not willing to read the whole article, you can scroll down to “1, 2, 3 and we’re done!” section where the solution is written in 3 steps.

Table of contents

1. Digging deep inside the OS with Process Monitor
2. Tricks against directions
3. Hey what about icons?
4. 1, 2, 3 and we’re done!

Digging deep inside the OS with Process Monitor

Before I started I made a clear prediction. Information about Accelerators and Search Providers has to be stored somewhere. Be it a system drive or the registry. It has to be somewhere. Now I had to find out where. Searching trough the drive or registry wouldn’t bring me anywhere, so I had to find a different way. If you ever heard about Process Monitor – a great application to monitor events in the OS, you know that it’s the best place to start from. I downloaded it from the internet and started to dig deep inside the OS events.

As I wasn’t interested in watching all events from all processes I added a filter to list only events from “iexplore.exe” process.

Once I got rid of useless events the picture become much more clear…

…but I still had 38k+ events to look at and find where Accelerators and Search Providers are stored. And of course I still didn’t know where information is stored.

Tricks against directions

Best practice would direct me to add more filters to shrink the list of results, but I had a better idea in my mind. So what I did? I cleared all events to make sure only events from now on are listed. We certainly don’t want to look at all events from the past, right? After that I opened “Manage Add-ons” window and selected “Search Providers” to get a list of installed Search Providers.

Right after that I switched to Process Monitor and stopped monitoring events, to make sure only events that happened when I opened “Manage Add-ons” window were listed.

Having only 600+ events allowed me to quickly find a pattern among listed events. I suspected that this could be the location where Search Providers are stored. I opened Registry Editor (regedit.exe) and exported the following key:

HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\SearchScopes

To make sure this is 100% solution I copied the exported file to another machine and imported it into machine’s registry. Once I checked the solution worked, I did the same for Accelerators.

I cleared the list of events in Process Monitor, selected “Accelerators” option in “Manage  Add-ons” windows and switched back to Process Monitor to stop watching events.

I expected to get another pattern and I was right. What surprised me, was a location where Accelerators are stored, but that doesn’t even matter as long as it works The registry key for them is:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings\Activities

Hey what about icons?

The solution I wrote works on any machine, but you has a small cosmetic error. All icons for Search Providers and Accelerators disappears. Huh…how to solve that?

If you look closely at the image bellow you notice that read to “Icon” value was logged.

We use “Jump To…” command to quickly open the correct registry key in Registry Editor.

Now we can find out where icons are stored and backup this folder as well.

1, 2, 3 and we’re done!

There’s nothing more to write about, just to put a solution together at one place. So If you want to backup your Search Providers and Accelerators you need to do the following:

Step 1

To backup Accelerators, export the following registry key: HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings\Activities

Step 2

To backup Search Providers, export the following registry key: HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\SearchScopes

Step 3

To backup icons, copy the following folder, where {Username} stands for you username.

C:\Users\{Username}\AppData\LocalLow\Microsoft\Internet Explorer\Services

Coding Assistance in ReSharper is great,  meanwhile templates are one big disappointment.
They should be done much better, but I’ll talk about them latter. First I’ll focus
on what ReSharper brings.

In code editor you notice some nice icons that appear next to the caret location.
This are context actions, which are allowing you to quickly edit, refactor, navigate,
fix or generate code. Very handy, indeed. Here are icons that you should pay attention
to:

	- for code editing
	- for refactoring
	- for navigation
	- for quick fixes
	- for code generating

Context actions are accessible by clicking the icon or by pressing Alt+Return. Below
is an example how context actions looks like.

It’s also hard to miss hints above context actions. They usually appear in association
with missing using directives, like shown on a picture below.

When a reference to assembly is missing, this hint doesn’t appear. However, ReSharper
is able to add a correct reference to project references.

Once you start typing you’ll notice that IntelliSense from Visual Studio has been
replaced with a new one. Don’t panic, this is ReSharper’s default option and can
be later changed in Options dialog. New IntelliSense is much better from the one
in Visual Studio and what I especially like is code completion. It provides three
different modes:

• Symbol Completion (Ctrl+Space) – completes
  names of classes, methods, variables, keywords, and any other symbols that are available
  within the current visibility scope (including extension methods that were
  previously imported).

  

• Smart Completion (Ctrl+Shift+Space)
  - filters the list of types, methods, and variables to match the expected type of
  an expression. It works anywhere as long as ReSharper can determine the expected
  type of the expression, for example, right-hand sides of assignments, variable initializers,
  or return statements. If several return types are possible, ReSharper detects the
  most recently used symbol of an applicable type and automatically selects it in
  the lookup list. Smart Completion can also suggest creating anonymous delegates,
  lambda expressions, and regular methods, as well as local variables for out parameters.
  In addition to that, in object initializers, Smart Completion suggests fields/properties
  that were not yet assigned a value.

  

• Import Symbol Completion (Shift+Alt+Space) –
  displays all types that match a given prefix regardless of what namespace they belong
  to (as opposed to Symbol Completion, which only completes names of currently visible
  types). Import Symbol Completion automatically inserts appropriate namespace import
  directives to the current file if a selected type has not been imported previously.
  It also works after dot with extension methods and puts necessary using directives.

  

In general, this IntelliSense is quite a monster, but it takes a little bit to get
used to it.

Wondering what’s more? There’re some really nice sugars like

• Complete Statement (Ctrl+Shift+Enter)
  – is a feature that inserts necessary syntax elements (braces, semicolons etc.)
  and gets you in position to start the next statement.

  

• Parameter Information – shows up the tooltip regarding the current parameter.
  I find this very useless. Maybe a picture tells thousand words why. But that’s just
  my opinion.

  
  

• Quick Documentation… – shows up a tooltip with
  a quick documentation. Very handy.

  

• Generate Code (Alt+Ins) - this functionality provides you with options to
  generate code from editor and solution tree. With it, your able to generate classes,
  interfaces, constructors, delegates, override members,… Oh god, I love this. No
  more “Add new dialog”.

  
   

• Insert Live Template… – allows you to insert a code template. Tough a list
  of predefined templates is very short (around 30 templates all together), it’s possible
  to create your own templates with ease.

  
  

• Surround With Template… – gives you an ability to surround your code with
  region, compiler directives, code block,… At times, this could be useful, but
  that’s up to you.
  
• Extend Selection (Ctrl+W) – allows
  you to successively select expanding blocks of code so that you can easily select
  any expression in the code by placing the caret somewhere inside it and pressing
  Ctrl+W a few times
• Shrink Selection (Ctrl+Shift+W) – opposite of “Extend Selection”
• Duplicate Text (Ctrl+D) – duplicates selected text if any, otherwise it duplicates current line.
• Comment with Line Comment(Ctrl+/) – comments selected text with // in front of each line. This functionality doesn’t work correct with XML comments and is also provided by Visual Studio.
• Comment with Block Comment (Ctrl+Shift+/) – comments the selected text with /* and */ block.
• Rearrange Code – allows you to rearrange members in your code up, down. It’s also possible to move code in or out of block. Generally this is a useful feature, but it doesn’t support moving regions.
• Paste – Clipboard history.

Templates

Templates in ReSharper are one big disappointment in comparison with CodeRush. Although
it provides around 50 live templates (this is a total count – for all languages)
and around 30 surround templates (this is total count – for all languages) I find
it pretty poor. Many of those are pretty useless. The only good point about templates
is they’re easy to add and  edit. However once you start adding new templates
you quickly figure out that your options are limited, which is another minus regarding
the templates.

Other posts in the series

Part 1 – Installation & First-time Configuration
Part 2 – Coding Assistance & Templates
Part 3 – Refactoring
Part 4 – Navigation
Part 5 – Code Inspection
Part 6 – Unit Tests
Part 7 – Performance & Memory Consumption
Part 8 – Ease of Use
Part 9 – Extensibility
Part 10 – Other Cool Features
Part 11 – Final Thoughts