《最新java-毕业论文外文文献翻译.doc》由会员分享，可在线阅读，更多相关《最新java-毕业论文外文文献翻译.doc（36页珍藏版）》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。
1、Four short words sum up what has lifted most successful individuals above the crowd: a little bit more.-author-datejava-毕业论文外文文献翻译Advantages of Managed CodeAdvantages of Managed CodeMicrosoft intermediate language shares with Java byte code the idea that it is a low-level language with a simple synt
2、ax , which can be very quickly translated into native machine code. Having this well-defined universal syntax for code has significant advantages.Platform independenceFirst, it means that the same file containing byte code instructions can be placed on any platform; at runtime the final stage of com
3、pilation can then be easily accomplished so that the code will run on that particular platform. In other words, by compiling to IL we obtain platform independence for .NET, in much the same way as compiling to Java byte code gives Java platform independence.Performance improvementIL is actually a bi
4、t more ambitious than Java byte code. IL is always Just-In-Time compiled (known as JIT), whereas Java byte code was often interpreted. One of the disadvantages of Java was that, on execution, the process of translating from Java byte code to native executable resulted in a loss of performance.Instea
5、d of compiling the entire application in one go (which could lead to a slow start-up time), the JIT compiler simply compiles each portion of code as it is called (just-in-time). When code has been compiled.once, the resultant native executable is stored until the application exits, so that it does n
6、ot need to be recompiled the next time that portion of code is run. Microsoft argues that this process is more efficient than compiling the entire application code at the start, because of the likelihood that large portions of any application code will not actually be executed in any given run. Usin
7、g the JIT compiler, such code will never be compiled.This explains why we can expect that execution of managed IL code will be almost as fast as executingnative machine code. What it doesnt explain is why Microsoft expects that we will get a performanceimprovement. The reason given for this is that,
8、 since the final stage of compilation takes place at runtime, the JIT compiler will know exactly what processor type the program will run on. This means that it can optimize the final executable code to take advantage of any features or particular machine code instructions offered by that particular
9、 processor.实际上，IL比Java字节代码的作用还要大。IL总是即时编译的(简称JIT)，而Java字节代码常常是解释型的，Java的一个缺点是，在运行应用程序时，把Java字节代码转换为内部可执行代码的过程可可能导致性能的损失。JIT编译器并不是把整个应用程序一次编译完(这样会有很长的启动时间)，而是只编译它调用的那部分代码。代码编译过一次后，得到的内部可执行代码就存储起来，直到退出该应用程序为止，这样在下次运行这部分代码时，就不需要重新编译了。Microsoft认为这个过程要比一开始就编译整个应用程序代码的效率高得多，因为任何应用程序的大部分代码实际上并不是在每次运行过程中都执行
10、。使用JIT编译器，从来都不会编译这种代码从来都不会被编译。这解释了为什么托管IL代码的执行几乎和内部机器代码的执行速度一样快，但是并没有说明为什么Microsoft认为这会提高性能。其原因是编译过程的最后一部分是在运行时进行的，JIT编译器确切地知道程序运行在什么类型的处理器上，利用该处理器提供的任何特性或特定的机器代码指令来优化最后的可执行代码。传统的编译器会优化代码，但它们的优化过程是独立于代码所运行的特定处理器的。这是因为传统的编译器是在发布软件之前编译为内部机器可执行的代码。即编译器不知道代码所运行的处理器类型，例如该处理器是x86兼容处理器或Alpha处理器，这超出了基本操作的范围
11、。例如Visual Studio 6优化了一台一般的Pentium机器，所以它生成的代码就不能利用Pentium III处理器的硬件特性。相反，JIT编译器不仅可以进行Visual Studio 6所能完成的优化工作，还可以优化代码所运行的特定处理器。Traditional compilers will optimize the code, but they can only perform optimizations that are independent of the particular processor that the code will run on. This is beca
12、use traditional compilers compile to native executable before the software is shipped. This means that the compiler doesnt know what type of processor the code will run on beyond basic generalities, such as that it will be an x86-compatible processor or an Alpha processor. Visual Studio 6, for examp
13、le, optimizes for a generic Pentium machine,so the code that it generates cannot take advantage of hardware features of Pentium III processors. Onthe other hand, the JIT compiler can do all the optimizations that Visual Studio 6 can, and in addition itwill optimize for the particular processor the c
14、ode is running on.Language interoperabilityThe use of IL not only enables platform independence; it also facilitates language interoperability. Simply put, you can compile to IL from one language, and this compiled code should then be interoperable with code that has been compiled to IL from another
15、 language.Youre probably now wondering which languages aside from C# are interoperable with .NET, so letsbriefly discuss how some of the other common languages fit into .NET.Visual Basic .NETVisual Basic .NET has undergone a complete revamp from Visual Basic 6 to bring it up-to-date with .NET. The w
16、ay that Visual Basic has evolved over the last few years means that in its previous version, Visual Basic 6, it was not a suitable language for running .NET programs. For example, it is heavily integrated into COM and works by exposing only event handlers as source code to the developermost of the b
17、ackground code is not available as source code. Not only that, it does not support implementation inheritance, and the standard data types Visual Basic 6 uses are incompatible with .NET. Visual Basic 6 was upgraded to Visual Basic .NET, and the changes that were made to the language are so extensive
18、 you might as well regard Visual Basic .NET as a new language. Existing Visual Basic 6 code does not compile as Visual Basic .NET code. Converting a Visual Basic 6 program to Visual Basic .NET requires extensive changes to the code. However, Visual Studio .NET (the upgrade of VS for use with .NET) c
19、an do most of the changes for you. If you attempt to read a Visual Basic 6 project into Visual Studio .NET, it will upgrade the project for you, which means that it will rewrite the Visual Basic 6 source code into Visual Basic .NET source code. Although this means that the work involved for you is h
20、eavily cut down, you will need to check through the new Visual Basic .NET code to make sure that the project still works as intended because the conversion might not be perfect.One side effect of this language upgrade is that it is no longer possible to compile Visual Basic .NET to native executable
21、 code. Visual Basic .NET compiles only to IL, just as C# does. If you need to continue coding in Visual Basic 6, you may do so, but the executable code produced will completely ignore the .NET Framework, and youll need to keep Visual Studio 6 installed if you want to continue to work in this develop
22、er environment.Visual C+ .NETVisual C+ 6 already had a large number of Microsoft-specific extensions on Windows. With Visual C+ .NET, extensions have been added to support the .NET Framework. This means that existing C+ source code will continue to compile to native executable code without modificat
23、ion. It also means, however, that it will run independently of the .NET runtime. If you want your C+ code to run within the .NET Framework, then you can simply add the following line to the beginning of your code:#using You can also pass the flag /clr to the compiler, which then assumes that you wan
24、t to compile to managedcode, and will hence emit IL instead of native machine code. The interesting thing about C+ isthat when you compile to managed code, the compiler can emit IL that contains an embedded nativeexecutable. This means that you can mix managed types and unmanaged types in your C+ co
25、de. Thusthe managed C+ code:class MyClassdefines a plain C+ class, whereas the code:_gc class MyClasswill give you a managed class, just as if youd written the class in C# or Visual Basic .NET. The advantageof using managed C+ over C# code is that we can call unmanaged C+ classes from managed C+code
26、 without having to resort to COM interop.The compiler raises an error if you attempt to use features that are not supported by .NET on managedtypes (for example, templates or multiple inheritance of classes). You will also find that you will need touse nonstandard C+ features (such as the _gc keywor
27、d shown in the previous code) when usingmanaged classes.Because of the freedom that C+ allows in terms of low-level pointer manipulation and so on, the C+compiler is not able to generate code that will pass the CLRs memory type safety tests. If its importantthat your code is recognized by the CLR as
28、 memory type safe, then youll need to write your source codein some other language (such as C# or Visual Basic .NET).Visual J# .NETThe latest language to be added to the mix is Visual J# .NET. Prior to .NET Framework 1.1, users wereable to use J# only after making a separate download. Now the J# lan
29、guage is built into the .NETFramework. Because of this, J# users are able to take advantage of all the usual features of Visual Studio.NET. Microsoft expects that most J+ users will find it easiest to use J# if they want to work with .NET.Instead of being targeted at the Java runtime libraries, J# u
30、ses the same base class libraries that the restof the .NET compliant languages use. This means that you can use J# for building ASP.NET Web applications,Windows Forms, XMLWeb services, and everything else that is possiblejust as C# and VisualBasic .NET can.Scripting languagesScripting languages are
31、still around, although, in general, their importance is likely to decline with theadvent of .NET. JScript, on the other hand, has been upgraded to JScript .NET. We can now write ASP.NETpages in JScript .NET, run JScript .NET as a compiled rather than an interpreted language, and writestrongly typed
32、JScript .NET code. With ASP.NET there is no reason to use scripting languages in serversideWeb pages. VBA is, however, still used as a language for Microsoft Office and Visual Studio macros.COM and COM+Technically speaking, COM and COM+ arent technologies targeted at .NET, because components basedon
33、 them cannot be compiled into IL (although its possible to do so to some degree using managed C+, ifthe original COM component was written in C+). However, COM+ remains an important tool, becauseits features are not duplicated in .NET. Also, COM components will still workand .NET incorporatesCOM int
34、eroperability features that make it possible for managed code to call up COM components andvice versa (this is discussed in Chapter 29). In general, however, you will probably find it more convenientfor most purposes to code new components as .NET components, so that you can take advantage of the.NE
35、T base classes as well as the other benefits of running as managed code.托管代码的优点Microsoft中间语言与Java字节代码共享一种理念：它们都是一种低级语言，语法很简单，可以非常快速地转换为机器码。对于代码来说，这种精心设计的通用语法，有很大的优点。1. 平台无关性首先，这意味着包含字节代码指令的同一个文件可以放在任一个平台中，运行时编译过程的最后阶段可以很容易完成，这样代码就可以运行在该特定的平台上。也就是说编译为中间语言就可以获得.NET平台无关性，这与编译为Java字节代码就会得到Java平台无关性是一样的。
36、2. 提高性能实际上，IL比Java字节代码的作用还要大。IL总是即时编译的(简称JIT)，而Java字节代码常常是解释型的，Java的一个缺点是，在运行应用程序时，把Java字节代码转换为内部可执行代码的过程可可能导致性能的损失。JIT编译器并不是把整个应用程序一次编译完(这样会有很长的启动时间)，而是只编译它调用的那部分代码(这是其名称由来)。代码编译过一次后，得到的内部可执行代码就存储起来，直到退出该应用程序为止，这样在下次运行这部分代码时，就不需要重新编译了。Microsoft认为这个过程要比一开始就编译整个应用程序代码的效率高得多，因为任何应用程序的大部分代码实际上并不是在每次运行过
37、程中都执行。使用JIT编译器，从来都不会编译这种代码。这解释了为什么托管IL代码的执行几乎和内部机器代码的执行速度一样快，但是并没有说明为什么Microsoft认为这会提高性能。其原因是编译过程的最后一部分是在运行时进行的，JIT编译器确切地知道程序运行在什么类型的处理器上，利用该处理器提供的任何特性或特定的机器代码指令来优化最后的可执行代码。传统的编译器会优化代码，但它们的优化过程是独立于代码所运行的特定处理器的。这是因为传统的编译器是在发布软件之前编译为内部机器可执行的代码。即编译器不知道代码所运行的处理器类型，例如该处理器是x86兼容处理器或Alpha处理器，这超出了基本操作的范围。例如
38、Visual Studio 6优化了一台一般的Pentium机器，所以它生成的代码就不能利用Pentium III处理器的硬件特性。相反，JIT编译器不仅可以进行Visual Studio 6所能完成的优化工作，还可以优化代码所运行的特定处理器。3. 语言的互操作性使用IL不仅支持平台无关性，还支持语言的互操作性。简言之，就是能将任何一种语言编译为中间代码，编译好的代码可以与从其他语言编译过来的代码进行交互操作。那么除了C#之外，还有什么语言可以通过.NET进行交互操作呢？下面就简要讨论其他常见语言如何与.NET交互操作。(1) VB.NETVisual Basic 6在升级到Visual B
39、asic .NET时，经历了一番脱胎换骨的变化。Visual Basic是在最近的几年中演化的，其早期版本Visual Basic 6并不适合运行.NET程序。例如，它与COM的高度集成，且只把事件处理程序作为源代码显示给开发人员，大多数后台代码不能用作源代码。另外，它不支持继承，Visual Basic使用的标准数据类型也与.NET不兼容。Visual Basic 6已经升级为Visual Basic .NET，对VB进行的改变非常大，完全可以把Visual Basic .NET当作是一种新语言。现有的VB6代码不能编译为VB.NET代码，把VB6程序转换为VB.NET时，需要对代码进行大量
40、的改动，但大多数修改工作都可以由Visual Studio .NET(VS的升级版本，用于与.NET一起使用)自动完成。如果要把一个VB6项目读取到Visual Studio .NET中，Visual Studio .NET就会升级该项目，也就是说把VB6源代码重写为VB.NET源代码。虽然这意味着其中的工作已大大减轻，但用户仍需要检查新的VB.NET代码，以确保项目仍可正确工作，因为这种转换并不十分完美。这种语言升级的一个副作用是不能再把VB.NET编译为内部可执行代码了。VB.NET只编译为中间语言，就像C#一样。如果需要继续使用VB6编写程序，就可以这么做，但生成的可执行代码会完全忽略.
41、NET Framework，如果继续把Visual Studio作为开发环境，就需要安装Visual Studio 6。(2) Visual C+ .NETVisual C+ 6有许多Microsoft对Windows的特定扩展。通过Visual C+ .NET，又加入了更多的扩展内容，来支持.NET Framework。现有的C+源代码会继续编译为内部可执行代码，不会有修改，但它会独立于.NET运行库运行。如果要让C+代码在.NET Framework中运行，就要在代码的开头添加下述命令：#using 还要把标记/clr传递给编译器，编译器假定要编译托管代码，因此会生成中间语言，而不是内部机
42、器码。C+的一个有趣的问题是在编译托管代码时，编译器可以生成包含内嵌本机可执行代码的IL。这表示在C+代码中可以把托管类型和非托管类型合并起来，因此托管C+ 代码：class MyClass定义了一个普通的C+类，而代码：_gc class MyClass生成了一个托管类，就好像使用C#或VB.NET编写类一样。实际上，托管C+比C#更优越的一点是可以在托管C+代码中调用非托管C+类，而不必采用COM交互功能。如果在托管类型上试图使用.NET不支持的特性(例如，模板或类的多继承)，编译器就会出现一个错误。另外，在使用托管类时，还需要使用非标准的C+特性(例如上述代码中的_gc关键字)。因为C+
43、允许低级指针操作，C+编译器不能生成可以通过CLR内存类型安全测试的代码。如果CLR把代码标识为内存类型安全是非常重要的，就需要用其他一些语言编写源代码，例如C# 或VB.NET。(3) Visual J#最新添加的语言是Visual J#。在.NET Framework 1.1版本推出之前，用户必须下载相应的软件，才能使用J#。现在J#语言内置于.NET Framework中。因此，J#用户可以利用Visual Studio .NET的所有常见特性。Microsoft希望大多数J+用户认为他们在使用.NET时，将很容易使用J#。J#不使用Java运行库，而是使用与其他.NET兼容语言一样的基
44、类库。这说明，与C#和VB.NET一样，可以使用J#创建ASP.NET Web应用程序、Windows窗体、XML Web服务和其他应用程序。(4) 脚本语言脚本语言仍在使用之中，但由于.NET的推出，一般认为它们的重要性在降低。另一方面，JScript升级到JScript.NET。ASP.NET页面可以用JScript.NET编写，现在可以把JScript.NET当作一种编译语言来运行，而不是解释性的语言，也可以编写输入量比较大的JScript.NET代码。有了ASP.NET后，就没有必要在服务器端的Web页面上使用脚本语言了，但VBA仍用作Office文档和Visual Studio宏语言。(5) COM和COM+从技术上讲，COM 和 COM+并不是面向.NET的技术，因为基于它们的组件不能编译为IL(但如果原来的COM组件是用C+编写的，使用托管C+，在某种程度上可以这么做)。但是，COM+仍然是一个重要的工具，因为其特性没有在.NET中完全实现。另外，COM组件仍可以使用.NET组合了COM的互操作性，从而使托管代码可以调用COM组件，COM组件也可以调用托管代码(见第29章)。在大多数情况中，把新组件编写为.NET组件，其多数目的是为了更加方便，因为这样可以利用.NET基类和托管代码的其他优点。-