Developer Express Inc.

Document MS Access Table Schemas

Paul Kimmel (Developer Express) — Fri, 03 Jul 2009 07:40:04 GMT

There are a lot of little things one has to do to complete any project. Exporting files, tweaking data, documenting things, coming up with graphics are just some of the skills developers need. Technical books projects are a lot like software projects. There are a little of extra little computer skills, sometimes basic but useful, that have to be managed to get a finished product. One of the samples in the book project—Professional DevExpress ASP.NET Controls—uses an Access database. It was useful to describe the schema of the Access for the Access tables because they were to mapped to another implicit schema. The odd challenge was that there didn’t seem to be an analog for querying the schema of Access tables in Access. You can show hidden objects and query tables like MSysAccessObjects, which will give you some information, but it doesn’t appear that you can query schema tables like you can in SQL Server. (Perhaps one of you knows how to do this and can enlighten me.)

You can of course write code to load a table and dump table and field names, data types, and sizes, and you can use the tools in MS Access to create schema reports. The following numbered steps describe how to create a report for the Cars and CarScheduling tables in Developer Express’ CarsDB.mdb database. You can of course substitute any Access database and tables, if you’d like. To print database documentation follow these steps:

Open MS Access and open your database. (For this sample the CarsDB.MDB sample database installed with ASPxperience was used)
Press ALT+T+Y+D to open the Documentor. (This is a legacy menu option that still works as long as you know the shortcut)
Click the Table tabs
In the Documentor Table tab check the Cars and CarScheduling tables (see Figure 1)
Click the Options button
In the Include for Table group check Properties only
In the Include for Fields group select the Names, Data Types, and Sizes radio button
In the Include for Indexes group select the Nothing radio button (see Figure 2).
Click OK to close the Print Table Definition dialog
Click OK to generate the documentation
When the documentation report is finished the Print Preview tab will be displayed. Click Text File in the Data section to export the report to a text file
In the Export – Text File dialog (see Figure 3)
Check open the destination file after the export operation is complete
Click OK
For the encoding choose Windows default

The export documentation is provided in Listing 1. That’s all there is to it.

Figure 1: The Documentor in MS Access.

Figure 2: The Print Table Definitions dialog lets you choose what you want to print.

Figure 3: Export the printed result to a text file and open the results.

Listing 1: The exported text content based on the options selected.

C:\Websites\SchedulerDemo\App_Data\CarsDB.mdb Friday, July 03, 2009

Table: Cars Page: 1

Properties

DateCreated: 7/16/2002 5:48:37 PM DefaultView: 2

GUID: {guid {8EECDB13- LastUpdated: 7/4/2006 12:02:46 PM

A77D-45D5-84D5-

NameMap: Long binary data OrderByOn: False

Orientation: Left-to-Right RecordCount: 15

Updatable: True

Columns

Name Type Size

ID Long Integer 4

Trademark Text 50

Model Text 50

HP Integer 2

Liter Double 8

Cyl Byte 1

TransmissSpeedCount Byte 1

TransmissAutomatic Text 3

MPG_City Byte 1

MPG_Highway Byte 1

Category Text 7

Description Memo -

Hyperlink Text 50

Picture OLE Object -

Price Currency 8

RtfContent Memo -

C:\Websites\SchedulerDemo\App_Data\CarsDB.mdb Friday, July 03, 2009

Table: CarScheduling Page: 2

Properties

DateCreated: 7/15/2005 5:09:08 PM DefaultView: 2

GUID: {guid {26F80294-9FDD- LastUpdated: 11/1/2007 1:31:56 PM

4A29-8A9C-

NameMap: Long binary data OrderByOn: True

Orientation: Left-to-Right RecordCount: 20

RowHeight: 1425 Updatable: True

Columns

Name Type Size

ID Long Integer 4

CarId Long Integer 4

UserId Long Integer 4

Status Long Integer 4

Subject Text 50

Description Memo -

Label Long Integer 4

StartTime Date/Time 8

EndTime Date/Time 8

Location Text 50

AllDay Yes/No 1

EventType Long Integer 4

RecurrenceInfo Memo -

ReminderInfo Memo -

Price Currency 8

ContactInfo Memo -

XAF – Distributed Pair Programming and Fast Prototyping

Gary Short (Developer Express) — Thu, 02 Jul 2009 12:09:44 GMT

Using XAF recently reminded me of my Smalltalk days in the early ‘90s, more on why that was at the end of the post, but for now let’s talk about pair programming. You know about pair programming right? It’s a practice in eXtreme Programming whereby two programmers sit at the same keyboard and work on the same programming task. One concentrates on the strategic purpose of the task, the other (normally the ‘driver’) concentrates on the tactical aspects of getting the task done. Working this way, the theory goes, both together can be more productive than two programmers working separately and, to be fair, this is generally true.

I’ve been involved with agile since back in the mid ‘90s when I worked with DSDM at IBM and I’ve tried most agile practices, some I like and they work for me others, not so much. With paired programming however I’ve always managed to get the sort of productivity gains that have been advertised, I guess I’m just one of those types who works better collaboratively. There is one area however, where paired programming can be a bit of a PITA and that is if the guy playing the “strategic role” can’t keep his mitts off of the “tactical role”, those are fun days.

The solution for this, I’ve found, is to pair with a subject matter expert. They have no problem keeping their mind fixed on the strategic goals, as it’s all they know, and they are happy to let you bash away on the keyboard and handle all the “tedious” tactical stuff. Okay, now I know that this is not the way paired programming is supposed to work and I know that doing this will mean that I lose some of the benefits of pairing, but it works for me and it gets the job done; which, at the end of the day, is what the Agile Manifesto is all about, right?

So, in general, that’s worked well for me in the past, back when I had a proper job cutting code. Now of course, I’m an evangelist for an American company and I work from home on the banks of the Tay in Scotland. How can I pair program now? Well, as it happens, there are tools that will help you do that if distributed paired programming is your thing. I found this out earlier this week when I had a conversation that went something like this…

Her: This sucks!
Me: Something in particular, or just everything in general?
Her: We have this information and it’s all locked up in places I don’t need it to be and that sucks!
Me: (Knowing what’s coming) Yeah, that certainly sounds sucky.
Her: What I really need is an app to handle all this…
Me: (Wincing) Hmmm…
Her: How long would it take you to work your XAF magic on this problem?
Me: Longer than I have to spend on it.
Her: Oh puuuleeeeeeeese! Besides, coding stuff is fun, you know it is.
Me: (damn she found my week spot) Okay, let’s do it!

Now as we don’t work together in an office “doing it” is a little more complex than her just moving her chair over to my desk, but there are tools that help. So we got on Skype so we could talk, and we started up SharedView so she could see my desktop and I fired up XAF so we could hack away and in under an hour we had a working prototype of an app that solved her problem.

So what’s my point? Twofold really, firstly, just because you are not co-located does not mean that you can’t work in an agile manor. Secondly, XAF is a cracking prototyping tool! So if you have XAF, even if you have no intention of using it to build your finished product for whatever reason, don’t forget that you can use it to build a prototype, in real time, whilst you sit down with your subject matter expert.

A fact, that brings us full circle. Remember I said, at the top of this post, that I’d been reminded of my Smalltalk days when using XAF? Well this is why. One of the first jobs I had as a Smalltalker was in a C++ shop, prototyping work that was to be carried out by the C++ devs? Why? well because with Smalltalk we calculated that I could get code up and running in around a fifth of the time that they could. You can get similar productivity gains by using XAF, so why not check it out?

Using Custom Objects with ASPxScheduler

Paul Kimmel (Developer Express) — Wed, 01 Jul 2009 20:25:51 GMT

I was curious and surprised to discover that some employers are literally listing “Developer Express controls experience” as a pre-requisite for some programming employment. For some employers it is not enough to be a good developer, a good ASP.NET programmer, a good database guy, and a good JavaScript guy (or gal). Some employers want to know that a potential candidate has real experience with Developer Express controls. The reason for this has quite simply got to be that one need a tremendous amount of experience to use what Developer Express has to offer. The reason for this is not that our controls are inordinately difficult to use, rather it is that there is a tremendous amount of pre-existing work available for the picking if one knows where to look. Experience is how one knows where to look.

I have spent the better part of 1,500 hours this year working on Professional DevExpress ASP.NET Controls—the book—and am in awe of how much material is added regularly to our product line. The ASP.NET controls is a big part of our product line—by no means all—but there is a lot there. In retrospect I think we could have written an ASPxGridView book and easily covered 400 pages. It was actually hard to keep the grid coverage at 100 pages. The ASPxScheduler is another big control. In fact, the ASPxScheduler is more of a sub-system than a control. With a little bit of code and a couple of data source you could create an MS Outlook (tm) style interface, a project management tool, or just about any scheduler you could imagine (I suspect). And, you could probably create a substantial amount of functionality without writing hardly any code at all. The caveat being that you know how to use the control.

One of my objectives as evangelist is to give you the information you need to leverage as much of the code we have already written for you without you having to re-write from scratch what more than likely already exists—if you just know where to look. To that end, me, Mehul, Oliver, Gary, Mark and many others write blogs, tweets, articles (and a book) now to point you in the right direction. I use custom objects a lot for development, and this blog post shows you how to use the ASPxScheduler with custom objects. (You can of course use a database, but that’s another blog post and its covered in the book.) Here is an overview of what it takes to use custom objects with the ASPxScheduler:

The ASPxScheduler normalizes appointment item as the appointment (as well as recurring appointment detail) from one source and resources from another
The ASPxScheduler separates presentation from Storage with pre-determined fields for appointments and resources
You simply map your appointment fields to our appointment fields and your resource fields to our resource fields, specify how the CRUD happens—SQL or whatever—and the scheduler is fully operational

So for custom objects with the ASPxScheduler you need the custom objects, a BindingList<T>, and the equivalent of an object data source class, and if your custom object fields use dissimilar names then you need to map your properties to the scheduler’s properties. it sounds like a lot of code, but the example can actually be coded—custom objects, lists, and data source—with just under 200 lines of code, most of which is represented by your custom objects. And, if you use CodeRush or automatic properties this can be done very quickly.

Reviewing the Appointment and Resources Schemas

The “schemas” for the Appointment and Resources objects as the ASPxScheduler sees the world are represented by Figures 1 and 2 respectively. the closer your objects reflect these schemas the easier the mappings are. for example, if your appointment class has a StartDate named StartDate then it is a straight forward map. If you are using the mapping wizard it will guess. the closer the names and data types are the better the guesses will be.

Figure 1: The ASPxScheduler’s view of an appointment.

Figure 2: The ASPxScheduler’s view of the resources world.

For resources the demo simply uses an array of random names and the index as the ResourceId and ResourceName. You can get away with this because it isn’t necessary to map all of the fields. You can just specify the ones you need. The Appointments will be mapped to the custom object DentalAppointment (see Listing 1). DentalAppointment is defined using automatic properties and has a one-to-one mapping between its properties and the fields an Appointment uses in the ASPxScheduler (except for one extra field Price, which goes unused).

Listing 1: The DentalAppointment class has almost the identical set of properties and types as the Appointments used by the ASPxScheduler, making mapping pretty easy.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

[Serializable]
public class DentalAppointment
{
public object Id { get; set; }
public DateTime StartTime{ get; set; }
public DateTime EndTime{ get; set; }
public string Subject{ get; set; }
public int Status{ get; set; }
public string Description{ get; set; }
public long Label{ get; set; }
public string Location{ get; set; }
public bool AllDay{ get; set; }
public int EventType{ get; set; }
public string RecurrenceInfo{ get; set; }
public string ReminderInfo{ get; set; }
public object OwnerId{ get; set; }
public double Price{ get; set; }
public string ContactInfo{ get; set; }
}

Implementing the Custom BindingList<T>

The most common in-memory holder for custom types is some kind of collection or collection<T>. The BindingList<T> is a good candidate for custom collections because it is a generic collection and it supports data binding. Because BindingList<T> is a generic collection it can be instantiated with any type for the teplate parameter T. The BindingList<T> supports data binding because it has methods and events that are typical of databound operations, including AddNew, CancelNew, InsertItem, RemoveAt, OnAddingNew, etc. (You can check the help for the complete list of operations.) Listing 2 contains the DentalAppointmentList class, that inherits from BindingList<DentalAppointment>, for the sample.

Listing 2: The generic data-bindable collection.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Web;
using System.ComponentModel;

[Serializable]
public class DentalAppointmentList : BindingList<DentalAppointment>
{
public void AddRange(DentalAppointmentList events)
{
    Array.ForEach(events.ToArray(), e => this.Add(e));
}
public int GetEventIndex(object eventId)
{
    var result = this.Where(item => item.Id == eventId).First();
    if (result != null)
      return this.IndexOf(result);

return -1;
}

}

Generally you can just instantiate Bindinglist<T>, but I use inheritance to create a place to add a few additional business behaviors. In our example AddRange was added to supported appending a list of items, and GetEventindex finds an object by its Id instead of by the object itself. AddRange and GetEventsIndex both use one of the newer features in .NET Lambda expressions--e=>this.Add(e) and item=>item.Id == eventId, respectively. A Lambda expressions is an even more condensed version of an anonymous method. The left side is like the function header and parameters and the right side is the method body. The funny operator => (referred to as “goes to” or a “gosinta” by me) is borrowed from the original mathematical expression language.

You could use a plain vanilla for loop for both methods, but where is the fun in that.

Implementing the Custom DataSource

The custom datasource plays the role of negotiating CRUD behaviors between the client control—the ASPxScheduler in this case—and an ObjectDataSource component. The custom datasource—DentalAppointmentDataSource in Listing 3—will be the TypeName property of an ObjectDataSource. The ObjectDataSource component will be assigned to the ASPxScheduler’s AppointmentDataSource property. (Remember that the ASPxScheduler has an AppointmentDataSource and ResourceDataSource.)

The key to a custom datasource is to define methods that are assigned to the ObjectDataSource’s Selectmethod, UpdateMethod,, InsertMethod and DeleteMeethod properties. The ObjectDataSource will forward these operations to the business object’s methods defined by ObjectDataSource.TypeName that perform these functions. Referring to Listing 3 it is evident by name which behaviors implement the required operations.

Listing 3: A custom business object that performs CRUD operations for a custom ObjectDataSource.

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Web;

public class DentalAppointmentDataSource
{
private DentalAppointmentList events;
public DentalAppointmentList Events
{
get { return events; }
set { events = value; }
}

    public DentalAppointmentDataSource(DentalAppointmentList events)
    {
    this.events = events;
    }

public DentalAppointmentDataSource()
: this(new DentalAppointmentList())
{}

#region ObjectDataSource methods
public void InsertMethodHandler(DentalAppointment appointment)
{
Events.Add(appointment);
}

public void DeleteMethodHandler(DentalAppointment appointment)
{
Events.Remove(appointment);
}

public void UpdateMethodHandler(DentalAppointment appointment)
{
    int eventIndex = Events.GetEventIndex(appointment.Id);
    if (eventIndex >= 0)
    {
      Events.RemoveAt(eventIndex);
      Events.Insert(eventIndex, appointment);
    }
}

public IEnumerable SelectMethodHandler()
{
    DentalAppointmentList result = new DentalAppointmentList();
    result.AddRange(Events);
    return result;
}
#endregion
}

Defining the GUI

The presentation for the demo is an ASPxScheduler bound to an ObjectDataSource who’s behaviors are supported by the custom business object DentalAppointmentDataSource (in Listing 3). To implement the GUI—shown at runtime in Figure 3—follow these steps:

Place an ASPxScheduler on a Web form
Right click the Smart tags menu, select Appointment Data Source|New data source
In the Data Source Configuration Wizard select Object as the data source type
Click OK
Choose the DentalAppointmentDataSource as the business object
Click Next
In the Define Data methods step pick the relevant method for each of the SELECT, UPDATE, INSERT, and DELETE operations (see Figure 4)
Click Finish
Clear the ASPxScheduler’s AppointDataSourceID from the properties window because in this example we will be setting the DataSource and data binding in the code behind

Figure 3: The running demo application with its default appearance and one appointment added by me.

Figure 4: Define the data source’s various CRUD operations.

The numbered steps above will generate (minus a few bits we still have to do) the ASPX shown in Listing 4. With just a few lines of code more you will have a functioning appointment/scheduling sub-system.

Listing 4: The ASPX generated by adding the ASPxScheduler and the ObjectDataSource.

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>

<%@ Register assembly="DevExpress.Web.ASPxScheduler.v9.1, Version=9.1.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" namespace="DevExpress.Web.ASPxScheduler" tagprefix="dxwschs" %>
<%@ Register assembly="DevExpress.XtraScheduler.v9.1.Core, Version=9.1.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" namespace="DevExpress.XtraScheduler" tagprefix="dxschsc" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

Writing the Code-Behind

The code behind performs five general tasks: data binding, populating the ASPxScheduler’s Resources, storing the DentalAppointmentList in Session, mapping the DentalAppointment properties to the ASPxScheduler appointment fields, and creating a unique appointment id when an appointment item is inserted in the scheduler. Listing 5 contains the code-behind—which is less than 100 lines of code—for the Web page, followed by a brief synopsis of the tasks being performed.

Listing 5: The code-behind for the sample application.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using DevExpress.Web.ASPxScheduler;
using DevExpress.XtraScheduler;
using DevExpress.Data;
using System.Diagnostics;

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
      MapCustomObjectsToAppointmentFields();
      PopulateResourcesData(Storage, 5);
      ASPxScheduler1.AppointmentDataSource = ObjectDataSource1;
      ASPxScheduler1.DataBind();

}

ASPxSchedulerStorage Storage { get { return ASPxScheduler1.Storage; } }

    private void MapCustomObjectsToAppointmentFields()
    {
      ASPxAppointmentMappingInfo mappings = Storage.Appointments.Mappings;
      Storage.BeginUpdate();
      try
      {
        mappings.AllDay = "AllDay";
        mappings.AppointmentId = "Id";
        mappings.Description = "Description";
        mappings.End = "EndTime";
        mappings.Label = "Label";
        mappings.Location = "Location";
        mappings.RecurrenceInfo = "RecurrenceInfo";
        mappings.ReminderInfo = "ReminderInfo";
        mappings.ResourceId = "OwnerId";
        mappings.Start = "StartTime";
        mappings.Status = "Status";
        mappings.Subject = "Subject";
        mappings.Type = "EventType";
      }
      finally
      {
        Storage.EndUpdate();
      }
    }

    public static string[] Users = new string[] { "Peter Dolan", "Ryan Fischer", "Andrew Miller", "Tom Hamlett",
                        "Jerry Campbell", "Carl Lucas", "Mark Hamilton", "Steve Lee" };
    private void PopulateResourcesData(ASPxSchedulerStorage storage, int count)
    {
      ResourceCollection resources = storage.Resources.Items;
      storage.BeginUpdate();
      try
      {
        int c = Math.Min(count, Users.Length);
        for (int i = 1; i <= c; i++)
          resources.Add(new Resource(i, Users[i - 1]));
      }
      finally
      {
        storage.EndUpdate();
      }
    }
    private DentalAppointmentList GetDentalAppointments()
    {
      DentalAppointmentList events =
        Session["ListBoundModeObjects"] as DentalAppointmentList;
      if (events == null)
      {
        events = GenerateDentalAppointmentEventList();
        Session["ListBoundModeObjects"] = events;
      }
      return events;
    }

    private DentalAppointmentList GenerateDentalAppointmentEventList()
    {
      return new DentalAppointmentList();
    }

    protected void ASPxScheduler1_AppointmentInserting(object sender, PersistentObjectCancelEventArgs e)
    {
      ASPxSchedulerStorage storage = (ASPxSchedulerStorage)sender;
      Appointment appointment = (Appointment)e.Object;
      storage.SetAppointmentId(appointment, "d" + appointment.GetHashCode());

    }
    protected void ObjectDataSource1_ObjectCreated(object sender, ObjectDataSourceEventArgs e)
    {
      e.ObjectInstance = new DentalAppointmentDataSource(GetDentalAppointments());
    }
}

The Page_Load method performs initialization by performing calling the mapping step, adding resources, and data binding. The Storage property is a simplifcation property that simply surfaces the underlying ASPxScheduker’s Storage property. MapCustomObjectsToAppointmentFields does exactly what the method name indicates: it tells the ASPxScheduler what names in the custom objects refer to which fields in the scheduler. (The name-strings are case sensitive.) PopulateResourcesData creates some resources, in this case, random names playing the role of Dentist. GetDentalAppointmentList manages creating the events list and storing it in Session. GenerateDentalAppointmentList is really just a placeholder. In a real business application this method would ultimately construct appointments from a data source like a Web service, XML file, or database. AppointmentInserting is event that needs to be created on the ASPxScheduler.This method sets the AppointmentId, cleverly using an object’s guaranteed to be unique hash code. Finally, ObjectCreated.ObjectCreated is associating the custom datasource with the ObjectDataSource.

    }
    protected void ObjectDataSource1_ObjectCreated(object sender, ObjectDataSourceEventArgs e)
    {
      e.ObjectInstance = new DentalAppointmentDataSource(GetDentalAppointments());
    }
}

The ASPxScheduler peforms a large number of housekeeping tasks, including adding user controls for editing appointments, searching and recurring appointments. While it takes some work to get the scheduler up and running, the work—represented by this article—is infinitesimally smaller than the amount of code needed to implementing a custom scheduler control.

Thanks for playing.

DevExpress Newsletter 5: Message from the CTO

Julian M Bucknall — Wed, 01 Jul 2009 18:33:33 GMT

Here's the Message from the CTO from the fifth DevExpress Newsletter:

Being first or being best...

It's a problem to be sure. You're working on a software solution for some new problem space. You know your competitors are working on similar solutions. What do you do: produce the best solution you possibly can, or release something quickly, but not quite as high quality or not quite as full-featured, just to be first?

On the one hand, you're First. People will buy and then perhaps get "locked in" to your solution. You have the opportunity to do some of that dreaded marketing, but you also have the problem of persuading people that the problem space is worth solving.

On the other hand, you have the opportunity to see what the first guy is doing, and how it falls short. You can modify your development to target the shortcomings. Maybe it's performance, maybe it's ease-of-use, maybe it's data import/export, or reliability or stability. No matter what, you have the ability to be more measured in your release. It's not guaranteed that you'll be able to persuade customers to buy yours or switch, but you'll have a better chance should the problem space be worth solving.

Over the years DevExpress have been in the former camp and sometimes in the latter. With our WPF controls, we're firmly in the latter: we wanted to understand what people wanted (and whether the market was there) and we're almost ready to issue our first release. So expect better performance, improved ease-of-use, a more intuitive API, and all the other good things.

Next time, maybe we'll be first, and best...

It's the dichotomy we all face when writing software for sale. I'm reminded of it with the iPhone App Store, which is a place you can see this First vs. Best natural selection going on all the time. So long as the stuff you want to buy isn't "Duke Nukem Forever"...

Re-registering DevExpress Controls with Visual Studio

Paul Kimmel (Developer Express) — Tue, 30 Jun 2009 17:19:28 GMT

Every once in a while some confluence of events causes my Developer Express controls to disappear from the Visual Studio toolbox. I am not going to be an apologist for this, but support are having problems reproducing this problem. (If any of you have any hints they’d be appreciated by all.) I think it is annoying and would like to see the problem permanently resolved, but if it happens to you here is what you can do to quickly and painlessly re-register the controls with Visual Studio.

To re-register DevExpress controls with Visual Studio click Start|All Programs|Developer Express v2009 vol1|Components|Tools|ToolboxCreator.exe (clicking on the ToolboxCreator.exe executable). All other variations of running this command results in the dreaded error dialog (see Figure 1). Make sure you close Visual Studio before running the ToolboxCreator.exe utility.

Figure 1: Avoid this command and re-register your Developer Express controls with the ToolboxCreator utility.

Implementing a Class in JavaScript

Paul Kimmel (Developer Express) — Thu, 25 Jun 2009 21:05:15 GMT

JavaScript is most commonly used for client-side Web programming. You can use JavaScript for other things, for example, it is used with Visual Studio Add-Ins and wizards, but generally we think of JavaScript as a Web technology. JavaScript is syntactically pretty close to the C programming language, but JavaScript is object based. JavaScript supports functions, data, and objects, and you can implement your own classes. You can dynamically define an object and add properties to JavaScript objects simple by referring to the property as a member. You can also statically define a class (at design and add fields, properties, and functions) and then create instances of that class and interact with those members in your code. Obviously the reason for defining JavaScript classes is valid for the same reason you define VB or C# classes; classes help manage state and organize your code.

Dynamically Defining Object Properties and Functions

You can add properties and functions on the fly. By literally creating an instance of the Object type and using the member of (. operator) syntax the name on the right side of the dot operator becomes a dynamic member. For example, if you instantiate a variable named Person as a type of Object and refer to a property then the property exists. Here is an example:

var Person = new Object();
Person.FirstName = “Paul”;

(Its sort of weird, but) by referring to FirstName it becomes a bonafide property of Person. You can use the same approach to dynamically assign a function to Person too. Suppose for example you have a function Print—Print will just display the alert dialog. You can make Print a member of Person by assigning the function Print to a dynamically used member function. Listing 1 contains a block of script that dynamically adds properties and a function Print to object Person. Notice that the Print function can use the reference-to-self object this to access FirstName and LastName because Person.Print = Print makes the Print function a member of Person. (You can use the QuickWatch window to see that this refers to Person and shows the members FirstName, LastName, and Print.

Listing 1: A dynamic class is created by simply using names as if they were statically defined as members of the class.

var Person = new Object();
Person.FirstName = "Paul";
Person.LastName = "Kimmel";
Person.Print = Print;

Person.Print();

function Print() {
debugger;
alert(this.FirstName + ' ' + this.LastName);
}

</script>

Figure 1: Use the QuickWatch when the debugger statement is hit to see that this refers to Person and Person contains the dynamically used members.

Dynamically adding properties is a useful technique for returning data from a modal dialog. In script window.showModalDialog returns a single value. The way to return multiple values is to dynamically create a composite value—a dynamic object—and return the composite value. For example, if a modal dialog supported editing properties like first and last name then you could return the Person object from the showModalDialog function.

Defining JavaScript Classes

You can statically define JavaScript classes. The notation for a statically defined class is the function notation. (The outer function is treated as the constructor function.) The difference between a function and a class exists when a function contains nested properties and functions. Then, the function implicitly is playing the role of a class. For example, to retrofit the code in Listing 1 to a class rework the code as shown in Listing 2.

Listing 2: A Person class; classes in JavaScript use the function notation.

function Person() {
    this.FirstName = “”;
    this.LastName = “”;
    this.Print = print;
    function print() {
      debugger;
      alert(this.FirstName + ' ' + this.LastName);
    }
}

By declaring this.FirstName and this.LastName and initializing them they become part of the Person class. The statement this.Print assigned to print (note the case difference) then the print function is accessible. Listing 3 demonstrates how to create an instance of the Person object, assign values to the properties, and invoke the function. If you place a debugger statement right after the var aPerson statement and use the QuickWatch you will see that the Person object contains FirstName, LastName, and Print.

Listing 3: Using the Person class.

var aPerson = new Person();
aPerson.FirstName = "Paul";
aPerson.LastName = "Kimmel";
aPerson.Print();

JavaScript OO is a little awkward if you compare it to a more fully developed OO language like C#. Using a property makes it a member, adding a function and assigning it to a name makes it an accessible member, and the wonkiest bit of all is the constructor function as class. The upside is that writing code like this will help you organize your JavaScript, maintain state, and promote reusable code and good housekeeping.

CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008

Mark Miller (Developer Express) — Thu, 25 Jun 2009 20:00:00 GMT

CodeRush Xpress is a powerful developer productivity tool from Dev Express. The product is free, licensed by Microsoft on behalf of all developers working in Visual Studio 2008 in all paid-for product skus (e.g., Standard, Professional, Team System). Note however that CodeRush Xpress will not load in the Express Editions of Visual Studio.

CodeRush Xpress includes features that support common developer tasks in the following areas:

CodeRush Xpress fully supports all language features of Visual Basic and C# in Visual Studio 2008. If a specific feature applies to only one of these two languages, it will be noted with one of these icons:

More details on CodeRush Xpress functionality follow.

Navigate

CodeRush Xpress includes seven powerful navigation features to make getting to that important location fast and easy.

Camel Case Navigation

You can move among the lowercase-to-uppercase transitions using Camel Case Nav.

To move right, hold down the Alt key and press the Right arrow key inside a camel case identifier.

To move left, hold down the Alt key and press the Left arrow key inside a camel case identifier.

Camel Case Nav is useful when you want to rename an identifier and change the name in a manner that keeps a portion of the existing camel case identifier. For example, if an existing identifier was called "StartTasks" and you wanted to rename it to "StartFilteredTasks", you could use Camel Case Nav to instantly get the caret between the "Start" and "Tasks" parts before typing in the new part.

Collect Marker

Whenever a CodeRush Xpress feature takes you to a new place in the code, CodeRush Xpress drops a stack-based marker at the original location. You can return to the original location (collecting the marker and popping it off the stack) by pressing Escape (when no other tool tip windows or context menus are active).

When you press Escape, CodeRush Xpress animates a small locator beacon around the marker. This locator beacon is useful when your eyes are looking elsewhere on the screen, especially if you work with a large monitor. CodeRush Xpress also attempts to shift the code vertically so its position is roughly equivalent to what it was when you last viewed it.

Structural Highlighting

Structural Highlighting helps you visually navigate the structure of the code. Matching delimiters are connected with low-contrast lines that are easy to read when this information is useful, and easy to ignore when your mind is on the code.

Structural Highlighting is useful for understanding the flow of large methods or third-party C# code using a different leading brace position than you might otherwise work with.

Tab to Next Reference

You can quickly jump to the active identifier's next reference in the solution file by pressing the Tab key (as long as the caret is somewhere inside the identifier). All matching references (and declaration) to this identifier will be underlined and the selection will move to the next reference. Continuing to press the Tab key will cycle through all identifiers in the solution. Shift+Tab brings you back. You can also press Escape to return to the starting location (where the Tab to Next Reference feature was first invoked on this identifier).

Tab to Next Reference is useful when you want to quickly visit all references to a particular identifier or type.

Highlight All References

Highlight All References is visually similar to Tab to Next Reference, however it does not move the caret. Just press Ctrl+Alt+U to see all references to the active identifier.

Quick Navigation

Quickly find a member, class, field or variable using Quick Nav. Just press Ctrl+Shift+Q to bring up the Quick Navigation window.

You can filter the list by entering a portion of the identifier text you are looking for. If you hold down the Shift key and enter uppercase letters, you can find all identifiers named with those uppercase letters, as in the example below:

You can preview the target location by holding down the Ctrl key. To jump to the selected symbol, press Enter. To return to the starting location, press Escape.

Quick File Navigation

Quickly find and open any file in your solution. Just press Ctrl+Alt+F to bring up the Quick File Navigation window. The filtering mechanism in this window is similar to what we've just seen in the Quick Navigation window. Just enter a few letters from the file name. CodeRush Xpress will filter down the list. Use the Up and Down arrow keys to select the file you want to jump to, and press Enter to go there (or Escape to close the Quick File Navigation window and return to where you were).

Select

CodeRush Xpress includes five intelligent features for selecting code more efficiently.

Camel Case Select

If you need to select one or more words from inside a camel-case identifier, just use the Shift key along with the Camel Case Nav keys.

For example, to select from the caret to the start of the camel case part to the left, use Alt+Shift+Left.

Selection Increase

First, there is a command to increase the selection by logical blocks. For example, if the caret is inside an expression, you can quickly expand the selection so it entirely holds the expression. Being able to quickly define a selection around a logical block is useful for refactoring. You can also use it to quickly select code you want to move to another location. This command is bound to a shortcut: Alt+Shift+=.

Selection Reduce

If you accidentally overshoot the block you want to select, you can reduce the selection by logical blocks using Alt+Shift+-.

Intelligent Cut, Intelligent Copy, and Paste Replace

If you need to cut or copy an identifier to the clipboard, there's no need to select it with CodeRush Xpress. Just place the caret on the identifier and press the cut or copy key (e.g., Ctrl+X, Shift+Delete, Ctrl+C, or Ctrl+Insert). CodeRush Xpress will select the identifier before the cut or copy operation.

Once you have an identifier on the clipboard, you can move the caret to a different identifier and replace it with the one on the clipboard using Ctrl+B. This Paste Replace command will select the identifier at the caret before pasting in the contents of the clipboard.

If you need to cut or copy a larger structure, such as a for loop, a try/finally block, a member or a class, just place the caret at the start of the block you want to copy and press the cut or copy key. CodeRush Xpress will select the entire block before cutting or copying the block to the clipboard.

Declare

CodeRush Xpress includes powerful features to intelligently declare classes, members, fields, local variables and so much more.

Consume-first Declaration

The consume-first declaration features of CodeRush Xpress are a quick way to generate the code you need. It starts with a call or a reference to something that doesn't exist yet (the consumption code). Just move the caret to the reference that needs to be declared and press the CodeRush key (Ctrl+` by default). CodeRush Xpress will do the rest, declaring the missing member, type, enum, or variable.

Consume-first declaration is useful because it gets you thinking in terms of developers who would consume the code you write. This can improve the quality of the code and make it easier for developers to work with your code. Consume-first declaration is also almost always an essential component of Test Driven Development (TDD).

However one of the most significant benefits of consume-first declaration is the efficiency gain -- you can quickly craft the code you need significantly faster than doing the same by hand.

To illustrate, let's look at a practical example. Often developers will use Intellisense to discover the return type of an unfamiliar method call or property, by entering that expression right inside the code, like this:

Typically what happens next is the developer's eyes move to the front of the tool tip and note the type (circled in red above). Then the developer accepts the suggestion and moves the caret to the beginning of the line to enter a variable declaration of the correct type (e.g., a variable of type "Module[]" in this example).

Overall there's a great deal of caret movement and typing involved just to declare a variable. To save a little time, some developers avoid specifying the type to implicitly declare variables (using the var keyword in C#, for example), thus avoiding the discovery and text entry costs associated with explicit declaration.

Fortunately, CodeRush Xpress makes it easy to explicitly declare variables in a way that exploits the power of Visual Studio's Intellisense and is likely to be highly compatible with how you already work:

Create the expression fragment on an empty line using Intellisense or simply typing the expression by hand.

If you're working in C#, there is no need to end the expression with a semi-colon.
With the caret at the end of the line, press the CodeRush key (Ctrl+`) and select "Declare Local" from the menu. CodeRush Xpress will generate the local variable declaration and select the variable so you can give it a meaningful name:

So the steps behind exploiting consume-first features are:

Write the call or reference to the member, type or variable that doesn't exist, OR enter an expression on an empty line (as in the example above).
Place the caret on the part that doesn't exist.
Press the CodeRush key (Ctrl+`). If a menu appears select the item you want to declare. For methods and properties, you may also see a horizontal red line appear (called the Target Picker) that allows you to select the insertion point for that member. Just use the up and down arrow keys to select the ideal location and press Enter to insert the declaration.
Sometimes CodeRush Xpress will shift the view or take you to another file, to show you the code just inserted. This allows you to rename or edit the newly-declared code. When you're satisfied with the declaration you can press Escape to collect the marker and return to where you started.

More details on specific consume-first declaration features follow:

Declaring Members

Want to add a member to a type? Just write the code as you would like it to appear. If it's a method, pass in the parameters you need (tip: if you're passing in parameters that are undeclared, declare those first before declaring the method). Place the caret on the member and press the CodeRush key.

Here are the consume-first member declarations you get with CodeRush Xpress:

Declare Constructor
Declare Method
Declare Property
Declare Property (auto-implemented)
Declare Property (with backing field)
Declare Getter
Declare Setter
Declare Event Handler

Declaring Types

To declare a new type, add a reference to it. Usually when you want a new type, you also want a constructor for it. So it's usually most efficient to enter the constructor call like on an empty line:

At this point you can press the CodeRush key (Ctrl+`) to declare a new local variable as we've seen before. You can also place the caret on the "FileLogger" text and press the CodeRush key to declare a class or struct.

Here are the consume-first type declarations you get with CodeRush Xpress:

Declare Class
Declare Delegate
Declare Enum
Declare Enum Element
Declare Interface
Declare Struct

Declaring Variables

As we've already seen, declaring variables to represent an expression on a line is easy. Another way to declare variables is to simply place the caret on a reference to the variable name in an assignment, as in the "_StartTime" text in the assignment below:

Press the CodeRush key (Ctrl+`) and select the declaration you'd like. A preview hint will let you see the changes to the code before you commit.

Here are the consume-first variable declarations you get with CodeRush Xpress:

Declare Field
Declare Local
Declare Local (implicit)

Create Method Contract

Often inside methods, before you work with the parameters, you need to verify that those parameters are valid. Developers typically select one of three mechanisms to ensure the data coming in is correct:

Throw an exception
Call Debug.AssertXxxx()
Exit the method

Regardless of which one of these you prefer, CodeRush Xpress makes it easy to build this contract code. Just move the caret to the start of the method, like this:

Then press the CodeRush key (Ctrl+`). The Create Method Contract menu will appear, allowing you to select the ideal mechanism for validating any parameters that are without validation code.

The preview hint shows you exactly what you're going to get. Create Method Contract makes the process of ensuring parameters are valid fast and easy.

Duplicate Line

Duplicate line lets you create a new line of code based on an existing line of code. You can duplicate variable declarations, constants, and method calls. The shortcut is Shift+Enter. For example, if the caret is on a declaration like this in C#:

Pressing Shift+Enter will create a duplicate declaration that looks like this:

Now it's simply a matter of typing in the new field name. Note that the Camel Case features , shown above, may be useful here if you want to change only a portion of the name (for example, changing _StartTime to _EndTime would be easy with Camel Case Nav and Camel Case Select).

Refactor

Refactoring is a powerful way to improve the quality and flexibility of your code, without changing program behavior. Well-refactored code costs less to maintain, is easier to extend, and is a more valuable asset than code that is allowed to accumulate technical debt (also referred to as design debt).

CodeRush Xpress includes over 50 refactorings, and nearly all work in both C# and Visual Basic. A few refactorings are available in only a single language due to features of that particular language.

For example, Inline With Statement and Create With Statement are both available in Visual Basic.

Similarly, refactorings to Add Block Delimiters and Remove Block Delimiters are only available in C#.

In some cases CodeRush Xpress provides wrappers for existing refactorings in either language. These wrappers ensure a more complete experience, making all refactorings contextually available in one location, accessed from a single keystroke (Ctrl+`). In many cases wrappers will also implement a preview hint, so you can see the impact of the changes before you commit. Wrappers are indicated in the refactoring menu with a Visual Studio icon, as in the Rename and Reorder Parameters refactorings appearing in the refactoring menu below:

In this section you'll find descriptions for all refactorings shipping inside CodeRush Xpress, arranged in the following categories:

Changing Signatures
Conditionals
Declaration & Initialization
Expressions
Interfaces
Lambda Expressions & Anonymous Methods
Loops & Blocks
Properties & Fields
Moving/Extracting Methods
Resource Files & Strings
Types
Visibility

Consult the Visual Studio help after installing CodeRush Xpress for additional details and example code in both C# and Visual Basic demonstrating these refactorings in action.

Changing Signatures

Add Parameter

Adds a new parameter to a method declaration and updates all calls accordingly.

Create Overload

Creates an overloaded method similar to the one at the caret, with fewer parameters. Applying this refactoring leads to an interactive phase where you can select which parameters to exclude from the new overload. XML doc comments are updated appropriately. You can even create overloads of constructors, as shown in the screen shot below:

Decompose Parameter

Replaces a single parameter with one or more new parameters, each standing in for a property access on the original parameter. For example, consider the code below:

In the first constructor, only a single property of the parentGrid parameter, Children, is accessed inside the code (and aside from this property reference, parentGrid is never referenced or assigned to directly in the code). So we can replace this parameter with a parameter of the same type as the property referenced. The preview hint for Decompose Parameter shows the impact of this change:

After applying this refactoring, all calls to the method are updated. The final code looks like this:

Promote to Parameter

Removes all references to the local declaration or field from the method, replacing it with a parameter. Calling code is adjusted to pass in the promoted field or expression.

In C#, CodeRush Xpress simply adds a preview hint wrapper around the existing refactoring.

In Visual Basic the refactoring is available as well, however in this case CodeRush Xpress actually implements the refactoring instead of handing off to the language service:

Remove Unused Parameter

Removes an unused parameter from a method declaration and updates all calls accordingly.

In Visual Basic this refactoring is only available on parameters that are not referenced within the method:

In C# the Remove Unused Parameter refactoring is not available, however there is a wrapper for the built-in C# refactoring Remove Parameters, and that wrapper is available when the caret is on any parameter:

When you select the Remove Parameters, CodeRush Xpress calls the built-in C# refactoring, which allows you to select the parameters to remove:

Note: The image above is a dialog from Visual Studio and is not part of CodeRush Xpress.

Reorder Parameters

Reorders parameters in the current method, and then updates calling code to reflect the new order.

In C#, this refactoring hands control over to the existing C# implementation of Reorder Parameters:

Note: The image above is a dialog from Visual Studio and is not part of CodeRush Xpress.

In Visual Basic, the application of this refactoring leads to an interactive phase where parameters can be rearranged using the CodeRush Xpress in-source UI. A hint appears revealing available shortcuts in the interactive mode.

Safe Rename

Safely renames non-private methods and properties by creating a duplicate member to preserve the old signature, calling the renamed member from the old member. The old member is hidden from Intellisense and marked "Obsolete". References to the old member will generate compiler warnings directing developers to the new renamed member.

After applying this refactoring, CodeRush Xpress selects and links the method name for an easy rename.

Safe rename is useful if you want to change the signature of a public or protected method referenced by code outside of your solution (e.g., on a developer's machine in another part of the world making calls to your API). For example, after performing the Safe Rename on the code shown above, we can next apply Remove Parameter to the unused deprecatedData in the FindPlayers method, cleaning up its signature without breaking any code that calls the now-obsolete FindAllThePlayers method.

Conditionals

Combine Conditionals

Combines nested conditionals to into a binary expression performing a logical AND operation. For example, "if (e1) if (e2)" becomes "if (e1 && e2)". This refactoring is the opposite of Split Conditional. This refactoring can also combine two or more neighboring conditionals with identical bodies into a single conditional statement where each conditional expression is logically OR’d.

Here's an example where nested conditionals can be combined:

And here's an example where neighboring conditionals with identical bodies can be combined:

Combine conditionals will also remove any redundancy that might appear in the newly combined expression. For example, notice in the preview hint for the following how the reference to the hasQualified parameter appears only once:

Compress to Ternary Expression

Converts an if/else conditional with assignments in each branch into a ternary expression. This refactoring is the opposite of Expand Ternary Expression.

Expand Ternary Expression

Converts a ternary expression into an if/else block. This refactoring is the opposite of Compress to Ternary Expression.

Before:

column = cellPosition == CellPosition.Last ? _NumColumns - 1 : 1;

After:

if (cellPosition == CellPosition.Last)
    column = _NumColumns - 1;
else
    column = 1;

Flatten Conditional

Unindents all or a portion of the conditional statement. This refactoring applies one of the following refactorings: Replace Nested Conditional with Guard Clause, Remove Redundant Else, or Reverse Conditional followed by Remove Redundant Else. Flatten conditional can also recognize “if (E) return true; else return false;” and convert all of this to simply “return E;”.

Here's one example for Flatten Conditional, where an indented code block (the last one of a method) becomes unindented by reversing the conditional and exiting the method:

Here's another example preview hint for Flatten Conditional, where an else keyword and the corresponding braces are removed, unindenting the contents of the block:

Reverse Conditional

Inverts the logic in this conditional statement and swaps the If and Else blocks.

Split Conditional

Two behaviors:

Converts a conditional with a binary expression performing a logical AND operation into nested conditionals. For example, in C#, "if (e1 && e2)" becomes "if (e1) if (e2)".

Before:
   if (fileName != null && fileName != String.Empty)
     PlayInCell(fileName, column, row);

After:
   if (fileName != null)
     if (fileName != String.Empty)
       PlayInCell(fileName, column, row);

Converts a conditional with a binary expression performing a logical OR operation into neighboring conditionals.

Before:
   if (fileName == null || fileName == String.Empty)
     return;

After:
   if (fileName == null)
     return;
   if (fileName == String.Empty)
     return;

Declaration & Initialization

Convert to Initializer

Converts a default constructor call immediately followed by object initialization into an object initializer.

Decompose Initializer

Converts an object initializer to a default constructor call followed by object initialization. Available when the caret is on type reference in the constructor call.

Before:
MediaPlayerPro mediaPlayerPro = new MediaPlayerPro { NumColumns = 3, StartingFolder = @"C:\Images" };

After:

Note the variable name is linked up after decomposing the initializer, allowing for a quick rename if desired.

Make Explicit

Converts an implicitly-typed local variable to a variable with an explicit type.

Make Explicit (and Name Anonymous Type)

Converts an implicitly-typed local variable to a variable with an explicit type, creates a named type to represent the expression on the right, and replaces the anonymous type with a newly-declared type. Other anonymous types in this project having the same shape will also be replaced by the new type.

Make Implicit

Converts an explicitly-typed variable declaration to an implicit one.

Move Declaration Near Reference

Moves the declaration statement for a local variable near its first reference.

This refactoring is sometimes useful in preparing a block of code for Extract Method (if a selected block contains the variable declaration, the variable won't need to be passed in as a input parameter).

Move Initialization to Declaration

Combines a local variable's declaration with its first initialization.

Name Anonymous Type

Replaces the anonymous type with a newly-declared type.

Additionally, other anonymous types in this project having the same shape (matching property names of the same types) will be replaced by the new type. For example, watch what happens when you apply this refactoring the first anonymous type assigned to the variable superCar1 below:

Before:
var superCar1 = new { MaxSpeed = 250, Driver = "Speed" };
var superCar2 = new { MaxSpeed = 250, Driver = "Racer X" };

After:
var superCar1 = new SuperCar(250, "Speed");
var superCar2 = new SuperCar(250, "Racer X");

The anonymous type assigned to superCar2 is also replaced by the new type.

Remove Assignments to Parameter

Removes assignments to value parameters, declaring a new local at the first assignment.

Split Initialization from Declaration

Breaks an initialized declaration for a local variable into a declaration and a separate initialization statement.

Before:
string[] files = System.IO.Directory.GetFiles(_StartingFolder);

After:
string[] files;
files = System.IO.Directory.GetFiles(_StartingFolder);

Split Temporary Variable

Splits a local variable which has too many assignments, declaring a new local at the first new assignment following the first reference. In this example where the local variable "i" has multiple assignments and references, the preview hint shows a new variable named "splitI" will be introduced, and all subsequent references to "i" will be replaced with the new splitI variable.

Expressions

Inline Temp

Replaces all references to a local variable with its initial value.

Introduce Constant

Declares a new constant, initialized to the value of the string or number at the caret.

Introduce Constant (local)

Declares a new local constant, initialized to the value of the string or number at the caret.

Introduce Local

Creates a new local variable initialized to the selected expression. Replaces the selection with the new variable.

After applying this refactoring, the new local variable name is selected and linked up...

So it is easy to rename...

Introduce Local (replace all)

Creates a new local variable initialized with the selected expression. Replaces the expression everywhere it appears inside the code block with the new variable.

Simplify Expression

Resolves an expression to its simplest form. Simplify Expression will remove redundancy such as extra parentheses and sub-expressions that have no impact on the outcome of the evaluation. For example, consider the redundancy in the expression in the method below:

To simplify this, select the expression and press the CodeRush key (Ctrl+`). The preview hint shows how the expression will be simplified. Notice that we lose the redundant reference to the hasQualified parameter, and we also lose an extra pair or parens, resulting in a cleaner expression that is easier to read.

Interfaces

Extract Interface

Extracts an interface based on public members in a class.

Lambda Expressions & Anonymous Methods

Compress to Lambda Expression

This refactoring is only available in C#.

Converts an anonymous method to an equivalent lambda expression.

Expand Lambda Expression

This refactoring is only available in C#.

Converts a lambda expression to an equivalent anonymous method.

Inline Delegate

This refactoring is only available in C#.

Inlines the delegate, creating an anonymous method. If there are no other references to the delegate method, it is removed.

Name Anonymous Method

This refactoring is only available in C#.

Creates a new delegate method from an anonymous method which does not access any local variables from the parenting method body.

After applying this refactoring the method names will be linked up allowing you to easily rename the new method.

Loops & Blocks

Add Block Delimiters

This refactoring is only available in C#.

Embeds a child statement inside brace delimiters.

Before:
if (files == null)
    files = Directory.GetFiles(_StartingFolder);

After:
if (files == null)
{
    files = Directory.GetFiles(_StartingFolder);
}

Create With Statement

This refactoring is only available in Visual Basic.

Creates a Visual Basic With statement for the specified instance within the selection.

If more than one qualifying instance exists, a sub menu will allow you to select the instance to become the subject of the With statement.

Inline With Statement

This refactoring is only available in Visual Basic.

Inlines the object reference of a Visual Basic With statement into all dot-references.

Remove Block Delimiters

This refactoring is only available in C#.

Removes unnecessary brace delimiters in C#.

Before:
if (files == null)
{
    files = Directory.GetFiles(_StartingFolder);
}

After:
if (files == null)
    files = Directory.GetFiles(_StartingFolder);

Properties & Fields

Convert to Auto-implemented Property

This refactoring is only available in C#.

Removes the backing store and converts the active property to a C# auto-implemented property. Available when the caret is on the property name.

Convert to Auto-implemented Property (convert all)

This refactoring is only available in C#.

Converts all properties in the active C# type to auto-implemented properties, removing the associated backing store fields.

Create Backing Store

This refactoring is only available in C#.

Converts a C# auto-implemented property to a conventional property with a backing store.

Before:
public string StartingFolder { get; private set; }

After:
private string _StartingFolder;
public string StartingFolder
{
   get
   {
    return _StartingFolder;
   }
   private set
   {
    _StartingFolder = value;
   }
}

Encapsulate Field

Encapsulates a field into a read-write property and replaces all occurrences of this field with the newly declared property. In C# control is passed to the built-in refactoring that encapsulates fields. In Visual Basic CodeRush Xpress implements this refactoring.

Encapsulate Field (read only)

Encapsulates a field into a read-only property and replaces all read-references to this field with the newly declared property.

Method to Property

Creates a property from the current method.

Before:
public string GetStartingFolder()
{
    return _StartingFolder;
}

After:
public string StartingFolder
{
    get
    {
      return _StartingFolder;
    }
}

Property to Method(s)

For read-only properties:
    Converts the property into a function.
For write-only properties:
    Converts the property into a method (or Sub in Visual Basic).
For read/write properties:
    Converts the property into two methods, creating a new function for the getter, and a new method for the setter.

Moving/Extracting Methods

Extract Method

Creates a new method from the selected code block. The selection is replaced with appropriate calling code to invoke the newly-declared method.

In C# control is passed to the built-in refactoring that extracts methods. In Visual Basic CodeRush Xpress implements this refactoring.

Extract Method to Type

Creates a new method from the selected code block and moves it to the specified type, updating the selected code block appropriately. The selection is replaced with suitable calling code to invoke the newly-declared method through an instance of the target type. This refactoring is useful when you have a block of code that references several properties or methods on a variable of a type that is declared elsewhere in your solution.

After extracting the code block above, the new method looks like this:

And the calling site looks like this:

Extract Property

Creates a new property from the selected code block. The selection is replaced with appropriate code to reference the newly-declared property.

After extraction the property name is selected and linked up for an easy rename.

Replace Temp with Query

Replaces each reference to this local variable with a call to an extracted method, which returns the initial value assigned to this local.

Resource Files & Strings

Extract String to Resource

Extracts the string at the caret into a resource file.

After extracting the string, the resource identifier is selected and linked for an easy rename.

This refactoring is useful if you have text that needs to be translated into one or more target languages. Placing all text that needs translation into a resource file makes it possible to change and add foreign language support without changing the code.

Extract String to Resource (replace all)

Extracts all matching strings in the file to a resource file.

Extract XML Literal to Resource

This refactoring is only available in Visual Basic.

Extracts the active embedded XML literal to a resource file.

After the extraction the resource identifier is selected and linked up for an easy rename.

Use String.Format

Converts a composed string expression into a single String.Format call.

Notice in the preview hint how the formatting arguments passed to the ToString calls in the original expression (e.g., "listPrice.ToString("c")") are properly converted to the appropriate format strings (e.g., "{0:c}").

This refactoring is useful if you have concatenated display text such as this that needs to be translated into another language. Complete sentences are more effectively translated than sentence fragments, as they can be grammatically rearranged as is sometimes necessary with translation, without touching the code.

Use StringBuilder

Replaces the selected string concatenation operations with corresponding method calls on a local StringBuilder instance. For example, consider the following code:

To change these string concatenation operations to equivalent code that works uses a StringBuilder, just select the text to convert and press the CodeRush key (Ctrl+`).

The preview hint gives you an idea of the changes this refactoring will apply to the code. Old string concatenation operations ("+=") are updated.

Notice also the intelligent changes applied to the second line that had previously called String.Format. That call has been converted to an AppendFormat call.

Types

Move Type to File

Creates a new file with the same name as the type at the caret, adds the file to the project, and then moves the type to that file, along with any leading comments, attributes, and XML doc comments. This refactoring is available when the caret is on a type declaration and the file contains two or more types.

After applying this refactoring, the type is moved to a new file with a matching name, and added to the active project:

The new file is activated so you can work in that file if needed. As always, when a feature in CodeRush Xpress takes you away from where you started, you can get back to the original location by pressing Escape.

Visibility

Widen Scope

Moves a variable declaration up (out) in scope, increasing the area where it can be referenced within the method.

Widen Scope (promote constant)

Moves the local constant declaration out of the member and up to the type, replacing all matching values in the type with a reference to the constant.

Widen Scope (promote to field)

Converts a local variable to a field variable.

More Information

Documentation on all the features of CodeRush Xpress, including samples in both C# and Visual Basic, can be found in the Visual Studio help after installing. Just select the Help | Contents menu item:

The help also includes sample animations for C# and Visual Basic, so you can see the features in motion.

Apple logos pop up in the strangest places

Richard Morris (Developer Express) — Thu, 25 Jun 2009 16:00:00 GMT

So I'm sure you probably noticed more than a few DXers talking about Apples lately, Our CTO Julian just tweeted that his new IPhone 3GS was on it's way to him, and Evangelist Gary just blogged about new features in the latest IPhone 3.0 software, the other day Silverlight guru Azret had as his FaceBook status "Hating myself for loving the IPhone UI", and you probably recognize these likely lads and that ... let's face it ... "In Your Face" logo on the back of the latptop they are both clearly mocking.

That logo is so "In Your Face", that at a recent conference (run by a company that shall not be named) where Oliver was speaking, a conference room functionary was dispatched by some marketing weasel to slap a sticker over the Apple logo on his laptop while he was in mid-present.

I've just got myself a new 17" MacBookPro myself (I'll blog later about how to set up a Mac for developing .NET apps) and I've also been using an IPhone for 6 months so I guess I'm as much an Apple Fanbois as anyone else here ... but that gaudy Apple logo is giving me the irits. I paid enough for this laptop, I'm not going to give away any more free advertising to them.

What I really want is to get some inkjet printed surface tension held "sticker" to put over it ... maybe I'd do an old school Apple II Rainbow (My first PC back in 1980) or a map of Australia or such.

...

Speaking of Australia, as you may know we're drifting as a continent towards Japan at a rate of about 6cm a year ... or about one ninth of a cubit for my nonmetricated friends. As we are headed north we seem to be dropping bits of giant limestone islands off the southern edge of the continent, and in our trip around Australia we took a very windswept trip out to see some of these called the 12 Apostles.

This is the southern most edge of Australia, and that wind is bitterly cold comes directly from Antarctica and smells of penguins. You can see some of the 12 Apostles in the background. Those are the giant limestone Islands, and because they are essentially chalk left out in the elements they erode rapidly and dramatically.

Check out the interesting way this one is eroding ... at its top left ... see that hole in the limestone that you can see through to the waves behind?

That bloody Apple logo ... it's everywhere.

XAF – Project Management Application

Gary Short (Developer Express) — Thu, 25 Jun 2009 14:31:12 GMT

Recently I had an IM chat with the XAF team that went something like this (I paraphrase of course):

Them: Hey Gary we need a new PM app so we’re gonna write one and we want you to blog about it as we go.
Me: Cool, no problem. Just let me know what you want and I’ll get it out there on the blog.
Them: That’s great. Thanks. You know you’re the best evangelist we’ve got, right?
Me: yeah I do.
Them: The thing is…
Me: Yeeeeees?
Them: We’re kinda busy with the whole Writing-XAF-Thing, so maybe you could write the app and we’d be your customers; it’d be done agile like?
Me: You mean you’d change your mind at every turn?
Them: Yeah.
Me: And whilst this is going on, you want me to blog about it so our customers can throw in their tuppence worth too?
Them: Yeah oh, and can you ship the code too so that they can use it for reference?
Me: By ‘reference’ you mean pick apart every line of my code and hold it up for scrutiny and public ridicule?
Them: Yeah, sucks to be you, huh?

And so our XAF Planning Application was born. Now I know what you are thinking (even you Rory Becker and frankly that’s disgusting). You’re thinking here’s another XAF RWA. Well you’re wrong, it’s not. We’ve spoken before about the fact that we’re not doing a RWA for XAF, not now, not ever, no siree Bob. What this is, is an application that will be used in the real world, and that, dear reader, is completely different. :-)

This application is going to be used by the XAF team for planning projects, and umm… holidays and gadget buying trips and… well you get the idea, and it works something like this. Well, it works something like this for this iteration, I dare say there’ll be changes prompted by the team (and you guys) for iteration 2 – N, but for now, it works like this:

When you open the application you will notice that there are two groups. The first group, labelled “Project” holds an action for Project and one for Estimate. The first will allow you to work with Projects whilst the other will allow you to work with Estimates. Projects are pretty self explanatory and Estimates will allow you to “size” a project at the “getting the budget” phase, before there’s even is a project to speak of. (Of course, being the first iteration that functionality is not complete, but we can CRUD Estimates in the meantime). Once the project has been given the go ahead, Tasks can be created from these Estimates, or they can be created manually.

Okay so let’s have a closer look at Estimates:

As you can see, an Estimate has a name, a summary of the work to be done, the effort required to complete the task (in days) and, optionally, the Resource who will carry out / test / manage the Task.

Now let’s have a look at the Project:

Our Project has name, a manager (the person we’ll all blame when it goes wrong), the percentage complete (this will be calculated from the percentage completes of the tasks attached to this project), a start date and an end date. The Project also has collections of Estimates, Tasks, Resources and Milestones for the Project.

In the second group there are actions for Project Manager and for Resource. Currently anybody working on the Project who is not a Project Manager is just a Resource, this may change in the future. Resource inherits from the built in Person class within XAF and Project Manager inherits from Resource.

As this is the first iteration I have not included the source code as it only contains the class definitions and validation rules and, as anyone who works with XAF will tell you, that is not very exciting. Having said that, if anyone desperately wants the code from this iteration just leave a comment here and I’ll publish it.

Well that is it for this post. I’m planning weekly iterations and in next week’s iteration we’ll look at creating Estimates and then adding those to a newly created Project, before using them to automatically generate Tasks for the new Project.

What’s new in the iPhone OS 3.0?

Gary Short (Developer Express) — Thu, 25 Jun 2009 12:30:40 GMT

So June 17 finally rolled round and I was able to update my iPhone from 2.X to 3.0, yay! Of course it wasn’t that straight forward, when is it ever, right? I mean the download went smoothly enough, but then I had to wait for the Apple Activation Server, and wait, and wait, and wait… Finally, everyone else stopped getting their activation and I managed to get mine through. So having done that, what’s new…?

Well for a kick off, they’ve finally fixed my two bug bears with the iPhone:

Finally, we have MMS, yes that’s right iPhone users, welcome to the ‘90s we, at last can send and receive picture messages! I mean we always could before, sort of, but it was a real pain. Firstly, if someone sent you a picture then you got a text from your provider telling that you had a picture and giving you a url to go to. Then you had to open Safari and head over there and then type in your phone number plus a passcode and then you could finally see the picture. Phew, what a lot of needless effort!

Now it’s much better, now the pictures appear, inline, in your text conversations (as shown) and you can double tap to open them to full size if you wish, all seamlessly. Yay, about time Apple!

Talking of text messages, that brings me nicely on to the second bug bear of mine that Apple have fixed with this release and that’s the fact that you couldn’t delete single messages in a text conversation. You had to delete the whole conversation or nothing. How dumb was that? Happily that is fixed now and you can delete individual messages.

Speaking of ‘90s usability, Apple have also giving us iPhone users the ability to forward messages too. So the next time somebody sends you a joke by text, you’ll be able to pass it on, instead of just having to remember it for the next time you are with your mates in the pub, by which time of course, they’ve all already heard it as they got the original text forwarded to them! :-)

Rounding off our trip back to the ‘90s with the iPhone we now have, the long awaited (at least by me), copy cut and paste functionality. Why that wasn’t there from the get go, I’ll never know.

But this release is not all about playing catch up with functionality, there are several new features. There’s what I call Etch-a-Sketch functionality. If you are typing away in an email or something and you make a mistake, then just shake the iPhone and it’ll pop up a dialog box asking you if you want to undo the typing.

Also Apple have beefed up the iPhone’s search features in two way. Firstly it is enhanced in applications like mail etc, but also there is a new “Spotlight” feature which can be accessed by swiping left from the home screen or by pressing the home button when on that screen.

More Etch-a-Sketch functionality can be found in the iPhone’s iPod player. Simply shake the iPhone to enter shuffle mode; though Apple may have this set a little to sensitively as there are reports on the Net of iPhones shuffling during particularly bumpy flights, or when running to cross the road. If this happens to you, never fear, you can turn this functionality off under Settings –> iPod. Staying with the iPod functionality for a moment longer, there is now the ability to playback video in either landscape or portrait modes you can also jump back exactly 30 seconds and play at either half or double speed.

The 3.0 release also come with parental controls, but we don’t really care about that do we? I mean, let’s face it, our kids are not going to get their grubby little hands on our lovely shiny iPhone now are they?

Well this has been a short tour around some of my favourite functionality in 3.0, it’s by no means complete, but I hope you’ve enjoyed it. For a more complete run down you might want to check out the Apple site for more details.

XAF and the Secret Validation Information

Gary Short (Developer Express) — Thu, 25 Jun 2009 10:24:26 GMT

Ever seen the XAF validation dialog?

Yeah of course you have. Ever double clicked on the text in the “Description” column? Nope, me neither until recently, try it now:

Whoah, what happened there?! DevExpress secret sauce happened! Well okay, not so secret now I’ve told you. What it is, is a dialog that will give you all kinds of handy information about the validation that was just executed. Information that will help you if your validation isn’t working just how you think it should.

Pretty cool eh? Right, I’m off before the XAF team finds out I’ve spilled the beans. :-)

XAF – RuleCriteria and Read Only Properties

Gary Short (Developer Express) — Thu, 25 Jun 2009 09:56:46 GMT

As a man I never read the instructions; it’s baked into our DNA. There were no instruction manuals back when we lived in caves, right? So if we didn’t need them then, we sure as heck don’t need them now. This applies doubly so when I’m working with XAF. Why? Two reason really. Firstly, it allows me to see how intuitive XAF is – does it work, out of the box, the way I naturally think it should? Secondly, when I get stuck, it allows me to see how easy it is to get unstuck using our documentation. (okay when I said I never read instructions, I meant never *before* the fact.)

Right now I’m working on an XAF application (more on that later) and I want to set up some validation rules; specifically I want to validate that a StartDate is greater than or equal to today’s date. So, naturally, I intuitively I write:

[RuleCriteria("StartDateMustBeAfterToday", DefaultContexts.Save, "StartDate >= DateTime.Now.Date")]

Which doesn’t work and throws this error:

Well okay, so much for intuition, time to find out how it should really be done. So, I open the documentation page for RuleCriteria and I read it; and it’s right there, you saw it didn’t you? No? Meh, me neither first time round. It’s there in the “Remarks” section.

“In criteria, you can use Read-Only Parameters. For instance, the "Today = '@CurrentDate'" criterion means that the Today property must be set to the current date.”

That single sentence, tucked away in the remarks section is important, hence my post today. It means two things. One, that my code should have be written as:

[RuleCriteria("StartDateMustBeAfterToday", DefaultContexts.Save, "StartDate >= '@CurrentDate'")]

Which will throw the following validation error, as required:

It also means that all the read-only parameters, which we document as being used for filtering (which is true) can also be used in RuleCriteria, so go check them out and have fun!

TechEd Video Interview: Miguel Castro, MVP, discusses ASP.NET

Mehul Harry (Developer Express) — Wed, 24 Jun 2009 22:05:00 GMT

Check out this 10 minute TechEd video interview with Miguel Castro. Miguel is an ASP.NET MVP and the wizard behind the DXAirways real world application videos.

At TechEd 2009, Miguel gave a talk called “ASP.NET: Under the covers” and I was lucky to grab him and talk about some current ASP.NET topics.

In the video, we discuss:

Miguel’s motivation for learning ‘ASP.NET under the covers’
What’s changed from ASP.NET 2.0 to 4.0
Http handlers in ASP.NET pipeline
Miguel’s passion for http handlers
Real world use case of a http handlers
Microsoft’s Velocity Project for distributed caching

[Keep an eye out for Amanda on the Segway around the 6:43 mark]

You can follow Miguel on his geekswithblogs.net blog: ICaramba and also on twitter as @miguelcastro67. Thanks Miguel!

Video: How to use LINQ with ASP.NET GridView

Mehul Harry (Developer Express) — Wed, 24 Jun 2009 08:01:00 GMT

Check out this in-depth LINQ integration with ASPxGridView video. This video updates an older LINQ video and is probably the best LINQ video evar!

Because of your comments (and questions) in the blogs, forums and TV site, the video is now packed with technical goodness. It’s broken down in 3 major levels to address the needs of different developers:

The LINQ support with Server mode technology gives you superior performance gains for your projects. Btw, all products are included in DXperience.

Click the image above and watch the ASPxGridView and LINQ integration video. This by no means is the last LINQ video … Will you help me improve it by adding your voice to the comments?

DXperience? What's That?

DXperience is the .NET developer's secret weapon. Get full access to a complete suite of professional components that let you instantly drop in new features, designer styles and fast performance for your applications. Try a fully-functional version of DXperience for free now: http://www.devexpress.com/Downloads/NET/

Sneak Peek: New ASP.NET Editors’ Features and Demo for 2009 volume 2!

Mehul Harry (Developer Express) — Wed, 24 Jun 2009 06:50:00 GMT

Check out this list of new controls and features for ASP.NET editor controls in the DXperience 2009 volume 2 release.

First, the common ASP.NET editors like the textbox, combo box and others are finally get their due respect. Yes, these ASP.NET editors, or ASPxEditors, will have their very own demo section in the DXperience 2009 volume 2 release! Preview the editors online or send out direct links to management as you convince them about how much you need these features.

We needed the new demo because the ASPxEditors packs so much functionality with new controls and exciting features:

New ASP.NET ColorEdit Control!

This slick new control displays a set of colors so that you and your users can customize website pages.

Here’s technical breakdown:

ASPxColorEdit has the Color property whose type is System.Color
Client-side methods available: GetColor / SetColor
ASPxColorEdit works with both color codes(#ff00ff, #D8D8D8) and standard colors (red, green, silver)! The standard colors are converted into color codes
ASPxColorEdit is a text editor with a dropdown window

The power of suggestion! The ASPxColorEdit was implemented from your suggestions in the support center. Thanks and keep em coming.

New ‘Drop-down Edit’ Control !?!

Another new control in 2009 volume 2 is the ASPxDropDownEdit. The DevExpress ASP.NET team have created a new derived editor to support custom popup windows. These custom popup windows allow you to easily embed things like the ASPxGridView.

DropDownEdit vs ComboBox

The ASPxDropDownEdit is not a combo box control. Instead, it's really a textbox with a dropdown window template. Place just about anything into this window template. For example, by using the ASPxDropDownEdit, create an extended lookup control (with editing) using the ASPxGridView or implement a folder selection dropdown using the ASPxTreeList.

Styles for NullText and Focused Event

By adding the NullTextStyle and FocusedStyle properties, you’ll have more control of your ASPxEditors’ look and feel at runtime.

Display Format for all ASP.NET Editors!

All the ASPxEditors now support the DisplayFormat property including the combo editors! Here’s the full control list: (ASPxTextBox, ASPxButtonEdit, ASPxMemo, ASPxSpinEdit, ASPxDateEdit, ASPxComboBox, ASPxDropDownEdit)

Multiple-Selection List Box and Combo Box!

The ASPxListBox control will now provide three selection modes:

Single – Allows end user to select only one item
Multiple - End users can select several items at once by using the mouse and keyboard keys: Shift (to select a range of items) and Ctrl (to add an item to a current selection)
Check Column - provides multiple selection by using a specific checkbox column (end users don't need to use the Ctrl and Shift keys).

Using the new ASPxDropDownEdit control and the multiple selection list box, you can easily create a dropdown(combo box style) check list box of your own.

With all these sweet new controls and features, I’m very excited about the DXperience 2009 volume 2 release. Which of these controls and features are you most excited about?

DXperience? What's That?

Sneak peek: Not only 2D funnel charts but 3D ones too

Julian M Bucknall — Tue, 23 Jun 2009 23:14:52 GMT

One of a series of posts on the new functionality that'll appear in DXperience v2009 vol 2. This is all pre-beta stuff. The beta will be released to DXperience Enterprise and Universal customers at the beginning of July.

Ha! Didn't take long. Our chart guys decided to make the funnel chart described here into a 3D one as well:

Love the rendering of an "interior" to the funnel.

Sneak peek: Scale breaks in WinForms and web charts

Julian M Bucknall — Tue, 23 Jun 2009 23:01:17 GMT

This particular new feature has been requested for a while and is essential for bar charts or line charts where the point coordinates for the Y-axis vary widely (or maybe wildly).

Certainly you can use logarithmic scales to bring the coordinates into control or into view, but the interpretation of and relationships between the data points become a little more difficult. Scale breaks divide up the axis in to disjoint "bands", so that you can still get some understanding of how the data differs. Note that there can still be some difficulty, but it's a different quality than from trying to interpret logs.

Of course, using neither logs or scale breaks means that the "large" data overpowers the "small" data, which could be, in itself, difficult to interpret (imagine the above chart as a normal bar chart: the bar for Jupiter would be 30 times the height of that of the inner four planets, dominating the chart, and it would be then hard to understand the relationship between the inner four's data).

Everyday's a school day - upcoming training classes on ASP.NET controls

Oliver Sturm (Developer Express) — Tue, 23 Jun 2009 18:39:00 GMT

I'm hijacking Mehul's blog today and I hope he'll forgive me. The reason is that I have something to say about our ASP.NET products: they are going to be the first to be covered by a course in our new training program!

I have been working on this first course for a while - you wouldn't believe the efforts that go into something like that, especially the first time round. Now we're finally (almost) there, and the title of our first course is this:

Business Applications with DXperience ASP.NET

We will shortly put more details online, syllabus, cost and all that. The gist of it is that this is a two-day training course which provides an overview of several of our ASP.NET products. Within those two days you will learn to use the products to create a web application with an external, public-facing part and an internal management part. As the title says, we'll view these topics from the perspective of a developer creating a business application, so it'll be about presenting data, allowing data input, analysis, reporting, ... and of course using all those "glue" elements that make a web site complete. This is training, so it's all about learning - seeing things demonstrated, sure, but also trying everything yourself and getting questions answered.

We are currently planning the first two dates for this course, so I can't tell you those yet. The rough timeframe is "end of August 2009", and one of the classes is going to be in Las Vegas for people in the US, the second one in Amsterdam for those in Europe. I'm hoping to see lots of you there - meanwhile, if you have any feedback to give, leave it here please!

Coming Up: CodeCentral Examples for DevExpress Channel Tutorials

Emil Mesropian (Developer Express) — Mon, 22 Jun 2009 22:54:00 GMT

As the number of training videos on the DevExpress Channel increased, so did the number of requests to provide the source code for each training video. Not too long ago, this was also suggested and discussed in length on our community forums.

We listened and while we have been providing source code to some of our videos in an “on and off” basis, we have decided to increase the integration between the DevExpress Channel tutorials and their corresponding examples listed on Code Central. We will be working hard to organize and create Code Central projects for nearly all the training videos published so far. A slow process, but one that when completed, will help our customers learn about our tools easier and faster than before.

As the projects are created and added to our already massive Code Central database, you will start seeing an extra “Code Central Example” link at the bottom of each video (see the screenshot). This link will take you to the corresponding Code Central page and allow you to download the project pertaining to the video for both C# and VB.NET.

For now, here is a short list of some of the videos that have their projects uploaded to Code Central:

From the DevExpress Labs: Early preview of ASP.NET MVC grid

Julian M Bucknall — Fri, 19 Jun 2009 16:44:42 GMT

We can't help it. We love grids. We love new technology. So the opportunity to marry them together is irresistible. Here's a very early preview of what could become a new product, although I emphasize there is a very long way to go. So don't ask about release dates or betas just yet, just enjoy.

We were slightly dissatisfied with the "force your ASP.NET controls to work in ASP.NET MVC" solution and wondered if there was a way to write a "native" control for ASP.NET MVC. You know the patter by now: MVC gives you full control over your HTML and CSS, etc, and ASP.NET controls tend to be "heavy" in that kind of environment. So, a team went off and did some experiments and wrote some code.

Here's a screenshot of the resulting control:

First off, it's read-only; no editing of data yet. But, nevertheless, it's fully interactive: click on the column headers to sort by those headers, drag a header to rearrange the columns:

As you can see by the navigation links bottom right, the grid is paged.

And the pièce de résistance: a snapshot of the HTML behind it:

Is that clean or what? Some nifty REST links, and it's all ready for that extra touch of custom CSS.

At present there's quite a bit of code that needs to be written to get this up-and-running, and, as this is likely to change, I won't go into any details here. But, note that MVC, in comparison to the traditional ASP.NET, will always require you to write some code. It's that whole "getting full control" thing again.

But, despite all that, a brilliant bit of work from our ASP.NET MVC team. Thanks, guys.

Debugging with Tracepoints

Paul Kimmel (Developer Express) — Thu, 18 Jun 2009 17:32:51 GMT

When you press F9 in Visual Studio—or select Debug|Toggle breakpoint—a little red circle representing the breakpoint is placed in the left-hand column of the editor window adjacent to the line of code containing the break. Breakpoints used to be a literal interrupt 0x03 inserted in the code quietly. I am not sure if that is how Visual Studio ultimately does it way underneath the covers, just thought I’d throw that bit if Jeopardy trivia out there.

A variation on the Breakpoint is called a Tracepoint. A Tracepoint is represented as a red diamond in the left hand margin. You can insert a Tracepoint by right-clicking on a line of code and selecting Breakpoint|Insert Tracepoint. This option is the same as clicking an existing Breakpoint in the left margin and selecting the When Hit Count… (You can also access this feature from the Breakpoints window.) When you insert a Tracepoint the When Breakpoint Is Hit dialog is displayed (see Figure 1). If you click Print a message then you can use pre-defined constants like $FUNCTION or $TID to write trace information to the Output window. $FUNCTION represents the current function, and $TID is the thread id. (Other special keywords include $CALLER, $ADDRESS, $CALLSTACK, and $PID (process id). In the same dialog—see Figure 1—you can leave Continue execution checked, and the ‘When Breakpoint is Hit’ feature will act just like a Debug.Trace statement in your code. The final thing you can do is check Run a macro. Run a macro has a dropdownlist of existing macros you can choose from to run when the Tracepoint is hit. Visual Studio also has a Macro IDE, and you can code your own macros. If you write a macro then your macro (or macros) will also show up in the dropdownlist for the Run a macro section.

Figure 1: The Tracepoint dialog is part of the Visual Studio Debugging environment.

Given the (default) settings shown in the When Breakpoint Is Hit in Figure 1 and the code in Listing 1, the Output window in the IDE will contain the content shown in Figure 1.

Listing 1: A simple ‘Jello Mold’ style demo with the Tracepoint as configured in Figure 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TracePointDemo
{
class Program
{
    static void Main(string[] args)
    {
      Console.WriteLine("This is a test!");
      Console.ReadLine();

}
}
}

Figure 2: The Tracepoint writes the literal text and replaces the special keywords with their values, in this instance the function name and thread id is displayed in the Output window.

Localizing resources for DevExpress ASP.NET controls

Nick (Developer Express Support) — Thu, 18 Jun 2009 17:07:00 GMT

If you develop web applications with DevExpress' ASP.NET controls and the language used by your customers is anything other than English, this message is for you.

The ASPxGridView and other ASPx components show messages to end-users in certain situations. These messages are written in English, but can be easily translated into any other language, as explained in the Localizing Developer Express ASP.NET Controls help topic.

The popularity of our How to localize .NET Windows Forms components article has made me think about collecting language resources for our ASP.NET components. Last week I wrote the Localized resources for ASPx controls knowledgebase article with only two language packs: Italian and Polish. This language collection will certainly grow as time goes by, and you, our customers, will be able to pick up the required resources from it any time.

I invite all non-English speakers to participate. If your native language is other than English, and you don't mind contributing to the community, take the RESX files from the attachment, translate the strings into your language, and submit them back to me via the Support Center as a new Question or Suggestion. By the way, you may already have these files localized, in which case, just pack them up and send them to me if you want to help the cause. Once I get them, I'll add the new localized resources to the knowledgebase.

Sneak Peek: ASP.NET HTML Editor Table Support

Mehul Harry (Developer Express) — Wed, 17 Jun 2009 23:38:00 GMT

The ASPxHTMLEditor component lets you easily drop a high quality editor into any page. The next major DXperience release will add HTML Table support to the ASP.NET HTML Editor, the ASPxHTMLEditor.

Featuring a toolbar icon to create, edit, and delete table items, the ASP.NET HTML Editor easily manage tables through the front-end.

If your users are more comfortable with HTML then there is also the HTML source view option.

The ASPxHtmlEditor is part of the DXperience ASP.NET Subscription. You can start playing with the table support feature when the DXperience 2009 volume 2 released in a few weeks.

DXperience? What's That?

VCL 2009 roadmap

Julian M Bucknall — Wed, 17 Jun 2009 23:32:18 GMT

Despite the replies I've posted in forum posts over the past few months about our VCL roadmap, they're proving hard to find. Indeed, I couldn't find my previous answers myself and I wrote them. Sigh. Someone needs to teach me how to add searchable keywords...

Anyway, a quick recap of the 2009 roadmap for VCL customers is in order:

ExpressQuantumTreeList v5 is almost done.

Will be released in Build 44 in a few days.
Details on new features here: ExpressQuantumTreeList 5 – New Features

ExpressLayout Control v2

First beta will be released in Build 44
List of features will be published with Build 44 (I'll publish them in a blog post then)
Aiming for an August release

ExpressPrinting System v4

Beta in August
Release in September/October
Features include:

PDF support
Separate the ReportLink packages into design and runtime parts
Skinnable dialogs to bring visual consistency in skinned applications
Add the capability to display the Print Preview dialog using the Ribbon style (to bring visual consistency in Ribbon style applications)
Add the capability to print TcxLabel controls

ExpressQuantumGrid v7

Beta in Q4 perhaps.
Release late in the year, maybe next year
No official details on features yet

SD Times 100 Award

Julian M Bucknall — Wed, 17 Jun 2009 23:08:31 GMT

SD Times has just announced the winners for their 2009 SD Times 100 awards, the 100 companies that have influenced and innovated the most in our industry. Actually that's not quite right: although they've just published the list on their website, last week they "leaked" the awards ahead of time by tweeting them on Twitter.

For the third year in a row, DevExpress was given one of the awards in the Components and Libraries section. W00t! I must say it's always good to be recognized as one of the "companies that have stayed on top of the latest platforms and protocols". It's a tough job, but someone's got to do it.

Thanks Alan and David and all of the other editors for the recognition!