Mark Miller
  • Updating Plug-ins on the Community Site

    Update: The content at the community site has been updated, and nearly all the plug-ins there currently build with 10.2.


    Binary plug-in compatibility across versions of the DXCore is a huge priority for us. For most of our releases, we’ve delivered on that intention; after updating you could simply continue to use a plug-in compiled for a previous version. In a few releases, we required a recompile but no source code changes to the plug-in. In 2010, we introduced changes that meant the code had to change in a few plug-ins that were still using the obsolete architecture, and we moved our parsers out to a separate DLL.



    There are CodeRush and DXCore plug-ins out on the community site in need of updates to match the architectural changes introduced in 10.1 and 10.2. Here’s where things currently stand at the community site:


    No Changes Needed

    The following plug-ins compile:

    • CR_BlockPainterPlus
    • CR_CCConsole
    • CR_ClearAllMarkers
    • CR_CodeIssuesContrib
    • CR_CreateTestMethod
    • CR_DeclareClassInProject
    • CR_DrawLinesBetweenMethods
    • CR_ExecuteScript
    • CR_GenerateTest
    • CR_JumpToImplementation
    • CR_Loop
    • CR_MetricShader
    • CR_NavigateToTest

    Need References

    The following plug-ins need to add a reference to DevExpress.DXCore.Parser:


    • CR_CodeBlockContentProviders 
    • CR_ColorizeMemberNames 
    • CR_CreateDelegate
    • CR_CreateHeader
    • CR_DumbAss_Issues
    • CR_EnhancedForEach
    • CR_EasyGoto – also Specific Version needs to be set to false for DevExpress.CodeRush.Library
    • CR_EventHandlerCheckTC
    • CR_ExceptionHelper – also needs ambiguous Xml references changed to System.Xml and needs a change to DxCoreEvents1_EditorPaintForeground handler which uses m_Highlighter
    • CR_Execute
    • CR_MoveFile
    • CR_MsdnBclHelp
    • CR_MultiFileTemplates
    • CR_NavigationContrib
    The following plug-ins need references to both DevExpress.DXCore.Controls.Utils.v6.3 and DevExpress.DXCore.Parser.
    • CR_Initials
    • CR_MarkerExtensions
    • CR_mdMarkerExtensions (also needs to change LocatorBeacon to GdiLocatorBeacon)

    The following plug-ins need to set the Specific Version property to false for DevExpress.DXCore.Parser:

    • CR_NavigateToDefinition
    • CR_MethodNameReformatting
    • CR_MethodPreview

    The following plug-in needs a reference to DevExpress.DXCore.Controls.Utils.v6.3 (with its Specific Version property to false)

    • CR_ClassCleaner


    Code Changes Required

    These plug-ins require some changes to the source code to meet the recent architecture changes.


    Needs reference to DevExpress.DXCore.Parser.
    Adding this reference and recompiling produces this error:
    Error    1    'DevExpress.CodeRush.Core.TextView' does not contain a definition for 'Repaint' and no extension method 'Repaint' accepting a first argument of type 'DevExpress.CodeRush.Core.TextView' could be found
    We recommend fixing with this code:

      IGdiTextView gdiTextView = CodeRush.TextViews.Active as IGdiTextView;
      if (gdiTextView != null)


    Could not locate the assembly "Typemock.ArrangeActAssert, Version=, Culture=neutral, PublicKeyToken=3dae460033b8d8e2, processorArchitecture=MSIL".

    It also needs DevExpress.DXCore.Parser and DevExpress.DXCore.Platform references.

    Specific Version needs to be set to False for all DXCore assemblies
    Needs references to DevExpress.DXCore.Controls.Utils.v6.3 and DevExpress.DXCore.Parser.
    Also, the findFileInSolution method needs this change:

      SolutionElement solution = currentProject.Solution as SolutionElement;

      foreach (var project in solution.AllProjects)

    And this:

      SourceFile namedQueriesXmlFile = getNamedQueriesXmlFile(hqlQueryElement.Project as ProjectElement);

    Working to Make this Better

    Both Rory Becker (CodeRush evangelist) and the CodeRush team are working right now to update the plug-ins at the community site. If you’re an author of one of these plug-ins, I encourage you to update your source code using the hints on this page (it might be a good idea to check first to make sure the fix hasn’t already been submitted). I want to thank you for your patience and support as we go through the 50+ plug-ins and update them accordingly. In the future as we prepare to release, the CodeRush team will check the new build against all the plug-ins on the community site and if there are any issues, we’ll either change things on our side or connect with the plug-in author and get them to change their code before we ship.

    Our commitment is to a strong plug-in community. We will invest whatever it takes to support the plug-in community and make transitions to future versions as painless as possible.

  • WPF & Silverlight Grids – Faster Creation Using CodeRush Templates and a Custom Plug-in

    A few days ago a customer asked for a faster way to create WPF and Silverlight grids. Rory Becker and I recorded a video showing how to create this feature in CodeRush. Rory and I discuss and build the feature in about 30 minutes.

    Here’s the final version of the feature in action (the mnemonic is “g” followed by the dimensions of the grid, so “g2x3” creates a 2x3 grid):


    In the video Rory and I show how we built this feature step-by-step. We create a template and add a custom plug-in to make the template more dynamic and intelligent. You can follow along with the video to create this yourself and learn about templates and plug-ins, or you can follow the download instructions below if you simply want the feature. Here’s the video (be sure to watch it through to the end – I added a video update where I improved the template to make it even easier to use):


    Installing the Smart Grid Templates

    1. Right-click and download this Smart Grid templates link.
    2. Start Visual Studio.
    3. From the DevExpress menu, select Options.
    4. Inside the Editor folder, select the Templates options page.
    5. IMPORTANT: In the Language combo box at the bottom of the Options page, make sure XAML is selected:

    6. Right-click the template tree list and choose Import Templates….

      Import Templates
    7. Navigate to the folder where you downloaded the Smart Grid templates. Select XAML_SmartGrid.xml and click Open. The smart grid templates will appear inside the template tree list.

    8. Click OK to close the Options dialog.
    9. From the DevExpress menu, selection About…. The DXCore About box will appear.

    10. Click the Settings… button. A Windows Explorer window will appear.
    11. Navigate to the Settings.xml\Core folder inside Explorer.
    12. Download and save the Numbers dynamic list to this folder.
    13. Back on the DXCore About box, click the Plug-ins… button. This will open two more Windows Explorer windows (Bin\PlugIns and Community\PlugIns). Download and save the
    14. Download and unzip the CR_Loop binary to the Bin\PlugIns folder (latest CR_Loop source is here if you’re interested).
    15. Click OK on the DXCore About box.
    16. Restart Visual Studio.
  • Mads Torgersen on the Future of C# and the New Async Keyword

    I had the pleasure of interviewing Mads Torgersen, product manager for the C# language at Microsoft. Mads talks about the new async and await keywords coming in C# 5.0, the criteria behind C# design choices, and C# futures.



  • Upcoming CodeRush Webinars

    Join us every Tuesday at 12:00pm Pacific time for an in-depth dive into CodeRush with Mark Miller and Rory Becker. Here's what we have coming up:


    4 Jan 2011
    Navigation with CodeRush
    Mark Miller and Rory Becker reveal powerful CodeRush features that help you get to where you want to be, featuring Quick Nav, Recent Files, Bookmarks, Markers, Structural Navigation, Tab to Next Reference, Jumping to Member Overrides, Base Types, Interface Implementers, Camel Case navigation and more.


    11 Jan 2011
    Consume-first Declaration with CodeRush
    Mark Miller and Rory Becker show how to write consumption code first (which can improve the quality of your API), and then use CodeRush to generate and fill in the missing pieces.


    18 Jan 2011
    Declaring and Refactoring Properties with CodeRush
    Mark Miller and Rory Becker reveal everything you need to know about working with properties in CodeRush.


    25 Jan 2011
    Declaring and Refactoring Events with CodeRush
    Mark Miller and Rory Becker reveal everything you need to know about working with events in CodeRush.



  • Visual Studio’s Greatest Test Runner? Take a Look at CodeRush 10.2

    CodeRush 10.2 was released last week and the Test Runner that ships inside appears to be the greatest Test Runner available for .NET development.

    So before I show you why the CodeRush Test Runner is the best, let’s first consider the criteria by which we might judge greatness. I suggest greatness can be measured in one or more of the following:

  • Native support for your test frameworks
  • Ability to run unit tests quickly
  • A user interface prioritizing clarity over noise
  • Ability to run and debug a single test
  • If you can think of important criteria that isn’t listed above please let me know in a comment below. However, if your criteria for greatness is listed above, we have really good news for you: The CodeRush Test Runner is going to impress you.


    Native Test Framework Support

    The CodeRush Test Runner natively supports NUnit, MSTest, xUnit, MbUnit and Silverlight. Native support means CodeRush fully supports each framework, so new extensions and new features added to the framework can be exploited immediately without needing an update from DevExpress. No other test runner out there has built-in native support for all these testing frameworks.



    The CodeRush Test Runner is the fastest test runner available for .NET. With our new multi-threaded run option, you can run tests in multiple assemblies in separate threads, resulting in a test run that is up to three times as fast as the competition.


    Like waiting? You don’t have to. CodeRush finishes your multi-assembly test run up to three times faster.


    Run & Debug a Single Test

    Seems like a simple request, but being able to run and debug a single test is important, especially to Silverlight developers. CodeRush is currently the only unit test framework that lets you run or debug a single test in all frameworks supported, including Silverlight. Not even Visual Studio’s built-in test runner can do this.


    Clarity in the User Interface

    The CodeRush Test Runner user interface delivers more clarity and less noise than any of the competing test runners, helping you see essential information quickly.

    Here’s the output of a failed test in CodeRush:


    Differences between expected and actual values are highlighted automatically.

    Redundant details (e.g., “String lengths are both 28. Strings differ at index 4.”) are removed to reduce noise and enhance clarity. CodeRush is the only test runner that visually highlights differences between expected and actual results like this.

    If you right-click the debug output…


    you can change the call stack display from line view to tree view, which groups methods by parenting class, like this:


    You may find this call stack view more interesting as methods are grouped by owning class.

    You can change the syntax highlight colors in the DevExpress Options dialog on the Unit Testing\Test Runner Window options page:


    Note: If you don’t see this options page, change the Level combo box from "New User” to “Advanced”.



    Compare Results with the Competition

    Compare the readability of the CodeRush Test Runner results with similar results from competing test runners.

    Competitor #1:


    This competing test runner (shown above) does not ship a test result tool window for Visual Studio, so test results can only be viewed through the Output window (the CodeRush Test Runner can send output here as well if needed). Note that only the first change is shown (the letter “f” in “fox”). Subsequent differences (e.g., “dog” vs. “log”) are much harder to see and must be determined by visually scanning and comparing the results.


    Competitor #2:


    This competitor makes the most important information harder to read by including redundant details (e.g., “String lengths are both 28”) in the results. Paradoxically, the essential information is rendered in black text on a gray background. Contrast for important information needs to be higher so it’s easy to see. And just like competitor #1, only the first difference is shown.


    Competitor #3:

    This competitor shows the results in a variable-width font, so the difference indicator actually points to the wrong character (e.g., the “h” in “The” – but there’s no difference there). Also, this competitor wraps the results in the window, which can make reading the call stack more challenging.


    Here is the result from CodeRush Test Runner again:


    Which presentation do you prefer to read?


    In-source Test Result Icons

    CodeRush also makes it easier to work with tests in the source code, with test result icons appearing next to each test case. In the screenshot below, the first test has not run yet (TestTube), however the next two tests have run, one passing (TestPassed) and the other failing (TestFailed):



    If your hand is on the mouse, you can click the icon to bring up a test case menu, which allows you to run or debug that test.



    Test fixtures & namespaces containing unit tests have icons summarizing the run results of their contents. For example, the namespace below and the test fixture both have a red “X” (TestFailed), indicating they contain at least one test which has failed:



    If you hover the mouse over one of these test fixture icons, you can see a summary of results for unit tests in this class.



    If you click one of these test fixture or test namespace icons, a popup menu appears that allows you to run or debug all tests contained within.



    If your hands are on the keyboard, don’t worry – CodeRush gives you powerful commands to run test cases without reaching for the mouse.


    Full Keyboard Control

    CodeRush offers full keyboard control over your test runs from inside Visual Studio. The keyboard shortcuts for running tests that ship with 10.2:

    Shortcut   Behavior
    Ctrl+T, S   Run all tests in the solution
    Ctrl+T, P   Run all tests in the active project
    Ctrl+T, F   Run all tests in the active file
    Ctrl+T, R   Run active test
    Ctrl+T, D   Debug active test
    Ctrl+T, T   Show the CodeRush Test Runner

    If you prefer the Visual Studio shortcuts, CodeRush ships an alternate collection of bindings reflecting those commands. You can change the bindings for any of these commands if you like.


    What’s Coming in 2011

    OK, so we just shipped 10.2, so it seems a bit crazy to tell you what’s coming in 11.1. But, you know, things get a little crazy over here at DevExpress from time to time. Our intention is to continue to maintain test runner dominance among all .NET alternatives, including Visual Studio. With that in mind, we will add support for even more testing frameworks, add more commands for controlling which test cases to run, and we’re working on improving visualization of code coverage, as well as a bigger feature we are going to save for later discussions.

  • Minority Report Meets Visual Studio

    One of the cool things I get to do here at DevExpress is explore new technologies to interface humans with machines, and more specifically, developers with their code. In the past you’ve seen us write code with chopsticks, super models, guitars, and our minds. With the release of Microsoft’s Kinect, we knew it wouldn’t be long before we’d be working on an interface for Visual Studio to let you write code with your hands, Minority Report style.


    Navigating, coding, declaring, refactoring, testing – you’ll do it all with your hands. As with everything else we build here at DevExpress, our intention is to craft a great user interface around this technology. An experience that's as efficient at writing code as using the keyboard and mouse. And we expect to make the source code available so you’ll be able to play with it yourself.

    Don't be surprised if you see this at a major developer conference in the very near future. Stay tuned.

  • Science of Great UI & Windows Phone 7

    The Windows Phone 7 release is imminent. Here are screenshots of two versions of the start page tiles:


    When I first saw this screenshot I noticed a few variances from the guidelines presented in my Science of Great UI talk.

    One of the things I mention in my talk is that everything presented onscreen is information (everything – data, background, borders, etc.), and not all information has the same relevance. Since our eyes are attracted to great contrast, relevant information should be rendered in a higher contrast than less important information.

    When I look at the screenshots above, my eyes are primarily attracted to the large black “+” sign formed by the proximity of the top four tiles (in bright amber or blue) over the black background. The sharp edges of the borders attract my eyes. After that the bright tiles themselves attract my eyes. However the data that varies inside the tiles (presumably the important information), is rendered in a much lower contrast – white on a highly saturated light background.

    Here’s my redesign of the front page, using the guidelines from the Science of Great UI session:


    Here you can see I’m placing a higher emphasis on the actual data inside the tiles, and a lower emphasis on the tile background itself. Also, I’ve softened the edges of the tiles with a subtle gradient to lower their contrast against the black background. I’ve increased the size of the time – an important piece of information that is now easier to see. And since we’re showing the time, I added the day and date as well near the top. The final change was a redesign of the high-contrast button (the arrow pointing to the right).

    Here are the original (on the left) and the redesign (on the right):


    What do you think?

  • CodeRush Screenshot of the Week – Rotate 90 Degrees

    You may have noticed this entry showing up in the Code menu and wondered “What does Rotate 90 Degrees do?”. This code provider is useful when you are working in a two-dimensional space, and you’ve written code to work in one dimension and you want to create similar code to work in the other dimension.

    Here I’ve taken the first method, CalculateHorizontalPosition that works on the x-axis, copied it, and now I’m converting it into a functionally similar method that works on the y-axis:


    So DeltaX becomes DeltaY, _HorizontalPosition becomes _VerticalPosition, Left becomes Top, StrongRight becomes StrongBottom (hmmm… maybe I should rename that), etc..

    Seen something cool in CodeRush? Take a screenshot and send it to me (markm at the DevExpress domain). If we use your image we’ll send you one of these highly coveted CodeRush Nation t-shirts.

    CodeRush Nation t-shirt

  • CodeRush Template Deep Dive Wrap Up

    Here's the source code and an export of the templates folder Rory and I created today for the CodeRush Template Deep Dive. The session was indeed deep and intense. We hope you enjoyed it and found the information useful.

  • CodeRush Template Deep Dive - Thursday 10am PDT, 17:00 GMT

    This webinar will provide a brief overview of existing CodeRush template technology followed by a deep dive behind-the-scenes look at how CodeRush templates are built. Rory and I will show how to position the caret, select text, call templates from templates, create alternate expansions, and use fields, linked identifiers, context, dynamic lists, TextCommands, and StringProviders -- everything you need to know about exploiting the power of CodeRush templates.

    To register for this session, click here:

    If you have a common code sample you would like to see us turn into a template, send it to me at markm at the DevExpress domain and we may discuss it in this session.

2 3 4 5 6
8 9 10 11

Chat is one of the many ways you can contact members of the DevExpress Team.
We are available Monday-Friday between 7:30am and 4:30pm Pacific Time.

If you need additional product information, write to us at or call us at +1 (818) 844-3383


DevExpress engineers feature-complete Presentation Controls, IDE Productivity Tools, Business Application Frameworks, and Reporting Systems for Visual Studio, Delphi, HTML5 or iOS & Android development. Whether using WPF, ASP.NET, WinForms, HTML5 or Windows 10, DevExpress tools help you build and deliver your best in the shortest time possible.

Copyright © 1998-2018 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners