Since it’s a new year, time to think deep thoughts. Consider this proposition: when some technology graduates from expensive/uncommon to affordable/prevalent, there is a corresponding major advance in software to take advantage of it. That software extends the technology in ways that were never thought of in the first place.

In some way, this is ruddy obvious: why write software for a technology that is not succeeding? For sure, if the technology is expensive enough, you could make money providing expensive software for it, but in reality, why should you? You are in essence laying a bet that said technology will become more affordable and therefore common in the future, at which point you will be well poised for dominance in the field.

No, what I find more interesting here is what happens to software when a technology hits the real mainstream. A small diversion if I may.

The other day I bought an Eye-Fi Pro X2 SD card for my DSLR, mainly to try it out to see if it fits into my way of taking photos. If you’ve not heard of it, it’s not only a memory card but also a WiFi adapter: take a photo and it’s automatically uploaded to your PC via your WiFi network. The card came in a cardboard sleeve with just a USB adapter. No leaflets, no instructions, the sleeve had a sticker saying “go to this website to learn more about configuring the Eye-Fi card”. This points out to me several things. First, the SD card format had to become standard before making this adapter even made sense. Second, there has to be a reliance on the use of WiFi in the home. And third, it assumes that customers have ready access to fast internet (a driver and an app had to be downloaded and installed, you had to register with the site so that, if you wanted to, your photos would be uploaded to their servers).

Fast internet is one of those technologies I’m talking about. Remember the days of Hayes modems and top speeds limited to 14.4Kbps? Would you do all you do now on the internet if you were limited to dialing up? No, of course not. The explosion of access to broadband internet has resulted in – for better or worse – blogging, Facebook, Twitter, Flickr, software installs via the web, regular updates to your operating system, browser wars, YouTube and streaming video, sharing of information and services, and so on, ad infinitum. Web software changed dramatically once fast internet was ubiquitous and no longer the province of the wealthy. Nowadays, we pretty much write software that assumes some kind of always-on connection, or we write software that can work anywhere so long as there’s a browser running it. What ideas do you have for software that need this always-there, fast internet?

The smartphone (and tablet) form factor is another one of those technologies that, once it reached a certain tipping point, resulted in an explosion of different types of software and different kinds of apps. Just today, I typed “gas station” into Google Maps on my phone to get directions to the nearest gas station: the car was running on fumes and I didn’t know the area. What other kinds of apps do you rely on every day that would be impossible if you didn’t have this small computer in your pocket attached to some fast internet?

Even more basic, just think of the software that’s now getting written in interpreted languages. Once the hardware got fast enough, and the computer science got clever enough, interpreted languages started being used all over the place, from server-side web apps to client-side apps in browsers. It’s not that long ago that Google showed the way with the V8 interpreter engine for JavaScript, meaning that client-side apps were valuable and fast enough for everyday use. And of course with interpreted apps, we’re now used to the speed and agility with which we can deploy changes to those apps (there’s no install!). Once the tech was there, the software and the way we use and deploy that software grew rapidly.

And as a final example, let me point to the cloud. It wasn’t that long ago that putting your publicly-accessible servers on the internet (that same fast internet) was something only high-tech companies did, like Google and Amazon. Now the cloud (whatever your definition may be) is a commodity. Sure, you can store your photos “in the cloud” or your music (or even your license to listen to music that you don’t actually have locally on your hard disk as MP3s), but these days people are doing so much more: storing data and making it available, web sites, app servers, scalability, development, all on a pay-as-you-go type plan, rather than having to purchase servers for your own data center. The interesting thing about the cloud is that over the past year or so, it’s become almost ubiquitous and it’s certainly cheap. Are you a start-up? It’s cheaper to provision a few virtual servers from Microsoft or Amazon than to purchase the infrastructure to do it yourself. You are developers, not IT managers. Where this will lead, I’m not sure, but of one thing I am certain, this same fast internet plus the cloud will result (has resulted) in some new and innovative software.

The basic problem is of course (a) spotting a technology that could/might/will turn mainstream (I, for example, am no clairvoyant), and (b) what kind of software could be designed and written to take advantage of that technology. Here’s a list of tech that is at least interesting, but not yet mainstream, what do you think?

• Wearable computers, like Google Glass
• Televisions, such as 4K TVs, Google Chromecast, Microsoft XBOX, etc
• Automobile intelligence, such as performance monitoring, car-to-car communications
• The connected home, for example, Nest
• Big Data provisioning and processing (for some definition of Big Data)
• 3D printing

Which of those (or others) triggers that spark? What ideas do you have that, if only some technology X became prevalent, would mean giving up your day job for a chance at software fame and fortune?

This week, Seth, Amanda, and myself are at the CodeMash 2014 conference in Sandusky, Ohio. Every January, thousands of developers from many different platforms converge at the Kalahari Resort (and water park).

DevExpress is happy to be a sponsor and have the chance to meet and talk with so many developers in the mid-west region.

The conference officially starts on Thursday so today was “setup day”. Here’s Amanda with the completed setup:

CodeMash is sold out again for another record year. However this year many of the attendees, including us, did not make it on time. There’s been severe cold temperatures on the east coast. Flights have been cancelled and road closed due to the weather. In fact, here’s the temperature from Monday night:

In the meantime, enjoy some of the pictures we’ve been taking at the conference so far:

I’ll share a full album of the fun with you on Friday.

Be sure to check out Seth Juarez’ two talks at CodeMash:

Thursday, 9:45am to 10:45am, Cypress Room:
Practical Machine Learning – Recommender Engine and Anomaly Detection

Friday, 9:30am to 10:30am, Indigo Bay
Math for .NET Developers – Making Data that Looks Real

And if you’re at CodeMash, be sure to drop by and say Hi, we’d love to meet you.

You know what it’s like. Every now and then you spot that you’re performing the same sequence of tasks over and over again, and you find yourself wishing that there was a way to automate what you’re doing.

Well you’re not alone. Just recently I had one such situation.

The pattern in question is a relatively simple one.

It usually starts with a method which itself calls several other methods.

In the middle of that code, you realise there are a few lines which you’d like to be able to reuse a little easier.

Naturally you reach for your trusty Extract Method refactoring. Highlight the code and extract away.

However what you’re left with isn’t quite what you want.

What you really want is to have those literal values passed in as parameters.

Your ultimate goal is more like:

There are 2 ways to go about this with CodeRush.

Option 1 – Method First

In this first case, you…

- Extract your Target Code as shown in the first example. (Extract Method x 1)
- Promote each literal to a parameter of the new method. (Promote Parameter x L)

For a hypothetical method with 3 parameters, this will result in 4 operations. (3 x Promote Parameter + 1 x Extract Method)

Option 2 – Params First (and Last)

This second version is more complicated, but suits the way some people think a little better.

- Extract each of the literal values in your Target Code (Introduce Local x L)
- Move the resultant locals up above the portion of code you’re looking to extract. (Copy and Paste x L)
- Extract your Target Code (Extract Method x 1)
- Re-Inline the literals you created in the first step. (Inline Temp x L)

For the same hypothetical method (with 3 params), this solution requires 10 operations. (3 x Introduce Local + 3 Copy\Paste + 1 Extract Method + 3 Inline Temp)

Each option suits different people’s approach, but both are a few more steps more than I’d like to have to perform

It’s lucky then that CodeRush is so Extensible

Enter a new plugin

The new plugin provides an additional refactoring (Extract Method And Inline Temp) which sits in the usual smart Tag menu, and makes itself available alongside Extract Method.

All that’s required is a single click, and CodeRush will whisk you passed all of those tedious (and potentially error ridden) manual steps.

As usual, this project is Now available on github with full source code and VSIX Install.

In a future post I’ll walk you through how this plugin works.

For now, just look for the latest release, and away you go

Marion from our support team for all things JavaScript – she knows more than me, I kid you not – has written this excellent article about the new support for BrowserStack in the 13.2 version of TestCafé. “BrowserStack”, what’s that? was my immediate reaction, coupled with a blank look, but Marion explains all:

We took great care to ensure that our TestCafe framework is easy to use no matter how you intend to test your applications. And now we’ve published our new testcafe-browserstack npm module, I am thrilled to let you know that testing your applications in all existing desktop and mobile browsers is now a breeze.

How? BrowserStack, FTW!

The testcafe-browserstack module allows you to create a tunnel between your machine and the BrowserStack network. Once a local tunnel is created, you can test your internal or external websites in BrowserStack remote browsers as easily as you would in your local browser. A nice capability, isn’t it?

Here are the three simple steps you need to follow in order to run your tests in the browsers listed on BrowserStack:

1. Install the TestCafe-BrowserStack module

Use the following command line to install the module from npm:

npm install testcafe-browserstack

2. Connect a worker

Get the sample code from here and create a new worker in TestCafe.

3. Enjoy!

Check whether you wish to run your tests with all the browsers installed on your machine or just in BrowserStack remote browsers or both.

To learn more about how to install and use the testcafe-browserstack module, read the following support article: TestCafe - How to add remote workers from the BrowserStack web service

Summary

Use the powerful TestCafe framework to create functional tests for your application. Then, run your tests in all browsers and on all devices of your choosing using BrowserStack.  A win-win for all!

(Julian writes: A week or so ago I was chatting with an old customer and friend and raconteur, Joe Hendricks, about the inestimable work he does for non-profit organizations. Specifically, I wondered if he was up to writing about using DevExpress Universal from the viewpoint of an amateur developer (his words!) who helps non-profits improve their web presence. Before he jumps all over me, I hasten to add that “old” there refers to his time as a customer of ours, not his age. Which is young. Well, OK, a young middle-aged. There, I’m sure that sorted that out. So… before I continue shooting myself in the foot, I’m handing it over to Joe.)

Hi! I am Joe Hendricks, a 61yr retired healthcare marketing manager, incurable punster, avid mountain climber/hiker and more importantly - amateur C#/ASP.NET programmer and volunteer webmaster for 20+ anti-poverty nonprofits. My limited database and programming skills did help my career a lot.

The purpose of this series of posts is to share my experience (especially my mistakes) in using Developer Express’s Universal Subscription product to help those nonprofits.

Project Background

Since 2007, my wife and I have provided the graphic layout, content, CMS access and web hosting for nonprofits on our collocated Windows 2008 Webserver running ASP.NET/Internet Information Services(IIS). The nonprofits include a wide range of antipoverty services: retired policemen helping Darfur genocide refugee camp guards protect the refugees from raiders, a free medical clinic in Honduras, senior services here in my small town, an orphanage in Africa, education for the poor in the Dominican Republic, etc.

We used the ASP.NET open source library called “My Web PagesStarter Kit” at Codeplex, mainly for these reasons:

• Easy to use CMS for nonprofit staff
• Text storage instead of database
• Easy deployment (drag and drop onto server via Remote Desktop)
• Basic features needed by small nonprofits (text with embedded images, photo gallery, contact form, login, search button, image and file uploading)
• Works fine with Google Analytics, a PayPal Donate button and AddThis social media buttons
• Some extensibility

Although it’s worked well for several years, it is now becoming insufficient for these reasons:

• Boxy CSS layout is becoming increasingly out of date
• Cannot easily handle multimedia or scheduling/calendar
• Suboptimal display on mobile devices
• Too time consuming (my beloved wife lost her cancer battle and so now I have to do all the work for the websites)
• Decreasing open source community interest and updates

Because I had used some of the DevExpress Universal features at work before retirement, I have no doubt I will find more than what I need in their products. Why not just select their ASP.NET subscription? Well, Coderush and XPO/XAF, doh!

The Project

I plan to slowly switch over the nonprofits needing new functionality for their website visitors from the open source framework to DevExpress by the end of 2014. By the end of 2015, I hope to have full CMS functionality added. I can only apply 20 volunteer hours/week to this which must include my own training, continued webserver management and continued support for the current websites. I’m sure I’ll be “seeing” a lot of Oliver, Mehul and Amanda via their online DevExpress webinars and training - fun! (Thank heavens he didn’t mention me – Ed.)

So the next blog update on this project will be after I finish installing Visual Studio 2013 Pro (due here next Monday) and finish going through the DevExpress demos that seem to apply to the project (including deployment, XPO setup, and each DevExpress ASP.NET control). I will also be using the new online training for ASP.NET to further improve my web skills. Hopefully by my discussing my path to ASP.NET enlightenment, you’ll find something to learn from my inevitable mistakes.

PUNishing Summary

If your project suffers from open sores like mine, dev in and grab control(s)!

CodeMash v2.0.1.4 or 2014 is over and what great conference it was. DevExpress was happy to attend and be an “Adamantinum” level sponsor.

(Note: Clicking on any picture will take you to the DevExpress Facebook album).

Amanda, Seth, Mark, and myself had a great time here meeting the devs, speakers, and even the families that come along to the Kalahari Resort and water park.

After we survived the winter weather earlier in the week, we had 3 great days  here. First day was setup. The next two days is when the conference officially started.

On day 1, we saw a surge of people at our booth. We met a ton of developers that use so many technologies. Everything from .NET, Ruby, Java, JavaScript, NodeJS, and more. The keynote speaker was Ann Pendleton-Jullian, a professor and TED speaker. She delivered a great TED-style talk in front over 1,000 attendees.

After which the conference and sessions started. And there were a ton of talks. Including Seth’s talk and Mark’s short presentation on CodeRush.

The day ended with the attendee party. And finally at 10pm, as is custom at CodeMash, they opened the water park exclusively for CodeMash attendees and their families.

On day 2, Seth delivered his second talk. I attended some great sessions myself. We met more dev folks, many who use DevExpress currently that stopped by to say how they loved DevExpress (thank you btw!). At lunch, Amanda and Seth got up on the big stage to raffle off a universal license. While up there, they attempted to start a “We want Bacon!” chant. Fun times. :)

As CodeMash is over, all four us agree that this is a fun conference for developers. The atmosphere is great and people very friendly. This is the 8th year anniversary for CodeMash and DevExpress is proud to have been here for the last 3 years.

Check out all the great pictures from the DevExpress Facebook album for CodeMash 2014:

Thanks!

We have just announced several new training events for the next few months. This is the largest lineup yet, with seven classes coming up between now and early June, in the US and Europe.

March: WinForms and ASP.NET classes in New York

We have listened to requests from many of our customers, and we're targeting a new location with these two events in March 2014. The classes are also revised for our 13.2 release, and for ASP.NET we target 3 days now instead of the traditional 2-day length. For details on the classes, download syllabus documents and to sign up directly, please use these links:

WinForms Training Event USA March 2014

ASP.NET Training Event USA March 2014

April: Reports and Analytics class in Los Angeles

Seth is the trainer for this course, slightly extended in comparison with previous iterations, and including additional content on our data analytics products. The class takes place in the DevExpress offices in Los Angeles,  giving you a unique opportunity to see our LA-based guys at work. I can't promise anything in this regard, but usually you'll have a chance to meet up with a few of them as well! Here's the link for details, syllabus and sign-up:

Reports and Analytics Training Event USA April 2014

April: WinForms and ASP.NET classes in Bad Ems, Germany

Our trusty old location for the whole of Europe. Bad Ems is quite central in Germany and easy to reach from Frankfurt International Airport. We usually have mixed groups here from all around the world, and the class language is English. The classes have the same updated content as the March events in New York, and they are also 3 days each. Here are the links for details, syllabus and sign-up:

WinForms Training Event Europe April 2014

ASP.NET Training Event Europe April 2014

May: XAF class in Los Angeles

Only the second time we're bringing an XAF class to the US, this time it'll take place in the DevExpress offices in Los Angeles. An entire week of content, covering a large part of the functionality provided by our XAF application framework. Click this link to see all the details and the class syllabus, and to sign up:

XAF Training Event USA May 2014

June: XAF class in Bad Ems, Germany

A whole week of XAF for Europe based customers, in our much appreciated location in Bad Ems, Germany. An international audience gathers here for this English language class. Here are all the details for this event, the class syllabus and the sign-up form:

XAF Training Event Europe June 2014

You can see the complete overview of all courses we currently offer by going to this URL. If you have any questions or comments, feel free to send us email at training@devexpress.com. I'm looking forward to seeing you at one or more of the upcoming events!

If you recall in my previous post, I presented a new plugin "CR_ExtractMethodAndInlineLiterals”

In this post I’ll walk you through exactly how it works.

Overview

This plugin does it’s job by automating the execution of existing Refactorings, moving the caret around and executing more Refactorings.

Broadly speaking there are 3 parts to this task.

Extraction of the literals

The first part of extracting the literals is to find them. For this we will use an instance of ElementEnumerable. The ElementEnumerable constructor requires a scope (in which to search) and a filter (to use for testing found items). We can’t pass the current selection as scope (Selection isn’t a LanguageElement). Instead we’ll pass the ActiveFileNode. For the Filter, we’ll pass a custom implementation of an IElementFilter. The bulk of our class (TypeInRangeFilter) is shown here:

IElementFilters are used to test IElements (or sequences of them) against specific criteria. The criteria will vary from implementation to implementation. In this case we have created an IElementFilter which passes elements if they are both of the required type, and their start is within the supplied range.

We use this IElementFilter together with the ElementEnumerable in order to produce a list of PrimitiveExpressions (strings, numbers etc) )within the selected SourceRange.

Having found these literals, we need to place our caret within their name, or better yet, select them entirely…

Once selected, we need to call a refactoring.

However calling a Refactoring from within another refactoring, is a little more complicated that just getting a reference and calling it:

Using this helper method, we make the call to the ‘Introduce Local’ refactoring

At this point it’s worth noting that the refactoring will have changed our code, and naturally enough the Active Document will have to be reparsed.

For this, we need a call to…

… which will cause CodeRush to update it’s internal representation of the code.

Each call to Introduce Local will have caused the the introduction of a new Initialized variable. However each of these will have been placed immediately prior to it’s initial usage. This is less than ideal since since we’d like to exclude these initializations from the extraction. Not to worry, we can move these statements up above the original selection.

Finding these InitializedVariables involves another custom implementation of IElementFilter (InitializedVarFilter).

This time the internals look more like this:

This IElementFilter looks for IElements whose type is InitializedVariable and also match a given name

As before, we use our new IElementFilter like this

Iterating through our InitializedVars we can move each above the selection using:

Extract Method

Next we reselect our original selection. (Messing with code doesn’t always alter your selection, but it can be a good practice to ensure things are the way you want them anyway)

… and then Extract the Method using the helper function we created earlier.

Inline Variables

Our final official step is to inline the Initialized Variables back into the method call.

Once more we can iterate through our previously gathered list of InitializedVariables

Select the range of each in turn

Then Execute the Inline Temp refactoring

Essentially that’s all there is to it.

As usual the full code to this plugin can be found on github.com as well as the VSIX.

Feel free to use these as a reference for your own plugins, or to extend them and contribute changes back again.

Disclaimer

Yes I know. Regions are bad. Regions are awful. Regions should be shot repeatedly until dead. Try to bear in mind that not everyone views everything the same way, and openness to alternatives is a good thing. For the purposes of this blog post, I’m going to ignore the fact that some people see regions as a bad thing. The customer asked for this functionality. Hopefully it will be useful. For the benefit of the customer in question, I’m going to try to keep them relatively anonymous :)

No regions were harmed in the making of this plugin. Sorry.

Customer Request (Paraphrased for security reasons)

I love CodeRush Templates. Is there a way to have CodeRush expand a template, but leave regions that it generates collapsed?

Short answer: No, there’s nothing built in. Sorry.

Longer Answer: That sounds like a challenge. Let me see what I can do.

TemplateExpand with Collapsed Regions

When you expand a template in CodeRush, your space (or sometimes Tab) key is firing our TemplateExpand command. This in turn invokes all sorts of clever magic and emits text and other things into your editor, with considerably less effort on your part, than if you’d had to type it all yourself.

This new plugin provides a single new (alternative) command TemplateExpandWithCollapsedRegions.

To use it, simply bind it to a shortcut of your choice. In testing I have bound it, as I usually do, to Ctrl+T. You can of course pick anything you like. You may even decide you like it so much that you want to replace the original TemplateExpand command. If that’s the case then you’ll need to locate the existing binding on the shortcuts page, and alter the command from TemplateExpand to TemplateExpandWithCollapsedRegions.

Once you have assigned this command to a shortcut you can use it just like the original command.

This latest version of this plugin can be found on github.
Feel free to download, install it and see what you think

Previously I outlined some of the more interesting features that were released in Snap reporting for our 13.2 release cycle (including mail-merge). I thought it would be interesting to take a detailed approach at the Snap mail merge features to show you the power that we’ve added to an already rich product. We’ll first start with the general merge process and then sprinkle in what Snap adds to the mix.

Traditionally the mail-merge process consists of 4 general steps:

1. Creating a template document,
2. Selecting a data source,
3. Adding merge fields to the document, and
4. Merging the data with the template document

With Snap this is pretty simple. So what is different/better? Let’s look at three things: master-detail, in-place filtering, and navigation/sort/preview.

Master-Detail Mail-Merge

Turning a document into a mail-merge template is performed by enabling this mode for one of the connected data sources.

In the resulting document, the whole of the static content becomes wrapped around any inserted merge field. When merging a finished document, the static template is repeated with each record supplied by the corresponding merge field’s data source. This is in contrast to creating regular Snap reports, where an inserted field instantly unfolds to list all of its data records within the document body.

When performing a master-detail mail-merge we’ve combined the best of two worlds. Within a master-detail structure of a report, Snap derives a field's role from its level in the data source hierarchy.

Master Report: Merge Fields

When inserted from a hierarchical data source, fields that belong to its top level are attributed to the "master" section of a template. To blend with the rest of report content, the data from these merge fields is inserted as inline text.

Detail Report: Data Fields

Fields that belong to nested levels of a data source form part of the "detail" document section. Inserted to a template, such data field is displayed as a list conveying the rows of underlying data records.

In a document structure, this template is reproduced with each new occurrence of data rows belonging to the "master" section, to accompany it with a corresponding accessory data.

Data fields that belong to the same hierarchical level add up to create a document table with multiple columns. For further arrangement of data, Snap tables support automatic summaries, sorting, grouping, and filtering.

In-Place Filtering

Once the Snap template is created and bound, the need arises for creating filters to narrow the data displayed. With Snap there are two filtering options: quick filter and the expression filter.

Quick Filter

Quick filtering is exactly what you’d expect – pick records by their name. All you need to do is select the element in question on the Snap design surface and the quick filter dialog box replaces the items with the distinct set of the item in question. In this case I’ve highlighted the country field in order for the quick-filter selection to include the list of countries.

Expression Filter

When simple record selection is not enough, you can easily create any complex expression using the following dialog:

This editor allows for the creation of any criteria with any available fields.

Navigation, Sorting, and Preview

Lastly I wanted to talk about navigation, sorting, and preview. Navigation is simply a case of selecting the appropriate record you wish to display.

To the left of the navigation controls you can bring up the Sort dialog box to order records based on any field (or sub-field in the master-detail case) available from the data source.

To publish a report, you have the following options:

1. send it to a printer;
2. export to a third-party document format (such as doc, docx, rtf, odt, html, pdf, etc.);
3. display the document on-screen in a Print Preview window.

Once one of these options is selected, you further have the ability to select which records to publish as well as how to separate each record.

We also are careful to process the actual document assembly to an entirely separate thread. This ensures snappy response and avoids lock-ups.

This process produces a clear preview based on our award winning reporting tool.

Summary

Overall Snap is truly a remarkable no-touch reporting tool that can be easily embedded in your WinForms applications.

As always, if there are any comments and/or questions, feel free to get a hold of me!

Seth Juarez
Email: sethj@devexpress.com
Twitter: @SethJuarez

Disclaimer (Yes again)

Yup, some people still don’t like regions. If that’s you, then you might not be that interested in how a region-appreciative plugin works.
We’re not here to discuss if they’re good or bad. We’re here to show you how the plugin from my previous post does what it does.

Overview

There are only 2 parts to this plugin.

1. Expand the Template
2. Collapse Regions

Expand the Template

If you’re looking to write an action which needs to be able to expand templates as part of it’s remit, then there really is no better way to get this done, than to call the original command which already takes care of this.

To call another command, you’ll want code like this:

Locate Regions to Collapse

So the next issue is which regions to collapse. You see there might already be regions in the document before your template is expanded, and you don’t necessarily want to collapse those.

Ideally we would like to know the sourceRange into which the template expanded. The TemplateExpand command does not provide this information out of the box, so we’ll have to work it out ourselves. I picked what seemed at the time, like the simplest approach possible.

I calculate the LinesFromStart and LinesFromEnd. (ie the number of lines from these points to the line the caret is on.)

…then these values can be used (together with the size of the post-expansion document) to calculate the size and position of the region into which the template expanded.

Collapse the Regions

Once we have expanded our template, and have a range of code to process, it should be a simple enough procedure to iterate through RegionDirectives in this range and collapse each of them in turn.

Except that it’s unfortunately not that simple.

A Problem of Timing

As indicated, the problem is one of timing.

You see VS is a multi-threaded application. This allows it to delegate certain non-essential tasks to background threads. These task are assumed to be less vital than some others and thus will take something of a back seat if other more processor intensive work is being done.

So what does this mean for us? Well it turns out that fully hydrating new regions added to code is considered a less important task.

You can definitely understand that point of view. The 500ms delay between adding a region and it being considered a real region is nothing right. I bet most of you have never even noticed that small delay between moving off the line after creating a region and the point when VS recognises it as a region and adds outlining to it.

However as indicated this does provide us with a small issue.

If we run our code as suggested so far, we’ll hit a situation where the instruction to collapse a detected region is ignored, because there isn’t yet any sort of outlining associated with the region(s) in question.

So what to do instead?

Well the simplest solution is just to wait until the relevant information is available. I’d prefer to do this via event, but at the time of writing the code, I couldn’t find one that would alert me at the proper time.

So I created a DelayedRunner class (main code below) whose purpose is to repeatedly run a passed func<bool> until such time as that function returns true.

I added a parameter to specify a delay between each execution, and another to provide a maximum length of time, after which the DelayedRunner would turn itself off and essentially give up.

This required that I alter the code of CollapseRegions so that it returned a bool indicating it’s level of success.

Note: If no regions are detected in the range, the routine returns success immediately.

Finally this delayed execution is executed using the following code:

Limitations

The multithreaded nature of this command means that it is not possible to wrap this up in a singe UnitOfWork and add it to the undo stack. Therefore when attempting to undo the effects of this command, the user will have to invoke Ctrl+Z twice to achieve the desired results.

As always the code for this plugin is available on github and the latest release is also available as a VSIX

It's one thing to be able to make a stunning looking website (especially with the DevExpress ASP.NET controls), but sooner or later we all come across a need for security. A quick Google search on web security will reveal a plethora of links all telling you what method to use, how to do this and that, however it's not always an easy choice on which path is which. So on February 11, I am going to show you how to create a website from scratch and implement some basic roles restricting access to certain aspects of your site.  Starting with the DevExpress Project Wizard, we will create a new project featuring the ASPxRibbon control, wire up the databases and set some page access.  Implementing role restriction on a page is one thing, we'll also take a look at how to manage your users and roles from within your site. The webinar will be in a new 30 minute sharp concise format delving straight into the code from the word go. Register today 

DevExpress ASP.NET - Recent rendering change in v13.2

There's an old joke going around:

"A web designer walks into a bar - but immediately leaves in disgust upon noticing the tables layout."

A long time ago, in a galaxy far away...

Web developers used tables for website layout. Thankfully, this went out of fashion many, many years ago. For more info on why it's not a good idea to use tables for layout, check out this StackOverflow thread.

A little history

This post is not about using tables for site layout.

Tables are useful and serve a purpose. In fact, back in the day when browsers didn't play so nicely with HTML standards, tables were critical to getting cross-browser rendering that looked and worked the same. But I digress.

This post is about the recent rendering changes in DevExpress ASP.NET controls and how it might affect you. And if you've experienced any issues, then we are here to help you.

A (breaking) change

DevExpress introduced the Lightweight render mode in many of our ASP.NET controls several years ago. You can see a list of the controls here.

From 2010 to 2013, our controls supported two render modes:

1. Classic: based on HTML tables
2. Lightweight: based on 'light' HTML elements, e.g. 'div' and unsorted lists (UL)

In the v13.2 release, we stopped support for Internet Explorer 6 (IE6).

We also dropped the "Classic" render mode from our controls. This caused a breaking change for some of our customers and this will explain the why, support for issues, and the future of rendering.

After we stopped support for IE6, we were able to update several controls to make them lighter.

On the web, you need to be light, fast, functional, and powerful to remain competitive. And so, it's our goal to ensure that we're competitive while still maintaining that great cross-platform browser support.

What does the change involve?

Less use of HTML tables for rendering and more use of div, ul (lists), etc.

Specifically:

• ASPxButton control - its HTML render was rewritten and now it does not use TABLE tag.
• ASPxEditors - Heavy refactoring of the buttons render for: ASPxCalendar, APSxComboBox, ASPxDateEdit, ASPxSpinEdit and other editors which contain button elements.
• ASPxRoundPanel - its HTML render was rewritten and we removed any unnecessary TABLE tags).

Why the change?

Dropping support for the Classic render mode was a difficult decision. However, we could not support Classic render mode because it made our controls 'heavier' and took additional browser resources for processing.

The Lightweight render mode is much lighter and more semantic. It allows our products to be quick and modern. In fact, it should help to reduce the negative effect of this issue: Visual Studio 2012 (2010) performance is very slow when a page with ASP.NET controls is opened in Designer.

Removing Classic render does not mean that our customers should abandon the use of HTML tables in a page layout.

There are cases where tables are more effective than using divs and lists. Tables are great for tabular data. In fact, a lot of our controls still use tables (e.g., ASPxFormLayout, ASPxTreeList, ASPxGridView, etc.).

However, tables are not effective in other cases. So, we updated several controls to make them lighter by not using tables to render them. Another side effect is that it allows you, the developer to create more effective web applications.

There are a lot of pros and cons of both render modes. I recommend reading the Table Layouts vs. Div Layouts: From Hell to... Hell? article, where both render approaches are objectively described.

Issues

With each release, we have many types of tests in place that test our products in different scenarios, operating systems, and browsers. However, we cannot test every scenario.

And so with the v13.2 release, we received bug reports from some of our customers who found some issues. We have already fixed many of these known issues in the next minor release, v13.2.7.

Our support is also ready to help you. If you've experienced any issues in upgrading, please take a look at this knowledgebase article for a list of the known issues first to see if there's a workaround or solution that may help you.

DevExpress Cares

The DevExpress support team is here to help in case you run into any issues. Contact them either via support@devexpress.com or better yet, log a ticket.

Thank you.

Cheers to all!  Thanks for checking out my new endeavor!

I’d like to begin by introducing myself – my name is Marion by day and Marina by night. J  No doubt that some of you are already familiar with my other posts, such as Pros and Cons of CDN Usage in Projects With ChartJS and Get Started With Videos.  But this new blog is something very new for me and I am not sure what it will evolve into.  I am looking forward to sharing many interesting things with you, including videos, tutorials, tips, etc.

I bet you are wondering why a gal from a web team in love with web technologies wants to now write about  a client-side story? Well, it just so happens that DevExpress has this fairly new client-side product – DevExtreme.  Since there is such a limited amount of information on it, I am thrilled to tackle this subject.  DevExtreme is this remarkable treasure troth of many different suites (like charts) and client-side widgets, all of which can be used both in desktop and mobile applications. I will use this blog to cover all these suites and widgets in detail. Again, thanks for visiting and stay tuned.

-Marina

P.S.  Since DevExtreme is one of our newest products and is still being actively developed, your input is of great value to us.  So, don’t shy away from dropping me a line once you’ve had the opportunity to check out DevExtreme.

CodeRush’s Templates are awesome.

Sadly we can’t ship every conceivable variation of awesome out of the box. However we do ship the ability for you to write your own templates.

I’ve blogged about creating templates before, but thought it might be worth reminding you how to Export your templates for sharing and how to Import templates written by others.

Exporting Templates

From the templates options screen (Ctrl+Shift+Alt+O, Editor\Templates) you should arrange your templates such that:

1. Custom templates are positioned in a custom folder within the Hierarchy
   Note: This isn’t required as such, but it can make a great deal of sense to have all your custom templates beneath a single location.
2. Position the templates you’d like to export in a folder on their own.
   We’re not trying to make the templates feel bad, it’s just that the unit of export for templates is folder based.
   For example: I have a bunch of plugin templates positioned in a Custom\Plugins folder.

To perform the actual export…

1. Right click the folder you’d like to export and choose Export Folder…
2. Name your export file. (The default name provided is based on the language of the template set, and the folder being exported.)

At this point you have a totally portable .xml file which can be taken to another computer and imported.

Importing Templates

From the templates options screen (Ctrl+Shift+Alt+O, Editor\Templates)

1. Ensure you have the correct language selected.
   
2. Right anywhere in the template tree
3. Choose Import Templates…
   
4. Locate and choose the file containing the templates you’d like to import

If the template file indicates a folder that you already have then you will be offered the following dialog:

The default choice here will wipe any duplicate templates found in your existing system in favour of those found in the templates file.

In the example above, I am importing some templates into a ‘Custom’ folder so those are the only ones at risk.

If you are unsure, feel free to pick the 2nd option and change the top level folder to something new (perhaps ‘Custom2’). You can then examine the plugins imported into that folder and decide which ones you’d like to keep. You can either move them around manually or decide that they’re all fine and reimport over the top of the original location (remembering to delete the ‘Custom2’ folder if this is the case)

Summary

So you now have the tools to let you export some of your own awesome templates for others to use.

Why not spread the wealth and share your templates with co-workers or even with the wider community.

In some upcoming posts I’ll be doing exactly that. Sharing some of my own custom templates with you to help make your coding lives easier.

With the release of v13.2.6, XAF supports Entity Framework 6 by default. If you are upgrading from an earlier version of EF, please take special notice of the following Microsoft article: Upgrading to EF6.

Due to the recent Entity Framework changes we have also updated and restructured our related documentation to help you get started with Entity Framework in XAF. More is also coming as we could simplify some of our EF-related APIs.
To learn more about these changes, please be sure to visit the Business Model Design with Entity Framework section in our docs.

In addition to service refactorings and usability improvements, v13.2.7 brings additional features requested by our Entity Framework users.
In particular, we now support composite keys and custom calculated fields in the entity data model. These changes enable your end-users to extend the business model at runtime without recompiling the app. Since there is no built-in support for custom fields in Entity Framework (as it is done in XPO)  we had to provide our own implementation (check the docs for more details on this).

If you haven't tried XAF, see how much time and money you can save when building modern LOB apps for Windows and the Web by completing this simple getting started tutorial.
Already familiar with XAF? Then this tutorial is an excellent place to brush up on your skills and fill the important XAF knowledge gaps.

CodeRush User Richard O'Neil has created his own set of FakeItEasy templates to speed his development.

These templates give him an edge when creating his fake objects using this popular framework.

In case you’re unaware, FakeItEasy is a Mocking framework for .Net which is hosted on GitHub

Templates

As I write this, Richard has support for the following templates:

Setup FakeItEasy

Trigger: ufie<space>
Effect: Adds ‘FakeItEasy’ to the namespace references of the current file.

Note:This template does not need to be called explicitly since it is called for each of the following templates already. Additionally, the reference is added in the correct location above the class definition.

Create a Fake Object

Trigger: fief<space>
Expands to:

Set up a call to return a value

Trigger: fiecr<space>
Expands to:

Creating ignore parameters

Template: fieany?Type?

Examples:

fieanyi<space>
Expands to:


fieanys<space>
Expands to:

Being the awesome community person he is, Richard has published these templates on github so anyone can take advantage of them.

If you’d like to use these templates in your own projects, download the xml file from the repository and follow the Import instructions in this post

You have a simple idea for a CodeRush plugin.

1. An Action you’d like to trigger from your IDE.
2. A Refactoring or a CodeProvider you’d like to add.
3. A new Context which you could use to fine tune the availability of your templates.
4. A StringProvider, a TextCommand or a Code Issue.

But you can’t be bothered with all of that drag and drop visual designer business.

Visual Designers are Slow

From the moment you reach for the mouse you know you’ve already lost speed. Visual designers aren’t just slow though. They’re very awkward to use. Even if they responded at the speed of light, they’d still be awkward to use.

Assuming that they invoke instantly, you still have to wave that mouse around all over the place in order to get anything done at all.

For a simple control/component with 2 properties and 2 events the procedure is something like this.

1. Mouse –> Open Toolbox
2. Mouse –> Drag control onto design surface
3. F4 –> Bring up properties tool window
4. Mouse –> Scroll to find property
5. Mouse –> Select property
6. Keyboard –> Set property value
7. Mouse –> Scroll to find property
8. Mouse –> Select property
9. Keyboard –> Set property value
10. Mouse –> Click event tab in properties toolwindow.
11. Mouse –> Scroll to find event
12. Mouse –> Double-click Event to produce event handler.
13. F4 to return to properties tool window
14. Mouse –> Click event tab in properties toolwindow.
15. Mouse –> Scroll to find event
16. Mouse –> Double-click Event to produce event handler.

That’s 8 mouse operations and 4 keyboard operations. It’s also 8 context changes (Mouse –> Keyboard or Keyboard –> Mouse)

There have been improvements in this area (The toolbox can be searched or filtered using the keyboard), but so much switching from mouse –> keyboard –> mouse can’t be a good thing. Now I know what you’re thinking. There’s likely some set of really easy to remember set of keystrokes that can emulate all that mousing around. Yeah I’m sure I heard something like that once as well, but I sure can’t remember it now. It obviously wasn’t that intuitive.

So what’s the alternative?

Enter… CodeRush

Well what is the toolbox ultimately used for? That’s right, it’s an easy way to write code quickly.

Ok well CodeRush already has many ways to write code quickly. One of the most effective of these, is also one of the easiest to use.

Templates

Type a few characters…. Hit space… Oh look there’s your code. Awesome!

So back to the main point of this post: I’ve been putting together a group of templates that can ease the creation of plugins. I’m collecting these in a Github repository which I’m just going to leave over here.

I’ll go through them in some upcoming posts, but the general gist is this.

1. Place caret in plugin class.
2. Invoke template.
3. Call register method from InitializePlugin method.
4. Follow instructions left in plugin.

I’ve summarized these instructions in this handy screenshot.


The Templates

The templates presented emit code designed to replace the drag and drop designer approach typically used for such things. This is my own preferred approach. I do not suggest it is the only approach. However it is one that works for me :)

Upcoming posts will walk you though several templates including (but not limited to) NewAction, NewRefactoring and NewCodeProvider.
So stick around and we’ll help kick-start that plugin for you.

Building on the initial presentation in early February, the second part of this webinar mini-series will focus on how to add roles to users in your ASP.NET Project. I'll also address some of the questions you raised...  

• Do you use Claims? Roles? what's the difference?  
• Can you add the new Identity feature into an existing WebForms or MVC Project?  

Join me on February 27 to see these and other questions answered.  

In addition, I'll showcase some of the amazing features of the DevExpress ASPxGridView control, see how to edit user details with simple inline features, secure your admin page and provide access to basic pages based on user permissions.

A big thank you to everyone for their feedback on Part 1, which of course is available via our YouTube channel here.  

Click here to register today for Part #2 of the ASP.NET Security series.

I’ve recently been asked:

How come you’re putting all your plugins on GitHub? Have you abandoned the DXCoreCommunity site?

This post is an attempt to answer this question.

The Problem

The tech and structure underlying the existing DXCore Community Site is old and out of date. It’s an SVN repository hosted with Google Code. It’s a single repository that holds many plugins. The site is larger than I ever though it would be. We have over 100 plugins and their associated wiki pages and it’s “getting” out of hand.

Within the current structure, branching and merging is so much of a pain that I don’t think it’s been done in a very long time. Its actually an inertial barrier to making any changes at all.

With hind-sight, it should probably never have been created as a single repository of plugins. Rather it should have been an index to many repositories, each holding their own plugin project. However what’s done is done and porting 100+ projects out of a single SVN repository and into 100+ individual repositories (along with their various wiki pages and links between them) is a task that seems a little impractical to take on wholesale.

The other major pain point of the SVN based site, is it’s centralized nature. A single central repository means that it has a single central access management system.
ie Anyone who needs write access, needs to be given explicit write access. In addition there is no way to give access to only those parts of the project that make the most sense. Write access is site wide, or not at all. As the breadth of a project grows, so does this issue.

First Steps

The first step in solving any problem is to recognise it’s existence. In this case, I acknowledge: the community site is too big and unwieldy to manage properly, and it has been for some time.

The second step is to stop making it worse. If I can help it, I will not be adding any additional plugins to that site.

So how to move forward?

The Code

So far as the code is concerned, I’ll be doing what you have seen recently. Creating each new plugin within it’s own repository. Each repo will contain code, readme and releases (including binaries).

I will be using Git, because I believe I find it quicker, easier and more flexible than any other source control I have used before. The use of Git, along with isolating each plugin in its own repo, will make branching and merging much easier. This in turn will allow easier experimentation, and more innovation.

This means that there, will be many more repositories than before. This was always the case anyway, but the community site ironically didn’t do much to acknowledge the community outside it’s own walls. People already create plugins which are not a part of the site. They blog about them independently and even host them in different types of source control.

So in acknowledging that there are plugins beyond the community site, we justify the continuing need (perhaps a bigger need than before) for a site whose purpose is to provide a location for people to learn about the existence of such plugins.

The Community Site

This rise in plugin locations increases the need for somewhere to index them. Whilst I could repurpose the existing Community site, it’s worth noting that the single central access management system is as much of an issue with the wiki side of things as it is with the source code side.

The Community Site, or rather the tech that supports it, is not up to the task of providing a central location to locate useful plugins.

So we need a new community site which needs to be…

• Somewhere where pages can easily be edited.
• Somewhere that’s easy to backup.
• Somewhere that’s easy for others to contribute to.

Can you see where I’m going with this?

Yup… I decided I decided to depart the shores of Google Code and set sail for the land of GitHub.

Hosting the site using Git has a lot of advantages:

• Local Everything
  Local edits mean you can use a local editor and all the speed and other features that come with it.
  Local branching, merging and committing and merging, means you don’t need to reply on the server (or the speed of that server) to get almost anything done.
• Push Technology
  Pushing your website to a server in the same way you push your code is awesome. It makes revision control easy and rollbacks (if they are needed) are completely painless.
• Fork Me!
  The ultimate in open. Others can copy the entire site if they want, and make an even better index. Improvements can be offered back and absorbed without any permissions ever being allocated.

In addition there are particular advantages to hosting with GitHub

• GitHub Pages
  A feature where a branch of a repository is treated as the source files of a website. This benefits from a backend system which compiles markdown into html.
• Pull requests
  A feature where someone forks code and makes changes. Later they can request the original repo pull those changes back into said repo.
  This is entirely possible via email without GitHub, but much smoother with it.
• Releases
  A feature where any tagged commit can be elevated to a release which then can have associated binaries and release notes attached.

The new community site will be a pure index. It will not be responsible for any plugin code. It will not be responsible for any plugin readme file. It will likely have to contain a basic description of each plugin and might list any given plugin on multiple pages according to it’s categorization. However the plugins will not be hosted on this site and the plugin’s authors will retain complete responsibility for them.

Not hosting the plugin code or binaries gives the new community site an advantage over the old one. Every linked plugin is equal in the eyes of the community site.

The site can link directly to:

…without granting any of them special treatment because of their local status, because none of them will be local.

Licensing

The previous community site used the MIT licence. this was felt to be a lowest common denominator. It was understood that plugins hosted on the site were essentially anything as long as the original author was recognised. However not everyone wanted to use this licensing model. Now they don’t have to. Simply create a repository of your own (github or anywhere else), upload your code and add the license of your choice. Then let us know and we’ll add your plugin to our lists in all the appropriate places.

We’re live!

The first version of the site is already up and running at: 

http://rorybecker.github.io/CodeRushPlugins/

It lists all of my most recent plugins and links back to the original community site for completeness. Go on. Check it out. If you’d like me to add your plugin, send me a link to your repo or blog-post and I’ll add you to the list. If you’d like to help improve the look and feel or content of the site, Fork it! and send me a pull request.