C#PRO Cover Story

C#Builder vs. VS .NET: Choose Wisely

With Borland's new C#Builder, VS.NET now has a real competitor. Both are great tools, but which will work best for you?

By Joe Mayo

In case you haven't heard, C#Builder is a new Integrated Development Environment that lets you build .NET applications in C#. This new product debuted just a few months after Microsoft released Visual Studio .NET 2003. Although both products target the same audience - the C# developer - and have many of the same capabilities, each certainly is unique. Now that you've got a choice, you're bound to wonder: What does C#Builder offer? How does C#Builder compare to VS .NET? And of course, why would you choose one over the other? Well, let's see what we can do about answering these questions. (For a quick side-by-side comparison, see the sidebar, "Making the Grade.")

Out of the box, C#Builder and VS .NET look similar. They sport a single document interface for code editing and visual design surfaces, property editors, tool palette, project managers, and docking/sliding windows. The first impression many developers get is that C#Builder looks just like VS .NET (see Figure 1). Then again, first impressions often are misleading. In fact, C#Builder innovates in pleasingly surprising ways that are definitely worth a second look.

 

Figure 1. This shows the C#Builder Default Layout, which is quite similar to VS .NET. Besides multiple layouts, another difference with C#Builder is its Tool Palette, shown in the lower-right corner, as well as its ability to show live design-time data. Also notice the close buttons on the tabs in the designer and the tab at the bottom of the designer, which lets you navigate quickly between code and a graphic view.

The VS .NET desktop opens with a tabbed view on the editor/design surface, and it lets you split the editing window and move to MDI-style editing (see Figure 2). C#Builder takes a different approach, however, by having different desktop layout styles. The default style is similar to VS .NET, but you can change it to a floating window style, similar to JBuilder and Visual Basic. Another C#Builder desktop layout is used for specifying window layout while debugging.

 

Figure 2. VS .NET has a consistent look and feel, but it is not quite as colorful as C#Builder. Code and GUI have separate tabs, and notice that, unlike C#Builder, VS .NET does not have live design-time data.

From a C# developer's perspective, there is no difference between the two IDEs when it comes to the ability to build any type of .NET application. Because Borland licensed the .NET Framework SDK from Microsoft, both C#Builder and VS .NET use the same C# compiler and library. You can develop any .NET technology with C#Builder, including Windows Forms, ASP.NET, ADO.NET, and Web services.

The major advantage of VS .NET is it allows development in multiple languages such as C#, Visual Basic .NET (VB .NET), Managed C++, and J#. C#Builder, as its name suggests, limits your language choice to C#. It does let you work with VB .NET source code, but it is only a supplementary capability intended for the convenience of people who need to incorporate existing VB .NET code into their project.

Go for the Code

Sure, the fancy designers and wizards offered by both IDEs help me be more productive; I use them quickly and I'm done. But the code editor is where I spend most of my time. Both IDEs have configurable syntax-colored code and code folding, but the differences in code formatting, commenting, navigation, and Code Completion/IntelliSense are significant.

When testing an IDE, the first thing I do is start typing and banging out code. The VS .NET code editor has intelligent indentation, where pressing Enter after beginning a block auto-indents to the next tab. If I am typing in an indented state and type an end-of-block, VS .NET will line up the curly brace in the proper column. C#Builder will indent to the same column under the begin block, but I have to press the Tab key to indent. Furthermore, typing an end-of-block in the C#Builder editor simply types the character where it is. Another formatting feature in VS .NET is the ability to highlight a block of code and press Ctrl+K+F to auto-format the entire block. Perhaps I'm spoiled by VS .NET formatting, but I like it and it makes me more productive.

One of the great things about C# is its XML documentation-commenting facilities, and both IDEs have options for extracting documentation comments to file. VS .NET provides automated support for XML documentation comments. All you have to do is type "///" on the line above a type or class member and VS .NET automatically generates a template shell for documentation comments. For a method with multiple parameters and a return type, this is a big gain. VS .NET also offers a documentation-generation facility that applies a transform to the XML documentation to produce HTML pages. Another capability of VS .NET is to highlight a block of text and press Ctrl+K+C; this adds comments to every highlighted line. Conversely, pressing Ctrl+K+U removes comments from a highlighted block. In the C#Builder code editor, you must type in all comments manually and it doesn't have automated commenting or a comment/uncomment capability.

I was pleased to see that C#Builder lets you jump to a declaration, the same as VS .NET. There are, however, differences in how to navigate to specific portions of code. VS .NET has a Class View window that lets you locate types and their members. C#Builder provides a similar capability, but it does so through a Model View window. One feature C#Builder doesn't have, which is something I use frequently in VS .NET, is the Members ComboBox (located above the editor), which lets you navigate directly to a type member.

Both C#Builder and VS .NET include context-sensitive help in the editor, but there are nuances that make them different. In VS .NET, context-sensitive help is named IntelliSense, and in C#Builder it is named Code Completion. IntelliSense includes descriptions when a method is selected from a list, but C#Builder simply lists the member. Additionally, IntelliSense is smart enough to remember your most frequently selected item (or the item you'll most likely choose) and highlight it first. Although Code Completion isn't that smart, it will filter results so only relevant items appear in the list. Additional IntelliSense capabilities, not found in Code Completion, include support for the new keyword, automatic implementation of interfaces, automatic delegate implementation, and automatic override implementation.

Nuts and Bolts

Project management in both C#Builder and VS .NET is a case of being able to accomplish the same goal but in different ways. The C#Builder Project Manager window lets you control build order in the Project Manager directly, but the VS .NET Solution Explorer has a separate dialog box where you can specify build order. The primary difference in philosophy is VS .NET determines build order and dependencies automatically if you create project references between projects, but C#Builder makes you maintain your own build order. I know for a fact that casual tinkering with the build order and dependencies in VS .NET can totally spike your project, which is why you instead should use project references and let VS .NET sort these things out. Because C#Builder is so new, it will take some time to see if people have any project-management problems. I've given some consideration in this area to C#Builder and have done some experimentation, but I have yet to reproduce such problems.

Both IDEs also have integrated Help; you simply press F1 to get it. C#Builder Help pops up in a separate window, and VS .NET Help appears in an IDE window with its search options displayed as dockable windows (including Dynamic Help). Fortunately, you can turn off Dynamic Help or hide it behind another docked window in a tab group if you don't want to view it.

As for designers, C#Builder uses the same design surface as VS .NET, so you get a very similar look-and-feel to visual user-interface design. Similarly, the C#Builder Object Inspector is a modified Property Grid from the .NET Framework's Base Class Library.

The difference in design interface lies with the C#Builder Tool Palette, which is analogous to the VS .NET Toolbox. The Tool Palette sports a configurable list of categories where you can change the color, order, and layout of items. VS .NET holds its controls on a standard sliding ListBox. In code-editing mode, the Tool Palette displays a list of snippets, which are blocks of commonly used code you can drag to the editor. VS .NET has a clipboard ring containing the most commonly copied code. The difference is that C#Builder's snippets are persistent between invocations of C#Builder; in VS .NET, contents of the clipboard ring disappear when it shuts down. Also, the C#Builder Tool Palette includes a search box that filters the components you seek as you type in each character of the component name.

When opening files, VS .NET opens a new window for every file, which is cumbersome because when you are working with multiple files the work area soon becomes full. Also, a form and its code are separated, prompting you to hunt and peck to find the correct code. In C#Builder, form and code are grouped together and you can switch between each easily using tabs at the bottom of the work area. Another nice C#Builder feature is the Close button on each workspace window tab, where a single click closes the window. VS .NET requires you to find the tab, select it, and click on the close button on the top right-corner of the workspace.

In addition to supporting the SQL Server, Oracle, OleDb, and ODBC data providers included in the .NET Framework that VS .NET supports, C#Builder also includes the Borland Data Provider (BDP). BDP is an extensible data provider that lets you connect to multiple databases with the same code. Current databases supported include Borland InterBase, IBM DB2, Microsoft SQL Server, and Oracle 9i. At press time, Borland is adding even more support for new data providers and, by every indication I've seen, it is committed to continue doing so for the foreseeable future.

Both VS .NET and C#Builder have code browsers for looking at the internals of individual assemblies. But C#Builder Professional and above also include an application-diagramming capability named Model View (see Figure 3). Based on standard UML diagrams, Model View lets you view the relationships between application objects, drill down into their contents, and navigate between model and code. Although this is only a viewing capability, it helps you get a better idea of how an application is put together. VS .NET doesn't have this capability.

 

Figure 3. C#Builder has a feature named Model View that shows static UML diagrams of a project's code. This is useful for familiarizing yourself with code that someone else has written or even reacquainting yourself with your own code after not seeing it for a while.

One feature set that might entice you to make C#Builder part of your tool suite is its ability to export and import VS .NET projects. C#Builder has a wizard for exporting to a VS .NET project and, correspondingly, you can import a VS .NET project by selecting Add Existing Project in the C#Builder Project Manager and choosing a VS .NET project. Think of an architect who uses C#Builder as her preferred modeling tool. When complete, she would export the C#Builder project, which would be added easily to any VS .NET project.

Finally, C#Builder Architect edition has integrated Together UML modeling technology into the IDE. This provides a design-time capability where developers and architects may build UML models and the underlying code is updated. Similarly, code changes update the UML model immediately. There is no intermediate translation or representation of the model, which means there is direct interaction between code and model. VS .NET Architect has Visio, but the capability doesn't even compare.

Another exciting offering in C#Builder Architect is Enterprise Core Objects, or ECO (pronounced eeko). ECO is a runtime-modeling capability that implements the vision of the Object Management Group (OMG) Model Driven Architecture (MDA). With ECO, you can build new models or import existing XMI format models created from other modeling tools. ECO's primary capabilities include support for data persistence, transactions, security, and data binding. ECO models may also evolve as changes to database schema are made. VS .NET has no offerings in this area.

Collaborating Lifecycle Management

Borland has begun an initiative named Application Lifecycle Management (ALM), where people involved in projects can coordinate and work in a collaborative fashion via tools that integrate into the environment. ALM is divided into six distinct phases, which include Define, Design, Develop, Test, Deploy, and Manage. (For more information on ALM, visit Borland's Web site at http://www.borland.com.) The significance of ALM is the way tools integrate and interoperate in the C#Builder environment. For example, CaliberRM, which is a requirements-management tool for the Define phase, integrates directly with C#Builder to put customer requirements directly into the developer cockpit. ALM doesn't prescribe a specific methodology, but it is presented in a way that supports agile processes. Additionally, C#Builder is open to integration with third-party vendors, avoiding lock-in from single-vendor solutions. The integration story goes much deeper than this, but the fact is C#Builder is part of a larger vision to help development teams that include managers, testers, and developers build better software faster.

VS .NET integrates well with other Microsoft technologies, and third-party vendors may integrate if they obtain a license for the Visual Studio .NET Integration Program (VSIP). Microsoft prescribes the Microsoft Solutions Framework (MSF), but it doesn't have integrated tools and guidance on how to perform an ALM-like process with VS .NET.

I could have touched on many other subjects in this article, but I chose what I felt to be the most important issues. Both C#Builder and VS .NET are wonderful tools that let you develop any type of .NET application you want. The difference is the way you construct your code. For coding, I love the VS .NET source-code editor. From a team-development perspective, though, C#Builder delivers on tool integration and productivity for the entire application lifecycle. I personally welcome Borland into the .NET arena and expect more innovative technology to be built into C#Builder in upcoming versions. With the extra competition in the .NET arena, I have no doubt future versions of both C#Builder and VS .NET will be released with many more wonderful features that make developers more productive in shipping their code.



Joe Mayo is an author, independent consultant, and trainer specializing in .NET technologies. He operates the C# Station Web site (http://www.csharp-station.com), and he is the author of C# Unleashed (Sams) and C#Builder Kick Start (Sams). E-mail him at mailto:jmayo@MayoSoftware.com.

Making the Grade

Here's a report card of how VS .NET and C#Builder stack up in different programming areas. Each product excels in some areas while lacking in others, so choose the product that most closely maps to your development style and needs.

动E论坛（http://www.dong-e.com/bbs）lg_netarea翻译

    Borland的C# Builder的出现，意味着VS.NET现在有了一个真正的竞争对手。但对于你来说选择那一个开发工具来说才是最好的呢？
    正如我们所了解到的一样，C#Builder是基于C#语言的、用来开发.NET应用程序的完整的开发环境。它发布的时间仅比微软发布VS.NET晚了几个月。虽然两种产品都是针对相同的客户（即C#一发人员）、都具有相同的开发能力；但是它们又有各自的特点。既然你必须要选择其中一个，那么你想知道：C# Builder能够提供什么功能？与VS.NET相比怎么样？当然还包括为什么选择这一个而不选择另一个？下面我们将要回答这些问题。
    从表面上来看，C# Builder和VS.NET很相似。它们展现给用户的都是一个源代码编辑窗口，可视化窗口，属性菜单，工具栏，项目管理器和docking/sliding windows。C# Bukder给许多开发人员的第一映象就是它跟VS.NET很相似。然而，第一映象常常是一个误导。实际上，在你仔细研究后你会发现C# Builder有很多令人高兴而且有实用价值的地方。
    VS.NET的界面打开时在编辑器和设计器表面有一个标签视图，它能让你把编辑窗口分开以及移向多文档编辑器。然而C# Builder却采用了另一种方法，即不同的界面布局类型。默认的方式很像VS.NET，但是你可民把它改变成一种浮动窗口类型，这有点像Jbuilder和Visual Basic。另外在调试的时候C# Builder也使用一种特殊的窗口。
    从C#开发者的角度出发，这两个IDE工具开发.NET应用程序的开发能力没有什么不同。因为Borland从微软获得了.NET Framework SDK许可。也就是说C# Builder和VS.NET使用了相同的C #编译器和类库。你可以用C# Builder开发任何.NET技术，包括：Windows Forms,ASP.NET和Web Services。
    VS.NET的优点在于它能在多种语言开发，而不像C# Builder仅局限于C#语言，这些语言包括：C#,Visual Basic.NET,Managed C++和J#。C# Builder确实能让你在项目中存在VB.NET源代码，但它仅仅是为那些已经把VB.NET编码到项目中的人提供一种方便的附加的功能。
获取代码

当然，那些具有想象力的设计者和天才使用两个IDE工具来帮助自己更加快速的开发，我就是这么做的。但是代码编辑器是我花时间最多的地方。两个IDE工具都有可配置的语言着色和代码缩进，但是在代码的格式化、注释、定位和代码生成/智能化方面的不同具有关键的作用。
我们在测试一个IDE时，要做的第一件事就是键入代码。VS.NET的代码编辑器有自动缩进的功能，在开始下一条语句时将缩进一个制表符。如果当前的状态是缩进的，在键入一个块结束标记时，VS.NET将按适当的方式重新排列代码。C# Builder却不会这样，你需要使用Tab键来缩进；另外，在键入块结束标记时也不会自动排列。在VS.NET中另一个格式化特点是它能突出一个代码块，而且在你按Ctrl+K+F时能自动格式化整个块。或许我会被这些格式搞糊涂，但是我很喜欢这项功能，它能提高我的工作效率。
C#的一个最大的特点在于它的XML文档注释，这两个IDE工具在提取文件的文档注释方面都有相应的先项。VS.NET提供了对XML文档注释的自动支持。你要做就是在需要的地方标上“///”，VS.NET能自为文档注释生成一个模块。对于一个有多参数，一个返回类型的方法来说这种方式会好很多。VS.NET也提供了一个用来生成XML文档以便制作成HTML页面的文档生成工具。VS.NET的另一个特点是在按Ctrl+K+C时能对选定的行添加注释。相反的按住Ctrl+K+U能取消注释。在C# Builder的代码编辑器中，你必须自己键入所有的注释，而没有自动注释/自动取消注释的功能。
我很高兴能看到C# Builder能让你跳到一个申明，就像VS.NET一样。然而，他们在定位到代码的特定位置的方式不同，VS.NET使用对象察看窗口（Class View window）来查找类型和他们的成员。而C# Builder采用了原型察看窗口（Model View window）实现了相似的功能。成员列表框（在代码编辑时自动出现）这项功能在C# Builder中没有，但在VS.NET中我却经常用到，它能让你直接指向你想要的成员。
C#Builder和VS.NET都在编辑器中包含了一个敏感的与上下文相关的(context-sensitive)帮助功能，但是它们也有细微的差别。在VS.NET中，context-sensitive 帮助被称作IntelliSense,而在C# Builder中叫做Code Completion。当我们从列表中选择一个方法的时候，IntelliSense包含了一个方法描述，而C# Builder仅仅列出了其成员。另外，IntelliSense设计得十分巧妙，以至于以记住你使用最频繁的选项，并在出现时突出显示。虽然Code Completion没有设计得如此巧妙，但也能过滤出相关的选项显示在列表框中。另外的一些功能包括：支持新关键字，界面的自动执行，自动的委托执行和自动的覆盖执行等等在Code Completion中也没有。

具体细节

    C# Builder和VS.NET中的项目管理都能完成相同的目标，但是它们的方式却不同。C# Builder的项目管理窗口让你直接控制编译命令，但是VS.NET的方案管理器有一个各自的对话框，在那儿你可以指定编译命令。在基本原理上的主要不同的在于：如果你在两个项目之间创建了一个项目，VS.NET将自动确定编译命令和从属关系。但是C# Builder会让你自己维持你自己的编译命令。事实上我知道在VS.NET中偶然地糊乱修改编译命令会阻止你的项目开发，那就是你为什么要用项目参考以及让VS.NET来为那些事情分类的原因。由于C# Builder刚出来，所以还需要花时间来看看人们是否有项目管理方面的问题。在这一部分我已经对C# Builder一些考虑，同时也做了一些实验，但是我仍然不得不出现这些问题。
    两个IDE都提供了完事的帮助；你仅仅按F1就可以获得。C# Builder的帮助是从一个单独的窗口弹出的，而VS.NET的帮助则出现在IDE窗口中（其中还包括动态帮助）。幸运的是，如果你不想看到动态帮助你可以关闭它，或者隐藏在其它窗口后。
    对于设计者来说，C# Builder使用了与VS.NET相似的设计界面，因此对于可视化的用户界面设计你有相似的感觉。同样的，C# Builder的对象检查器也是一个经过改进的基于.NET Framework的基类库的属性网格（Property Grid）。
    对于两者来说，设计界面的不同在于C#Builder的工具栏（Tool Palette）,它类似于VS.NET的工具箱。工具栏中列出了可配置的分类列表，在这个列表中你可以改变颜色，命令和选项的外观。VS.NET的控件放在一个可能滑动的列表框中，在代码编辑的模式下，工具栏显示列表的一段，这一段通常是经常需要用到的。VS.NET有一个剪贴板环(clipboard ring)，其中包含了最普通的复制代码。对于C# Builder来说却不是这样，它是持久不变的，而VS.NET中的内容随着它的关闭将不存在。另外，C# Builder的工具栏有了一个搜索栏，它能根据你键入的控件名过滤控件。
    当打开文件时，VS.NET为每个文件打开一个新的窗口，当你在多文件的情况下工作时你的工作区很快将被占完，这是一件很让人讨厌的事。它的表单和代码也是分开的， 这使你不得不看着界面来找相应的代码。在C# Builder中，表单和代码被组织在了一起，你在工作区的底部使用标签方便的来回切换。另一个好的功能是每一个工作区窗口的关闭按钮仅仅是单一，而VS.NET需要你找标签，选择它，然后点击工作区右上角的关闭按钮。
    除了在.NET Framework中支持的SQK Server,Oracle,OleDb和ODBC之外，C# Builder还支持Borland Data Provider(BDP)。DBP是一个可扩展的数据提供者，它能让你使用相同的代码连接到多种数据库。当前的数据库支持包括：Borland InterBase,IBM DB2,Microsoft SQL Server和Oracle 9i。在完成本文时，Borland正在增加对许多新数据库的支持，在我看来，在可预见的将来，它将继续这样做下去。
    VS.NET和C# Builder都有代码浏览器来用查看个体之间的关系。但是C# Builder的专业版和更高版本还包括了一个叫做Model View的应用程序图表。它是基本标准的UML图表，能够让你查看应用程序各个对象之间的关系，从而进一步查看他们的内容，还可以在模式和代码之间导航。虽然这些仅仅是查看功能，但是它却帮助你怎么样把一个应用程序放在一起才是最好的。而VS.NET却没有这个功能。
    最后，C# Builder中还IDE中引入UML的建模技术，这项技术提供了一个在设计时的功能，即：开发者和建模者可以创建UML模型，同时它的代码也是更新过的。同样的，代码的改变也将立即引起UML模型的改变。没有内部的模型转换和描述就意为着在代码和模型之间有直接的相互作用。
    另一个让人兴奋的是C# Builder建模是企业核心对象，或者是ECO(pronounced eek0)。ECO是一个能在运行时建模功能，它是OMG（Object Management Group）MDA(Model Driver Architecture)所追求的目标。有了ECO，你可以创建新的模型或者导入已经存在的从其它建模工具创建的XML模型。ECO的主要功能包括：数据的持久性，数据处理，安全性和数据绑定等的支持。ECO模型也能适应由数据库计划引起的变化。VS.NET没有提供这一功能。

生命周期的管理

    Borland首先命名了应用程序周期管理（ALM），把这个管理工具包含到我们的项目中，我们能够协调我们的工作。ALM被分成了六个明确的阶段，包括：定义（Define），设计（Design），开发（Develop），测试（Test），配置（Deploy）和管理（Manage）。ALM的重要性在于：在C# Builder的环境下工具集合的整合和相互操作。例如：CaliberRM（在定义阶段需求分析管理的工具）被直接整合到了C# Builder中，以便把用户的需求直接与开发者相联系。ALM没指定一种特定的方法论，但是它描述了一种支持灵活过程的方式。
    VS.NET与其它微软的技术能整合得很好，如果第三方卖主获得了VSIP(Visual Studio.NET Integration Program)那么他们也可以整合。微软规定了MSF（Microsoft Solutions Framework），但是它在VS.NET中没有完事的工具和向导程序来创建像ALM这样的过程。
    在这篇文章中我还涉及到了许多方面，但是我选择了我认为最重要的问题。C# Builder和VS.NET在开你想要开发的各种.NET应用程序方面都是十分出色的工具，不同点仅在于你创建的代码。对于编辑代码，我喜欢VS.NET的源代码编辑器。但是从一个开发团队来看，对于整个开发周期来说，C#Builder在工具的完整性和有效性方面要出色得多。我个人的观点就是欢欣Borland进入.NET舞台，并希望C# Builder在将来的版本中有更多的创新之处。在.NET舞台的竞争中，毫无疑问，C#Builder和VS.NET的后继版本都将有更多令人惊奇之处，而这些方面正是为了提高开发者的开发效率。（完）