C # Chief Architect Anders Hejlsberg Interview
John Osborn
Glory translation
In July, O'Reilly edit John Osborn participated in the Microsoft Occupational Developer Meeting. Here, he interviewed the famous engineer, Microsoft .NET framework C # language chief architect Anders Hejlsberg interviewed. Anders Hejlsberg is widely known by one of the earliest languages on the PCS - Turbo Pascal. He license Turbo Pascal gave Borland, and then the team was able to create Delphi-an extremely successful visualized Client / Server application design tool. There is also a Microsoft C # product manager Tony Goodhew and O'Reilly Windows editing ron petrusha.
Osborn:
I have seen some news stories about C # (pronounced "see Sharp"), and note that there is a lot of views that seem to be like this, or in theory, C # is not Java clone is a Microsoft alternative to Java. If you come to advertise, what do you want people to comment on this language?
HEJLSBERG:
First, C # is not Java cloning. During the design C #, we examined many languages. We examined C . We examined Java, we examined MODULA 2, C, and we also examined SMALLTALK. Many languages have the same core idea we are interested in, such as deep object-oriented, simplified objects (Object-Simplification).
The key to C # and these other languages, especially Java, is very close to C , working hard in our design. C # From C directly borrowed most operators, keywords, and statements. We also retain many language features abandoned by Java. Why is there no enumeration in Java, what is the truth? I mean, what the theoretical basis is discarded? In C , enumeration is obviously a very meaningful concept. In C #, we retain an enumeration and make it safe. Also, the enumeration is not just intellectual, which is actually a strong type of value type that is derived from the .NET base library. If there is no styling conversion, enumeration type "foo" and enumeration type "BAR" is inseparable. I think this is an important difference. We also retain operator overload and type conversion. The overall structure of C # namespace is also very close to C .
However, beyond these traditional language negatives, a key goal of our design language is to make C # facing components. We join the language itself in all the concepts you need to write components. For example, Properties, Methods (Method), Events, Attributes, and Documentation (documentation), they are all equally language components. Our work made by the feature is brand new and innovative, and the utilization feature can be added to any object to add a type, scalable metadata. This is not seen in any other program language. C # is also the first language that combines the XML annotation tag, the compiler can be used directly from the source code.
Another important concept is what I said "One-stop-shoping software". Once you use C # write code, you have written everything. No longer need header files, IDL (interface definition language) files, guids, and complex interfaces. Because it is a self-contained unit, so once you can write the self-described code in this way, you can embed your software into the ASP page or implanted a variety of different environments, which is not previously impossible. . Let's go back to these key components concept. Whether language should support attributes or events, there are many arguments in the industry. That's right, we can use way to express this concept. We can use the active behavior of the program blocks such as "Get" or "SET". We can use interfaces and implement interface adapters and forward them to objects. This is achievable, just like object-oriented programming in the C language. Just it is more difficult, need more manual labor, in order to truly express your thoughts, you can finally do all the work. We think it is time, there should be a door language, making it easy to create components. In recent years, developers have created software components in recent years. They are not creating the entire application or the entire class library. Everyone is inheriting the components that inherited from the base components provided from the host environment. These components overload some methods and properties, which handle events and install the component back to the system. Establishing these concepts is the key to the first lesson.
Osborn:
When you have introduced C # recently, the first slide is written on the first slide: "The first face-oriented language in the C / C family".
HEJLSBERG:
Yes. This is one of my primary goals. We talk about everything is an object, which is also very important. It can be done like this like SmallTalk and Lisp languages, but the cost is high. I think C # contains some beautiful and interesting innovations so that the assembly is easier to develop. For example, packages and unpacking concepts. Packing can convert a value of a value type to an object, and the unpacking can make an object to a simple type value. This is also possible in previous perhaps, but we apply it to the language is a beautiful innovation.
We strive to avoid designing C # and .NET frameworks in the "ivory tower". We can't afford to override all the burdens of all our software. The industry is also can't afford, especially today we are moving to the Internet era. You have to be good at using you already have. So, I think interoperability is also critical. We are committed to providing programmers with all of the internet standards, such as HTTP, HTML, XML, and Microsoft technology that have existed. So you won't have the moment of the abyss - I find that there is no something you use under the new .NET framework, or when you realize that you want to take advantage of some already existing APIs or components. You have seen we have built all COM interoperability, you have seen the existing DLL (dynamic connection library) that you can use to use the DLLIMPORT feature; you have seen even if you can't you Wishing, we also have the concept of unsafe code. Insecured code allows you to write inline C code using the pointer, you can do unsafe modeling conversion, suppress memory to make it unforeseen garbage collection.
There are a lot of arguments about unsafe code, people seem to think that we are taking drugs or doing something else. I think this is a misunderstanding. The code will not only be managed only because it is marked "unsafe". Of course, we will not throw out unsafe pointers to make people vulnerable from an unsafe code from the Internet. The unsafe code is deeply constrained in the security system. We offer such flexibility: If you stay in this box, we will make the code more secure because the system knows what it wants to do. In fact, even if you write unsafe code, it doesn't mean that you leave the managed space. Therefore, your unsafe code will become more capable.
Osborn: Please tell me more about some mechanisms that handle unsafe codes in the hosted environment.
HEJLSBERG:
Ok. Describe an important feature of the hosted enforcement environment such as SmallTalk, Java, and .NET universal language, it provides a garbage collection mechanism. In order to provide a garbage collection mechanism, at least a modern garbage collector, a "marker and sweep" garbage collector, you must learn more about the code being executed more than the traditional non-hosting code. In order to find the dead object to exclude, you must be able to traverse the stack, find the root of all activities, and point out which objects are activities that are no longer accessed. However, in order to be able to achieve this goal, you must work closely with the code you execute. The code has to have better descriptive. It is going to tell you how it is distributed in the stack, where its local variable is in place.
When you write unsafe code in C #, you can do something that is not type, such as pointer operation. Of course, the code marked as unsafe is not absolutely executed in an untrusted environment. In order to make it, you must grant trust, otherwise the code will not be executed. From this point of view, there is no difference between and other local code, the real difference is that they still run in the managed space. The method you have written has a descriptor, which tells you which object is an activity, so, no matter when you enter these code, you don't have to cross the column boundary (Marshalling Boundary). Otherwise, when you enter non-descriptive, non-hosting code (such as through the Java local interface), you have to set a watermark or set a barrier on the stack. You have to list the quotes outside all boxes (arguments). Once you start using the object, you must be careful about what you touched, because the GC (garbage collector) is still running in another different thread. If you don't use some concealed methods to lock objects to properly suppress garbage collectors, it may remove objects. If you forget that, then you will not be lucky.
We use a different way. We said, "Let us integrate this into the language. Let us provide statements, such as Fixed declarations, which allows you to suppress objects and GC collaboration and integrate." Use this method, we provide best way, lead All existing code is forwarded together, instead of just abandoning them. This is a different design.
Osborn:
Therefore, the memory of the unsafe code you dealt, is actually under the monitoring of the garbage collector?
HEJLSBERG:
That's right, this is the case. However, just like the so-called "buyer is self-exclusive, no inclusion", it is not safe. You can get a pointer and do something wrong, of course, you can do the same mistake in your local code.
Osborn:
I think another confusing place is to understand where C # is stopped and generic when running. What is the innovation of C # language itself compared to it from a general runtime library?
HEJLSBERG:
Ok, I think this confusion comes from the fact that when people talk about Java, they don't really know which one is the runtime. When people talk about Java, some confusion happened. Which one is the language is running? What is they referred to when they talk about Java? Java, language? Java, syntax? Or Java, platform? People will mix these different aspects. Our way indicates that we want to be a multilingual platform. We will create a platform that allows you to make multilingual programming and share a common API (Application Programming Interface). Let us admit this, some people like to use COBOL programming, some people like to use Basic programming, some people like C , and some people will like to use C # - I hope. However, we will not try to tell you, forget all what you have done, we will not say, "Now there is only one language, there will be no further innovation in this competition." We said that the industry is friendly because of elasticity. What is Java comes? Its appearance is because some programming languages will also appear after it has existed before it. We want to create a platform, where you can prefer a language but will not deny the entire value orientation; we want to build a platform, it can be constantly innovating. Who is helping COBOL programmers today? Who will bring them into the web? You can only embide the Fujitsu COBOL to the ASP page on the .NET platform. I mean, it is truly revolutionary! Osborn:
Assume that the .NET platform supports multilingual, why choose C # instead of Visual Basic, C or even COBOL? What makes C # is coming?
HEJLSBERG:
First, C # can start us from a white paper. In other words, we don't have any backward compatible burden. This will obviously make things simple, regardless of the position from the realization or the position from the use. For example, in C #, we only have a class and always collect it. On the other hand, the hosted C has two sets because it is necessary to retain the procedure for non-garbage collection. Therefore, in C #, you only need to understand some simple concepts.
The language is an interesting thing, it is a taste; language is a serious thing, it is a way of lifestyle selection. I mean, we realize that we can't come out, "There is a platform, you can only use a language." Even in that platform can do all things, people may still don't like it. Syntax, they may like braces or some other block dividers. That is what they are familiar. That is to make them feel comfortable and productive and ability. We treat C programmers who think the language is too complex, and to provide a replacement for Java programmers who have lost some C and C language features. We seek a simplified C way and put into a multilingual platform, which provides greater interoperability and provides complete component concepts, and more.
Goodhew:
One interesting thing comes from our trace survey of developers, more than 60% of professional developers use two or more languages to create their applications. Especially when we ask what development tools they use, the answer we have received is: No object-oriented language will be the terminator and all programmers will use it. As Anders said earlier, people expect some symptoms that can meet what they do or their feelings. This is a personal choice, which is also the entire .NET platform - providing a developer's language implementation. I think we have a beautiful job. You basically do the same thing in Visual Basic.Net and C #. Visual Basic is still easy to accept for most programmers. C # has more activity space and is more powerful than VB. Osborn:
This means that more statements can be implemented in C #?
HEJLSBERG:
Yes. It means that you can get more capabilities by unsafe code.
Osborn:
That is to say, can not write unsafe code in VB?
HEJLSBERG:
Yes. No.
Goodhew:
However, basically, both languages can do the same thing. This is a fundamental change than Visual Studio 6. In Visual Studio 6.0, if you want to create multithreaded MTS objects, and you are a VB programmer, you have no trouble. You have to use C . Now, there is a .NET framework, you can use any language you like.
HEJLSBERG:
This is what I have said in the general meeting, .NET framework provides a consistent programming model. During the evolution of language and framework, we seem to have consistently tied a program language in a specific API and a specific programming method. VB is a fast application development tool; the MFC (Microsoft Basic Class) is a subclass; ASP is plugging something to the web page. In each case, your choice of programming model always determines the choice of your program language and available API. Every time you transform the framework, you have added the workload you learn from the new language and the API. We truly tried to unify all, we provide an API, a tool that supports visual design, and we also provide an elasticity that can optionally be suitable for your language.
Osborn:
I don't know what is the use of those like VBScript and JScript scripting languages?
HEJLSBERG:
One of the wonderful things under the .NET framework is to make the scripting language to compile. Take a look at the ASP (Today, it is called asp.net), now, in fact, running the true compiled code in your page. It is not late, dispatch-finding - If the user does not click on the page, you will not see the runtime error. ASP developers can use Visual Basi.Net complete power rather than VBScript. And the first time they can use Perl, Python, and other popular languages if they choose.
Petrusha:
Can the server JavaScript can now be compiled?
HEJLSBERG:
Yes, that's right.
Goodhew:
The .NET Framework allows the use of the scripting language like a language with a fully characteristic because they are now accessing a real programming frame, and access is the same base class API. You should look at what engages in jscript implementation have been completed. (Note: JScript is the implementation of Microsoft's ECMA 262 Language Norm (ECMAScript Version 3), only some small exceptions (JScript is a complete implementation of ECMA standards). Therefore, the .NET platform provides a general language framework, which has great benefits for script writingers.
Osborn:
We have discussed Java, C and scripting languages. On the PDC, I heard a lot of people arguing .NET IL (IL is a Microsoft intermediate language, all compilers must generate it to run on the .NET framework) and the Java byte size running in the Java virtual machine is nothingord. From your conversation, it is apparent that you don't agree with this. Do you mind going further commenting the difference between them?
HEJLSBERG:
I certainly disagree with this statement. First of all, the idea of ILS is a very old thought. You can trace this concept to UCSD PASCAL P-Machine (an early Personal Computer Pascal implementation) or SmallTalk. P-Code has been used by Basic and Visual Basic, a component of Word, using a P-Code engine inside because it is more streamlined. Therefore, P-CODE is not a new thing at all.
I think that I think we use the IL way to be interested in this: we give you a choice - if you want - you can control the timing of compiling or translate IL or translate the local code. In fact, using Managed C , you can generate local code directly from the source program. Managed C can also generate IL, just like C # and VB. When you install your code, we give you a compilation option, you can compile the IL cost code. Therefore, when you run them, there will be no instant compilation burden. We also give you an option for dynamic operation and compile code: instant compilation. With IL, it brings you a lot of convenience, such as it provides these capabilities: porting to different CPU architecture, introducing real types of security, and building security systems here.
I think our IL design and Java bytecode key differences are that we have made advanced decisions - no interpreter. Our code is always running locally. Therefore, even if IL is generated, you have never run an interpreter. We even provide different styles of JITS. For the compact framework, we have eConnojit, just like we call it, it is a very simple JIT (note: .NET Compact is a subset of .NET Framework, is transferred to other devices and Designed in the platform). For desktop version, we have a full functionality JIT. We can even share a backend JIT with our C compiler. However, this will be time consuming, so you should only use them when installing.
Once you make a decision that is biased with the local code rather than explaining the code, it will strongly affect the IL design. It changes the instructions that should be included, which type information should be included, and how it should be expressed. If you take a closer look, you will notice that they are very different if you look at the two IL (the translation: ie .NET IL and Java bytecode). In a sense, our IL is type neutral. There is no information for the specified quota type in the instruction. Further, it is inferred by something that has been staked. This way makes IL more streamlined. Anyway, a JIT compiler needs to know those information, so there is no reason to carry them in the instruction. Therefore, we finally made a different design decision, and this makes it easy to translate the IL translation cost.
Osborn:
What is the difference between explanation and how you described?
HEJLSBERG:
The core of the interpreter is a loop - some bytes from the P-Code stream, then enter a big Switch declaration, "Oh, this is the add instruction, so it is here, but this is not ..." and so on.
Interpreter analog CPU. We have reversed it, we only take a way, we have always taken a way, we translate the instructions as machine code. Now, in the case of ECONOJIT, the machine code is actually very simple. It only creates a list of calls and stack instructions, and calls the runtime auxiliary device, and then run the auxiliary. Of course, this code is performed faster than the interpretation code. Osborn:
Let me always build a word: you fully compile the code. So when you compile, BITS is fully ready to run, although the timing from IL translation into machine code may not be the same.
HEJLSBERG:
Yes. However, if it is in an environment where a memory is limited, you can discard the code.
Osborn:
Let us enter the grammatical details of the language. I am thinking, whether the C # includes built-in support for the regular expression. I have not seen it in the language reference, maybe it may be otherwise else.
HEJLSBERG:
First, there is a regular expression class in the base library. We did not join any direct support to regular expressions in the language, but in fact, we have some very similar features. It is not worthwhile to do with significant processing. However, for example, when you need to specify one, we give this ability: write a string one by one without having to write two rear slashes each time. When you write a regular expression, and when your regular expression is set, it actually has a lot of help. Although it is generally, this help is inadequate, but obviously its core is in the .NET framework, and this framework can be shared by any programming language.
Osborn:
C # and Java name space look different. Do they achieve the same concept?
HEJLSBERG:
Conceptually, but in realization, it is very different. In Java, the name of the package is also something in the physical sense, indicating the directory structure of your source code file. In C #, physical bags and logical names are completely independent, no matter how you call your name space, it is not related to your actual code. This gives you more flexibility - packages the physically distributed unit and does not force you to build a lot of directories. In the language itself, there are some obvious differences. In Java, the package is also your physical structure, so the Java source file must be in the correct path and can only include a public type or a utility. Because C # does not have that physical and logical bindings, you can name your source files anywhere. Each source file can be used by multiple namespaces and can have multiple common classes. For further words, if you like, you can write all the source code in a big file, or you can take the small files dispersed. Concept, C # compile what happens - you provide all the source files that make up your project, then it takes out what to do.
Osborn:
I have a problem about generic programming: Do you think it is an important concept? Should it be part of an object-oriented language? If so, how do you add generic program to a part of C #?
Goodhew:
Hey, the desire to incorporate generic programming in the first version is restricted. Because, it is not like each person, Microsoft does not have unlimited resources. For anything in this first version, we have to make some difficult decisions.
Osborn:
How many people participate in the development C #?
HEJLSBERG:
The language design group consists of 4 people, and the compiler group consists of another five developers.
Petrusha:
Frame?
HEJLSBERG:
That's more, the entire company is rolled out.
Goodhew:
For the entire Visual Studio and .Net platform team, our department has about a thousand people. Including program managers, developers, testers, including all construct functions, frames, runtime, ASP programming models, and other people, for example, my own, management. HEJLSBERG:
As far as you have just mentioned, I clearly think that it is a very useful concept, and you can of course include all generics in academia and industry. Template is a solution for this issue. In our internal discussion, we decided to do this in the new platform. But we really like to do it is to let the generics can be understood by the underlying runtime. This is different from how to create generic prototypes. With Java's "Erase" concept, there is no real generic information in the system. If you understand the concept of generic concepts, multiple languages can share this feature. You can write a generic class with C # in a place, other people can use it in other languages.
Make generics a part of the runtime, you can make you more efficiently. The most ideal time for generic instantiation is running at runtime. If you use C , you have two options when you are compile, you have two options: you can remove some expansion code when your code expansion or try to remove some expansion code when you are linked. However, if you have multiple applications, you may forget this, you will only get expanded code.
If generic knowledge is incorporated in a generic language, then it can be understood - when an application or component requests a "foo" list, it will first ask: "I already have an entity" foo " Is the list? "If so, use that one. In fact, if foo is a reference type, and if we design, we can let all reference types share an entity. For value types, such as integer and floating point, we can create an entity for each value type, but this should be done when applying requests. In order to join the generic joining, we have made a lot of design work and the necessary basic work.
What you previously mentioned about IL is interesting because the decision to join generics affects the design of IL. If the IL instruction is embedded, if a "plus" instruction is no longer a "plus", it is an integer "plus" or the floating point number "plus" or a double precision "plus", you Gring the type information to the instruction stream, in this point, IL is not generic. Our IL format is actually a real type neutral. Also, in order to keep the type neutral, we can add generics from time to time and will not give us trouble, at least not too much trouble. This is also one of our IL and Java's bytecode looks different. Our IL type is neutral. The "plus" instruction can add any two things on top of the stack. In the generic world, when it is physically, it can be converted into different code.
Osborn:
Can all .NET languages get generic capabilities?
HEJLSBERG:
Yes. Microsoft Cambridge Research Institute has created a versions of generic language running and C # compilers that support generic capabilities, and we are studying how to advance it as soon as possible. The first version is impossible to join generics, we know so much. But we are working to make sure we do the right thing in the first version, so that generics can be applied to the entire blueprint.
Osborn:
What is the date issued by the next version of the C # and .NET framework and Visual Studio?
Goodhew:
Hey, we brought technical preview for 6,500 people who came here to participate in PDC. We hope to release a beta version at some time in the fall of 2000, and then after you are ready, we release a formal version. One of the truly exciting things we do is to see how the Windows2000 release release is made to let key customers come in the process of cooperative development and cooperation deployment. Regarding the .NET framework and Visual Studio.Net, we will cooperate again with our customers to determine the date of issue of the final product. We intend to let them tell us when the product is ready. And, because there is a real customer involved in this process, we should get better product quality. The unfavorable side of this approach is to make the process development and release process a bit uncertain. But this is a fundamental change. We are looking for a product release method that breaks quality barriers, not just the date of challenge, say we have to ship. Osborn:
So, not a date of completion, we are looking for a date "ready to depart"?
Goodhew:
Yes, that's right. I think developers will find that the Visual Studio.net release is one of the highest quality releases in Microsoft's history.
Osborn:
You have already submitted C # to ECMA (Translation: European Computer Manufacturers Association). Is standardization really a serious goal? Do you want to use C # on other platforms?
HEJLSBERG:
indeed so! Providing C # as a possible standard to the industry is of course our goal, this is one of the reasons why we submit it to ECMA. In the process of guiding this language with common language infrastructure, (??) We certainly hope to get ECMA support. Regarding the general infrastructure, I mean a set of core class library sets specified in this specification, if other companies implement it with other platforms, they have reason to find out that they can use these classes in their programs.
Goodhew:
I want to point out that we are doing real open standards with ECMA. When ECMA is reached for C # and universal language infrastructure, the true openness will be realized under the copyright and licensing policies of ECMA. Any customer, anyone can license ECMA C # standard, subset, super-collection, and no payment. They can be implemented on any platform or on any device. We are completely hoped to do so. This is different from our competitors. They are in the standard, looking for a certain person to print in their private language.
John:
I heard about breakfast and lunch: "If Microsoft did not bring COM to infrastructure, how really may be possible?"
HEJLSBERG:
It is entirely possible. COM is not the standardization of C # and universal language infrastructure. Not at all. C # has a completely rich model, while COM is interoperability from another perspective. However, C # and general runtime cores have never been said to have COM, GUID, HRESULT, AddRef or Release, and more. not a single one. .NET universal language is completely abandoned, but it still gives you huge COM interoperability. Given the previous previous, I still think it will be very important, but it is not indispensable.
Goodhew:
I think these comments are due to the language specifications of our public version. Microsoft wrote it in a certain meeting. At that time, we believe it is very important in accordance with the Microsoft platform. As a result, we have quoted COM and DLL many times in the specification. How the DLL is on a given platform to activate a general question in the general problem of local code. One benefit of the collaboration in the collaboration between the standardized organization and the IBM (us and them to formulate SOAP specifications), you can make sure we don't do any such mention, to prevent us from being killed in the normative future version Or lock in something like a COM frame. As Anders says, COM interoperability and COM support are extremely important to us and existing Microsoft customers. I think I have a great job to support COM on .NET. However, people in the industry have read a lot of things we reference to COM and DLL words, which is quite designed for the .NET platform is only designed for Windows platforms, which is definitely wrong.
HEJLSBERG:
Also, I think it is important that COM interoperability is important to Microsoft and customers who build solutions on Microsoft Platforms. C # and universal language infrastructure standardization will allow this language to join in any other platform to join meaning. Major platform interoperability.
Osborn:
So will you not insist on "pure C #" and "pure .NET" implementation?
HEJLSBERG:
What is "pure"? How much "pure" Java application is really existed? I adventure guess, very very small. That is the number I estimate. Let us admit this, people want to use the code they have. It is impossible to tell those companies to throw away.
Goodhew:
Have you exchanged with Roger Sessions? (Note: Roger sessions is the president of ObjectWatch, and is the author of "COM AND THE BATTLE for the Middle Tier").
Osborn:
No.
Goodhew:
Roger talked about the relevant chapters of the EJB (Enterprise Javabeans), and there were manufacturers licensed expansion. Not surprisingly, vendor extensions include transaction management, security, message technology, and more other aspects, which is quite important in building enterprise-class systems. In an article [translation: http://www.objectWatch.com/issue_24.htm], Sessions roughly enumerated 11 field functions, which is the allowable manufacturer specification. So if you choose IBM WebSphere as your EJB implementation, your code written for your EJB will inevitably lock you on WebSphere. Java is a 100% pure and 100% portable concept is unrealistic. On the IBM's developer work site, there is a great interview with James Gosling (translation: http://www-106.ibm.com/developerworks/features). James gosling directly pointed out this. He said, yes, the whole "Write once everywhere", "100% pure things" is a stupid idea, more is something on marketing. He said, in fact, "We don't think we can deliver all this, basically, we can't do it." This is what the inventors of this language do not have any pureness and portability.
Osborn:
Do we have a great feature or innovation that is not disclosed, you are willing to add?
HEJLSBERG:
Regarding the entire .NET framework, implied, including C #, I want to mention: it is a means of building distributed applications. It is not a long time ago, we created two class-class client / server applications, and then the object protocols such as CORBA, IIOP, RMI, and DCOM came one after another. This type of programming is the basis of EJB (implemented in CORBA or RMI). We have constructed such a strongly connected distributed system, but they do not have scalability. They cannot expand in the Web because they are stateful, they keep in the server, you can't transfer it to another machine, insert it and let the relevant things copy yourself. At the beginning, when we sat down and set the .NET framework, we looked back at what happened to see what I had. It is becoming a loose connection, very distributed world. We strive to understand its impact on potential programming models. Therefore, we fundamentally assume that the distributed application is constructed in loose connection, there is no status style, and our design provides huge scalability, you only expand. You transfer to more frames and insert them into them. Once this fundamental assumption is made, everything will change. It changed how to design your basic services, how to design your message technology, and even desigrate your user interface. This is a new programming model. We have decided to use XML and SOAP as a way to make this model. They are deeply integrated into .NET, and this integration is so attentive for every decision made when we design .NET framework, it is not that kind of thing that you only come in, you can only go shopping. .
Osborn:
Can you point out some places for programmers?
HEJLSBERG:
A considerable example is how XML is integrated into C #. C # ATTRIBUTE, it allows you to add declarative information to types and members. Just like you can say that a member is public or private, you may want to say this is a business, or this assumption is a web service, or this assumption can be serialized to XML. Therefore, we join feature to provide general mechanisms, but we use it in all Web Service and XML infrastructure. We also give you the ability to modify the class and fields. In your class, you can say "When this class turns into XML, it should become a" this "tag name, and belongs to" this "XML name space." You will be able to specify a field to become an element, and Another change into an attribute (translation: Attribute, here refers to the properties in XML). You can also control the XML mode (translation: 即 schema); control it in your statement, so that all additional declarative information is available. Once in this way, characteristics is used to modify your C # code, the system can simply convert a specific class into XML, transfer online, you can rebuild the object on the other side when it is back. This is all done in one definition. It is not like a traditional definition file or a miscellaneous information and naming mode, it is there. When you create them in IDE, it gives you a complete statement. We can also provide more advanced tools to make it do this.
I know that I have a bit left, but the infrastructure we offer is indeed exciting. Because we have these features, you can request an XML serialized infrastructure or the Web Service infrastructure to convert the given classes into XML. When you do this, we will actually match XSD Schema for this class, and we will create a specialized parser, which is derived from our general XML parser (which is part of the .NET base class) Down, and override the method, and add logic to the parser, so it is specifically served. We have physicalized a parser and analyze XML at the speed of local code. If it is incorrect, we will give you a decent error message, it can tell you what is wrong. We can cache it in the code cache infrastructure, it will sit or wait until a class with the same mode is coming and will take action, "嘭!", I mean, incredible, incredible processing power! Osborn:
So, there is indeed a lot of interesting engines ...
HEJLSBERG:
Yeah. I think that in this field, we are a leader.
Osborn:
Wonderful. Thank you, delay you.
HEJLSBERG:
Welcome.
- Full text -
