回 帖 发 新 帖 刷新版面

主题:请高\手翻译下谢谢

Why VCL for .NET 
Why VCL for .NET? - by Danny Thorpe 


Abstract: Why did Borland create VCL for .NET, and when should you use it instead of .NET's own Windows Forms framework? 
Delphi 8 for .NET is kicking up enormous excitement in the Delphi community! Newsgroups, chat rooms, and user group coffee klatsches are abuzz with questions about the .NET infrastructure and how it relates to the Win32 platform we're all familiar with.  

One topic that has been generating a bit of heated discussion is Delphi 8's VCL for .NET. Most of the arguments seem to be over what VCL for .NET's purpose is in the grand scheme of things. Is it a short-term migration bridge or a long-term application framework? Why would Borland create something that competes with Microsoft's WinForms? "Tastes great" or "Less filling"?  

Ok kids, settle down. There's no need to come to blows over this, really. Here's the story.  

Background 
Microsoft's .NET Framework supplies a hardware-independent execution environment and language-agnostic type system. That's great, but not enough for producing client applications for the Windows operating system. .NET also includes a Windows Forms ("WinForms") application framework for building graphical applications for the Win32 operating system. Coders familiar with Borland's VCL application framework in Delphi and C++Builder will recognize many of the design patterns in .NET's WinForms framework. That should come as no great surprise: as Anders Hejlsberg noted, "Good ideas don't just go away."  
For all the similarities between VCL and WinForms, though, there are just enough core differences to make porting existing Win32 VCL applications to WinForms very difficult. Difficult means painful, and pain inhibits adoption of new ideas... as well as sales of tools to take you there.  

.NET is a new platform. Even with all of the new activity now going on in .NET in the software industry, .NET application development is still just a drop in the bucket compared to existing and ongoing Win32 development. In our early inquiries to determine customer interest in the .NET platform, it was very clear that while many Borland customers had speculative interest in .NET, they could not afford to abandon everything they had invested in Win32 to start from scratch on a new .NET platform. That is still true today, and will continue to be true for many years.  

It's a snap to create a WinForms application in Delphi 8 for .NET. Existing Delphi developers told us "That's great, but what do we do with all this VCL code we've built up and rely upon for our business?"  

To "sweeten the deal" and make the .NET platform even more attractive to existing Delphi developers, something was needed to bridge the chasm between existing Win32 development and new .NET development. It needed to be as pure .NET as the .NET Framework itself, and it needed to provide a very high degree of compatibility with the existing Win32 VCL architecture. What Delphi for .NET needed to entice existing VCL developers was an implementation of VCL on the .NET platform.  

We first considered implementing VCL on top of the WinForms framework. After a bit of research, it became clear that the same architectural differences that made it difficult to port VCL apps to WinForms would make it difficult to build a VCL layer on top of WinForms - and still function in a VCL way.  

What we noticed in evaluating WinForms was that WinForms sits right on top of Win32 API calls. WinForms window classes call CreateWindow() to create Win32 window handles, they hook the Win32 WndProc to listen to window messages and fire related events within the class, and so on and so forth.  

Just like VCL.  

If Win32 API calls from managed .NET code are good enough for the .NET Framework, they should be good enough for VCL! The process of implementing VCL on the .NET platform then became a matter of figuring out how to make the Win32 API calls that the existing VCL architecture relies upon and make as few changes to the VCL code itself as we could manage.  



回复列表 (共8个回复)

沙发


The Case for VCL for .NET 
VCL for .NET is an evolution and continuation of the VCL architecture that stands toe to toe with Microsoft's WinForms architecture. WinForms and VCL for .NET both sit on top of Win32 API calls and thus have similar platform restrictions and similar performance characteristics. There are even potential opportunities for VCL to perform better than WinForms, since VCL implements handle sharing for pens and brushes and DCs that WinForms does not. Fine-tuning and exploiting those performance opportunities are ongoing tasks for the Delphi development team, just as fine-tuning the performance of WinForms and the .NET platform is an ongoing task for Microsoft.  
VCL has proven itself adaptable to platform change - from 16 bit Windows to 32 bit Win95 and NT to QT based CLX on Linux. WinForms is inextricably tied to .NET, and to large degree to Win32.  

Rant: While .NET Compact Frameworks implements many classes from the WinForms namespaces, so many things on CF are different or just plain missing that I don't consider CF WinForms compatible with Win32 WinForms in any meaningful sense. Microsoft apparently concedes this point, since they made the .NET CF execution environment binary incompatible with Win32 .NET exe's. The .NET CF system assemblies are strong-named using a different key than the Win32 .NET system assemblies, so Win32 .NET exe's will fail to load on CF devices. The only way to get to .NET CF is to recompile from source and link against the CF assemblies themselves.  

Migrating code from Win32 VCL to VCL for .NET is fairly simple for application code, but will probably require a bit more work for components that work more closely to the Win32 API metal. This is very similar to the porting expectations for CLX. However, Delphi developers should find that VCL for .NET requires less effort to port from Win32 VCL than CLX required to port from Win32 VCL. VCL for .NET changes the execution environment considerably, but implements nearly the same message handling, exception handling, and Win32 API support as Win32 VCL. CLX had to sacrifice message handling and Win32 API support to live on the Linux platform.  

VCL for .NET migration is not a one-way street. Application code written for VCL for .NET can also migrate back to Win32 VCL within reasonable bounds. Again, code that operates closer to the metal (such as custom controls) will be more difficult to maintain same-source across platforms than application business logic written in non-exotic Delphi syntax. (Non-exotic meaning avoiding dubious typecasts and pointer arithmetic.)  

Writing applications using C# requires the developer to completely abandon their existing code and developer experience and start from scratch in .NET. C# requires the developer to fully commit to .NET platform lock-in. There is no C# implementation on other platforms. (Yes, there is Mono on Linux, but it has not implemented UI / WinForms support so it's not a complete solution for client application development yet.) VB.NET is pretty much in the same boat, as VB.NET users have complained bitterly about fundamental language incompatibilities that make migrating code between VB.NET and VB6 more hazardous than rewriting from scratch.  

Writing code in the Delphi language for the .NET platform does offer the option of migrating that code to other non-.NET platforms (Windows and Linux). Writing applications in VCL for .NET offers application migration options that simply don't exist for any other .NET language.  


VCL for .NET is for Delphi Coders 
The VCL architecture relies on several powerful features of the Delphi language that are not commonly available in other .NET languages (including C#). Therefore, I do not expect C# or VB programmers to have much interest in VCL for .NET. C# code can use VCL for .NET components, but some aspects of VCL (such as virtual constructors) will be awkward and non-obvious to use in C#.  
GUI controls implemented in VCL for .NET will be of interest only to Delphi programmers, but not of much interest to C# or VB.NET programmers.  

Non-visual components, utility classes, and business logic can be implemented in Delphi and easily used by C# or VB.NET programmers, if the Delphi developer keeps in mind the kinds of syntax that are uniquely Delphi and not well understood by C# or other .NET languages, such as virtual class methods, virtual constructors, sets, AnsiStrings, and class references.  

VCL for .NET forms can host WinForms controls. Delphi developers writing VCL for .NET applications can use both VCL for .NET components and controls as well as any WinForms components and controls.  

Perhaps even more important than actual source code compatibility is developer skill set compatibility. Developers familiar with VCL are immediately familiar with VCL for .NET. How you create an application, or create a custom component, or create a custom message handler are all exactly the same in VCL for .NET as in Win32 VCL. VCL for .NET enables experienced Delphi developers to be productive on the .NET platform immediately, avoiding the typical three to six months of idle time lost to reeducating the developer for a different application framework architecture.  

板凳



Delphi Language Independent of VCL 
VCL for .NET depends upon features of the Delphi language, but the Delphi language does not require VCL. You can write WinForms applications using Delphi syntax without dragging VCL for .NET into the app. You can also write WinForms applications using Delphi RTL utility functions and classes you are accustomed to, so that you don't have to lose time wondering what the .NET equivalent of Delphi's IntToStr() is, for example.  
Every programming language must define how it binds its language concepts to the available constructs of the underlying platform. In .NET, those underlying constructs can include code as well as core language types. The Delphi language includes concepts and semantics that CLR does not implement, so Delphi requires a bit of code in the language binding to backfill what CLR does not provide. This language binding may be linked directly into your Delphi application exe or assembly, or you may link to an external assembly (package) called Borland.Delphi.dll.  

Every .NET language has such a language binding library. VB.NET's Microsoft.VisualBasic.dll weighs in at 300k. JScript's Microsoft.JScript.dll runs about 700k. C#'s language binding library is between 3 and 20MB, depending on whether you draw the line at mscorlib.dll and System.dll or count all of the .NET Framework as C#'s required minimum install. Delphi's Borland.Delphi.dll is less than 64k in size.  

Delphi for .NET is of interest to people with investments in VCL source code and developer skill set (using VCL for .NET), as well as people interested in starting new projects from scratch to run only on the .NET platform (using WinForms).  

Changes Ahead 
On the Microsoft long-term platform / OS roadmap, there indications that significant changes are in store for us all in the next major release of the Windows operating system. Specifically, the Microsoft operating system code-named "Longhorn" will incorporate a major shift in UI appearance and underlying implementation. The Win32 API will become a compatibility layer that sits between legacy Win32 apps and the actual OS presentation layer. Microsoft is already building a new application framework ("Avalon") for the Longhorn OS. You can read more about that on MSDN.  
Change can be scary at times, so it's good to hear from Microsoft that WinForms apps will continue to work in Longhorn and beyond. VCL for .NET is built on the same footing as WinForms, so VCL for .NET apps should also continue to run in Longhorn and beyond. VCL has been through the platform migration wringer a few times (Win16 to Win32, Win32 to Linux, and now Win32 to .NET) more than WinForms, so it's reasonable to surmise that VCL for .NET might adapt to the changes expected in Longhorn more readily than WinForms.  

This all adds up to making VCL for .NET an even stronger peer of the WinForms architecture. VCL for .NET has a much longer useful lifespan than just a temporary one-way bridge and a much better Return On Investment (ROI) for existing VCL applications than rewriting for WinForms.  

Why rewrite your application? Migrate your existing VCL applications to VCL for .NET and get the same mileage with less effort. Even if VCL for .NET ends up in the same boat as WinForms down the road, VCL for .NET means better ROI right now than WinForms.  

That's why we built VCL for .NET.  

Conclusion 
Microsoft's Windows Forms application architecture for the .NET platform is a sound architecture intended solely for new application development. Getting into WinForms is expensive, though, since there is no migration path for existing source code.  
Borland's VCL for .NET architecture offers the best of both worlds for Delphi developers: it enables you to capitalize on your existing source code and developer experience to target a new and growing .NET platform with a minimum of downtime lost to retooling and retraining.  

Danny Thorpe 
Delphi Compiler Architect and .NET Team Lead 
Developer Tools Group 
Borland Software Corporation

3 楼

汗...

4 楼


没什么好汗的,外文翻译,哪年都这样,
我只是不想用金山翻译,把老师吓坏了!

5 楼

.................

6 楼


帮下忙啊,.,..省略号是什么意思啊,
对了,我想问下,.DELPHI中创建多个窗体是怎么创建的!

7 楼

窗体的创建可以分为动态和静态.静态的在文件的新建下可以,或者直接点击新建的窗体图标.动态的用命令application.createform(tform(i),form(i));//(i)代表你要创建的窗体的序号.对于一次性创建多个窗体,可以先声明一个窗体组
myform:array of TForm;
再给myform动态的分配空间
setlength(myform,n);//n表示要创建的窗体的个数
再动态生成窗体
for i:=0 to n-1 do
begin 
myform[i]:=TForm.create(self);
一系列初始化语句;
end;
并用myform[i].show//(非模态方式显示) 或者用myform[i].showmodal;//模态显示
进行窗体间的切换.

8 楼

多谢,偶试试!!!!

我来回复

您尚未登录,请登录后再回复。点此登录或注册