Mark Miller
  • Advanced CodeRush Plug-ins: Converting an Object Initializer into a Constructor

    Today Rory Becker and I presented an Advanced CodeRush Plug-ins session, showing how to create CodeProviders and RefactoringProviders. These providers show up on the CodeRush/Refactor menu, like this:

    RefactoringMenu

    The session included several moments where we tasted sweet success, and at least one tough coding segment where we were pushing through some challenging code.

    The new feature converts code like this:

      Box box = new Box() { Height = 33, Width = 44, Depth = 22 };

    into this:

      Box box = new Box(33, 44, 22);

    and creates a constructor if needed.

    At the end of the two-hour session, we were left with a refactoring that worked, but a CodeProvider that needed more effort. The CodeProvider was challenging because it needed to modify code in two places (it is adding a constructor and replacing the object initializer with a call to new constructor), potentially in two files.

    Here’s an overview of the points we learned in the session:

    1. The Expressions Lab can reveal many of the hidden details behind the source code you want to analyze or generate.

    2. The ObjectCreationExpression class represents a call to a constructor.

    3. ObjectCreationExpression elements have three interesting properties:

    • Arguments – the parameters to the constructor call, if any
    • ObjectType – a reference to the type being constructed
    • ObjectInitializer – an ObjectInitializerExpression (if the constructor call includes an initializer).
    4. ObjectInitializerExpression has one interesting property:
    • Initializers – a collection of MemberInitializerExpressions
    5. MemberInitializerExpression has two interesting properties:
    • Name – the property name being assigned.
    • Value – the value assigned to the property in the initializer expression.
    6. MemberInitializerExpression also has an interesting method, Resolve, which allows us to determine the type of the initializer argument.

    7. We can use the FileChange object to queue up changes to multiple files.

    At the end of the webinar, we encountered an issue where the CodeProvider wouldn’t generate any code. The problem was due to this line of code which set the source file Path property of a FileChange instance to the folder holding the text document (but not the actual file name):

      newConstructor.Path = CodeRush.Documents.ActiveTextDocument.Path;

    it should have been this:

      newConstructor.Path = CodeRush.Documents.ActiveTextDocument.FileNode.Name;

    Correcting the two places where we set FileChange’s Path property enabled the plug-in to generate code correctly. We’ll record a part 2 to this webinar where we’ll see this fix and wrap up all remaining issues:

    1. Fix the FileChange code generation.
    2. Add code that transfers parameters to the properties.
    3. Declare parameters in the developer’s preferred style.
    4. Test, and handle any new issues found.
  • New CodeRush Feature: Quick Pair (Parens, Brackets, Quotes, etc.) for Visual Studio

    Today was the first CodeRush Feature Wednesday webinar presented by Rory Becker and myself. And for our first feature we decided to implement something I wanted – a better way to enter paired delimiters in code. When entering paired delimiters, there seem to be a number of common scenarios:

    • Enter the pair and move on (for example, parens in a C# method call that takes no arguments)
    • Enter the pair and place the caret between the pair (but then you have the challenge of moving outside the pair)
    • Surround a selection with the pair

    To implement this feature, in the webinar we created a new Action called QuickPair which accepts leading and trailing delimiters, and an optional third parameter to determine whether the caret goes inside the delimiters or to the right outside the delimiters.

    You can download and install the feature here:

    http://code.google.com/p/dxcorecommunityplugins/wiki/CR_QuickPair

    This plug-in includes shortcut bindings based on the US keyboard. You may need to change these bindings to match your keyboard locale settings. For example, on a US keyboard, the parens are located above the 9 and 0 keys, respectively, like this:

    90

     

    The curly braces are above the brackets:

    Brackets

     

    The angle brackets are above the comma and period keys:

    AngleBrackets

     

    And the double-quote is above the apostrophe (and the key to the left is the semi-colon):

    Quote

     

    With each of these key pairs, we’ve assigned two functionalities. The left key (e.g., Ctrl+[ ) places the caret between the two delimiters (adding a field, so you can just press Enter to get to the right of the delimiter pair), and the right key (e.g., Ctrl+] ) places the caret after the two delimiters (no fields needed). If there’s a selection, the left key will embed the selection within the delimiters (maintaining the original selection), and the right key will embed the selection within the delimiters, extending the selection to include the delimiters. Examples of all the bindings created in the webinar appear below.

    Given these key positions, the table below shows available functionality (the “|” character indicates the caret position and the blue background indicates the selection, after code is inserted):

    On a US Keyboard, press this: to get this:
    (no selection)
    or to modify a selection:
    Ctrl+(   (|)   (My Selection)
    Ctrl+)   ()|   (My Selection)
    Ctrl+[   [|]   [My Selection]
    Ctrl+]   []|   [My Selection]
    Ctrl+Shift+{   {|}   {My Selection}
    Ctrl+Shift+}   {}|   {My Selection}
    Ctrl+Shift+<   <|>   <My Selection>
    Ctrl+Shift+>   <>|   <My Selection>
    Ctrl+;   "|"   "My Selection"
    Ctrl+"   ""|   “My Selection”
    Ctrl+=   (|) =>   (My Selection) =>

    You may notice a lack of symmetry with the Ctrl+= binding (there is no corresponding binding to place the caret to the right of the lambda operator). I omitted this binding due to a lack of a suitable neighboring key to the equals sign. If you want to correct this asymmetry and add your own binding, feel free to. After installing this plug-in, you may view or change the shortcuts bindings in the IDE\Shortcuts options page. The QuickPair bindings are in the Code\QuickPair folder:

    QuickPairBindings

    Have a request for a new feature? Email roryb@devexpress.com and let us know what you’d like to see us build for you on CodeRush Feature Wednesdays.

  • Get Your CodeRush Training Here

    Here’s a summary of CodeRush training videos created so far, to help you find relevant training quickly:

     

    1.       Introduction to Features

    a.       Getting Started/Configuration

    2.       Navigation

    3.       Working with Selections and the Clipboard

    4.       Consume-first Declaration

    5.       Declaring and Refactoring:

    a.       Properties

    b.      Events

    6.       Refactoring in-depth:

    a.       Introduction

    b.      Changing Signatures

    c.       Conditionals

    d.      Declaration and Initialization

    e.      Dead Code

    f.        Expressions

    g.       Formatting and Structure

    h.      Lambda Expressions and Anonymous Methods

    i.         Loops & Blocks

    j.        Moving and Extracting Methods

    k.       Properties and Fields

    l.         Strings

    7.       Language/Framework follow-up:

    a.       ASP.NET

    b.      C++

    c.       MVC

    d.      Working with Color

    e.      WPF and Silverlight

    f.        XAF

    8.       Advanced Topics

    a.       CodeRush Template Deep Dive

    b.      TextCommands

    9.   Creating Plug-ins

    a.       Introduction – Actions and Tool Windows

    b.      Text Commands, StringProviders and ContextProviders

    c.       TextDocument and TextView

     

    Nearly every Tuesday at 12:00 noon Pacific time Rory Becker and I host a CodeRush training webinar, where we dive into a particular topic and answer questions from viewers. You can see a list of upcoming CodeRush webinars here.

  • Visual Studio Features Built Instantly for CodeRush Developers

    This week Rory and I continue our path-rip through the space time continuum by responding to customer requests yet again with mind-numbing development speed.

    Earlier today this question appeared on twitter:

    Request

    Joe needs to convert a method call with positional arguments (the old way of passing arguments), into a named argument call. For example, he wants to change something like this:

    RegisterDev("Mark", "Miller", 0);

     to this, in C#:

    RegisterDev(firstName: "Mark", lastName: "Miller", id: 0);

    Definitely a useful refactoring. Here’s how we built it:

    1. Create a new plug-in.
    2. Drop a RefactoringProvider on the design surface
    3. Fill out properties for the refactoring (Name, Description, AutoUndo)
    4. Handle three events (CheckAvailability, Apply, & PreparePreview)

    Within an hour the feature was implemented and published (working in C# and VB), ready for consumption by CodeRush devs, prompting this response from Joe:

    ResponseFromJoe

    But this isn’t unique. Over the last two weeks we’ve released a number of new features, all built and delivered on the same day they were requested (most in under an hour from the original request)…

    SurlyDev

    pajacobs

    Apeoholic

    Need a feature? Just let us know. CodeRush can do anything, and if the feature isn’t there, we can likely add it easily. Tell us on Twitter what you want CodeRush to do (include the word “CodeRush” in your tweet), and lets see if we can keep up the pace. Smile

  • Importing Namespace References for Extension Methods in CodeRush for Visual Studio

    From feature request to binary delivery in less than four hours. Here’s the timeline:

    At 10:06 this morning, Apeoholic tweets the following question:

    Is there a way to get #CodeRush to suggest namespace usages for extension methods?

    Which led to the following discussion with one of our CodeRush devs on IM:

    [10:08] Mark: Hey Alex, I have this question in a tweet -- "Is there a way to get #CodeRush to suggest namespace usages for extension methods?"
    [10:09] Alex: Hi Mark, I'm not sure what he means…
    [10:10] Mark: I think he's talking about adding namespace imports when an extension method is at the caret.
    [10:10] Mark: I'm wondering if VS fails to do this.
    [10:10] Alex: I suppose VS does it, doesn’t it?
    [10:10] Mark: Check it for me.
    [10:12] Alex: OK, VS fails to do this.
    [10:13] Alex: And we don't have such feature
    [10:13] Mark: Can we write this as a plug-in?
    [10:13] Alex: Of course, but this will take time.
    [10:14] Mark: What's the challenging part of this?
    [10:14] Alex: Find and resolve all the extension methods
    [10:15] Mark: Create a spike -- work on this for an hour and see what you get.
    [10:15] Mark: Then send me that source and I can finish it up
    [10:15] Alex: ok
    [10:15] Mark: Then I'll have Rory put it on the community site.
    [10:15] Alex: k

    Which led to the development of the feature, testing, a few changes, and then this IM with Rory Becker:

    [13:06] Mark: I had Alex create a plug-in spike for a feature request to add missing namespace references for extension methods (something VS does not do)
    [13:06] Rory: cool
    [13:06] Mark: I'm going to send this to you. Can you get this on the community plug-in site today?
    [13:06] Rory: yeah sure, no problem

    At 14:05, we published the feature on the community site.

    Here’s the feature in action:

    AddNamespaceReference

    Here’s the link to the feature on the CodeRush community plug-ins site: http://code.google.com/p/dxcorecommunityplugins/wiki/CR_ExtensionMethodsHelper

    We are likely to roll this functionality into a future version of CodeRush. If you have a CodeRush question or feature request, we want to hear from you. Post a comment below or include “#CodeRush” in your tweets and we’ll respond in a timely manner.

  • Creating CodeRush Plug-ins: Actions and Tool Windows

    Today Rory and I presented a webinar called Creating CodeRush Plug-ins: Actions and Tool Windows. In it, we created a tool window that displays all Markers dropped throughout all open files. To see how we built this, watch the webinar here, which should be published in the next 24 hours if it isn’t available already.

    MarkersToolWindowScreenShot

    The source to this plug-in can be found on the CodeRush community plug-in site, located here.

  • High-speed MVC Development in Visual Studio with CodeRush and DevExpress MVC Extensions

    If you saw our Using CodeRush with MVC webinar, Rory and I introduced new templates that make it easy to exploit the MVC Extensions from DevExpress. These templates will likely be integrated into CodeRush 11.1, however you can install and start using them right now (installation instructions appear below).

    Templates

    Controls

    Template        Control                     
    xb Button
    xc Calendar
    xcb ComboBox
    xde DateEdit
    xgv GridView
    xhe HtmlEditor
    xhl HyperLink
    xi Image
    xl Label
    xlb ListBox
    xm Menu
    xmo Memo
    xnb NavBar
    xp PopupControl
    xpg PageControl
    xrb RadioButton
    xrbl RadioButtonList
    xrp RoundPanel
    xs Splitter
    xse SpinEdit
    xtb TextBox
    xte TimeEdit
    xtv TreeView
    xu UploadControl

    Items, Nodes, Groups, Panes, and Tab Pages

    These templates make it easier to create elements inside the MVC controls. Copy the reference that will own these elements (e.g., “settings”, “settings.Properties”,  “firstMenu”,  etc.) to the clipboard before expanding.

    Template    Calls Use Inside              
    ga Groups.Add() NavBar
    ia Items.Add() ComboBox, ListBox, Menu, RadioButtonList
    na Nodes.Add() TreeView
    pa Panes.Add() Splitter
    tpa TabPages.Add()    PageControl

    Other Templates

    Template    Expansion
    xrs RenderScripts
    xrss RenderStyleSheets

    Installation

    To install, follow these steps:

    1. Right-click and save each of the templates below.

    HTML_MVC_DevEx Extensions.xml
    CSharp_ASP.NET_MVC_DevEx Extensions.xml

    IMPORTANT:  For VB developers, we have two sets of templates to choose from.

    2. Start Visual Studio if it’s not running already.

    3. From the DevExpress menu, select Options.

    4. Navigate to the Editor\Templates options page.

    5. IMPORTANT: Change the Language combo box at the bottom of the Options dialog to HTML.

    LanguageHtml

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

    7. Select the HTML_MVC_DevEx Extensions xml file downloaded in step one, and click Open.

    8. If you see a Category Exists warning message, click OK.

    CategoryExists

    Next, we need to install the templates for adding items, groups, nodes, panes, and tab pages. These templates must be imported into the appropriate language group of templates.

     

    If You Work in Visual Basic…

    1. IMPORTANT: Change the Language combo box at the bottom of the Options dialog to Basic.

    LanguageBasic

    2. Right-click the template TreeView and choose Import Templates….

    3. Select the Basic_ASP.NET_MVC_DevEx Extensions xml file downloaded in step one, and click Open.

    4. If you see a Category Exists warning message, click OK.

     

    If You Work in C#…

    1. IMPORTANT: Change the Language combo box at the bottom of the Options dialog to CSharp.

    LanguageCSharp

    2. Right-click the template TreeView and choose Import Templates….

    3. Select the CSharp_ASP.NET_MVC_DevEx Extensions xml file downloaded in step one, and click Open.

    4. If you see a Category Exists warning message, click OK.

     

    Testing

    After importing the MVC Extension templates as shown above, click OK to close the Options dialog. Inside an MVC application, open an aspx file, go to an empty line, and expand one or more of the templates on this page.

    MVC TreeView expansion

  • 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.

    CR_Colorizer

    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)

        gdiTextView.Repaint();


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

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


    CR_ExtractHqlNamedQuery
    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):

    GridTemplateExpansion

    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):

    BuildingGridsFasterVideoLink2

    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:

      LanguageXaml
    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.

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

      DXCoreAbout
    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.

    Enjoy!

    MadsTorgersenInterview

1 2 3 4 5
6
7 8 9 10
LIVE CHAT

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 info@devexpress.com or call us at +1 (818) 844-3383

FOLLOW US

DevExpress engineers feature-complete Presentation Controls, IDE Productivity Tools, Business Application Frameworks, and Reporting Systems for Visual Studio, along with high-performance HTML JS Mobile Frameworks for developers targeting iOS, Android and Windows Phone. 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-2017 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners