Developer Express Inc.

New WPF MVVM Scaffolding Wizard (released in v2013.1)

Azret Botash (DevExpress) — Thu, 13 Jun 2013 21:14:11 GMT

When developing WPF applications, the most commonly used and the most suitable architecture pattern is MVVM. The MVVM pattern is flexible and extensible. It is specifically designed to separate business logic and data layer from the user interface, thus keeping the application code clean and maintainable.

Let’s consider a typical MVVM architecture, illustrated below:

The challenging and, the most time consuming part in implementing this, would be writing all the plumbing for it. Just imagine a scenario where you have to deal with 20 or more data tables. For each table you would have to manually create your models and define their dependencies. And not only that... you would also have to spend time on implementing INotifyPropertyChanged, error handling and so many other minute details that it would take you away from actually building the app that you need.

To help with this laborious task, we created a Scaffolding Wizard. The idea is simple, help developers to create clean MVVM style applications fast. You start with providing your data tables by selecting them from a list, and the rest of the code is generated for you automatically.

Scaffolding Wizard will generate everything for you, from data loading and saving to error handling and synchronization.

From the above shown pattern, this first release supports the following flow, with the rest to come in the upcoming releases:

In addition to this, we have abstracted many MVVM scenarios into a DevExpress.Xpf.MVVM assembly, to help with Attached Behaviors, Services, Notification Services more.

To see all the Scaffolding Wizard in action please check out this video:

DevExpress WPF MVVM Scaffolding Wizard

A step by step by step tutorial could be found here: http://documentation.devexpress.com/#WPF/CustomDocument15281

Cheers,

Azret

Meet DevExpress in Redmond on June 25

Sara Faatz (DevExpress) — Thu, 13 Jun 2013 20:07:00 GMT

We've been having a great time meeting with you, our customers, all around the world. We've brought the DevExpress Developer Summit, the DXTREME Development Tour, and the Express Way Tour to Düsseldorf, San Francisco, Chicago, New York, Washington DC, Los Angeles, Sydney, Brisbane, Istanbul, and Munich.

We are pleased to announce our next roadshow event, Meet DevExpress, which will make a stop in Redmond, WA, on the Microsoft campus on Tuesday, June 25 from 11:00 a.m. till 4:30 p.m. Throughout the afternoon, you’ll have an opportunity to join members of the DevExpress team and discover how you can build engaging applications for the web with our comprehensive line of ASP.NET Controls and MVC Extensions. Our featured speakers include our Chief Scientist, Mark Miller, and our Technical Evangelist, Paul Usher.

You can find the detailed agenda and registration information here. As with our past tours, the event is free and lunch is provided.

We’d love the opportunity to meet with you face to face and share with you the amazing ways you can leverage your skills with our tools to build great apps. Hope to see you in Redmond!

CodeRush 13.1 - Enhancements to the Visual Studio Debugging Experience

Mark Miller (DevExpress) — Wed, 12 Jun 2013 23:31:00 GMT

With the release of CodeRush 13.1, we have made several significant enhancements to improve the Visual Studio debugging experience, shedding more light on some of the more challenging-to-discern aspects of debugging.

XAML Bindings in Silverlight 5

Now when stepping through Silverlight 5 XAML binding code you’ll see previews of the binding properties. Gone is the need to bring up the Locals window, open the BindingState object, and then find and open the FinalSource property. Now the information you need is right where you’re looking – in the code.

Instantly see binding properties without looking away from the code, reaching for the mouse, or pressing excessive keystrokes.

Improved Support for Exceptions and the Call Stack

To make finding bugs even easier we’ve added the Call Stack and Exceptions (CS&E) tool window. While at first it may appear to be simply an easier way to read call stacks, like CodeRush itself, it’s more than a pretty face. It is especially handy when debugging asynchronous code.

To show how useful it is, first let’s look at the typical Visual Studio asynchronous code debugging experience. We’ll measure the impact on usability along the way – if this gets too crazy for you, you can jump ahead to the “Now let’s try it with CodeRush…” section below.

Async Debugging Experience in Visual Studio (without CodeRush)

First the exception is thrown. Visual Studio stops execution here:

VS Usability Impact so far: 1 target area visually scanned, 3 seconds invested

Hmm. That’s not very helpful. Of course, Visual Studio also presents this dialog:

Where’s the useful information? We have no indication of what code caused the problem.

VS Usability Impact so far: 2 target areas visually scanned, 7 seconds invested

Next you look at the call stack. It looks like this:

Also, not useful.

VS Usability Impact so far: 3 target areas visually scanned, 11 seconds invested. We’re going nowhere fast.

OK, let’s go back to that exception helper window. Let’s click the “View Detail…” link.

VS Usability Impact so far: 1 click, 3 target areas visually scanned, 12 seconds invested

Here comes the View Detail dialog. It looks like this:

No useful information yet. Good thing our hand is on the mouse. Move it up to the triangle and click it.

VS Usability Impact so far: 2 clicks, 4 target areas visually scanned, 14 seconds invested

Now we see this:

Scanning this data, your eyes may have noticed the InnerException. What’s that all about? Let’s open it up. Click the triangle to the left of the InnerException node.

VS Usability Impact so far: 3 clicks, 5 target areas visually scanned, 17 seconds invested

You probably have to resize and scroll to see this data.

VS Usability Impact so far: 4 clicks, 1 scroll, 5 target areas visually scanned, 20 seconds invested

The contents of that InnerException node look like this:

OK, so it feels like we’re getting closer. After visually scanning the InnerException child nodes, we can see three important pieces of information:

The InnerException of this InnerException is null (which means we’re near the root of the problem). The Message tells us a parameter called “address” is null, and we have a stack trace that may finally be useful.

VS Usability Impact so far: 4 clicks, 1 scroll, 6 target areas visually scanned, 26 seconds invested, and it seems we’re almost there.

Let’s open up that stack trace. First, click anywhere on that StackTrace line in the dialog. Then click on the drop down button to the right. If your Visual Studio is like mine, you’ll see something like this:

Lovely. As an exercise in futility, try to read that wrapped call stack to figure out where your problem is. There is actually more to the call stack than you see in this drop down, unfortunately there’s no scroll bar to tip you off to that fact.

After more clicking, scrolling, and reading (both above and below the visible parts of the call stack above), we might infer that our problem is at the topmost position of the call stack that references our application code:

WindowsFormsApplication1.MailSenderAsync.<SendEmail> in MailSenderAsync.cs (line 27)

VS Usability Impact so far: 7 clicks, 2 scrolls, 9 target areas visually scanned, 33 seconds invested, and it seems we’re farther away than we thought.

So now we look at the code. Since there's no navigation support built in, we need to close this stack of windows.

VS Usability Impact so far: 10 clicks, 2 scrolls, 9 target areas visually scanned, 36 seconds invested.

Next we need to get to line 27 of MailSenderAsync.cs and take a look:

VS Usability Impact so far: 11 clicks, 2 scrolls, 5 keystrokes, 9 target areas visually scanned, 41 seconds invested.

Let’s press Ctrl+Shift+Space to see the parameter tool tip for the MailAddress constructor.

Excellent! We’ve found the parameter named “address”. Getting closer.

VS Usability Impact so far: 12 clicks, 2 scrolls, 8 keystrokes, 9 target areas visually scanned, 44 seconds invested.

OK, so the “sender” parameter must be null. But how did we get here? How do we fix this? Unfortunately, after almost a full minute of clicking, scanning, and reading, we’ve only scratched the surface of understanding the problem. Typically the next step is to set a conditional breakpoint to stop when sender is null so we can investigate the call stack in more detail.

From the Usability Count we’ve been maintaining it seems we’re investing a lot of development time going nowhere. We might need to set a breakpoint and try this again, or scan the call stack from the inner exception again to find out how we got here and find out how sender is getting a null value. Even a guru developer may be several seconds, if not minutes away from discovering the answer.

Let’s compare this experience with Visual Studio on some serious family-friendly steroids, err CodeRush, plus our new CS&E window.

Now let’s try it with CodeRush…

By the way, if you already have the latest version of CodeRush installed, we recommend starting a new debug session (create new project and run it) right now and then open and dock the CS&E window at your favorite place in the editor while VS is in debug mode. This one-time step will get Visual Studio to remember this position and make sure the CS&E window is there for you in future debug sessions.

I’ll wait while you do that.

DevExpress | (CodeRush) | Tool Windows | Call Stacks and Exceptions.

OK, ready? Here’s how easy it is to find the bug with CodeRush:

Starting with the same code and the same place as the previous example, click this link:

CR Usability Impact so far: 1 click, 1.5 seconds invested.

The CS&E window immediately looks like this:

We’re debugging Async, so we know this outer call stack isn’t interesting. Instead we click the “Show inner exception” link above the stack.

CR Usability Impact so far: 2 clicks, 3 seconds invested.

Now we see this:

Do you see that? The CS&E window is ACTUALLY HIGHLIGHTING the line of code contributing to our “sender equals null” problem. No need to visually scan the call stack. Just click the “MailSenderAsync.cs line 21” link, and we’re immediately inside this code:

Are you kidding me? The Sender field variable, the parameter to the SendMail overload is ACTUALLY SELECTED. It’s actually selected, kids, drawing your eyes right onto the source of the problem, explaining how the sender parameter became null – the Sender field variable, passed into the method from line 21, was null. Now we’re much closer to understanding the problem. Nice.

CR Usability Impact so far: 3 clicks, 5 seconds invested.

When you’re debugging asynchronous code, the difference is huge. Here are the usability totals for this example:

	Visual Studio (alone)	VS + CodeRush
Clicks	12+	3
Scrolls	2+	0
Keystrokes	8+	0
Areas Visually Scanned	9+	0
Time invested	44+ seconds	5 seconds

This is good stuff. CodeRush helps you stay focused on the code instead of wasting time struggling with suboptimal UI.

Important notes about the CS&E window:

Make sure you have the “Automatically paste exception or call stack from clipboard” button in the down state to get this seamless ease of use.
You can copy call stacks and exception data from any location (including Visual Studio’s Call Stack window).

This last point means you can send a call stack to a team member and they can copy it to the clipboard and see it inside the CS&E window, and they can use it to explore the same version of the code, EVEN IF THEY ARE NOT DEBUGGING. Impressive.

Dead Path De-emphasis

CodeRush de-emphasizes code on dead paths (e.g., outside the current execution path). Conditional blocks that won’t be executed on the current pass are grayed out, so as you’re stepping through code it’s even easier to focus on the code that will be executed.

Code along the dead path (e.g., inside the conditional block) is grayed-out. We won’t be stepping into that block in this pass.

Recursive Method Depth Counter

CodeRush now displays a counter indicating the depth of recursive method calls. The counter appears when a method is called from itself at least one time.

The Recursive Method Depth counter shows how deep you are into that method’s recursive call stack.

The recursive call indicator reveals how many times the method appears on the call stack, so “2” is shown on the first recursive call.

New Actions, New Options, and Other Debug Visualizer Improvements

The following actions and default shortcuts are now available:

Toggle Expression Values - Ctrl+Shift+Alt+F10
Focus Next Expression - Tab
Focus Previous Expression - Shift+Tab
ToggleDebugVisualizer - Ctrl+Alt+D

We have added a “Show historical values” option to the “Editor | Debug | Visualizer” options page. It specifies whether to show values only for the current code line or for all code lines within the current method. I prefer seeing a full history, however you may prefer a more compact display as you work.

In Visual Basic, CodeRush now shows icons indicating whether the current Boolean expression is true or false for “case” statements.

The Debug Visualizer is smarter and able to automatically preview more expression types than before.

CodeRush smoothly adjusts line height when showing or hiding debug visualizer visual elements (expression values or Expression Explorer). This results in a smoother debugging experience and keeps your eyes on the important data.

Enterprise Ready Reporting with the DevExpress Report Server

Seth Juarez (DevExpress) — Mon, 10 Jun 2013 21:29:21 GMT

Ever since our beta release of the DevExpress Report Server we have been busy adding important enterprise features to the product. One of those essential features is enterprise ready security. Starting with this release the DevExpress Report Server includes 4 unique built-in security groups associated with the report process:

System Administrator: Full access to all server functionality and user account administration.
Data Administrator: Ability to manage and control the data available to reports.
Report Creator: Maintain report categories and create/manage individual reports.
Report Viewer: Access to view and print reports and to receive report distributions.

While these were available in our previous release, the level of customizability we have added was not. These built-in groups are completely customizable. You can delete them (with the exception of the System Administrator group), rename them, and even modify the access and scope available to members of the group. In addition to these customizable roles you can create an infinite number of groups with 4 different access modes (Read, Read/Modify, Read/Modify/Delete, and Create) in 9 separate scopes (All Categories, Specific Category, All Reports, Reports in Category, Specific Report, All Data Views, Specific Data View, All Scheduled Jobs, and Specific Scheduled Job).

Groups

Adding, removing, and editing groups can now be done via a special Group Tab.

Clicking on the pencil icon leads to a screen where group membership can be established:

Clicking on the gears icon brings up the permission set window:

Notice that when adding permissions you can select both an Access Mode,

and restrict the Access Mode to a particular Scope:

In all, these collection of features allow for an infinite number of combinations in order to tailor to your specific security needs.

Individual

Adding an individual to a group automatically adds all of the corresponding permissions to the users. In addition to this automatic application of rights, you can also add additional permissions to the individual user by clicking on the gear icon of the user:

This leads to the familiar permissions area but for only the particular user in question:

Notice that in addition to the inherited permissions one can add additional ones by clicking “Add Permission".”

FAQ’s and Pricing

We are excited to finally release the DevExpress Report Server as a standalone product. We have a truly affordable price and clear licensing for the product.

Try It!

We would love for you to give it a spin! We have created an Azure based demo where you can try the server yourself: http://dxrs-demo.cloudapp.net/. There are a couple of things you need to do to try it:

Create an account by clicking “New User”
Install the Client Side Report Designer (you will receive an email with a download link)
Activate your account.

We really want this to be a product that you come to rely upon to deliver on your reporting needs. I want to personally know how you use the product, where it succeeds, and how we can make it better.

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

New XAML features in CodeRush 13.1 for Visual Studio

Mark Miller (DevExpress) — Fri, 07 Jun 2013 21:00:00 GMT

CodeRush 13.1 includes a number of new features to make working with XAML easier.

Navigation Support

The Declaration navigation provider is available in XAML code now. You can use it to navigate to:

Control declarations
Types
Properties
Resource keys
Named controls
xmlns aliases

Code Completion

With CodeRush 13.1 installed, Visual Studio’s XAML Intellisense is smarter and more capable. CodeRush suggestions are integrated with the Intellisense window, and include:

Available continuations for Binding path expressions and TemplateBinding arguments
Binding.ElementName, Setter.TargetName, and Trigger.SourceName values
Resource key completions for StaticResource and DynamicResource markup extensions.

New Code Cleanup Rules for XAML

The following XAML specific code cleanup rules are new for 13.1:
Remove All Comments – removes all XAML comments.
Remove Default Values – removes control attributes initialized to default values.

Code Providers

Declare XAML Namespace Reference

This CodeProvider declares a new XAML namespace reference for the active qualifier.

If the type resolves to multiple locations, a submenu will appear allowing you to select the namespace to declare.

Declare All XAML Namespace References

This CodeProvider declares multiple namespace references for every qualified control that can resolve to a single declaration. This refactoring can be useful after pasting XAML fragments from another source.

Seven New Grid CodeProviders

CodeRush 13.1 includes seven new Grid CodeProviders, which makes it much easier to work with controls inside XAML Grids.

Insert Columns/Rows

These CodeProviders insert the specified number of columns or rows at the specified location, shifting control position as needed. This CodeProvider can save a huge amount of time if you need to add a column or row to an existing grid. In the example below, we effortlessly add two rows to an already complex grid, shifting 50 control positions down automatically.

Position Control

This provider allows you to visually position a control inside the parent grid without reaching for the mouse or risking unintended changes (such as span and margins being set by the Visual Studio designer due to less-than-precise mouse operations).

Delete Columns/Rows

These CodeProviders remove the specified number of columns or rows at the specified location, shifting control position and span as needed. Controls contained entirely inside the deleted range will be removed unless the “(keep controls)” variation of this provider is applied.

All grid manipulation operations are intelligently performed so undo is simple:

Note: the first 13.1 release omitted the delete column/row providers. The subsequent minor update (and daily builds) include this feature.

New Templates

Setting Numeric Properties

Now setting common numeric properties is fast and easy. Here are your shortcuts:

Shortcut	Property
h	Height
m	Margin
p	Padding
w	Width

Just follow these with a number (1-4 digits) and press the template expansion key. For example, the h149 template, when expanded inside a control’s tag, produces the following:

Height="149"

Creating Controls

CodeRush 13.1 includes a new set of dynamic code templates for creating common XAML layouts. New shortcuts for common controls:

Shortcut	Control
b	Button
bd	Border
cb	ComboBox
l	Label
lb	ListBox
rb	RadioButton
sl	Slider
sp	StackPanel
tb	TextBlock
tbx	TextBox
tc	TabControl
ti	TabItem
vb	ViewBox

The shortcuts above work anywhere a control is valid inside XAML. These templates will expand with a unique name. For example, pressing “b” followed by the Space or Tab key will produce the following:

I should emphasize the name is unique, which is useful when you’re quickly prototyping or presenting to other developers.

If you want to omit the name from the expansion, just follow the template with a comma (the comma is used throughout the CodeRush template library to produce shorter versions of many templates). So if you want a nameless border, just expand the “bd,” template.

If you’re expanding one of these controls inside a grid, you can optionally specify the location using one of these modifiers:

r{RowNumber}c{ColumnNumber}

c{ColumnNumber}r{RowNumber}

r{RowNumber}

c{ColumnNumber}

So to place a TextBlock inside row 1, column 2 of the parent grid, you can expand this template:

tbr1c2

This template will do the same thing:

tbc2r1

To omit the name, just follow the template with the comma.

Modifying templates with grid position like we’ve seen above is optional. And as you might expect, with CodeRush, there is more than one way to get the job done…

Positioning Controls inside a Grid

The row and column modifiers seen above also work as stand-alone templates inside the main/start tag of a control. That means you can use any of these templates to set a control’s position within a grid:

r{RowNumber}c{ColumnNumber}

c{ColumnNumber}r{RowNumber}

r{RowNumber}

c{ColumnNumber}

Also, don’t forget the Grid | Position Control provider shown above if you prefer a more visual approach.

Creating Grids

Need a grid that’s 3x3? Use the g3x3 template.

Need a grid that’s 2x5? You guessed it – use the g2x5 template. Creating grids is easy. Just use this format:

g{ColumnCount}x{RowCount}

This animation shows how quickly you can set up a grid with the templates:

Note: the initial 13.1 release of this template limits row and column counts to 9x9. Subsequent releases will increase this to 20x20.

What’s that you say? You’re more of a visual person? Typing g2x5 is too much work for you? It gets easier. Here’s your new template:

g

That’s right kids. You need a Grid of any size? Just hit the letter g followed by the template expansion key (typically Space or Tab, depending on your settings). Here’s what you’ll get:

Exciting, isn’t it? On Monday I’ll show the cool new features we’ve added to the Debug Visualizer.

A New Release & Website!

Sara Faatz (DevExpress) — Fri, 07 Jun 2013 18:59:00 GMT

This has been an exciting week at DevExpress. We had a great time at TechEd North America in New Orleans and had the pleasure of talking with many of you who were there. We also officially released DevExpress Universal 13.1 and a new version of our website!

We hope you are as excited about the new release and changes as we are. Let us know what you think and tell us how we can improve. You can always reach us via email or, if you plan to be at Build in San Francisco later this month come by our booth and tell us in person. We look forward to your feedback.

DevExpress Universal 13.1: Binding tomorrow to today

Julian Bucknall (DevExpress) — Thu, 06 Jun 2013 10:00:00 GMT

There are some major releases which accrue a certain amount of importance, and, in looking through the What’s New for this first major release of 2013, I can’t help but feel that sense of significance. The reason? There’s so much good stuff here that, if I were to do it complete justice, I’d just be repeating the selfsame What’s New.

So, let me approach things from a thematic angle, if I may.

One of the things we’ve noticed over the past year, despite all the news from Microsoft during that time, is that around half of our customers are still writing thick-client apps on Windows, be it with WinForms or WPF. Yes, all the buzz might be about Windows AppStore apps, yet the bread and butter is being earned on desktop Windows. It seems that taking care of these desktop developers, helping them to slowly get their users accustomed to the Modern UI design esthetic and the new data visualizations and navigation metaphors, without abandoning their codebase or experience, might be a good idea.

We’ve already done some work, certainly, with our 12.x series of releases. Things like the Metropolis themes, the tiles, the concessions to touch, all these have helped. With 13.1 though, we decided to go much further to aid the desktop app developer with the addition of some major new controls.

A new spreadsheet control with full support for formulas, cell formatting, import/export to Excel file formats or CSV, and so on. No more shelling out via COM to Excel: you can drop a fully-optimized Microsoft Office-inspired spreadsheet right in your apps. We even provide a Ribbon configuration with all the usual spreadsheet functionality so you can quickly deliver your next stunning application. Since the engine is separate from the UI, you can use it programmatically to open a spreadsheet file (or create a new one), modify it, and save it.
A new map control that uses as provider either the Bing map web service (vector, photo tiles, or hybrid) or OpenStreetMap. Like our map controls on other platforms, there’s support for vector drawings on the map (a route, say, or maybe icons for special places). The control also comes with the standard UI elements needed for map manipulation, such as scroll, zoom, coordinate labels, and so on.
A PDF viewer control (beta release). At long last you can embed a DevExpress control in your app to display PDF files. Text, images, and vector shapes are supported, together with embedded fonts and font styles. The interface for the PDF Viewer implements zooming, scrolling, and a continuous page layout and provides a ready-to-use Ribbon tab, which makes it extremely easy to incorporate a Ribbon bar in your application.
A Live Tile Manager control. This new control, more than anything else in the list of new functionality for 13.1, exemplifies the title of this post: it binds the investment and code you have in your WinForms desktop apps now to the Windows 8 Start Screen. You can display a live tile on the Start Screen – updating on a regular basis just like all the other tiles there – driven by a WinForms app. Click on the tile, and the WinForms app comes to the forefront. Since only Modern UI apps can place tiles on the Start Screen, there’s just a little hint of some DevExpress magic going on in the background: the Live Tile Manager. This is a Windows AppStore app that can set up a communications channel to a WinForms desktop app and act as a middleman, displaying a tile, updating it according to commands from the desktop app, and switch to the same app when the tile is touched or a clicked.
And so much more: new editor controls (including sparklines), an icon library with an image picker.

Despite all this work on the WinForms side of things, WPF developers have much to celebrate too.

A new Banded Grid View. This is the ability to arrange column headers into bands and to create multi-row record layouts. It’s been a part of our WinForms grid for a long while and now it’s available in WPF and Silverlight.
A new Chart Wizard. A simpler and quick-to-invoke chart wizard. No longer do you have to struggle with the Visual Studio Properties window to configure your charts, just you can use this powerful visual tool instead. It can be invoked in your apps too, so your users can more easily configure their charts. (Added to Silverlight as well.)
Improvements to the Map control (Silverlight as well) include built-in tooltips, map element selection, data binding, and much more.
A new Property Grid Control (or vertical grid), just like the properties window in Visual Studio: edit a set of properties displayed as a vertical list with ease.
And many more enhancements and improvements.

Since we’re talking about XAML controls, at least tangentially, let’s discuss our Windows 8 XAML controls. When we first introduced these, we made them part of DXTREME. After all, they’re for mobile apps, so we reasoned that they should be part of a ‘mobile’ product together with our cross-platform HTML5/JS framework and widgets. Well, nice try, but no cigar: it soon became obvious they just didn’t fit there. So we revamped DXTREME and moved the Windows 8 XAML controls out into their own package. For 13.1, we’ve added a couple of new controls to this collection and made some improvements to the grid.

The new OneNote-inspired Radial Menu is a radically new way to present a UI that allows the user to make selections or initiate actions: a menu in a circle. Try it, you’ll be amazed at how smooth and easy to use it is.
A new Flyout Control for displaying a panel that slides in from the sides of the screen.

I’ve talked a lot about the desktop and Windows 8 apps up to now, but that doesn’t mean we’ve neglected the web developers among our customers. With ASP.NET and ASP.NET MVC there is a complete set of new enhancements and functionality

Endless Paging (also known as continuous scrolling) for touch-centric applications that use the GridView, DataView, NewsControl , and ImageGallery. This is the ability to show the items being displayed as an infinite list, with the control only loading extra items as the user scrolls down. Think of the functionality provided by the Facebook or Twitter apps.
A new MVC Image Slider, like the existing ASP.NET one.
A new MVC File Manager based on the ASP.NET version.
A new MVC Captcha control for those times you need to check that a real human being is entering data into your forms.
A new ASP.NET Image Gallery control.
And many more enhancements and improvements. Please see Mehul Harry’s series of blog posts on the new functionality in ASP.NET for 13.1.

At this point, a small diversion into a new product: the Document Server. This is a non-visual .NET Library, built and optimized for C#, VB.NET and ASP.NET developers alike. It allows developers to fully automate Excel and Word without using Microsoft Office automation. Generate XLS, XLSx, DOC, DOCx, RTF, CSV and Snap Report files using a straightforward API that's easy-to-use and ready for the enterprise. The DevExpress Document Server also includes a zip compression library and a barcode generation library.

For the Dashboard, we’re adding an OLAP Server Mode for SQL Server, a new Dashboard theme, and myriad printing enhancements.

Reporting has not been ignored, far from it. Expect to see a Table of Contents report control, a much-anticipated Sparkline control, and there’s a new Report Designer and set of management controls for WinForms. For WPF and Silverlight, we’ve added a new control that provides a ribbon-based report preview. Snap reports have improved too: there’s a new wizard to add a data source; support for nested fields; an API has been published so you can create Snap reports from code; there’s a new ability to edit table cell styles; and we’ve added a new hyperlink data field.

CodeRush doesn’t get off easy either, with some well-designed visual enhancements and some performance improvements across the board. We’ve much improved CodeRush’s support for XAML code; the Smart Tag menu is now populated asynchronously for extra performance; auto-initialization of variables, fields, or properties has been enhanced; CodeRush can now declare local variables implicitly; and there have been significant improvements to the Debug Visualizer and to linked identifiers.

All in all, DevExpress Universal 13.1 is a major release in every sense of the word. It’s out now, so download the release, install, and start using these new features. And above all please don’t forget to let us know your feedback: I’m at julianb@devexpress.com, and the management team can be reached at management@devexpress.com.

Connections: Andrew Connell

Sara Faatz (DevExpress) — Sun, 02 Jun 2013 23:01:00 GMT

There are all kinds of “communities” we can opt to be a part of – social, professional, athletic, etc. - and it is always fun for me to find people who are active in multiple communities and share similar interests. Andrew Connell, this month’s Connections interviewee, is one of those people.

A nine-time recipient of Microsoft’s Most Valuable Professional (MVP) award (2005-2013), Andrew’s background in content management solutions and Web development spans back to his time as a student at the University of Florida in the late 1990’s managing class websites.

He is active in the developer community and also an avid runner – two of my own personal passions.

This month, we chatted about ASP.NET and SharePoint, cool past projects, Legos, and what running has to do with any of that. Have I mentioned I love this part of my job?!?

SF: Over the years, Andrew, you have spent a lot of time in the .NET developer and SharePoint developer communities. What differences, if any, do you see between the two?

AC: Both the .NET developer and SharePoint community share a ton of similarities. However one thing I found with SharePoint is there is a much deeper & tighter integration between people who are from different countries & continents. This is true also in the .NET developer community, but I find it much more frequent and deeper with SharePoint. Some of my best work friends are people I only get to see a few times a year.

SF: The time I’ve spent with the SharePoint community I’ve noticed that as well. It’s been a long time since I was an outsider in the .NET space, but I can tell you as a “newbie” to the SharePoint world, everyone was uber friendly and very welcoming. For other newcomers to the SharePoint space, do you have any tips for ASP.NET people getting into SharePoint?

AC: With SharePoint 2013 Microsoft introduced something called the SharePoint App Model. This effectively pushes developers to work either fully client side or server side but off the box. Your apps talk to SharePoint via REST services or a client API (client-side object model, aka: CSOM) and authenticate via OAuth. As such, ASP.NET developers can leverage the formerly taboo MVC sites in SharePoint by hosting them external. Also, developers with strong skills in client side development, including the trending single page apps technique, are well suited.

SF: That’s great advice. Really helpful, for sure. You’re obviously really dialed in to the SharePoint space - what technology trends are you watching most closely?

AC: No surprise here... cloud. Cloud is huge in the SharePoint world. The latest version of Office 365 has a hosted version of SharePoint in the cloud. This could yield a huge new untapped customer base of small and medium sized businesses who didn’t consider SharePoint in the past due to the high entry cost.

SF: Wow. I hadn’t thought of that. That’s very exciting for the space and for your business. With extensive experience in both training – online, instructor led, and through conferences - and consulting, what do you like the most about each?

AC: The best part about training is that once you finish a class, you’ve nothing left to support… people just go forth and apply what they’ve learned. Another thing I like about it is that you get to spend time in just about every area of the product so you get a good all-up overview. As for consulting, I like it for the reasons training gets old as you get to dive deep into a specific subject area and you also get to spend more time on the real world application of a product.

SF: Very cool. Makes a lot of sense. With all of the clients you’ve worked with, you must have a favorite project…

AC: Years ago I used to work for an intelligence agency with the US DoD where I was responsible for consolidating a few different resources to one location. One of the challenges was that one of the targets we were consolidating was located in a datacenter who’s external pipe was fully saturated. The site we were consolidating wasn’t allowed to be down for more than 8 hours at any time. Unfortunately, the time to backup, transfer and restore the site was going to take 30+ hours due to the poor connection. In the end they ended up backing up the site to tapes, gave it to an Air Force pilot who flew it to the base where I was working. I met the pilot on the flight line and was the first person he spoke to upon climbing down from his fighter jet. The site was down for about 6.5 hours and the pilot got a few more training hours in, as well as a nice weekend in northeast Florida on the beach. It was very crazy though meeting an Air Force pilot while his plane was still hot to receive a box of tapes.

SF: That must have been an incredible experience! And to go from a potential of 30 hours down to just 6.5 is amazing!! Wow.

Switching gears just a little, I know you are into Legos. What is the coolest thing you’ve built with Legos?

AC: A few years ago my family got me the Lego Mindstorms set where you can build things and program/control them with your laptop via Bluetooth. I built a shooterbot that could drive around and shoot marbles at people. My wife hated it as my son and I would shoot her ankles when she was making dinner. I think I got grilled cheese that night.

SF: LOL! That’s awesome. How fun!

AC: It really was. But the coolest thing I’ve seen built is a collection of things by this guy on YouTube (his screen name is akiyuky). He’s built sorters, a Rubix cube solver, etc.

SF: I’ll definitely have to check that out! Tell, me, what is something people would be surprised to learn about you?

AC: There is a statue of an ancestor of mine, Daniel O’Connell, in Dublin, Ireland as he was known as The Great Liberator.

SF: That’s pretty cool! Not many people can say that!

Now, you and I share a passion for running. Have you learned anything as you’ve trained for races that has helped you in business/software development?

AC: Pacing & practice. While these are things you always hear from people in everything you do, it wasn’t until I started running that the importance and application started to pay off. The thing I like best about running is that I find that for the rest of the day after a morning run, I have laser focus and I’m not easily distracted.

SF: That is definitely true. I know I usually find clarity on a run. It has taken me a while to get the pacing part of my training down, but you are absolutely right – it bleeds into everything you do.

Well, thank you, Andrew. Always a pleasure to chat with you!

Introducing WinForms PDF Viewer (coming soon in v2013.1)

Azret Botash (DevExpress) — Fri, 31 May 2013 21:05:00 GMT

In the upcoming v2013.1 release, we will introduce a brand new PDF Viewer control for WinForms. Built from the ground up, PDF Viewer will let you view .PDF documents within your WinForms applications without the need to have external plug-ins installed.

Note: PDF Viewer will be released as a beta. We are still working on some critical features like text selection and forms.

Cheers

Azret

Introducing BarCode Library for .NET (coming soon in v2013.1)

Azret Botash (DevExpress) — Fri, 31 May 2013 18:50:00 GMT

In the upcoming v2013.1 release, we will introduce a new, standalone Barcode Generation Library for .NET. We always had the ability to use barcodes inside our Reporting Suite, and last year we released a WinForms control to render the barcodes.

With the upcoming v2013.1, we have reworked and separated everything out into a lightweight non visual library, so you can take advantage of it regardless of the platform you are developing for.

We will support the following barcode types:

· Codabar

· Industrial2of5

· Interleaved2of5

· Code39

· Code39Extended

· Code93

· Code93Extended

· Code128

· Code11

· CodeMSI

· PostNet

· EAN13

· UPCA

· EAN8

· EAN128

· UPCSupplemental2

· UPCSupplemental5

· UPCE0

· UPCE1

· Matrix2of5

· PDF41,

· DataMatrix

· QRCode

· IntelligentMail

· DataMatrixGS1

Here is a small example on how to create a QR code:

BarCode barCode = new BarCode();

barCode.Symbology = Symbology.QRCode;

barCode.CodeText = "http://www.devexpress.com";

barCode.CodeBinaryData = Encoding.Default.GetBytes(barCode.CodeText);

barCode.Options.QRCode.CompactionMode = QRCodeCompactionMode.Byte;

barCode.Options.QRCode.ErrorLevel = QRCodeErrorLevel.Q;

barCode.Options.QRCode.ShowCodeText = true;

barCode.BarCodeImage.Save("BarCode.png");

Fig 1: Generated QR Code

EDIT: The Barcode Library will be made available as part of the Universal Subscription and as part of our new .NET Document Server standalone subscription.

Cheers,

Azret

Introducing Compression/Zip Library for .NET (coming soon in v2013.1)

Azret Botash (DevExpress) — Thu, 30 May 2013 21:51:00 GMT

In the upcoming v2013.1 release, we will introduce a new Compression Library for .NET. The new Zip Compression Library was build from the ground up to help with compression and decompression tasks in your Desktop or ASP.NET (full and medium trust) applications. The library will allow you to fully manage existing .zip archive files, create new ones or to compress and decompress in memory streams.

The usage is very straight forward, to create a new archive:

using (ZipArchive archive = new ZipArchive()) {

archive.EncryptionType = EncryptionType.PkZip;

archive.AddFiles(

new String[] {

@"C:\Source\File 1.txt",

@"C:\Source\File 2.txt",

@"C:\Source\File 3.txt" },

@"\");

archive.AddDirectory(@"C:\Source\Folder\", @"\Folders\");

archive.Save(@"C:\Archives\Archive.zip");

}

To extract an existing one:

using (ZipArchive archive = ZipArchive.Read(@"C:\Archives\Archive.zip")) {

archive.Extract(@"C:\Exptracted\");

}

EDIT: The Barcode Library will be made available as part of the Universal Subscription and as part of our new .NET Document Server standalone subscription.

Cheers,

Azret

Introducing Spreadsheet Document Server (coming soon in v2013.1) – Part 3

Azret Botash (DevExpress) — Thu, 30 May 2013 20:20:00 GMT

Now that we know how to work with the Spreadsheet API, how to write to Cells and how to make Formulas, let’s build an invoice document.

Imagine our data model to be as follows:

public class Customer { 
    public string Name { get; set; } 
    public string Address1 { get; set; } 
    public string Address2 { get; set; } 
    public string City { get; set; } 
    public string State { get; set; } 
    public string Zip { get; set; } 
    public string Phone { get; set; } 
    public List<Product> Products { get; set; } 
}

public class Product { 
    public string Name { get; set; } 
    public int Quantity { get; set; } 
    public double Discount { get; set; } 
    public double Price { get; set; } 
}

Our goal is to create a Spreadsheet Invoice like this:

First thing, as you remember let’s new up a Workbook and set the defaults.

Workbook book = new Workbook();

// Setup document defaults... 
book.Styles.DefaultStyle.Font.Name = "Segoe UI"; 
book.Styles.DefaultStyle.Font.Size = 14;

This will be our mock customer:

Customer customer = new Customer() { 
    Name = "Alcorn Mickey", 
    Address1 = "Mickeys World of Fun", 
    Address2 = "436 1st Ave.", 
    City = "Cleveland", 
    State = "OH", 
    Zip = "37288", 
    Phone = "(203)290-8902" 
};

customer.Products = new List<Product> { 
    new Product() { Name = "Chai", Price = 100, Quantity = 3, Discount = 0.1 }, 
    new Product() { Name = "Chang", Price = 120, Quantity = 6, Discount = 0.15 }, 
};

Add the billing info:

// Add Billing info... 
book.Worksheets[0].Cells["B2"].Value = "BILL TO:"; 
book.Worksheets[0].Cells["B2"].Font.Bold = true; 
book.Worksheets[0].Cells["B3"].Value = customer.Name; 
book.Worksheets[0].Cells["B4"].Value = customer.Address1; 
book.Worksheets[0].Cells["B5"].Value = customer.Address2; 
book.Worksheets[0].Cells["B6"].Value = String.Format("{0} {1}, {2}", customer.City, customer.State, customer.Zip); 
book.Worksheets[0].Cells["B7"].Value = String.Format("Phone: {0}", customer.Phone);

Add the header:

// Add Header... 
book.Worksheets[0].Cells["B9"].Value = "Product"; 
book.Worksheets[0].Cells["C9"].Value = "Quantity"; 
book.Worksheets[0].Cells["D9"].Value = "Price"; 
book.Worksheets[0].Cells["E9"].Value = "Discount"; 
book.Worksheets[0].Cells["F9"].Value = "Due";

Format the entire header Range [B9:F9]:

// Format header... 
book.Worksheets[0].Range["B9:F9"].ColumnWidthInCharacters = 16; 
Formatting header = book.Worksheets[0].Range["B9:F9"].BeginUpdateFormatting(); 
header.Alignment.Horizontal = HorizontalAlignment.Right; 
header.Borders.BottomBorder.Color = Color.Black; 
header.Borders.BottomBorder.LineStyle = BorderLineStyle.Medium; 
header.Font.Bold = true; 
book.Worksheets[0].Range["B9:F9"].EndUpdateFormatting(header);

// Product is left aligned... 
book.Worksheets[0].Cells["B9"].Alignment.Horizontal = HorizontalAlignment.Left;

For every Product in the list, create the line items:

const int start = 10;

// Add line items... 
int row = start; 
foreach(Product product in customer.Products) { 
    book.Worksheets[0].Cells["B" + row].Value = product.Name; 
    book.Worksheets[0].Cells["C" + row].Value = product.Quantity; 
    book.Worksheets[0].Cells["D" + row].Value = (double)product.Price; 
    book.Worksheets[0].Cells["D" + row].NumberFormat = "$#,##0.00"; 
    book.Worksheets[0].Cells["E" + row].Value = (double)product.Discount; 
    book.Worksheets[0].Cells["E" + row].NumberFormat = "0%"; 
    book.Worksheets[0].Cells["F" + row].Formula = String.Format("=C{0}*D{0}*(1-E{0})", row); 
    book.Worksheets[0].Cells["F" + row].NumberFormat = "$#,##0.00"; 
    row++; 
}

Sum up the totals:

// Total... 
book.Worksheets[0].Cells["E" + (row + 1)].Value = "Total:"; 
book.Worksheets[0].Cells["E" + (row + 1)].Alignment.Horizontal = HorizontalAlignment.Right; 
book.Worksheets[0].Cells["E" + (row + 1)].Font.Bold = true; 
book.Worksheets[0].Cells["F" + (row + 1)].Formula = String.Format("=SUM(F{0}:F{1})", start, row - 1); 
book.Worksheets[0].Cells["F" + (row + 1)].NumberFormat = "$#,##0.00";

And we are done. We are now ready to save to a Spreadsheet document file or export it to a PDF.

book.ExportToPdf(@"Invoice.pdf");

Exporeted document:

Cheers

Azret

DXperience 13.1 will be .NET 4 or above

Julian Bucknall (DevExpress) — Thu, 30 May 2013 17:40:56 GMT

For quite some time now, we’ve had a somewhat weird split in the platforms we support. For WPF and Silverlight, we moved to a common set of underlying libraries way back in version 10.1, two years ago. As part of this restructuring we decided to take advantage of the new capabilities of Visual Studio 2010 and .NET 4. Overall, this change has been positive, and the implementation of our set of Windows 8 XAML controls in 12.2 (which require Visual Studio 2012 and .NET 4.5) was made much easier (and quicker) by this decision.

However, our WinForms and WebForms controls have not kept up. For these platforms, we are still supporting .NET 3.5 and Visual Studio 2008 or later. This has started to cause some issues with the cross-platform libraries we implement: we’d like to take advantage of newer C# 4 and .NET 4 features for our XAML code (and, indeed, for our WinForms and ASP.NET code), but we’re being held back. One of the biggest features we can’t take advantage of, as an example, is the new dynamic keyword, which is almost de rigueur when writing web code these days.

The other issue is that, we currently support three IDE versions, with all the required extra testing that entails (not to mention that the UI designer in VS 2010 was a big change in and of itself). We also took a look at the statistics we have about which IDEs you, our customers, are using and I’d have to say the vast majority (95%+) are using VS 2010 or VS2012. It seems in the Visual Studio ecosystem, developers tend to stay up to date. Heck, even I’m using VS2012, uppercase menus or not…

Consequently, after some debate, we decided to standardize and make .NET 4 (or later) and Visual Studio 2010 (or later) firm requirements for version 13.1 of DXperience.

Introducing Spreadsheet Document Server (coming soon in v2013.1) – Part 2

Azret Botash (DevExpress) — Thu, 30 May 2013 17:13:00 GMT

In the last post, we’ve looked at how easy and intuitive the Spreadsheet API is. Let’s explore other handy features.

Ranges

A Worksheet Range is a collection of sequential cells that can be updated in one shot, instead of iterating thru individual cells one by one. A Range, is referenced using the named coordinates from top-left cell to the bottom-right:

Fig 1: Cell Range

The following example demonstrates how to set a value to a cell range and update it’s formatting.

Workbook book = new Workbook();

// Set values and size... 
book.Worksheets[0].Range["B2:D4"].Value = "W"; 
book.Worksheets[0].Range["B2:D4"].ColumnWidth = 128; 
book.Worksheets[0].Range["B2:D4"].RowHeight = 128;

// Apply custom formatting... 
Formatting b2d4 = book.Worksheets[0].Range["B2:D4"].BeginUpdateFormatting(); 
            
b2d4.Alignment.Horizontal = HorizontalAlignment.Center; 
b2d4.Borders.BottomBorder.Color = Color.Orange; 
b2d4.Borders.BottomBorder.LineStyle = BorderLineStyle.Medium; 
b2d4.Borders.TopBorder.Color = Color.Orange; 
b2d4.Borders.TopBorder.LineStyle = BorderLineStyle.Medium; 
b2d4.Borders.LeftBorder.Color = Color.Orange; 
b2d4.Borders.LeftBorder.LineStyle = BorderLineStyle.Medium; 
b2d4.Borders.RightBorder.Color = Color.Orange; 
b2d4.Borders.RightBorder.LineStyle = BorderLineStyle.Medium; 
b2d4.Fill.BackgroundColor = Color.WhiteSmoke; 
b2d4.Font.Name = "Forte"; 
b2d4.Font.Color = Color.Navy;

book.Worksheets[0].Range["B2:D4"].EndUpdateFormatting(b2d4);

Fig 2: Cell Range

Formulas

The ability to calculate totals, averages, set current dates and to perform various calculations within the document, is of course one of the major reasons why Spreadsheets are an amazingly very power tool. We will ship countless of functions, ranging from simple Summations to Boolean logic operators, from Financial to a complete Trigonometry routines.

Formulas and expressions are set with the help of the Formula property on a cell or a range. For example, the code bellow sets a 3 values for cells B1:B3 and sums them up in B4

Workbook book = new Workbook();

book.Worksheets[0].Range["B1:B3"].Value = 43; 
book.Worksheets[0].Range["B1:B3"].NumberFormat = "$#,##0.00";

book.Worksheets[0].Cells["B4"].Formula = "= SUM(B1:B3)"; 
book.Worksheets[0].Cells["B4"].NumberFormat = "$#,##0.00"; 
book.Worksheets[0].Cells["B4"].Borders.TopBorder.Color = Color.Orange; 
book.Worksheets[0].Cells["B4"].Borders.TopBorder.LineStyle = BorderLineStyle.Medium;

Now that we know the basics, let's create an invoice.

Cheers

Azret

Introducing Spreadsheet Document Server (coming soon in v2013.1) – Part 1

Azret Botash (DevExpress) — Wed, 29 May 2013 22:28:00 GMT

The Spreadsheet Document Server is a powerful non visual .NET library, engineered to create and manage Spreadsheet documents natively, without the need for Microsoft Excel to be installed. With intuitive Spreadsheet API, you can produce: invoices, reports, payment schedules and a multitude of other documents, fast, avoiding the slow and very costly Microsoft Office automation.

Overview

To get started we will need to include four (4) assembly references to the project. They could be found in the GAC, or in the default installation, in C:\Program Files (x86)\DevExpress\DXperience 13.1\Bin\Framework folder.

Fig 1. Assembly References

The main object that represents a document is DevExpress.Spreadsheet.Workbook. Workbook gives access to the top level document from which we can apply document Options and Styles, access the Worksheets, as well as handy routines to Load a document from file or to Save it.

Each Workbook consists of multiple Worksheets, and in turn, Worksheets consist of Cells.

Fig 2. Workbook Structure

The following example demonstrates how to create the most basic XLSX file.

Workbook book = new Workbook();
book.Worksheets[0].Cells["B2"].Value = "Hello World";
book.SaveDocument(@"Document.xlsx");

Fig 3. “Hello World” document previewed in Microsoft Excel.

Working with Cells

From the example above, you might have noticed how intuitive it is to access or update a cell. A Worksheet Cell, may be referenced either via its named coordinates A1, B1, C1 etc… or alternatively via its direct coordinates:

Workbook book = new Workbook();
book.Worksheets[0].Cells[0, 0].Value = 42;

Nota bene: Direct coordinates are zero based.

Cell values accept all the default primitive types: Boolean, Text and Numeric. The built-in implicit operators will ensure the value is of the correct type when set from a .NET type.

book.Worksheets[0].Cells["B2"].Value = DateTime.Now;
book.Worksheets[0].Cells["B2"].NumberFormat = "m/d/yy";
book.Worksheets[0].Cells["B3"].Value = Math.PI;
book.Worksheets[0].Cells["B4"].Value = "Text value...";
book.Worksheets[0].Cells["B5"].Value = true;
book.Worksheets[0].Cells["B6"].Value = float.MaxValue;
book.Worksheets[0].Cells["B7"].Value = 'a';
book.Worksheets[0].Cells["B8"].Value = Int32.MaxValue;

Fig 4. Cell values

Cell Formatting

Each Worksheet Cell, exposes its formatting via the Formatting interface.

public interface Formatting {
    Alignment Alignment { get; }
    Borders Borders { get; }
    Fill Fill { get; }
    Font Font { get; }
}

The following example shows how to set various cell options.

book.Worksheets[0].Cells["B2"].Value = "...Text value";
book.Worksheets[0].Cells["B2"].Alignment.Horizontal = HorizontalAlignment.Right;
book.Worksheets[0].Cells["B2"].Borders.SetAllBorders(Color.Orange, BorderLineStyle.Thick);
book.Worksheets[0].Cells["B2"].Fill.BackgroundColor = Color.WhiteSmoke;
book.Worksheets[0].Cells["B2"].Font.Name = "Vivaldi";
book.Worksheets[0].Cells["B2"].Font.Color = Color.Navy;

Fig 5. Formatted Cell

Now, let's see how to work with Ranges, Formulas

Cheers

Azret