Question:
what is .net?,highlights & goals,.net applications,.net framework architecture,CLS,CTS?
2007-01-13 06:19:54 UTC
MUST TO BE EASY TO UNDERSTAND IT IS FOR WRIRTING ASSIGNMENT AND DIAGRAMS MUST ALSO BE GIVEN.THEN I WANT THIS ANSWER WITHIN 2 HOURS IT'S VERY URGENT.
Four answers:
VinK
2007-01-13 06:52:33 UTC
Earlier the interenet applications development wasa big problem coz all the users scattered around the globe used different Operating systems, n the applications that worked on ones PC wud not work on someone elses PC, and then came a language as a blesssing, which we call Java, this language was platform independent, which means it runs the same on windows as well as linux, but then this is a product by Sun Microsystems.



Windows hence lost its ground and monopoly to some extent, so in order to compete with their arch rivals they came up with the .NET framework.

this again is a platform independent framework, meaning it has incorporated many other languages too, for the commercial application development, systems application development, at the same time developing web sites and making them platform independent..



the above said can be taken as the highlights, the goals as i said is to make it platform independent and also to regain the lost market share of the Microsoft..



The architecture and the diagrams wud be impossible to give in here, coz yahoo hasnt made ny provision for a diagramatic explanations, u see...



i m sure this is the best answer u can get in 2 hrs, n m confident this shud be enuf to get to the mks u r looking for in ur assignments...now gimme my 10 points plz..... :-)
Richard H
2007-01-13 10:45:53 UTC
.NET is a collection of programming languages, including Visual BASIC.NET, C#, J#, ADO.NET, and ASP.NET, used to create web-based application software. Visual BASIC.NET is the intro level language, and ADO.NET is used for accessing databases. BASIC stands for "Beginner's All-purpose Symbolic Instructions Code", and ADO stands for "ActiveX Data Objects". ADO can integrate with Microsoft Structured Query Language Serve (MS-SQL Server) to create powerful data driven web based applications. ADO.NET is an adaptor that allows the other languages (Visual BASIC.NET, C#, and J#) to access thte data stored in a database.
englin
2016-10-31 04:00:23 UTC
Its a poem already, having such genuine theory, pouring in a gradual gentle bypass. If i fairly were given the conception you want to precise, then the observe " doppelganger" or its Anglo version 'doubleganger', is a ought to for a efficient closure.that still is going for the "more suitable sturdy more suitable"; the bypass says that there are a variety of of (conceptual) words entangled between, earlier, and after those 2 words. A truly astounding examine!
Srivatsa HG
2007-01-13 11:01:31 UTC
.NET is not a collection of languages as somebody pointed out ...!!!!!!

It is just a platform on top of which other languages operates.



The Microsoft .NET Framework allows developers to leverage technologies more than any

earlier Microsoft development platform did. Specifically, the .NET Framework really delivers

on code reuse, code specialization, resource management, multilanguage development,

security, deployment, and administration. While designing this new platform, Microsoft also

felt it was necessary to improve on some of the deficiencies of the current Windows platform.

The following list gives you just a small sampling of what the CLR and the FCL provide:

§ Consistent programming model Unlike today, where some operating system

facilities are accessed via dynamic-link library (DLL) functions and other facilities are

accessed via COM objects, all application services are offered via a common objectoriented

programming model.

§ Simplified programming model The CLR seeks to greatly simplify the plumbing and

arcane constructs required by Win32 and COM. Specifically, the CLR now frees the

developer from having to understand any of the following concepts: the registry, globally

unique identifiers (GUIDs), IUnknown, AddRef, Release , HRESULTs, and so on. The

CLR doesn’t just abstract these concepts away from the developer; these concepts

simply don’t exist, in any form, in the CLR. Of course, if you want to write a .NET

Framework application that interoperates with existing, non-.NET code, you must still be

aware of these concepts.

§ Run once, run always All Windows developers are familiar with “DLL hell” versioning

problems. This situation occurs when components being installed for a new application

overwrite components of an old application, causing the old application to exhibit

strange behavior or stop functioning altogether. The architecture of the .NET

Framework now isolates application components so that an application always loads the

components that it was built and tested with. If the application runs after installation,

then the application should always run. This slams shut the gates of “DLL hell.”

§ Simplified deployment Today, Windows applications are incredibly difficult to set up

and deploy. Several files, registry settings, and shortcuts usually need to be created. In

addition, completely uninstalling an application is nearly impossible. With Windows

2000, Microsoft introduced a new installation engine that helps with all these issues, but

it’s still possible that a company authoring a Microsoft installer package might fail to do

everything correctly. The .NET Framework seeks to banish these issues into history.

The .NET Framework components (known simply as types) are not referenced by the

registry. In fact, installing most .NET Framework applications requires no more than

copying the files to a directory and adding a shortcut to the Start menu, desktop, or

Quick Launch bar. Uninstalling the application is as simple as deleting the files.

§ Wide platform reach When compiling source code for the .NET Framework, the

compilers produce common intermediate language (CIL) instead of the more traditional

CPU instructions. At run time, the CLR translates the CIL into native CPU instructions.

Because the translation to native CPU instructions is done at run time, the translation is

done for the host CPU. This means that you can deploy your .NET Framework

application on any machine that has an ECMA-compliant version of the CLR and FCL

running on it. These machines can be x86, IA64, Alpha, PowerPC, and so on. Users will

immediately appreciate the value of this broad execution if they ever change their

computing hardware or operating system.

§ Programming language integration COM allows different programming languages

to interoperate with one another. The .NET Framework allows languages to be

integrated with one another so that you can use types of another language as if they are

your own. For example, the CLR makes it possible to create a class in C++ that derives

from a class implemented in Visual Basic. The CLR allows this because it defines and

provides a Common Type System (CTS) that all programming languages that target the

CLR must use. The Common Language Specification (CLS) describes what compiler

implementers must do in order for their languages to integrate well with other

languages. Microsoft is itself providing several compilers that produce code targeting

the runtime: C++ with Managed Extensions, C#, Visual Basic .NET (which now

subsumes Visual Basic Scripting Edition, or VBScript, and Visual Basic for Applications,

or VBA), and JScript. In addition, companies other than Microsoft and academic

institutions are producing compilers for other languages that also target the CLR.

§ Simplified code reuse Using the mechanisms described earlier, you can create your

own classes that offer services to third-party applications. This makes it extremely

simple to reuse code and also creates a large market for component (type) vendors.

§ Automatic memory and management (garbage collection) Programming requires

great skill and discipline, especially when it comes to managing the use of resources

such as files, memory, screen space, network connections, database resources, and so

on. One of the most common bugs is neglecting to free one of these resources,

ultimately causing the application to perform improperly at some unpredictable time.

The CLR automatically tracks resource usage, guaranteeing that your application never

leaks resources. In fact, there is no way to explicitly “free” memory. In Chapter 19,

“Automatic Memory Management (Garbage Collection),” I explain exactly how garbage

collection works.

§ Type-safe verification The CLR can verify that all your code is type-safe. Type safety

ensures that allocated objects are always accessed in compatible ways. Hence, if a

method input parameter is declared as accepting a 4-byte value, the CLR will detect

and trap attempts to access the parameter as an 8-byte value. Similarly, if an object

occupies 10 bytes in memory, the application can’t coerce the object into a form that will

allow more than 10 bytes to be read. Type safety also means that execution flow will

transfer only to well-known locations (that is, method entry points). There is no way to

construct an arbitrary reference to a memory location and cause code at that location to

start executing. Together, these measures ensure type safety eliminating many

common programming errors and classic system attacks (for example, exploiting buffer

overruns).

§ Rich debugging support Because the CLR is used for many programming

languages, it is now much easier to implement portions of your application using the

language best suited to a particular task. The CLR fully supports debugging applications

that cross language boundaries.

§ Consistent method failure paradigm One of the most aggravating aspects of

Windows programming is the inconsistent style that functions use to report failures.

Some functions return Win32 status codes, some functions return HRESULTs, and

some functions throw exceptions. In the CLR, all failures are reported via exceptions—

period. Exceptions allow the developer to isolate the failure recovery code from the

code required to get the work done. This separation greatly simplifies writing, reading,

and maintaining code. In addition, exceptions work across module and programming

language boundaries. And, unlike status codes and HRESULTs, exceptions can’t be

ignored. The CLR also provides built-in stack-walking facilities, making it much easier to

locate any bugs and failures.

§ Security Traditional operating system security provides isolation and access control

based on user accounts. This model has proven useful, but at its core assumes that all

code is equally trustworthy. This assumption was justified when all code was installed

from physical media (for example, CD-ROM) or trusted corporate servers. But with the

increasing reliance on mobile code such as Web scripts, applications downloaded over

the Internet, and e-mail attachments, we need ways to control the behavior of

applications in a more code-centric manner. Code access security provides a means to

do this.

§ Interoperability Microsoft realizes that developers already have an enormous amount

of existing code and components. Rewriting all this code to take full advantage of the

.NET Framework platform would be a huge undertaking and would prevent the speedy

adoption of this platform. So the .NET Framework fully supports the ability for the

developer to access their existing COM components as well as call Win32 functions in

existing DLLs.

Users won’t directly appreciate the CLR and its capabilities, but they will certainly notice the

quality and features of applications that utilize the CLR. In addition, users and your

company’s bottom line will appreciate how the CLR allows applications to be developed and

deployed more rapidly and with less administration than Windows has ever allowed in the

past.


This content was originally posted on Y! Answers, a Q&A website that shut down in 2021.
Loading...