Content deleted Content added
Rescuing 12 sources and tagging 0 as dead.) #IABot (v2.0.9.5 |
|||
Line 25:
FCL provides the [[user interface]], [[data access]], [[database connection|database connectivity]], [[cryptography]], [[web application]] development, numeric [[algorithm]]s, and [[computer networking|network communications]]. Programmers produce software by combining their [[source code]] with the .NET Framework and other libraries. The framework is intended to be used by most new applications created for the Windows platform. Microsoft also produces an [[integrated development environment]] for .NET software called [[Microsoft Visual Studio|Visual Studio]].
.NET Framework began as [[proprietary software]], although the firm worked to [[software standard|standardize]] the software stack almost immediately, even before its first release. Despite the standardization efforts, developers, mainly those in the [[free and open-source software]] communities, expressed their unease with the selected terms and the prospects of any free and open-source implementation, especially regarding [[software patent]]s. Since then, Microsoft has changed .NET development to more closely follow a contemporary model of a community-developed software project, including issuing an update to its patent promising to address the concerns.<ref>{{Cite web |date=November 19, 2014 |title=Microsoft gets on board with open source |url=https://opensource.com/business/14/11/microsoft-dot-net-empower-open-source-communities |access-date=2020-01-02 |website=Opensource.com |language=en |first1=Luis |last1=Ibanez |archive-date=January 2, 2020 |archive-url=https://web.archive.org/web/20200102202811/https://opensource.com/business/14/11/microsoft-dot-net-empower-open-source-communities |url-status=live }}</ref>
In April 2019, Microsoft released .NET Framework 4.8, the last major version of the framework as a proprietary offering, followed by .NET Framework 4.8.1 in August 2022. Only monthly security and reliability [[software bug|bug]] fixes to that version have been released since then. No further changes to that version are planned. The .NET Framework will continue to be included with future releases of Windows and continue to receive security updates, with no plans to remove it as of November 2023.<ref>{{Cite web|last=gewarren|title=.NET Framework & Windows OS versions|url=https://docs.microsoft.com/en-us/dotnet/framework/migration-guide/versions-and-dependencies|access-date=2020-11-21|website=Microsoft Learn|language=en-us|archive-date=September 3, 2022|archive-url=https://web.archive.org/web/20220903043259/https://docs.microsoft.com/en-US/dotnet/framework/migration-guide/versions-and-dependencies|url-status=live}}</ref>
==History==
Line 33:
Microsoft began developing .NET Framework in the late 1990s, originally under the name of Next Generation Windows Services (NGWS), as part of the [[.NET strategy]]. By early 2000, the first beta versions of .NET 1.0 were released.
In August 2000, [[Microsoft]], and [[Intel]] worked to standardize [[Common Language Infrastructure]] (CLI) and [[C Sharp (programming language)|C#]]. By December 2001, both were ratified [[Ecma International|ECMA]] standards.<ref>{{cite web|url=http://www.ecma-international.org/publications/standards/Ecma-335.htm|title=Standard ECMA-335: Common Language Infrastructure (CLI)|date=June 2012|publisher=[[Ecma International|ECMA]]|edition=6|access-date=August 31, 2005|archive-date=June 29, 2013|archive-url=https://web.archive.org/web/20130629235609/http://www.ecma-international.org/publications/standards/Ecma-335.htm|url-status=dead}}</ref><ref name="Ecma-334">{{cite web|url=http://www.ecma-international.org/publications/standards/Ecma-334.htm|title=Standard ECMA-334: C# Language Specification|date=June 2006|publisher=[[Ecma International|ECMA]]|edition=4|access-date=August 31, 2005|archive-date=October 31, 2010|archive-url=https://web.archive.org/web/20101031042906/http://www.ecma-international.org/publications/standards/Ecma-334.htm|url-status=dead }}</ref> [[International Organization for Standardization]] (ISO) followed in April 2003. The current version of ISO standards are ISO/IEC 23271:2012 and ISO/IEC 23270:2006.<ref>{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=58046|title=ISO/IEC 23271:2012 Information technology – Common Language Infrastructure|publisher=[[International Organization for Standardization]]|date=February 13, 2012|edition=3|access-date=March 17, 2012|archive-date=March 17, 2012|archive-url=https://web.archive.org/web/20120317142950/http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=58046|url-status=live}}</ref><ref>{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=42926|title=ISO/IEC 23270:2006 – Information technology – Programming languages – C#|publisher=[[International Organization for Standardization]]|date=January 26, 2012 |edition=2|access-date=April 1, 2008|archive-date=December 6, 2010|archive-url=https://web.archive.org/web/20101206152217/http://www.iso.org/iso/iso_catalogue/catalogue_ics/catalogue_detail_ics.htm?csnumber=42926|url-status=live}}</ref>
While Microsoft and their partners hold patents for CLI and C#, ECMA and ISO require that all patents essential to implementation be made available under "[[reasonable and non-discriminatory licensing|reasonable and non-discriminatory terms]]". The firms agreed to meet these terms, and to make the patents available royalty-free. However, this did not apply to the part of the .NET Framework not covered by ECMA-ISO standards, which included [[Windows Forms]], [[ADO.NET]], and [[ASP.NET]]. Patents that Microsoft holds in these areas may have deterred non-Microsoft implementations of the full framework.<ref>{{cite web|title=Microsoft's Empty Promise|url=http://www.fsf.org/news/2009-07-mscp-mono|work=[[Free Software Foundation]]|date=July 16, 2009 |first1=Brett |last1=Smith |quote=However, there are several libraries that are included with Mono, and commonly used by applications like Tomboy, that are not required by the standard. And just to be clear, we're not talking about Windows-specific libraries like ASP.NET and Windows Forms. Instead, we're talking about libraries under the System namespace that provide common functionality programmers expect in modern programming languages|access-date=August 3, 2009|archive-url=https://web.archive.org/web/20090819101829/http://www.fsf.org/news/2009-07-mscp-mono/|archive-date=August 19, 2009|url-status=live|df=dmy}}</ref>
Line 39:
[[Windows Vista]] is the first client version of Windows that integrated the .NET Framework.
On October 3, 2007, Microsoft announced that the [[source code]] for .NET Framework 3.5 libraries was to become available under the [[Microsoft Reference Source License]] (Ms-RSL{{efn|name=Ms-RSL-dab|The license was formerly abbreviated Ms-RL, but Ms-RL now refers to the [[Microsoft Reciprocal License]].}}).<ref name="sourcerelease">{{cite web|url=http://weblogs.asp.net/scottgu/releasing-the-source-code-for-the-net-framework-libraries|title=Releasing the Source Code for the NET Framework|website=Scott Guthrie's Blog|publisher=[[Microsoft]]|first=Scott|last=Guthrie|author-link=Scott Guthrie|date=October 3, 2007|access-date=September 15, 2010|archive-url=https://web.archive.org/web/20100907233621/http://weblogs.asp.net/scottgu/archive/2007/10/03/releasing-the-source-code-for-the-net-framework-libraries.aspx|archive-date=September 7, 2010|url-status=live|df=dmy}}</ref> The source code repository became available online on January 16, 2008, and included BCL, ASP.NET, ADO.NET, Windows Forms, WPF, and XML. [[Scott Guthrie]] of Microsoft promised that LINQ, WCF, and WF libraries were being added.<ref>{{cite web|title=.NET Framework Library Source Code now available|url=https://weblogs.asp.net/scottgu/net-framework-library-source-code-now-available|website=Scott Guthrie's Blog|publisher=[[Microsoft]]|access-date=February 28, 2015|date=January 16, 2008|first=Scott|last=Guthrie|author-link=Scott Guthrie|archive-date=March 18, 2015|archive-url=https://web.archive.org/web/20150318161340/http://weblogs.asp.net/scottgu/net-framework-library-source-code-now-available|url-status=live}}</ref>
The [[.NET Compact Framework]] and [[.NET Micro Framework]] variants of the .NET Framework provided support for other Microsoft platforms such as [[Windows Mobile]], [[Windows CE]] and other resource-constrained embedded devices. [[Silverlight]] provided support for [[web browser]]s via plug-ins.
Line 47:
In November 2014, Microsoft also produced an update to its patent grants, which further extends the scope beyond its prior pledges. Prior projects like [[Mono (software)|Mono]] existed in a legal [[loophole|grey area]] because Microsoft's earlier grants applied only to the technology in "covered specifications", including strictly the 4th editions each of ECMA-334 and ECMA-335. The new patent promise, however, places no ceiling on the specification version, and even extends to any .NET runtime technologies documented on MSDN that have not been formally specified by the ECMA group, if a project chooses to implement them. This allows Mono and other projects to maintain feature parity with modern .NET features that have been introduced since the 4th edition was published without being at risk of patent litigation over the implementation of those features. The new grant does maintain the restriction that any implementation must maintain minimum compliance with the mandatory parts of the CLI specification.<ref name="dotnet-patent-promise">{{cite web|title=Microsoft Patent Promise for .NET Libraries and Runtime Components|website=[[GitHub]]|url=https://github.com/dotnet/corefx/blob/master/PATENTS.TXT|access-date=November 16, 2014|archive-date=February 21, 2021|archive-url=https://web.archive.org/web/20210221070138/https://github.com/dotnet/corefx/blob/master/PATENTS.TXT|url-status=live}}</ref>
On March 31, 2016, Microsoft announced at [[Build (developer conference)|Microsoft Build]] that they will completely [[software relicensing|relicense]] Mono under an [[MIT License]] even in scenarios where formerly a commercial license was needed.<ref>{{cite web|last1=Krill|first1=Paul|title=Xamarin's Mono runtime gets a looser license|url=http://www.infoworld.com/article/3050732/microsoft-windows/xamarins-mono-runtime-gets-a-looser-license.html|website=[[InfoWorld]]|publisher=[[IDG]]|date=April 1, 2016|access-date=April 13, 2016|archive-date=April 16, 2016|archive-url=https://web.archive.org/web/20160416032759/http://www.infoworld.com/article/3050732/microsoft-windows/xamarins-mono-runtime-gets-a-looser-license.html|url-status=live}}</ref> Microsoft also supplemented its prior patent promise for Mono, stating that they will not assert any "applicable patents" against parties that are "using, selling, offering for sale, importing, or distributing Mono."<ref name=Ferraira1>{{cite web|url=http://techreport.com/news/29929/xamarin-now-comes-free-with-visual-studio|title=Xamarin now comes free with Visual Studio.|work=The Tech Report|date=March 31, 2016|first=Bruno|last=Ferraira|access-date=April 12, 2016|archive-date=April 2, 2016|archive-url=https://web.archive.org/web/20160402173444/http://techreport.com/news/29929/xamarin-now-comes-free-with-visual-studio|url-status=live}}</ref><ref name="Microsoft_PP_Mono">{{cite web|url=https://github.com/mono/mono/blob/master/PATENTS.TXT|title=Microsoft Patent Promise for Mono|work=Mono on GitHub |date=March 28, 2016|archive-url=https://web.archive.org/web/20160416133644/https://github.com/mono/mono/blob/master/PATENTS.TXT|archive-date=April 16, 2016|access-date=April 16, 2016|url-status=live|df=dmy}}</ref> It was announced that the Mono Project was contributed to the .NET Foundation. These developments followed the acquisition of [[Xamarin]], which began in February 2016 and was finished on March 18, 2016.<ref name="Friedman2">{{cite web|url=https://blog.xamarin.com/xamarin-for-all/|title=Xamarin for Everyone|work=Xamarin Blog |first1=Nat |last1=Friedman |date=March 31, 2016|archive-url=https://web.archive.org/web/20160412072728/https://blog.xamarin.com/xamarin-for-all/|archive-date=April 12, 2016|access-date=April 12, 2016}}</ref>
Microsoft's press release highlights that the cross-platform commitment now allows for a fully open-source, modern server-side .NET stack. Microsoft released the source code for WPF, Windows Forms and WinUI on December 4, 2018.<ref name="ms-wpf-winforms-oss">{{cite web|title=Announcing Open Source of WPF, Windows Forms, and WinUI at Microsoft Connect 2018|url=https://blogs.windows.com/buildingapps/2018/12/04/announcing-open-source-of-wpf-windows-forms-and-winui-at-microsoft-connect-2018/|website=Windows Developer Blog|date=December 4, 2018|publisher=Microsoft |first1=Kevin |last1=Gallo |access-date=December 24, 2018|archive-url=https://web.archive.org/web/20181215163944/https://blogs.windows.com/buildingapps/2018/12/04/announcing-open-source-of-wpf-windows-forms-and-winui-at-microsoft-connect-2018/|archive-date=December 15, 2018}}</ref>
Line 79:
FCL refers to the entire class library that ships with .NET Framework. It includes BCL, an expanded set of libraries, including [[Windows Forms]], [[ASP.NET]], and [[Windows Presentation Foundation]] (WPF), and also extensions to the base class libraries [[ADO.NET]], [[Language Integrated Query]] (LINQ), [[Windows Communication Foundation]] (WCF), and [[Workflow Foundation]] (WF). FCL is much larger in scope than standard libraries for languages like [[C++]], and comparable in scope to [[Java Class Library|standard libraries of Java]].
With the introduction of alternative CLI's implementations (e.g., Silverlight), Microsoft introduced the concept of Portable Class Libraries (PCL) allowing a consuming library to run on more than one implementation. With the further proliferation of implementations, the PCL approach failed to scale (PCLs are defined intersections of API surface between two or more implementations).<ref name="netstandard">{{cite web|url=https://github.com/dotnet/corefx/blob/master/Documentation/architecture/net-platform-standard.md|title=.NET Platform Standard|website=[[GitHub]]|access-date=April 23, 2016|archive-date=May 19, 2016|archive-url=https://web.archive.org/web/20160519180849/https://github.com/dotnet/corefx/blob/master/Documentation/architecture/net-platform-standard.md|url-status=dead }}</ref> As the next evolutionary step of PCL, the .NET Standard Library was created retroactively based on the <code>System.Runtime.dll</code> based APIs found in UWP and Silverlight. New CLI's implementations are encouraged to implement a version of the Standard Library allowing them to run existent third-party libraries with no need of creating new versions of them. The .NET Standard Library allows an independent evolution of the library and app model layers within the .NET architecture.<ref name="appmodels">{{cite web |url=http://www.hanselman.com/blog/AnUpdateOnASPNETCore10RC2.aspx |title=An update on ASP.NET Core 1.0 RC2 |date=April 14, 2016 |website=Scott Hanselman |access-date=April 23, 2016 |archive-date=April 19, 2016 |archive-url=https://web.archive.org/web/20160419194652/http://www.hanselman.com/blog/AnUpdateOnASPNETCore10RC2.aspx |url-status=live }}</ref>
[[NuGet]] is the package manager for all .NET platforms. It is used to retrieve third-party libraries into a .NET project with a global library feed at NuGet.org.<ref>{{cite web|url=https://nuget.org|title=NuGet Gallery – Home|website=nuget.org|access-date=February 21, 2021|archive-date=February 21, 2021|archive-url=https://web.archive.org/web/20210221070142/https://www.nuget.org/|url-status=live}}</ref> Private feeds can be maintained separately, e.g., by a build server or a file system directory.
Line 105:
While Microsoft has never implemented the full framework on any system except Microsoft Windows, it has engineered the framework to be cross-platform,<ref>{{cite web|url=https://channel9.msdn.com/shows/Going+Deep/Scott-Guthrie-Silverlight-and-the-Cross-Platform-CLR|title=Scott Guthrie: Silverlight and the Cross-Platform CLR|date=April 30, 2007|publisher=[[Channel 9 (discussion forum)|Channel 9]]|access-date=April 16, 2016|archive-url=https://web.archive.org/web/20150522144655/http://channel9.msdn.com/shows/Going+Deep/Scott-Guthrie-Silverlight-and-the-Cross-Platform-CLR|archive-date=May 22, 2015|url-status=live|df=dmy}}</ref> and implementations are available for other operating systems (see [[Microsoft Silverlight|Silverlight]] and [[#Alternative implementations|§ Alternative implementations]]). Microsoft submitted the specifications for CLI (which includes the Base Class Libraries, CTS, and CIL),<ref>{{cite web|url=http://www.ecma-international.org/publications/standards/Ecma-335.htm|title=ECMA 335 – Standard ECMA-335 Common Language Infrastructure (CLI) 4th edition (June 2006)|date=June 1, 2006|access-date=June 1, 2008|publisher=ECMA|archive-url=https://web.archive.org/web/20080614092650/http://www.ecma-international.org/publications/standards/Ecma-335.htm|archive-date=June 14, 2008}}</ref><ref>{{cite web|url=http://standards.iso.org/ittf/PubliclyAvailableStandards/c042927_ISO_IEC_23271_2006(E)_Software.zip|title=ISO/IEC 23271:2006|publisher=ISO Standards |date=September 29, 2006|access-date=April 17, 2012|archive-date=July 1, 2018|archive-url=https://web.archive.org/web/20180701142510/http://standards.iso.org/ittf/PubliclyAvailableStandards/c042927_ISO_IEC_23271_2006%28E%29_Software.zip|url-status=dead }}</ref><ref>{{cite web|url=http://www.ecma-international.org/publications/techreports/E-TR-084.htm|title=Technical Report TR/84 Common Language Infrastructure (CLI) – Information Derived from Partition IV XML File|date=June 1, 2006|publisher=ECMA|access-date=April 16, 2016|archive-url=https://web.archive.org/web/20150307073541/http://www.ecma-international.org/publications/techreports/E-TR-084.htm|archive-date=March 7, 2015|url-status=dead|df=dmy}}</ref> [[C Sharp (programming language)|C#]],<ref name="Ecma-334"/> and C++/CLI<ref>{{cite web|url=http://www.ecma-international.org/publications/standards/Ecma-372.htm|title=Standard ECMA-372 C++/CLI Language Specification|date=December 1, 2005|publisher=ECMA|access-date=January 16, 2008|archive-url=https://web.archive.org/web/20080810165757/http://www.ecma-international.org/publications/standards/Ecma-372.htm|archive-date=August 10, 2008|url-status=dead}}</ref> to both [[Ecma International]] (ECMA) and [[International Organization for Standardization]] (ISO), making them available as official standards. This makes it possible for third parties to create compatible implementations of the framework and its languages on other platforms.
Core cross-platform .NET (formerly .NET Core) is officially available also for many Linux distributions and MacOS.<ref>{{cite web|url=https://learn.microsoft.com/en-us/archive/msdn-magazine/2016/april/net-core-net-goes-cross-platform-with-net-core|title=.NET Goes Cross-Platform with .NET Core|access-date=February 19, 2024|archive-date=February 19, 2024|archive-url=https://web.archive.org/web/20240219220328/https://learn.microsoft.com/en-us/archive/msdn-magazine/2016/april/net-core-net-goes-cross-platform-with-net-core|url-status=live}}</ref>
===Security===
Line 116 ⟶ 115:
CLR frees the developer from the burden of managing memory (allocating and freeing up when done); it handles memory management itself by detecting when memory can be safely freed. Instantiations of .NET types (objects) are allocated from the managed heap; a pool of memory managed by CLR. As long as a reference to an object exists, which may be either direct, or via a [[graph (data structure)|graph]] of objects, the object is considered to be in use. When no reference to an object exists, and it cannot be reached or used, it becomes garbage, eligible for collection.
.NET Framework includes a [[Garbage collection (computer science)|garbage collector]] (GC) which runs periodically, on a separate [[thread (computing)|thread]] from the application's thread, that enumerates all the unusable objects and reclaims the memory allocated to them. It is a non-deterministic, compacting, [[tracing garbage collection#Naïve mark-and-sweep|mark-and-sweep]] garbage collector. GC runs only when a set amount of memory has been used or there is enough pressure for memory on the system. Since it is not guaranteed when the conditions to reclaim memory are reached, GC runs are [[Nondeterministic algorithm|non-deterministic]]. Each .NET application has a set of roots, which are pointers to objects on the managed heap (''managed objects''). These include references to static objects, objects defined as local variables or method parameters currently in scope, and objects referred to by CPU registers.<ref name="part1">{{cite web|url=https://msdn.microsoft.com/msdnmag/issues/1100/GCI/|archive-url=https://web.archive.org/web/20070703083608/http://msdn.microsoft.com/msdnmag/issues/1100/GCI/|archive-date=July 3, 2007|title=Garbage Collection: Automatic Memory Management in the Microsoft .NET Framework|access-date=June 1, 2008|url-status=dead|df=mdy-all}}</ref> When GC runs, it pauses the application and then, for each object referred to in the root, it [[recursion|recursively]] enumerates all the objects reachable from the root objects and marks them as reachable. It uses CLI metadata and [[reflection (computer programming)|reflection]] to discover the objects encapsulated by an object, and then recursively walk them. It then enumerates all the objects on the heap (which were initially allocated contiguously) using reflection. All objects not marked as reachable are garbage.<ref name="part1"/> This is the ''mark'' phase.<ref name="gcnet">{{cite web|url=http://www.csharphelp.com/archives2/archive297.html|title=Garbage collection in .NET|access-date=June 1, 2008|archive-url=https://web.archive.org/web/20080525165023/http://www.csharphelp.com/archives2/archive297.html|archive-date=May 25, 2008|url-status=dead|df=dmy}}</ref> Since the memory held by garbage is of no consequence, it is considered free space. However, this leaves chunks of free space between objects which were initially contiguous. The objects are then ''compacted'' together to make free space on the managed heap contiguous again.<ref name="part1"/><ref name="gcnet"/> Any reference to an object invalidated by moving the object is updated by GC to reflect the new ___location.<ref name="gcnet"/> The application is resumed after garbage collection ends. The latest version of .NET framework uses concurrent garbage collection along with user code, making pauses unnoticeable, because it is done in the background.<ref>{{cite web|url=https://blogs.msdn.microsoft.com/dotnet/2012/07/20/the-net-framework-4-5-includes-new-garbage-collector-enhancements-for-client-and-server-apps/|title=The .NET Framework 4.5 includes new garbage collector enhancements for client and server apps|date=July 20, 2012
The garbage collector used by .NET Framework is also ''[[Garbage collection (computer science)#Generational|generational]]''.<ref name=PART2>{{cite web|url=https://msdn.microsoft.com/msdnmag/issues/1200/GCI2/default.aspx|archive-url=https://web.archive.org/web/20070626080134/http://msdn.microsoft.com/msdnmag/issues/1200/GCI2/default.aspx|archive-date=June 26, 2007|title=Garbage Collection—Part 2: Automatic Memory Management in the Microsoft .NET Framework|access-date=June 1, 2008|url-status=dead|df=mdy-all}}</ref> Objects are assigned a ''generation''. Newly created objects are tagged ''Generation 0''. Objects that survive one garbage collection are tagged ''Generation 1''. Generation 1 objects that survive another collection are ''Generation 2''. The framework uses up to Generation 2 objects.{{r|PART2}} Higher generation objects are garbage collected less often than lower generation objects. This raises the efficiency of garbage collection, as older objects tend to have longer lifetimes than newer objects.{{r|PART2}} By ignoring older objects in most collection runs, fewer checks and compaction operations are needed in total.{{r|PART2}}
Line 123 ⟶ 122:
When an application is first launched, the .NET Framework compiles the [[Common Intermediate Language|CIL code]] into executable code using its [[just-in-time compiler]], and caches the executable program into the .NET Native Image Cache.<ref>{{cite web|url=http://blogs.telerik.com/justteam/posts/13-05-28/understanding-net-just-in-time-compilation|title=Understanding .NET Just-In-Time Compilation|date=May 28, 2013|website=telerik.com|access-date=May 21, 2015|archive-date=June 11, 2013|archive-url=https://web.archive.org/web/20130611052214/http://blogs.telerik.com/justteam/posts/13-05-28/understanding-net-just-in-time-compilation|url-status=live}}</ref><ref name="cache">[https://msdn.microsoft.com/en-us/library/ht8ecch6(v=vs.90).aspx Compiling MSIL to Native Code] {{Webarchive|url=https://web.archive.org/web/20150419013531/https://msdn.microsoft.com/en-us/library/ht8ecch6(v=vs.90).aspx |date=April 19, 2015 }}, MSDN, Microsoft</ref> Due to caching, the application launches faster for subsequent launches, although the first launch is usually slower. To speed up the first launch, developers may use the [[Native Image Generator]] utility to manually [[Ahead-of-time compilation|ahead-of-time compile]] and cache any .NET application.<ref name="cache"/>
The garbage collector, which is integrated into the environment, can introduce unanticipated delays of execution over which the developer has little direct control. "In large applications, the number of objects that the garbage collector needs to work with can become very large, which means it can take a very long time to visit and rearrange all of them."<ref>{{Cite web|url=https://www.red-gate.com/simple-talk/dotnet/net-framework/understanding-garbage-collection-in-net/|title=Understanding Garbage Collection in .NET|date=June 17, 2009|access-date=November 13, 2019|archive-date=October 10, 2019|archive-url=https://web.archive.org/web/20191010020210/https://www.red-gate.com/simple-talk/dotnet/net-framework/understanding-garbage-collection-in-net/|url-status=live}}</ref>
.NET Framework provides support for calling [[Streaming SIMD Extensions]] (SSE) via [[managed code]] from April 2014 in Visual Studio 2013 Update 2. However, [[Mono (software)|Mono]] has provided support for [[SIMD]] Extensions as of version 2.2 within the {{Not a typo|Mono.Simd}} namespace in 2009.<ref name="Release Notes">{{cite web|url=http://www.mono-project.com/docs/about-mono/releases/2.2.0/|title=Release Notes Mono 2.2 – Mono|website=mono-project.com|access-date=November 22, 2016|archive-date=November 22, 2016|archive-url=https://web.archive.org/web/20161122220434/http://www.mono-project.com/docs/about-mono/releases/2.2.0/|url-status=live}}</ref> Mono's lead developer [[Miguel de Icaza]] has expressed hope that this SIMD support will be adopted by CLR's ECMA standard.<ref>{{cite web|url=http://tirania.org/blog/archive/2008/Nov-03.html|title=Mono's SIMD Support: Making Mono safe for Gaming|publisher=Tirania.org|date=November 3, 2008 |first1=Miguel |last1=de Icaza |access-date=April 17, 2012|archive-date=November 4, 2010|archive-url=https://web.archive.org/web/20101104173338/http://tirania.org/blog/archive/2008/Nov-03.html|url-status=live}}</ref> Streaming SIMD Extensions have been available in [[x86]] CPUs since the introduction of the [[Pentium III]]. Some other architectures such as [[ARM architecture|ARM]] and [[MIPS architecture|MIPS]] also have SIMD extensions. In case the CPU lacks support for those extensions, the instructions are simulated in software.<ref>{{Cite web |title=Mono's SIMD Support: Making Mono safe for Gaming |first1=Miguel |last1=de Icaza |date=3 Nov 2008 |url=https://tirania.org/blog/archive/2008/Nov-03.html |access-date=2022-05-06 |website=tirania.org |archive-date=July 2, 2022 |archive-url=https://web.archive.org/web/20220702211916/https://tirania.org/blog/archive/2008/Nov-03.html |url-status=live }}</ref><ref>{{Cite web |title=SIMD-accelerated types in .NET |url=https://docs.microsoft.com/en-us/dotnet/standard/simd |access-date=2022-05-06 |website=Microsoft Learn |language=en-us |archive-date=May 6, 2022 |archive-url=https://web.archive.org/web/20220506202738/https://docs.microsoft.com/en-us/dotnet/standard/simd |url-status=live }}</ref>
==Alternative implementations==
| |||