Common Language Infrastructure: Difference between revisions

Revision as of 02:14, 6 August 2002

Latest revision as of 12:36, 14 March 2025

(354 intermediate revisions by more than 100 users not shown)

Line 1:

{{Short description|Open specification for runtime environments}}

The '''Common Language Infrastructure''' is used in the [[Microsoft]] [[.NET]] initiative as the basis for running programs written in different [[programming language | programming languages]]. Before this [[Visual Basic]] for example has required a component <i>VBRUN</i> and Visual C++ uses <i>MSVCRT</i> for the compiled programs to run. The common language infrastructure is an effort to unify the different runtime modules needed.

{{Infobox technology standard

| title = Common Language Infrastructure

| status = Published

| year_started = {{Start date and age|2000}}

| version = Sixth edition

| version_date = {{Start date and age|2012|06}}

| organization = '''Developed by:''' [[Microsoft]], [[Hewlett-Packard]], [[Intel]], and others<br />

'''Standardized by:''' [[Ecma International|Ecma]], [[International Organization for Standardization|ISO]]/[[International Electrotechnical Commission|IEC]]

| related_standards =

| abbreviation = CLI

| ___domain = Common Language ([[Cross-platform]])

| website = {{URL|https://www.ecma-international.org/publications-and-standards/standards/ecma-335/|ECMA-335}},<br />{{URL|https://www.iso.org/standard/58046.html|ISO/IEC 23271}}

| long_name = ISO/IEC 23271:2012(E)

| first_published = {{Start date and age|2001}} (Ecma) and {{Start date and age|2003}} (ISO/IEC)

| committee = [[ISO/IEC JTC 1/SC 22]]

| license = [[Reasonable and non-discriminatory licensing|RAND]]

}}

The '''Common Language Infrastructure''' ('''CLI''') is an open [[specification]] and [[technical standard]] originally developed by [[Microsoft]] and standardized by [[International Organization for Standardization|ISO]]/[[International Electrotechnical Commission|IEC]] ('''ISO/IEC 23271''') and [[Ecma International]] ('''ECMA 335''')<ref name="iso_iec_23271_2012">{{cite web| url = http://www.iso.org/iso/home/store/catalogue_ics/catalogue_detail_ics.htm?csnumber=58046| title = ISO/IEC 23271:2012 - Information technology -- Common Language Infrastructure (CLI) |website=ISO |url-status=live |archive-url=https://web.archive.org/web/20230702003946/https://www.iso.org/standard/58046.html |archive-date= Jul 2, 2023 }}</ref><ref name="ecma_355_2012">{{cite web| url = https://www.ecma-international.org/publications-and-standards/standards/ecma-335/| title = ECMA-335 |issue=6th edition |date=June 2012 |website=ECMA International |url-status=live |archive-url=https://web.archive.org/web/20231016101943/https://www.ecma-international.org/publications-and-standards/standards/ecma-335/ |archive-date= Oct 16, 2023 }}</ref> that describes executable code and a runtime environment that allows [[List of CLI languages|multiple high-level languages]] to be used on different [[Computing platform|computer platforms]] without being rewritten for specific architectures. This implies it is platform agnostic. The [[.NET Framework]], [[.NET]] and [[Mono (software)|Mono]] are implementations of the CLI.

The [[metadata]] format is also used to specify the [[API]] definitions exposed by the [[Windows Runtime]].<ref>{{cite web| url = https://www.microsoftpressstore.com/articles/article.aspx?p=2199428&seqNum=3| title = Introduction to Advanced Windows Store App Development using HTML5 and JavaScript |website=Microsoft Press Store |date=Oct 15, 2013 |url-status=live |archive-url=https://web.archive.org/web/20230330075408/https://www.microsoftpressstore.com/articles/article.aspx?p=2199428&seqNum=3 |archive-date= Mar 30, 2023 }}</ref><ref>{{cite web| url = https://tirania.org/blog/archive/2011/Sep-15.html| title = WinRT demystified |first1=Miguel |last1=de Icaza |date=15 Sep 2011 |url-status=live |archive-url=https://web.archive.org/web/20231130221232/https://tirania.org/blog/archive/2011/Sep-15.html |archive-date= Nov 30, 2023 }}</ref>

==Overview==

It uses a [[virtual machine]] and a class library [[Common Language Runtime]]. (see Microsoft site [http://www.microsoft.com/partner/products/microsoftnet/CLRTechPage.asp]). There are many compilers being developed which produce code for this virtual machine. The code it executes is called Common Intermediate Language (CIL) or Microsoft Intermediate Language (MSIL).

[[File:Overview of the Common Language Infrastructure 2015.svg|thumb|280px|Visual overview of the Common Language Infrastructure (CLI)]]

Among other things, the CLI specification describes the following five aspects:

;The [[Common Type System]] (CTS)

:A set of [[data type]]s and operations that are shared by all CTS-compliant [[programming language]]s.

;The [[Metadata (CLI)|Metadata]]

:Information about program structure is [[Language-independent specification|language-agnostic]], so that it can be referenced between languages and tools, making it easy to work with code written in a language the developer is not using.

;The Common Language Specification (CLS)

:The CLS, a subset of the CTS, are rules to which components developed with/for the supported languages must adhere.

:They apply to consumers (developers who are programmatically accessing a component that is CLS-compliant), frameworks (developers who are using a language compiler to create CLS-compliant libraries), and extenders (developers who are creating a tool such as a language compiler or a code parser that creates CLS-compliant components).

;The [[Virtual Execution System]] (VES)

:The VES loads and executes CLI-compatible programs, using the metadata to combine separately generated pieces of code at runtime.

:All compatible languages compile to [[Common Intermediate Language]] (CIL), which is an [[intermediate language]] that is abstracted from the platform hardware. When the code is executed, the platform-specific VES will compile the CIL to the [[machine language]] according to the specific hardware and operating system.

:In the CLI standard initially developed by Microsoft, the VES is implemented by the [[Common Language Runtime]] (CLR).

;The [[Standard Libraries (CLI)|Standard Libraries]]

It seems that in the future there will be at least two major [[virtual machine]] technologies competing (see [[Java virtual machine]])

:A set of libraries providing many common functions, such as file reading and writing. Their core is the [[Standard Libraries (CLI)#Base Class Library|Base Class Library]] (BCL).

==Standardization and licensing==

In August 2000, [[Microsoft]], [[Hewlett-Packard]], [[Intel]], and others worked to standardize CLI. By December 2001, it was ratified by the [[Ecma International|Ecma]], with [[International Organization for Standardization|ISO]]/[[International Electrotechnical Commission|IEC]] standardization following in April 2003.

Microsoft and its partners hold patents for CLI. Ecma and ISO/IEC require that all patents essential to implementation be made available under "[[Reasonable and non-discriminatory licensing|reasonable and non-discriminatory (RAND) terms]]." It is common for RAND licensing to require some royalty payment, which could be a cause for concern with [[Mono (software)|Mono]]. {{as of|2013|January}}, neither Microsoft nor its partners have identified any patents essential to CLI implementations subject to RAND terms.{{cn|date=October 2024}}

The Common Language Runtime: The .NET Framework provides a run-time environment called the Common Language Runtime, which manages the execution of code and provides services that make the development process easier. Compilers and tools expose the runtime's functionality and enable you to write code that benefits from this managed execution environment. Code that you develop with a language compiler that targets the runtime is called managed code; it benefits from features such as cross-language integration, cross-language exception handling, enhanced security, versioning and deployment support, a simplified model for component interaction, and debugging and profiling services.

{{as of|2009|July}},<ref>{{Cite web

|url=http://port25.technet.com/archive/2009/07/06/the-ecma-c-and-cli-standards.aspx

|title=The Ecma C# and CLI Standards

|website=Port 25

|first1=Peter |last1=Galli

|date=2009-07-06

|access-date=September 26, 2009

|archive-url=https://web.archive.org/web/20090709232640/http://port25.technet.com/archive/2009/07/06/the-ecma-c-and-cli-standards.aspx

|archive-date=July 9, 2009

|url-status=dead

}}</ref> [[Microsoft]] added [[C Sharp (programming language)|C#]] and CLI to the list of specifications that the [[Microsoft Community Promise]] applies to,<ref>{{Cite web |last=v-alje |title=[MS-DEVCENTLP]: Microsoft Community Promise |url=https://learn.microsoft.com/en-us/openspecs/dev_center/ms-devcentlp/8b8d1b7a-a10a-4667-9558-6d9c43adf60d |access-date=2023-05-01 |website=Microsoft Learn |date=March 16, 2023 |language=en-us}}</ref> so anyone can safely implement specified editions of the standards without fearing a patent lawsuit from Microsoft. To implement the CLI standard requires conformance to one of the supported and defined profiles of the standard, the minimum of which is the kernel profile. The kernel profile is actually a very small set of types to support in comparison to the well known core library of default .NET installations. However, the conformance clause of the CLI allows for extending the supported profile by adding new methods and types to classes, as well as deriving from new namespaces. But it does not allow for adding new members to interfaces. This means that the features of the CLI can be used and extended, as long as the conforming profile implementation does not change the behavior of a program intended to run on that profile, while allowing for unspecified behavior from programs written specifically for that implementation.

In 2012, Ecma and ISO/IEC published the new edition of the CLI standard.<ref name="iso_iec_23271_2012"/><ref name="ecma_355_2012"/>

The runtime automatically handles object layout and manages references to objects, releasing them when they are no longer being used. Objects whose lifetimes are managed in this way by the runtime are called managed data. Automatic memory management eliminates memory leaks as well as some other common programming errors.

==Implementations==

*[[.NET Framework]] is Microsoft's original commercial implementation of the CLI. It only supports Windows. It was superseded by .NET in November 2020.

*[[.NET]], previously known as .NET Core, is the free and open-source multi-platform successor to .NET Framework, released under the [[MIT License]]

*[[.NET Compact Framework]] is Microsoft's commercial implementation of the CLI for portable devices and [[Xbox 360]].

*[[.NET Micro Framework]] is an open source implementation of the CLI for resource-constrained devices.

*[[Mono (software)|Mono]] is an alternative open source implementation of CLI and accompanying technologies, mainly used for mobile and game development.

*[[DotGNU]] is a decommissioned part of the GNU Project started in January 2001 that aimed to provide a [[free and open source software]] alternative to Microsoft's [[.NET Framework]].

==See also==

The Common Language Runtime makes it easy to design components and applications whose objects interact across languages. Objects written in different languages can communicate with each other, and their behaviors can be tightly integrated. For example, you can define a class, then, using a different language, derive a class from your original class or call a method on it. You can also pass an instance of a class to a method on a class written in a different language. This cross-language integration is possible because language compilers and tools that target the runtime use a common type system defined by the runtime, and they follow the runtime's rules for defining new types, as well as creating, using, persisting, and binding to types.

*[[Standard Libraries (CLI)]]

*[[List of CLI languages]]

*[[.NET Standard]]

==Notes==

Registration information and state data are no longer stored in the registry where it can be difficult to establish and maintain; instead, information about the types you define (and their dependencies) is stored with the code as metadata, making the tasks of component replication and removal much less complicated. The Common Language Runtime can only execute code in assemblies. An assembly consists of code modules and resources that are loaded from disk by the runtime. The assembly may be an executable (exe) or a library (dll).

{{Reflist}}

==References==

The benefits of the runtime are as follows:

*{{Cite web

|title = Standard ECMA-335, Common Language Infrastructure (CLI)

|work = Ecma International

|url = https://www.ecma-international.org/publications-and-standards/standards/ecma-335/

|access-date = November 1, 2023

}}

*{{Cite web

|title = ISO/IEC 23271, Common Language Infrastructure

|work = ISO/IEC

|url = http://www.iso.org/iso/en/CatalogueDetailPage.CatalogueDetail?CSNUMBER=42927

|access-date = September 27, 2006

}}

*{{Cite web

|title = Ecma C# and Common Language Infrastructure Standards

|work = Microsoft Corporation

|url = http://msdn.microsoft.com/en-us/netframework/aa569283.aspx

|access-date = October 13, 2009

}}

*{{Cite web

|title = Language independence and language-independent components

|work = Microsoft Learn

|date = December 21, 2022

|url = https://learn.microsoft.com/en-us/dotnet/standard/language-independence

|access-date = May 19, 2023

}}

==External links==

*{{Official|https://www.iso.org/standard/58046.html|ISO/IEC 23271:2012 Information technology — Common Language Infrastructure (CLI)}}

{{Common Language Infrastructure}}

Performance improvements.

{{Ecma International Standards}}

The ability to easily use components developed in other languages.

{{ISO standards}}

Extensible types provided by a class library.

A broad set of language features.

{{Use mdy dates|date=January 2019}}

{{Use American English|date=January 2019}}

§1.2 The Intermediate Language: Currently Microsoft provides compilers for C# (Pronounced as C Sharp), VisualBasic.NET, Managed C++ and JScript in their .NET Framework SDK. These compilers generate the so called Intermediate Language(IL) code which is then assembled to a Portable Executable(PE) code. The PE code is interpreted at runtime by CLR for execution. Our first example is the traditional ‘Hello World’ program written in IL. (ilhello.il)

[[Category:Common Language Infrastructure| ]]

[[Category:Ecma standards]]

[[Category:IEC standards]]

[[Category:ISO standards]]

.assembly Hello{}

.method public static void run() il managed{

.entrypoint

ldstr “Hello World.NET”

call void [mscorlib]System.Console::WriteLine(class System.String)

ret

}

The above code declares Hello as an assembly(unit of code) and defines an il managed function called run. This function is marked as an entrypoint (the function which the CLR must invoke when this code is executed). Next it stores a string on the stack and invokes WriteLine method of Console class (this method displays a line on screen). For resolving name collisions all classes in .NET library are packaged in namespaces. The Console class for instance belongs to namespace called System (the root of all the namespaces in the .NET framework class library). The code for System.Console class is stored in mscorlib.dll. To execute this code, it must be first assembled to PE code using ilasm.exe utility available with .NET Framework SDK.

ilasm ilhello.il

The above command will create ilhello.exe which when executed will display

Hello World.NET

on the screen.

Needless to say that coding in raw IL is pretty difficult. For actual programming any .NET compliant high level language can be used. Given below (mcpphello.cpp) is the Hello World program coded ni Managed C++

#using <mscorlib.dll>

using namespace System;

void main()

{

Console::WriteLine(S"Hello World.NET");

}

Compile it using command cl /clr mcpphello.cpp

The listing below shows same program coded in VisualBasic.NET(vbhello.vb).

Imports System

Module Hello

Sub Main()

Console.WriteLine(“Hello World.NET”)

End Sub

End Module

Compile vbhello.vb using command:vbc vbhello.vb

The code below is hello program in JScript (jshello.js)

import System;

Console.WriteLine(“Hello World.NET”);

Compile jshello.js using command jsc jshello.js

Finally the Hello World program in C# would be (cshello.cs)

using System;

class Hello{

public static void Main(){

Console.WriteLine(“Hello World.NET”);

}

}

And it can be compiled using CSharp compiler as: csc cshello.cs

§1.3 Mixed Language Programming: The .NET framework not only allows you to write your program in any language but also allows you to use components coded in one language in a program written in another. Listed below is a component implemented in C#(bizcalc.cs) for calculating the price of a depreciating asset at an end of a given period:

namespace BizCalc{

public class Asset{

public double OriginalCost;

public float AnnualDepreciationRate;

public double GetPriceAfter(int years){

double price = OriginalCost;

for(int n = 1; n <= years; n++) price = price * (1 - AnnualDepreciationRate/100);

return price;

}

}

}

Compile asset.cs to create a dll using command: csc /t:library bizcalc.cs

A VB program below (assettest.vb) uses the above component:

Imports BizCalc

Imports System

Module AssetTest

Sub Main()

Dim ast As Asset = new Asset()

ast.OriginalCost = 10000

ast.AnnualDepreciationRate = 9

Console.WriteLine("Price of asset worth 10000 after 5 years: {0}", _

ast.GetPriceAfter(5))

End Sub

End Module

Compile the above program using: vbc /r:bizcalc.dll assettest.vb