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 "http:///" 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的出現(xiàn)，意味著VS.NET現(xiàn)在有了一個真正的競爭對手。但對于你來說選擇那一個開發(fā)工具來說才是最好的呢？
    正如我們所了解到的一樣，C#Builder是基于C#語言的、用來開發(fā).NET應(yīng)用程序的完整的開發(fā)環(huán)境。它發(fā)布的時間僅比微軟發(fā)布VS.NET晚了幾個月。雖然兩種產(chǎn)品都是針對相同的客戶（即C#一發(fā)人員）、都具有相同的開發(fā)能力；但是它們又有各自的特點。既然你必須要選擇其中一個，那么你想知道：C# Builder能夠提供什么功能？與VS.NET相比怎么樣？當(dāng)然還包括為什么選擇這一個而不選擇另一個？下面我們將要回答這些問題。
    從表面上來看，C# Builder和VS.NET很相似。它們展現(xiàn)給用戶的都是一個源代碼編輯窗口，可視化窗口，屬性菜單，工具欄，項目管理器和docking/sliding windows。C# Bukder給許多開發(fā)人員的第一映象就是它跟VS.NET很相似。然而，第一映象常常是一個誤導(dǎo)。實際上，在你仔細研究后你會發(fā)現(xiàn)C# Builder有很多令人高興而且有實用價值的地方。
    VS.NET的界面打開時在編輯器和設(shè)計器表面有一個標(biāo)簽視圖，它能讓你把編輯窗口分開以及移向多文檔編輯器。然而C# Builder卻采用了另一種方法，即不同的界面布局類型。默認(rèn)的方式很像VS.NET，但是你可民把它改變成一種浮動窗口類型，這有點像Jbuilder和Visual Basic。另外在調(diào)試的時候C# Builder也使用一種特殊的窗口。
    從C#開發(fā)者的角度出發(fā)，這兩個IDE工具開發(fā).NET應(yīng)用程序的開發(fā)能力沒有什么不同。因為Borland從微軟獲得了.NET Framework SDK許可。也就是說C# Builder和VS.NET使用了相同的C #編譯器和類庫。你可以用C# Builder開發(fā)任何.NET技術(shù)，包括：Windows Forms,ASP.NET和Web Services。
    VS.NET的優(yōu)點在于它能在多種語言開發(fā)，而不像C# Builder僅局限于C#語言，這些語言包括：C#,Visual Basic.NET,Managed C++和J#。C# Builder確實能讓你在項目中存在VB.NET源代碼，但它僅僅是為那些已經(jīng)把VB.NET編碼到項目中的人提供一種方便的附加的功能。
獲取代碼

當(dāng)然，那些具有想象力的設(shè)計者和天才使用兩個IDE工具來幫助自己更加快速的開發(fā)，我就是這么做的。但是代碼編輯器是我花時間最多的地方。兩個IDE工具都有可配置的語言著色和代碼縮進，但是在代碼的格式化、注釋、定位和代碼生成/智能化方面的不同具有關(guān)鍵的作用。
我們在測試一個IDE時，要做的第一件事就是鍵入代碼。VS.NET的代碼編輯器有自動縮進的功能，在開始下一條語句時將縮進一個制表符。如果當(dāng)前的狀態(tài)是縮進的，在鍵入一個塊結(jié)束標(biāo)記時，VS.NET將按適當(dāng)?shù)姆绞街匦屡帕写�碼。C# Builder卻不會這樣，你需要使用Tab鍵來縮進；另外，在鍵入塊結(jié)束標(biāo)記時也不會自動排列。在VS.NET中另一個格式化特點是它能突出一個代碼塊，而且在你按Ctrl+K+F時能自動格式化整個塊。或許我會被這些格式搞糊涂，但是我很喜歡這項功能，它能提高我的工作效率。
C#的一個最大的特點在于它的XML文檔注釋，這兩個IDE工具在提取文件的文檔注釋方面都有相應(yīng)的先項。VS.NET提供了對XML文檔注釋的自動支持。你要做就是在需要的地方標(biāo)上“///”，VS.NET能自為文檔注釋生成一個模塊。對于一個有多參數(shù)，一個返回類型的方法來說這種方式會好很多。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）實現(xiàn)了相似的功能。成員列表框（在代碼編輯時自動出現(xiàn)）這項功能在C# Builder中沒有，但在VS.NET中我卻經(jīng)常用到，它能讓你直接指向你想要的成員。
C#Builder和VS.NET都在編輯器中包含了一個敏感的與上下文相關(guān)的(context-sensitive)幫助功能，但是它們也有細微的差別。在VS.NET中，context-sensitive 幫助被稱作IntelliSense,而在C# Builder中叫做Code Completion。當(dāng)我們從列表中選擇一個方法的時候，IntelliSense包含了一個方法描述，而C# Builder僅僅列出了其成員。另外，IntelliSense設(shè)計得十分巧妙，以至于以記住你使用最頻繁的選項，并在出現(xiàn)時突出顯示。雖然Code Completion沒有設(shè)計得如此巧妙，但也能過濾出相關(guān)的選項顯示在列表框中。另外的一些功能包括：支持新關(guān)鍵字，界面的自動執(zhí)行，自動的委托執(zhí)行和自動的覆蓋執(zhí)行等等在Code Completion中也沒有。

具體細節(jié)

    C# Builder和VS.NET中的項目管理都能完成相同的目標(biāo)，但是它們的方式卻不同。C# Builder的項目管理窗口讓你直接控制編譯命令，但是VS.NET的方案管理器有一個各自的對話框，在那兒你可以指定編譯命令。在基本原理上的主要不同的在于：如果你在兩個項目之間創(chuàng)建了一個項目，VS.NET將自動確定編譯命令和從屬關(guān)系。但是C# Builder會讓你自己維持你自己的編譯命令。事實上我知道在VS.NET中偶然地糊亂修改編譯命令會阻止你的項目開發(fā)，那就是你為什么要用項目參考以及讓VS.NET來為那些事情分類的原因。由于C# Builder剛出來，所以還需要花時間來看看人們是否有項目管理方面的問題。在這一部分我已經(jīng)對C# Builder一些考慮，同時也做了一些實驗，但是我仍然不得不出現(xiàn)這些問題。
    兩個IDE都提供了完事的幫助；你僅僅按F1就可以獲得。C# Builder的幫助是從一個單獨的窗口彈出的，而VS.NET的幫助則出現(xiàn)在IDE窗口中（其中還包括動態(tài)幫助）。幸運的是，如果你不想看到動態(tài)幫助你可以關(guān)閉它，或者隱藏在其它窗口后。
    對于設(shè)計者來說，C# Builder使用了與VS.NET相似的設(shè)計界面，因此對于可視化的用戶界面設(shè)計你有相似的感覺。同樣的，C# Builder的對象檢查器也是一個經(jīng)過改進的基于.NET Framework的基類庫的屬性網(wǎng)格（Property Grid）。
    對于兩者來說，設(shè)計界面的不同在于C#Builder的工具欄（Tool Palette）,它類似于VS.NET的工具箱。工具欄中列出了可配置的分類列表，在這個列表中你可以改變顏色，命令和選項的外觀。VS.NET的控件放在一個可能滑動的列表框中，在代碼編輯的模式下，工具欄顯示列表的一段，這一段通常是經(jīng)常需要用到的。VS.NET有一個剪貼板環(huán)(clipboard ring)，其中包含了最普通的復(fù)制代碼。對于C# Builder來說卻不是這樣，它是持久不變的，而VS.NET中的內(nèi)容隨著它的關(guān)閉將不存在。另外，C# Builder的工具欄有了一個搜索欄，它能根據(jù)你鍵入的控件名過濾控件。
    當(dāng)打開文件時，VS.NET為每個文件打開一個新的窗口，當(dāng)你在多文件的情況下工作時你的工作區(qū)很快將被占完，這是一件很讓人討厭的事。它的表單和代碼也是分開的， 這使你不得不看著界面來找相應(yīng)的代碼。在C# Builder中，表單和代碼被組織在了一起，你在工作區(qū)的底部使用標(biāo)簽方便的來回切換。另一個好的功能是每一個工作區(qū)窗口的關(guān)閉按鈕僅僅是單一，而VS.NET需要你找標(biāo)簽，選擇它，然后點擊工作區(qū)右上角的關(guān)閉按鈕。
    除了在.NET Framework中支持的SQK Server,Oracle,OleDb和ODBC之外，C# Builder還支持Borland Data Provider(BDP)。DBP是一個可擴展的數(shù)據(jù)提供者，它能讓你使用相同的代碼連接到多種數(shù)據(jù)庫。當(dāng)前的數(shù)據(jù)庫支持包括：Borland InterBase,IBM DB2,Microsoft SQL Server和Oracle 9i。在完成本文時，Borland正在增加對許多新數(shù)據(jù)庫的支持，在我看來，在可預(yù)見的將來，它將繼續(xù)這樣做下去。
    VS.NET和C# Builder都有代碼瀏覽器來用查看個體之間的關(guān)系。但是C# Builder的專業(yè)版和更高版本還包括了一個叫做Model View的應(yīng)用程序圖表。它是基本標(biāo)準(zhǔn)的UML圖表，能夠讓你查看應(yīng)用程序各個對象之間的關(guān)系，從而進一步查看他們的內(nèi)容，還可以在模式和代碼之間導(dǎo)航。雖然這些僅僅是查看功能，但是它卻幫助你怎么樣把一個應(yīng)用程序放在一起才是最好的。而VS.NET卻沒有這個功能。
    最后，C# Builder中還IDE中引入UML的建模技術(shù)，這項技術(shù)提供了一個在設(shè)計時的功能，即：開發(fā)者和建模者可以創(chuàng)建UML模型，同時它的代碼也是更新過的。同樣的，代碼的改變也將立即引起UML模型的改變。沒有內(nèi)部的模型轉(zhuǎn)換和描述就意為著在代碼和模型之間有直接的相互作用。
    另一個讓人興奮的是C# Builder建模是企業(yè)核心對象，或者是ECO(pronounced eek0)。ECO是一個能在運行時建模功能，它是OMG（Object Management Group）MDA(Model Driver Architecture)所追求的目標(biāo)。有了ECO，你可以創(chuàng)建新的模型或者導(dǎo)入已經(jīng)存在的從其它建模工具創(chuàng)建的XML模型。ECO的主要功能包括：數(shù)據(jù)的持久性，數(shù)據(jù)處理，安全性和數(shù)據(jù)綁定等的支持。ECO模型也能適應(yīng)由數(shù)據(jù)庫計劃引起的變化。VS.NET沒有提供這一功能。

生命周期的管理

    Borland首先命名了應(yīng)用程序周期管理（ALM），把這個管理工具包含到我們的項目中，我們能夠協(xié)調(diào)我們的工作。ALM被分成了六個明確的階段，包括：定義（Define），設(shè)計（Design），開發(fā)（Develop），測試（Test），配置（Deploy）和管理（Manage）。ALM的重要性在于：在C# Builder的環(huán)境下工具集合的整合和相互操作。例如：CaliberRM（在定義階段需求分析管理的工具）被直接整合到了C# Builder中，以便把用戶的需求直接與開發(fā)者相聯(lián)系。ALM沒指定一種特定的方法論，但是它描述了一種支持靈活過程的方式。
    VS.NET與其它微軟的技術(shù)能整合得很好，如果第三方賣主獲得了VSIP(Visual Studio.NET Integration Program)那么他們也可以整合。微軟規(guī)定了MSF（Microsoft Solutions Framework），但是它在VS.NET中沒有完事的工具和向?qū)С绦騺韯?chuàng)建像ALM這樣的過程。
    在這篇文章中我還涉及到了許多方面，但是我選擇了我認(rèn)為最重要的問題。C# Builder和VS.NET在開你想要開發(fā)的各種.NET應(yīng)用程序方面都是十分出色的工具，不同點僅在于你創(chuàng)建的代碼。對于編輯代碼，我喜歡VS.NET的源代碼編輯器。但是從一個開發(fā)團隊來看，對于整個開發(fā)周期來說，C#Builder在工具的完整性和有效性方面要出色得多。我個人的觀點就是歡欣Borland進入.NET舞臺，并希望C# Builder在將來的版本中有更多的創(chuàng)新之處。在.NET舞臺的競爭中，毫無疑問，C#Builder和VS.NET的后繼版本都將有更多令人驚奇之處，而這些方面正是為了提高開發(fā)者的開發(fā)效率。（完）