What is CTS and CLS?

Open specification used to define the .NET framework, the legacy .NET Framework, and other runtimes

The Common Language Infrastructure (CLI) is an open specification and technical standard originally developed by Microsoft and standardized by ISO/IEC (ISO/IEC 23271) and Ecma International (ECMA 335)[1][2] that describes executable code and a runtime environment that allows multiple high-level languages to be used on different computer platforms without being rewritten for specific architectures. This implies it is platform agnostic. The .NET Framework, .NET and Mono are implementations of the CLI. The metadata format is also used to specify the API definitions exposed by the Windows Runtime.[3][4]

Overview

[

edit

]

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 types and operations that are shared by all CTS-compliant programming languages.

The Metadata

Information about program structure is 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

A set of libraries providing many common functions, such as file reading and writing. Their core is the Base Class Library (BCL).

Standardization and licensing

[

edit

]

In August 2000, Microsoft, Hewlett-Packard, Intel, and others worked to standardize CLI. By December 2001, it was ratified by the Ecma, with ISO/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 (RAND) terms." It is common for RAND licensing to require some royalty payment, which could be a cause for concern with Mono. As of January 2013, neither Microsoft nor its partners have identified any patents essential to CLI implementations subject to RAND terms.

As of July 2009,[5] Microsoft added C# and CLI to the list of specifications that the Microsoft Community Promise applies to,[6] 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.[1][2]

Implementations

[

edit

]

• .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 is an alternative open source implementation of CLI and accompanying technologies, mainly used for mobile and game development.

See also

[

edit

]

Notes

[

edit

]

References

[

edit

]

There are many articles are available in the web on this topic; I just want to add one more article over the web by explaining Components of .Net Framework.

Components of .Net Framework

Net Framework is a platform that provides tools and technologies to develop Windows, Web and Enterprise applications. It mainly contains two components,

1.   Common Language Runtime (CLR)

2.    .Net Framework Class Library.

1

. Common Language Runtime

(CLR)

.Net Framework provides runtime environment called Common Language Runtime (CLR).It provides an environment to run all the .Net Programs. The code which runs under the CLR is called as Managed Code. Programmers need not to worry on managing the memory if the programs are running under the CLR as it provides memory management and thread management.

Programmatically, when our program needs memory, CLR allocates the memory for scope and de-allocates the memory if the scope is completed.

Language Compilers (e.g. C#, VB.Net, J#) will convert the Code/Program to Microsoft Intermediate Language (MSIL) intern this will be converted to Native Code by CLR. See the below Fig. 

There are currently over 15 language compilers being built by Microsoft and other companies also producing the code that will execute under CLR.

2.

   

.Net Framework Class Library (FCL)

This is also called as Base Class Library and it is common for all types of applications i.e. the way you access the Library Classes and Methods in VB.NET will be the same in C#, and it is common for all other languages in .NET.

The following are different types of applications that can make use of .net class library. 

1.                   Windows Application.

2.                   Console Application

3.                   Web Application.

4.                   XML Web Services.

5.                   Windows Services.

In short, developers just need to import the BCL in their language code and use its predefined methods and properties to implement common and complex functions like reading and writing to file, graphic rendering, database interaction, and XML document manipulation.

Below are the few more concepts that we need to know and understand as part of this .Net framework. 

3.

  

Common Type System (CTS)

It describes set of data types that can be used in different .Net languages in common. (i.e), CTS ensures that objects written in different .Net languages can interact with each other.

For Communicating between programs written in any .NET complaint language, the types have to be compatible on the basic level.

The common type system supports two general categories of types: 

Value types:

Value types directly contain their data, and instances of value types are either allocated on the stack or allocated inline in a structure. Value types can be built-in (implemented by the runtime), user-defined, or enumerations.

Reference types:

Reference types store a reference to the value's memory address, and are allocated on the heap. Reference types can be self-describing types, pointer types, or interface types. The type of a reference type can be determined from values of self-describing types. Self-describing types are further split into arrays and class types. The class types are user-defined classes, boxed value types, and delegates. 

4. Common Language Specification (CLS)

It is a sub set of CTS and it specifies a set of rules that needs to be adhered or satisfied by all language compilers targeting CLR. It helps in cross language inheritance and cross language debugging.

Common language specification Rules:

It describes the minimal and complete set of features to produce code that can be hosted by CLR. It ensures that products of compilers will work properly in .NET environment. 

Sample Rules: 

1.       Representation of text strings 

2.       Internal representation of enumerations 

3.       Definition of static members and this is a subset of the CTS which all .NET languages are expected to support.

4.   Microsoft has defined CLS which are nothing but guidelines that language to follow so that it can communicate with other .NET languages in a seamless manner.

Below mentioned the .Net Architecture stack for easy understanding.