Mono для windows что это

This article needs to be updated. Please help update this article to reflect recent events or newly available information. (March 2016)

Mono

Diagram of Mono architecture
Original author(s)	Ximian
Developer(s)	.NET Foundation and Xamarin (a Microsoft subsidiary)
Initial release	June 30, 2004; 19 years ago
Stable release	6.12.0.200 / July 11, 2023; 2 months ago[1]
Repository	github.com/mono/mono
Written in	C, C#, XML
Operating system	Windows, macOS, Linux, IBM AIX, IBM i[2]
Platform	IA-32, x64, IA-64, ARM, MIPS, RISC-V, PowerPC, SPARC, S390
Type	Software framework
License	MIT License[3]
Website	www.mono-project.com

Mono is a free and open-source .NET Framework-compatible software framework. Originally by Ximian, it was later acquired by Novell, and is now being led by Xamarin, a subsidiary of Microsoft^[4] and the .NET Foundation. Mono can be run on many software systems.

History[edit]

When Microsoft first announced their .NET Framework in June 2000 it was described as «a new platform based on Internet standards»,^[5] and in December of that year the underlying Common Language Infrastructure was published as an open standard, «ECMA-335»,^[6] opening up the potential for independent implementations.^[7] Miguel de Icaza of Ximian believed that .NET had the potential to increase programmer productivity and began investigating whether a Linux version was feasible.^[8] Recognizing that their small team could not expect to build and support a full product, they launched the Mono open-source project, on July 19, 2001, at the O’Reilly conference.

After three years of development, Mono 1.0 was released on June 30, 2004.^[9] Mono evolved from its initial focus of a developer platform for Linux desktop applications to supporting a wide range of architectures and operating systems — including embedded systems.^[10]

Novell acquired Ximian in 2003. After Novell was acquired by Attachmate in April 2011, Attachmate announced hundreds of layoffs for the Novell workforce,^[11] putting in question the future of Mono.^[12][13]

On May 16, Miguel de Icaza announced in his blog that Mono would continue to be supported by Xamarin, a company he founded after being laid off from Novell. The original Mono team had also moved to the new company. Xamarin planned to keep working on Mono and had planned to rewrite the proprietary .NET stacks for iOS and Android from scratch, because Novell still owned MonoTouch and Mono for Android at the time.^[14] After this announcement, the future of the project was questioned, MonoTouch and Mono for Android being in direct competition with the existing commercial offerings now owned by Attachmate, and considering that the Xamarin team would have difficulties proving that they did not use technologies they formerly developed when they were employed by Novell for the same work.^[15] However, in July 2011, Novell, now a subsidiary of Attachmate, and Xamarin, announced that it granted a perpetual license to Xamarin for Mono, MonoTouch and Mono for Android, which officially took stewardship of the project.^[16][17]

Current status and roadmap[edit]

Mono’s current version is 6.0.0 (as of August 2019). This version provides the core API of the .NET Framework and support for Visual Basic.NET and C# 7.0. LINQ to Objects, XML, and SQL are part of the distribution. Windows Forms 2.0 is also supported, but not actively developed, and as such its support on Mono is incomplete.^[18] Version 4.0 was the first version that incorporates Microsoft original source code that was released by Microsoft as part of the .NET Core project.

As of January 14, 2021, Mono has full support for all the features in .NET 4.7 except Windows Presentation Foundation (WPF) (which the Mono team do not plan to support due to the amount of work it would need)^[18] and Windows Workflow Foundation (WF), and with only limited support for Windows Communication Foundation (WCF) and the ASP.NET async stack. However, System.Web and WCF are candidates for ‘almost immediate’ porting from the .NET reference source back to Mono.^[19] Some missing parts of the .NET Framework are under development in an experimental Mono subproject called Olive.^[20]

The Mono project has also created a Visual Basic .NET compiler and a runtime designed for running VB.NET applications. It is currently being developed by Rolf Bjarne Kvinge.

Moonlight[edit]

An open-source implementation of Microsoft Silverlight, called Moonlight, has been included since Mono 1.9.^[21] Moonlight 1.0, which supports the Silverlight 1.0 APIs, was released January 20, 2009. Moonlight 2.0 supports Silverlight 2.0 and some features of Silverlight 3.0.^[22] A preview release of Moonlight 3.0 was announced in February 2010 and contains updates to Silverlight 3 support.^[23]

The Moonlight project was abandoned on May 29, 2012.^[24] According to Miguel, two factors sealed the fate of the project: Microsoft added «artificial restrictions» that «made it useless for desktop programming», and the technology had not gained enough traction on the Web. In addition, Silverlight itself was deprecated by Microsoft by 2012.

Mono components[edit]

Mono consists of three groups of components:

1. Core components
2. Mono/Linux/GNOME development stack
3. Microsoft compatibility stack

The core components include the C# compiler, the virtual machine for the Common Language Infrastructure and the core class libraries. These components are based on the Ecma-334 and Ecma-335 standards,^[25] allowing Mono to provide a standards compliant, free and open-source CLI virtual machine. Microsoft issued a statement that covers both standards under their Community Promise license.^[26]

The Mono/Linux/GNOME development stack provide tools for application development while using the existing GNOME and free and open-source libraries. These include: Gtk# for graphical user interface (GUI) development, Mozilla libraries for working with the Gecko rendering engine, Unix integration libraries (Mono.Posix), database connectivity libraries, a security stack, and the XML schema language RelaxNG. Gtk# allows Mono applications to integrate into the Gnome desktop as native applications. The database libraries provide connectivity to the object-relational database db4o, Firebird, Microsoft SQL Server (MSSQL), MySQL, Open Database Connectivity (ODBC), Oracle, PostgreSQL, SQLite, and many others. The Mono project tracks developing database components at its website.^[27]

The Microsoft compatibility stack provides a pathway for porting Windows .NET applications to Linux. This group of components include ADO.NET, ASP.NET, and Windows Forms, among others. As these components are not covered by Ecma standards, some of them remain subject to patent fears and concerns.

Framework architecture[edit]

The major components of Mono include:

• Code Execution Engine
• Class Libraries
  • Base Class Library
  • .NET Compatibility Class Libraries
  • Mono specific class libraries:
    • Cross platform class libraries for both Mono and .NET (Gtk#, Mono.Cecil, Mono.CSharp, Text.Templating)
    • Unix-specific class libraries (POSIX, Filesystem in Userspace (FUSE), curses)
    • Platform-specific class libraries (bindings for: Mac, iOS, Android, MeeGo)
• CLI Assemblies
• CLI Metadata
• Mono’s Common Language Runtime
  • Compatible with the ECMA Common Language Infrastructure/.NET Common Language Runtime
  • Mono-specific enhancements:
    • Mono.SIMD support
    • Mono co-routines and continuations.
• Mono-specific enhancements
• Native interop services and COM interop
• Security — Transparent Code Framework

Code Execution Engine[edit]

The Mono runtime contains a code execution engine that translates ECMA CIL byte codes into native code and supports a number of processors: ARM, MIPS (in 32-bit mode only), SPARC, PowerPC, z/Architecture, IA-32, x86-64 and IA-64 for 64-bit modes.

The code generator is exposed in three modes:

• Just-in-time (JIT) compilation: The runtime will turn ECMA CIL byte codes into native code as the code runs.
• Ahead-of-Time (AOT) compilation: this code turns the ECMA CIL byte codes (typically found on a .exe or .dll file) and generates native code stored in an operating system, architecture and CPU specific file (for a foo.exe file, it would produce foo.exe.so on Linux). This mode of operation compiles most of the code that is typically done at runtime. There are some exceptions like trampolines and other administrative code that still require the JIT to function, so AOT images are not fully standalone.
• Full Static Compilation: this mode is only supported on a handful of platforms and takes the Ahead-of-Time compilation process one step further and generates all the trampolines, wrappers and proxies that are required into a static file that can be statically linked into a program and eliminates the need for a JIT at runtime. This is used on Apple’s iOS, Sony’s PlayStation 3 and Microsoft’s Xbox 360 operating systems.^{[citation needed]}

Starting with Mono 2.6, it is possible to configure Mono to use the LLVM as the code generation engine instead of Mono’s own code generation engine. This is useful for high performance computing loads and other situations where the execution performance is more important than the startup performance.

Starting with the Mono 2.7 preview, it is no longer necessary to pick one engine over the other at configuration time. The code generation engine can be selected at startup by using the --llvm or --nollvm command line arguments, and it defaults to the fast-starting Mono code generation engine.

Starting with Mono 5.18, support for LLVM is a default configuration option. Previous versions required a special LLVM fork, but now mono can fall back to its own code generator when it encounters something not handled by LLVM.^[28]

Garbage collector[edit]

As of Mono 2.8, the Mono runtime ships with two garbage collectors: a generational collector and the Boehm-Demers-Weiser Conservative Garbage Collector. The Boehm garbage collector could exhibit memory leaks on certain classes of applications, making it unsuitable for some long-running server applications.^[29][30] Mono switched to Simple Generational GC (SGen-GC) as the default collector in version 3.1.1.

The SGen garbage collector has many advantages over a traditional conservative scanner. It uses generational garbage collection where new objects are allocated from a nursery, during the garbage collection cycle, all objects that survived are migrated to an older generation memory pool. The idea is that many objects are transient and can quickly be collected and only a handful of objects are long-term objects that live for the entire life of the application. To improve performance this collector assigns memory pools to each thread to let threads allocate new memory blocks without having to coordinate with other threads. Migration of objects from the nursery to the old generation is done by copying the data from the nursery to the old generation pool and updating any live pointers that point to the data to point to the new location. This can be expensive for large objects, so Mono’s SGen uses a separate pool of memory for large objects (Large Object Section) and uses a mark-and-sweep algorithm for those objects.^[29]

Class library[edit]

The class library provides a comprehensive set of facilities for application development. They are primarily written in C#, but due to the Common Language Specification they can be used by any .NET language. The class library is structured into namespaces, and deployed in shared libraries known as assemblies. Speaking of the .NET Framework is primarily referring to this class library.^[31]

Namespaces and assemblies[edit]

Namespaces are a mechanism for logically grouping similar classes into a hierarchical structure. This prevents naming conflicts. The structure is implemented using dot-separated words, where the most common top-level namespace is System, such as System.IO and System.Net. There are other top-level namespaces as well, such as Accessibility and Windows. A user can define a namespace by placing elements inside a namespace block.

Assemblies are the physical packaging of the class libraries. These are .dll files, just like (but not to be confused with) Win32 shared libraries. Examples of assemblies are mscorlib.dll, System.dll, System.Data.dll and Accessibility.dll. Namespaces are often distributed among several assemblies and one assembly can be composed of several files.

Common Language Infrastructure and Common Language Specification[edit]

The Common Language Infrastructure (CLI) as implemented by the Common Language Runtime (CLR), is implemented by the Mono executable. The runtime compiles and executes .NET applications. The common language infrastructure is defined by the ECMA standard.^[25] To run an application, you must invoke the runtime with the relevant parameters.

The Common Language Specification (CLS) is specified in chapter 6 of ECMA-335 and defines the interface to the CLI, such as conventions like the underlying types for Enum. The Mono compiler generates an image that conforms to the CLS. This is the Common Intermediate Language. The Mono runtime takes this image and runs it. The ECMA standard formally defines a library that conforms to the CLS as a framework.

Managed and unmanaged code[edit]

Within a native .NET/Mono application, all code is managed; that is, it is governed by the CLI’s style of memory management and thread safety. Other .NET or Mono applications can use legacy code, which is referred to as unmanaged, by using the System.Runtime.InteropServices libraries to create C# bindings. Many libraries which ship with Mono use this feature of the CLI, such as Gtk#.

Mono-specific innovations[edit]

Mono has innovated in some areas with new extensions to the core C# and CLI specifications:

• C# Compiler as a Service (Use the C# compiler as a library).^[32]
• C# Interactive Shell.^[33]
• SIMD support^[34] as part of the Mono.SIMD namespace, where method calls to special vector types are directly mapped to the underlying processor CPU SIMD instructions.
• Full static compilation of .NET code^[35] (used on Mono/iPhone, Mono/PS3).
• Mono coroutines (used to implement micro-threading code and continuations, mostly for game developers).^[36]
• Assembly injection to live processes.^[37]
• Use of LLVM as JIT backend.
• Cxxi and CppSharp direct interop with C++ code and libraries.

In addition, Mono is available on a variety of operating systems and architectures.^[38]

System requirements[edit]

Windows 7, Windows 8, Windows 8.1, Windows 10, macOS or Linux

[edit]

Several projects extend Mono and allow developers to use it in their development environment. These projects include:

Cross-platform:

• Banshee Media Player (stalled), a cross-platform music media player built with Mono and Gtk# and also a driver of dozens of C#-based libraries and projects for media handling.
• Beagle (unmaintained), a search system for Unix systems.
• Gecko#, bindings for embedding the layout engine used in Mozilla (Gecko).
• Gtk#, C# wrappers around the underlying GTK and GNOME libraries, written in C and available on Linux, MacOS and Windows.
• Mono Migration Analyzer (MoMA), a tool which aids Windows .NET developers in finding areas in their code that might not be cross-platform and therefore not work in Mono on Linux and other Unixes. Not upgraded since Mono 2.8 (2013); use Microsoft’s .NET Portability Analyzer (dotnet-apiport) instead.
• MonoCross, a cross-platform model–view–controller design pattern where the Model and Controller are shared across platforms and the Views are unique for each platform for an optimized User Interface. The framework requires Xamarin.iOS and Xamarin.Android.
• MvvmCross, a cross-platform Model View ViewModel framework utilizing Xamarin.iOS and Xamarin.Android for developing mobile apps.
• MonoDevelop an open-source and cross-platform integrated development environment that supports building applications for ASP.NET, Gtk#, Meego, MonoTouch and Silverlight/Moonlight.
• Moonlight (discontinued), an implementation of Silverlight that uses Mono.
• OpenTK, a managed binding for OpenGL, OpenCL and OpenAL.
• QtSharp, C# bindings for the Qt framework.
• Resco MobileBusiness, a cross-platform developer solution for mobile clients.
• Resco MobileCRM, a cross-platform developer solution for mobile clients synchronized with Microsoft Dynamics CRM.
• ServiceStack a high-performance open-source .NET REST web services framework that simplifies the development of XML, JSON and SOAP web services.
• SparkleShare an open-source client software that provides cloud storage and file synchronization services.
• Tao (superseded by OpenTK), a collection of graphics and gaming bindings (OpenGL, SDL, GLUT, Cg).
• Xwt, a GUI toolkit that maps API calls to native platform calls of the underlying platform, exposing one unified API across different platforms and making possible for the graphical user interfaces to have native look and feel on different platforms. It enables building GUI-based desktop applications that run on multiple platforms, without having to customizing code for different platforms. Xwt API is mapped to a set of native controls on each supported platform. Features that are not available on specific platforms are emulated by using native widgets, which is referred to as hosting in the Xwt context.^[39] Xwt was partially used as GUI toolkit (beside GTK#) in the development of the Xamarin Studio.^[40] Supported «backend» engines are: WPF engine and Gtk engine (using Gtk#) on Windows, Cocoa engine (using MonoMac) and Gtk engine (using Gtk#) on Mac OS X, and Gtk engine (using Gtk#) on Linux.^[41]

macOS:

• Cocoa# – wrappers around the native macOS toolkit (Cocoa) (deprecated).
• Monobjc – a set of bindings for macOS programming.
• MonoMac – newer bindings for macOS programming, based on the MonoTouch API design.

Mobile platforms:

• MonoDroid. Mono for the Android operating system. With bindings for the Android APIs.
• MonoTouch. Mono for the iPhone, iPad and iPod Touches. With bindings to the iOS APIs.

Windows:

• MonoTools for Visual Studio A Visual Studio plugin that allows Windows developers to target Linux and macOS right from Visual Studio and integrates with SUSE Studio.

Other implementations[edit]

Microsoft has a version of .NET 2.0 now available only for Windows XP, called the Shared Source CLI (Rotor). Microsoft’s shared source license may be insufficient for the needs of the community (it explicitly forbids commercial use).

Free Software Foundation’s decommissioned Portable.NET project.^[42]

MonoDevelop[edit]

MonoDevelop is a free GNOME integrated development environment primarily designed for C# and other .NET languages such as Nemerle, Boo, and Java (via IKVM.NET), although it also supports languages such as C, C++, Python, and Vala. MonoDevelop was originally a port of SharpDevelop to Gtk#, but it has since evolved to meet the needs of Mono developers. The IDE includes class management, built-in help, code completion, Stetic (a GUI designer), project support, and an integrated debugger.

The MonoDoc browser provides access to API documentation and code samples. The documentation browser uses wiki-style content management, allowing developers to edit and improve the documentation.

Xamarin.iOS and Xamarin.Android[edit]

Xamarin.iOS and Xamarin.Android, both developed by Xamarin, are implementations of Mono for iPhone and Android-based smartphones. Previously available only for commercial licensing,^[43] after Microsoft’s acquisition of Xamarin in 2016, the Mono runtime itself was relicensed under MIT license^[44] and both Xamarin.iOS and Xamarin.Android are being made free and open-source.^[45]

Xamarin.iOS[edit]

Xamarin.iOS (previously named MonoTouch) is a library that allows developers to create C# and .NET based applications that run on the iPhone, iPod and iPad devices. It is based on the Mono framework and developed in conjunction with Novell. Unlike Mono applications, Xamarin.iOS «Apps» are compiled down to machine code targeted specifically at the Apple iPhone and iPad.^[46] This is necessary because the iOS kernel prevents just-in-time compilers from executing on the device.

The Xamarin.iOS stack is made up of:

• Compilers
  • C# from the Mono Project
  • Third-party compilers like RemObject’s Oxygene can target Xamarin.iOS also
• Core .NET libraries
• Development SDK:
  • Linker – used to bundle only the code used in the final application
  • mtouch – the Native compiler and tool used to deploy to the target device
  • Interface Builder integration tools
• Libraries that bind the native CocoaTouch APIs
• Xamarin Studio IDE

Xamarin Studio is used as the primary IDE, however additional links to Xcode and the iOS simulator have been written.

From April to early September 2010, the future of MonoTouch was put in doubt as Apple introduced new terms for iPhone developers that apparently prohibits them from developing in languages other than C, C++ and Objective-C, and the use of a middle layer between the iOS platform and iPhone applications. This made the future of MonoTouch, and other technologies such as Unity, uncertain.^[47] Then, in September 2010, Apple rescinded this restriction, stating that they were relaxing the language restrictions that they had put in place earlier that year.^[48][49]

Version history[edit]

Release History

Date	Version	Notes
September 14, 2009	MonoTouch 1.0[50]	Initial release
April 5, 2010	MonoTouch 2.0[51]	iPad support
April 16, 2010	MonoTouch 3.0[52]	iPhone 4 support
April 6, 2011	MonoTouch 4.0[53]	iOS 4 support
October 12, 2011	MonoTouch 5.0[54]	iOS 5 support
September 19, 2012	MonoTouch 6.0[55]	iOS 6 support
February 20, 2013	Xamarin.iOS 6.2[56]	Visual Studio support
July 24, 2013	Xamarin.iOS 6.4[57]	.NET 4.5 async/await support
June 19, 2013	Xamarin.iOS 7.0[58]	XCode 5 and iOS 7 support
September 10, 2014	Xamarin.iOS 8.0[59]	iOS 8 and Xcode 6 support
September 16, 2015	Xamarin.iOS 9.0[60]	iOS 9 and Xcode 7 support
September 13, 2016	Xamarin.iOS 10.0[61]	iOS 10 and Xcode 8 support
September 19, 2017	Xamarin.iOS 11.0[62]	iOS 11 and Xcode 9 support
September 14, 2018	Xamarin.iOS 12.0[63]	iOS 12 and Xcode 10 support
September 13, 2019	Xamarin.iOS 13.0[64]	iOS 13 and Xcode 11 support
September 20, 2020	Xamarin.iOS 14.0[65]	iOS 14 and Xcode 12 support

Xamarin.Android[edit]

Xamarin.Android (formerly known as Mono for Android), initially developed by Novell and continued by Xamarin, is a proprietary^{[citation needed][66]} implementation of Mono for Android-based smart-phones.^[67][68][69] It was first released on April 6, 2011.^[70] Mono for Android was developed to allow developers to more easily write cross-platform applications that will run on all mobile platforms.^[71] In an interview with H-Online, Miguel de Icaza stated, «Our vision is to allow developers to reuse their engine and business logic code across all mobile platforms and swapping out the user interface code for a platform-specific API.»^[72]

In August 2010, a Microsoft spokesman, Tom Hanrahan of Microsoft’s Open Source Technology Centre, stated, in reference to the lawsuit filed by Oracle against Google over Android’s use of Java, that «The type of action Oracle is taking against Google over Java is not going to happen. If a .NET port to Android was through Mono it would fall under the Microsoft Community Promise Agreement.»^[73][74]

The Xamarin.Android stack consists of the following components:

• Mono runtime
• An Android UI designer^[75]
• Libraries:
  • Core .NET class libraries
  • Libraries that bind the native Android/Java APIs
• SDK tools to package, deploy and debug
• Xamarin Studio and Visual Studio 2010 integration to design the UI, remotely debug, and deploy.

Mono on macOS[edit]

CocoaSharp[edit]

Cocoa# (also known as CocoaSharp) was a bridge framework for Mac OS X, which allowed applications developed with the Mono runtime to access the Cocoa API. It was initially released on August 12, 2004,^[76] and was included with the Mono distribution starting with version 1.0.6, released on February 18, 2005.^{[citation needed]} It has not seen any development since 2008,^{[citation needed]} and is now deprecated.^[77]

Monobjc[edit]

Monobjc was CocoaSharp’s replacement. It allows .NET developers to use most of the Mac OS X API, including Cocoa, with no native code, while still achieving a native UI.^{[citation needed]}

Xamarin.Mac[edit]

Xamarin.Mac is a library that allows developers to run .NET and C# apps on the Mac.^[78]

License[edit]

Mono is dual licensed by Xamarin, similar to other products such as Qt and the Mozilla Application Suite. Mono’s C# compiler and tools are released under the GNU General Public License (GPLv2 only) (starting with version 2.0 of Mono, the Mono C# compiler source code is also available under the MIT X11 License),^[79] the runtime libraries under the GNU Lesser General Public License (LGPLv2 only) and the class libraries under the MIT License. These are all free software and open-source licenses and hence Mono is free and open-source software.

The license of the C# compiler was changed from the GPL to the MIT X11 license^[80] to allow the compiler code to be reused in a few instances where the GPL would have prevented such:

• Mono’s Compiler as a Service
  • The Mono interactive Shell
  • The Mono embeddable C# compiler
• Mono’s implementation of the C# 4.0 dynamic binder.
• MonoDevelop’s built-in parser and AST graph

On March 18, 2016, Microsoft’s acquisition of Xamarin was officially closed.^[81]
On March 31, 2016, Microsoft announced at Microsoft Build that they’ll completely re-license Mono under the MIT License even in scenarios where previously a commercial license was necessary,^[82] and Microsoft stated that they won’t assert any «applicable patents» against parties that are «using, selling, offering for sale, importing, or distributing Mono.»^[83][84] It was also announced that Xamarin had contributed the Mono Project to the .NET Foundation.^[83]

Mono and Microsoft’s patents[edit]

Software developed with Mono[edit]

Many programs covering a range of applications have been developed using the Mono application programming interface (API) and C#. Some programs written for the Linux Desktop include Banshee, Beagle, F-Spot, Gbrainy, Docky/GNOME Do, MonoTorrent, Pinta, and Tomboy. The program, Logos 5 Bible Study Software (OS X Version), was written for the MacOS.

A number of video games, such as The Sims 3 and Second Life (for their scripting languages), OpenSimulator virtual world server, or games built with the Unity or MonoGame game engines, also make use of Mono.^[85] OpenRA bundles its Apple Disk Image and Linux AppImages with Mono essentially removing almost all dependencies from the game.^[86]

Version history[edit]

Release history^[87]

Date	Version[88]	Notes
June 30, 2004	1.0[89]	C# 1.0 support
September 21, 2004	1.1[90]
November 9, 2006	1.2[91]	C# 2.0 support
October 6, 2008	2.0[92]	Mono’s APIs are now in par with .NET 2.0. Introduces the C# 3.0 and Visual Basic 8 compilers. New Mono-specific APIs: Mono.Cecil, Mono.Cairo and Mono.Posix. Gtk# 2.12 is released. The Gendarme verification tool and Mono Linker are introduced.
January 13, 2009	2.2[93]	Mono switches its JIT engine to a new internal representation[94] that gives it a performance boost and introduces SIMD support in the Mono.Simd[34] Mono.Simd namespace. Mono introduces Full Ahead of Time compilation that allows developers to create full static applications and debuts the C# Compiler as a Service[32] and the C# Interactive Shell[33] (C# REPL)
March 30, 2009	2.4[95]	This release mostly polishes all the features that shipped in 2.2 and became the foundation for the Long-Term support of Mono in SUSE Linux.
December 15, 2009	2.6[96]	The Mono runtime is now able to use LLVM as a code generation backend and this release introduces Mono co-routines, the Mono Soft Debugger and the CoreCLR security system required for Moonlight and other Web-based plugins. On the class library System.IO.Packaging, WCF client, WCF server, LINQ to SQL debut. The Interactive shell supports auto-completion and the LINQ to SQL supports multiple database backends. The xbuild build system is introduced.
September 22, 2010	2.8[97]	Defaults to .NET 4.0 profile, C# 4.0 support, new generational garbage collector, includes Parallel Extensions, WCF Routing, CodeContracts, ASP.NET 4.0, drops the 1.0 profile support; the LLVM engine tuned to support 99.9% of all generated code, runtime selectable llvm and gc; incorporates Dynamic Language Runtime, MEF, ASP.NET MVC2, OData Client open-source code from Microsoft;. Will become release 3.0
February 15, 2011	2.10[98]
October 18, 2012	3.0[99]	C# 5.0 support, async support, Async Base Class Library Upgrade and MVC4 — Partial, no async features support.
July 24, 2013	3.2[100]	Default Garbage Collector is now the SGEN, instead of Boehm
March 31, 2014	3.4[101]
August 12, 2014	3.6[102]
September 4, 2014	3.8[103]
October 4, 2014	3.10[104]
January 13, 2015	3.12[105]
April 29, 2015	4.0[106]	Defaults to .NET 4.5 profile and ships only .NET 4.5 assemblies, defaults to C# 6.0. First release to integrate Microsoft open-source .NET Core code
May 10, 2017	5.0[107]	Shipping Roslyn C# compiler to enable C#7 support; Shipping msbuild and deprecating xbuild for better compatibility; Enabling concurrent SGen garbage collector to reduce time spent in GC; Introducing the AppleTLS stack on macOS for HTTPS connections; Continued Progress on .NET Class Library convergence; Updated libjpeg in macOS package
July 14, 2017	5.2[108]	Support for .NET Standard 2.0, strong assembly names, and experimental default interface members.
October 5, 2017	5.4[109]	The JIT Runtime now supports concurrent method compilation and various other Performance Optimisations; Added .NET 4.7 reference assemblies
February 1, 2018	5.8[110]	Initial WebAssembly port; Modes for the SGen GC; Includes Roslyn’s csi (C# interactive) REPL tool
February 26, 2018	5.10[111]	The Interpreter is now included in the default installation; runtime now supports Default Interface Methods; WebAssembly considered reliable now; Support for .NET 4.7.1 / C# 7.2 / F# 4.1
May 8, 2018	5.12[112]	Port to IBM AIX/i; now includes VB.NET compiler; option to use jemalloc
August 7, 2018	5.14[113]	Major Windows.Forms update to improve compatibility with .NET
October 8, 2018	5.16[114]	Hybrid suspend garbage collector; Client certificate support; C# 7.3 support
December 21, 2018	5.18[115]	.NET 4.7.2 support; more CoreFX code is used
July 17, 2019	6.0[116]	C# compiler defaults to version C# 8.0 RC; Various stability improvement in debugger support; Mono Interpreter is feature complete and stable
September 23, 2019	6.4[117]	C# compiler support for C# 8 language version; .NET Standard 2.1 support
December 10, 2019	6.6[118]	Added .NET 4.8 reference assemblies
January 15, 2020	6.8[119]	Various Bugfixes
May 19, 2020	6.10[120]	Various Bugfixes
November 24, 2020	6.12[121]	Various Bugfixes

See also[edit]

• Common Language Runtime
• .NET Framework
• .NET, an open-source framework and successor to .NET Framework
• Standard Libraries (CLI)
  • Base Class Library (BCL)
• Comparison of application virtual machines
• DotGNU – A free software umbrella project which includes Portable.NET
• MonoDevelop – An open-source IDE targeting both Mono and Microsoft .NET Framework platforms
• Moonlight (runtime), an open-source implementation of Microsoft’s Silverlight developed by the Mono Project
• Shared Source Common Language Infrastructure – Microsoft’s shared source implementation of .NET, formerly codenamed Rotor
• mod_mono – A module for the Apache HTTP Server that allows hosting of ASP.NET pages and other assemblies on multiple platforms by use of Mono

References[edit]

Citations[edit]

Sources[edit]

• This article incorporates text from Mono’s homepage, which was then under the GNU Free Documentation License.
• de Icaza, Miguel (October 13, 2003). «[Mono-list] Mono early history.». Archived from the original (mailing list) on June 6, 2011. Retrieved December 6, 2005.
• Dumbill, Edd (March 11, 2004). «Will Mono Become the Preferred Platform for Linux Development?». ONLamp. Archived from the original on October 19, 2006. Retrieved October 14, 2006.
• Loli-Queru, Eugenia (February 22, 2005). «Mono Applications? Aplenty!». OSNews. Retrieved December 6, 2005.
• Kerner, Sean Michael (November 18, 2005). «Mono Project Goes Virtual». Internet News. Retrieved October 14, 2006.
• Kerner, Sean Michael (November 9, 2006). «Months Late, Novell Ships Mono 1.2». internetnews.com.
• Northcutt, Corey (October 12, 2006). «In the World of mod_mono». Ubiquity. Archived from the original on February 23, 2007. Retrieved October 14, 2006.
• Campbell, Sean (October 8, 2008). «Interview with Joseph Hill — Product Manager — Mono — Novell». HSIB. Retrieved October 8, 2008.
• Smith, Tim (September 9, 2010). «A Brief Introduction to the Java and .NET Patent Issues». InfoQ. Retrieved September 13, 2010.

External links[edit]

• Official website
• MonoTouch Main Page for the port to Apple Inc.’s hand-held products

Mono для Windows — это платформа разработки, предназначенная для создания приложений на различных языках программирования. Она позволяет разрабатывать кросс-платформенное программное обеспечение, которое может работать на операционных системах Windows, Linux и macOS.

Mono для Windows базируется на технологии .NET Framework и обеспечивает среду выполнения для языков программирования, таких как C#, F# и Visual Basic. Она поддерживает библиотеки .NET Framework, что позволяет использовать существующий код и инфраструктуру, разработанную для .NET Framework.

Использование Mono для Windows позволяет программистам разрабатывать приложения, которые могут работать на разных операционных системах, не заботясь о различиях в среде выполнения. Благодаря этому, разработчики могут создавать гибкие и переносимые приложения, которые могут быть запущены на разных платформах без необходимости переписывать весь код.

Одной из ключевых особенностей Mono для Windows является его открытый исходный код. Это позволяет разработчикам настраивать и оптимизировать платформу под свои нужды, а также вносить вклад в развитие проекта.

Если вы хотите начать использовать Mono для Windows, вам необходимо установить соответствующий пакет, который доступен на официальном сайте проекта. После установки вы сможете создавать и запускать приложения на языках программирования, поддерживаемых Mono для Windows.

В заключение, Mono для Windows – это мощная и гибкая платформа разработки, которая обеспечивает переносимость и эффективность при создании кросс-платформенных приложений на разных операционных системах. Она активно развивается и поддерживается сообществом разработчиков, что делает ее привлекательным выбором для создания приложений на различных платформах.

Что такое Mono для Windows и для чего он нужен

Mono обладает большими возможностями в сфере кросс-платформенной разработки, позволяя создавать приложения, которые могут работать как на Windows, так и на других платформах, таких как Linux и macOS. Это особенно полезно для разработчиков, которые хотят создать приложение, доступное на разных операционных системах.

Использование Mono для Windows позволяет разработчикам переносить свои приложения с Windows на другие платформы не переписывая их код с нуля. Также Mono обеспечивает совместимость с платформой .NET, что означает, что приложения, разработанные на .NET, могут быть запущены на Windows с использованием Mono без дополнительных модификаций.

Кроме того, Mono предоставляет разработчикам доступ к библиотекам и инструментам для создания кросс-платформенных приложений. Например, с помощью Mono можно использовать GTK#, библиотеку графического интерфейса пользователя, для создания многофункциональных приложений с привлекательным дизайном.

В заключение, Mono для Windows – это мощный инструмент для разработчиков Windows, который позволяет создавать и запускать кросс-платформенные приложения на различных операционных системах. Он предлагает широкий спектр возможностей и облегчает перенос приложений между платформами, что делает его важным инструментом для разработки программного обеспечения.

Установка Mono на Windows

Шаг 1: Перейдите на официальный сайт Mono по ссылке https://www.mono-project.com/download/stable/.

Шаг 2: Скачайте установщик Mono для Windows, нажав на кнопку «Download» рядом с соответствующей версией Mono.

Шаг 3: Запустите скачанный установщик и следуйте инструкциям на экране. Убедитесь, что выбраны все необходимые компоненты для установки.

Шаг 4: После завершения установки откройте командную строку Windows и введите команду mono --version для проверки успешности установки. Если вы видите информацию о версии Mono, то установка прошла успешно.

Теперь, после установки Mono на Windows, вы можете разрабатывать и запускать кросс-платформенные приложения на языке C#. Mono предоставляет вам возможность использовать один и тот же код на Windows, macOS и Linux, значительно упрощая процесс разработки.

Работа с Mono в командной строке

Mono предоставляет возможность работать с платформой .NET на различных операционных системах, включая Windows. Для работы с Mono в командной строке необходимо выполнить несколько простых шагов.

1. Установите Mono на вашу операционную систему Windows. Загрузите установщик с официального сайта Mono и следуйте инструкциям по установке. После установки вы сможете использовать все инструменты и библиотеки Mono в командной строке.

2. Откройте командную строку Windows. Для этого нажмите клавишу Win + R и введите команду «cmd». Нажмите клавишу Enter, чтобы открыть командную строку.

3. Проверьте, что Mono установлен корректно, введя команду «mono» в командной строке. Если установка прошла успешно, вы увидите информацию о версии Mono и настройках.

4. Для запуска приложения, написанного на платформе .NET с использованием Mono, введите команду «mono <путь_к_файлу.exe>«. Замените <путь_к_файлу.exe> на полный путь к исполняемому файлу вашего приложения.

Теперь вы готовы работать с Mono в командной строке на Windows. Используйте команды и инструменты Mono для компиляции и запуска приложений на платформе .NET, а также для разработки и отладки вашего кода.

Создание и компиляция программ на Mono

1. Создание программы

Прежде чем начать, убедитесь, что у вас установлен фреймворк Mono на вашем компьютере. После этого вы можете использовать любой текстовый редактор для написания программы на языке C#. Создайте новый файл с расширением .cs и начните писать свой код.

Пример простой программы на C#:

using System;
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Привет, мир!");
}
}

2. Компиляция программы

Когда ваша программа готова, сохраните ее в файле с расширением .cs. Затем откройте командную строку и перейдите в каталог, где находится ваш файл с программой.

Для компиляции программы на Mono, используйте утилиту mcs. Запустите команду:

mcs -out:имя_выходного_файла.exe имя_файла.cs

Замените имя_выходного_файла.exe на любое имя, которое вы хотите использовать для исполняемого файла вашей программы. А имя_файла.cs — на имя файла вашей программы.

Например, если ваше имя выходного файла — hello.exe, а имя файла программы — hello.cs, запустите команду:

mcs -out:hello.exe hello.cs

После выполнения этой команды в каталоге появится исполняемый файл вашей программы.

3. Запуск программы

Для запуска программы на Mono, просто запустите исполняемый файл, созданный на предыдущем шаге. В нашем примере мы создали файл hello.exe, поэтому можно выполнить команду:

mono hello.exe

После этого в командной строке вы увидите вывод программы: «Привет, мир!»

Теперь вы знаете, как создавать и компилировать программы на Mono. Успешной разработки!

Mono is a software platform designed to allow developers to easily
create cross platform applications. It is an open source
implementation of Microsoft’s .NET Framework based on the ECMA
standards for C# and the Common Language Runtime.

The Mono project is part of the .NET Foundation

Join us on Discord in the #monovm channel:

Contents

1. Compilation and Installation
2. Using Mono
3. Directory Roadmap
4. Contributing to Mono
5. Reporting bugs
6. Configuration Options
7. Working with Submodules

Build Status

Public CI:

Legacy Jenkins CI (no longer available publicly):

OS	Architecture	Status
Debian 9	amd64
Debian 9	i386
Debian 9	armel
Debian 9	armhf
Debian 9	arm64
OS X	amd64
OS X	i386
Windows	amd64
Windows	i386
CentOS	s390x (cs)
Debian 9	ppc64el (cs)
AIX 6.1	ppc64 (cs)
FreeBSD 12	amd64 (cs)

(cs) = community supported architecture

Compilation and Installation

Building the Software

Please see our guides for building Mono on
Mac OS X,
Linux and
Windows.

Note that building from Git assumes that you already have Mono installed,
so please download and install the latest Mono release
before trying to build from Git. This is required because the Mono build
relies on a working Mono C# compiler to compile itself
(also known as bootstrapping).

If you don’t have a working Mono installation

If you don’t have a working Mono installation, you can try a slightly
more risky approach: getting the latest version of the ‘monolite’ distribution,
which contains just enough to run the ‘mcs’ compiler. You do this with:

# Run the following line after ./autogen.sh
make get-monolite-latest

This will download and place the files appropriately so that you can then
just run:

The build will then use the files downloaded by make get-monolite-latest.

Testing and Installation

You can run the mono and mcs test suites with the command: make check.

Expect to find a few test suite failures. As a sanity check, you
can compare the failures you got with https://jenkins.mono-project.com/.

You can now install mono with: make install

You can verify your installation by using the mono-test-install
script, it can diagnose some common problems with Mono’s install.
Failure to follow these steps may result in a broken installation.

Using Mono

Once you have installed the software, you can run a few programs:

• mono program.exe runtime engine

• mcs program.cs C# compiler

• monodis program.exe CIL Disassembler

See the man pages for mono(1), mcs(1) and monodis(1) for further details.

Directory Roadmap

• acceptance-tests/ — Optional third party test suites used to validate Mono against a wider range of test cases.

• data/ — Configuration files installed as part of the Mono runtime.

• docs/ — Technical documents about the Mono runtime.

• external/ — Git submodules for external libraries (Newtonsoft.Json, ikvm, etc).

• ikvm-native/ — Glue code for ikvm.

• libgc/ — The (deprecated) Boehm GC implementation.

• llvm/ — Utility Makefiles for integrating the Mono LLVM fork.

• m4/ — General utility Makefiles.

• man/ — Manual pages for the various Mono commands and programs.

• mcs/ — The class libraries, compiler and tools

  • class/ — The class libraries (like System.*, Microsoft.Build, etc.)

  • mcs/ — The Mono C# compiler written in C#

  • tools/ — Tools like gacutil, ikdasm, mdoc, etc.

• mono/ — The core of the Mono Runtime.

  • arch/ — Architecture specific portions.

  • benchmark/ — A collection of benchmarks.

  • btls/ — Build files for the BTLS library which incorporates BoringSSL.

  • cil/ — Common Intermediate Representation, XML
    definition of the CIL bytecodes.

  • dis/ — CIL executable Disassembler.

  • eglib/ — Independent implementation of the glib API.

  • metadata/ — The object system and metadata reader.

  • mini/ — The Just in Time Compiler.

  • profiler/ — The profiler implementation.

  • sgen/ — The SGen Garbage Collector implementation.

  • tests/ — The main runtime tests.

  • unit-tests/ — Additional runtime unit tests.

  • utils/ — Utility functions used across the runtime codebase.

• msvc/ — Logic for the MSVC / Visual Studio based runtime and BCL build system.
  The latter is experimental at the moment.

• packaging/ — Packaging logic for the OS X and Windows Mono packages.

• po/ — Translation files.

• runtime/ — A directory that contains the Makefiles that link the
  mono/ and mcs/ build systems.

• samples/ — Some simple sample programs on uses of the Mono
  runtime as an embedded library.

• scripts/ — Scripts used to invoke Mono and the corresponding program.

• support/ — Various support libraries.

• tools/ — A collection of tools, mostly used during Mono development.

Contributing to Mono

Before submitting changes to Mono, please review the contribution
guidelines.
Please pay particular attention to the Important
Rules
section.

Reporting bugs

To submit bug reports, please open an issue on the mono GitHub repo.

Please use the search facility to ensure the same bug hasn’t already
been submitted and follow our
guidelines
on how to make a good bug report.

Configuration Options

The following are the configuration options that someone building Mono
might want to use:

• --with-sgen=yes,no — Generational GC support: Used to enable or
  disable the compilation of a Mono runtime with the SGen garbage
  collector.

  • On platforms that support it, after building Mono, you will have
    both a mono-boehm binary and a mono-sgen binary. mono-boehm uses Boehm,
    while mono-sgen uses the Simple Generational GC.

• --with-libgc=[included, none] — Selects the default Boehm
  garbage collector engine to use.

  • included: (slightly modified Boehm GC) This is the default
    value for the Boehm GC, and it’s the most feature complete, it will
    allow Mono to use typed allocations and support the debugger.

  • none:
    Disables the inclusion of a Boehm garbage collector.

  • This defaults to included.

• --enable-cooperative-suspend

  • If you pass this flag the Mono runtime is configured to only use
    the cooperative mode of the garbage collector. If you do not pass
    this flag, then you can control at runtime the use of the
    cooperative GC mode by setting the MONO_ENABLE_COOP_SUSPEND flag.

• --with-tls=__thread,pthread

  • Controls how Mono should access thread local storage,
    pthread forces Mono to use the pthread APIs, while
    __thread uses compiler-optimized access to it.

  • Although __thread is faster, it requires support from
    the compiler, kernel and libc. Old Linux systems do
    not support with __thread.

  • This value is typically pre-configured and there is no
    need to set it, unless you are trying to debug a problem.

• --with-sigaltstack=yes,no

  • Experimental: Use at your own risk, it is known to
    cause problems with garbage collection and is hard to
    reproduce those bugs.

  • This controls whether Mono will install a special
    signal handler to handle stack overflows. If set to
    yes, it will turn stack overflows into the
    StackOverflowException. Otherwise when a stack
    overflow happens, your program will receive a
    segmentation fault.

  • The configure script will try to detect if your
    operating system supports this. Some older Linux
    systems do not support this feature, or you might want
    to override the auto-detection.

• --with-static_mono=yes,no

  • This controls whether mono should link against a
    static library (libmono.a) or a shared library
    (libmono.so).

  • This defaults to yes, and will improve the performance
    of the mono program.

  • This only affects the `mono’ binary, the shared
    library libmono.so will always be produced for
    developers that want to embed the runtime in their
    application.

• --with-xen-opt=yes,no — Optimize code for Xen virtualization.

  • It makes Mono generate code which might be slightly
    slower on average systems, but the resulting executable will run
    faster under the Xen virtualization system.

  • This defaults to yes.

• --with-large-heap=yes,no — Enable support for GC heaps larger than 3GB.

  • This only applies only to the Boehm garbage collector, the SGen garbage
    collector does not use this configuration option.

  • This defaults to no.

• --enable-small-config=yes,no — Enable some tweaks to reduce memory usage
  and disk footprint at the expense of some capabilities.

  • Typically this means that the number of threads that can be created
    is limited (256), that the maximum heap size is also reduced (256 MB)
    and other such limitations that still make mono useful, but more suitable
    to embedded devices (like mobile phones).

  • This defaults to no.

• --with-ikvm-native=yes,no — Controls whether the IKVM JNI interface library is
  built or not.

  • This is used if you are planning on
    using the IKVM Java Virtual machine with Mono.

  • This defaults to yes.

• --with-profile4=yes,no — Whether you want to build the 4.x profile libraries
  and runtime.

  • This defaults to yes.

• --with-libgdiplus=installed,sibling,<path> — Configure where Mono
  searches for libgdiplus when running System.Drawing tests.

  • It defaults to installed, which means that the
    library is available to Mono through the regular
    system setup.

  • sibling can be used to specify that a libgdiplus
    that resides as a sibling of this directory (mono)
    should be used.

• Or you can specify a path to a libgdiplus.

• --enable-minimal=LIST

  • Use this feature to specify optional runtime
    components that you might not want to include. This
    is only useful for developers embedding Mono that
    require a subset of Mono functionality.

  • The list is a comma-separated list of components that
    should be removed, these are:

    • aot:
      Disables support for the Ahead of Time compilation.

    • attach:
      Support for the Mono.Management assembly and the
      VMAttach API (allowing code to be injected into
      a target VM)

    • com:
      Disables COM support.

    • debug:
      Drop debugging support.

    • decimal:
      Disables support for System.Decimal.

    • full_messages:
      By default Mono comes with a full table
      of messages for error codes. This feature
      turns off uncommon error messages and reduces
      the runtime size.

    • generics:
      Generics support. Disabling this will not
      allow Mono to run any 2.0 libraries or
      code that contains generics.

    • jit:
      Removes the JIT engine from the build, this reduces
      the executable size, and requires that all code
      executed by the virtual machine be compiled with
      Full AOT before execution.

    • large_code:
      Disables support for large assemblies.

    • logging:
      Disables support for debug logging.

    • pinvoke:
      Support for Platform Invocation services,
      disabling this will drop support for any
      libraries using DllImport.

    • portability:
      Removes support for MONO_IOMAP, the environment
      variables for simplifying porting applications that
      are case-insensitive and that mix the Unix and Windows path separators.

    • profiler:
      Disables support for the default profiler.

    • reflection_emit:
      Drop System.Reflection.Emit support

    • reflection_emit_save:
      Drop support for saving dynamically created
      assemblies (AssemblyBuilderAccess.Save) in
      System.Reflection.Emit.

    • shadow_copy:
      Disables support for AppDomain’s shadow copies
      (you can disable this if you do not plan on
      using appdomains).

    • simd:
      Disables support for the Mono.SIMD intrinsics
      library.

    • ssa:
      Disables compilation for the SSA optimization
      framework, and the various SSA-based optimizations.

• --enable-llvm

  • This enables the use of LLVM as a code generation engine
    for Mono. The LLVM code generator and optimizer will be
    used instead of Mono’s built-in code generator for both
    Just in Time and Ahead of Time compilations.

  • See https://www.mono-project.com/docs/advanced/mono-llvm/ for the
    full details and up-to-date information on this feature.

  • You will need to have an LLVM built that Mono can link
    against.

• --enable-big-arrays — Enable use of arrays with indexes larger
  than Int32.MaxValue.

  • By default Mono has the same limitation as .NET on
    Win32 and Win64 and limits array indexes to 32-bit
    values (even on 64-bit systems).

  • In certain scenarios where large arrays are required,
    you can pass this flag and Mono will be built to
    support 64-bit arrays.

  • This is not the default as it breaks the C embedding
    ABI that we have exposed through the Mono development
    cycle.

• --enable-parallel-mark

  • Use this option to enable the garbage collector to use
    multiple CPUs to do its work. This helps performance
    on multi-CPU machines as the work is divided across CPUS.

  • This option is not currently the default on OSX
    as it runs into issues there.

  • This option only applies to the Boehm GC.

• --enable-dtrace

  • On Solaris and MacOS X builds a version of the Mono
    runtime that contains DTrace probes and can
    participate in the system profiling using DTrace.

• --disable-dev-random

  • Mono uses /dev/random to obtain good random data for
    any source that requires random numbers. If your
    system does not support this, you might want to
    disable it.

  • There are a number of runtime options to control this
    also, see the man page.

• --with-csc=roslyn,mcs,default

  • Use this option to configure which C# compiler to use. By default
    the configure script will pick Roslyn, except on platforms where
    Roslyn does not work (Big Endian systems) where it will pick mcs.

    If you specify «mcs», then Mono’s C# compiler will be used. This
    also allows for a complete bootstrap of Mono’s core compiler and
    core libraries from source.

  If you specify «roslyn», then Roslyn’s C# compiler will be used.
This currently uses Roslyn binaries.

• --enable-nacl

  • This configures the Mono compiler to generate code
    suitable to be used by Google’s Native Client:
    https://code.google.com/p/nativeclient/

  • Currently this is used with Mono’s AOT engine as
    Native Client does not support JIT engines yet.

• --enable-wasm

  • Use this option to configure mono to run on WebAssembly. It will
    set both host and target to the WebAssembly triplet. This overrides
    the values passed to --host or --target and ignored what config.sub guesses.

    This is a workaround to enable usage of old automake versions that don’t
    recognize the wasm triplet.

Working With Submodules

Mono references several external git submodules, for example
a fork of Microsoft’s reference source code that has been altered
to be suitable for use with the Mono runtime.

This section describes how to use it.

An initial clone should be done recursively so all submodules will also be
cloned in a single pass:

$ git clone --recursive git@github.com:mono/mono

Once cloned, submodules can be updated to pull down the latest changes.
This can also be done after an initial non-recursive clone:

$ git submodule update --init --recursive

To pull external changes into a submodule:

$ cd <submodule>
$ git pull origin <branch>
$ cd <top-level>
$ git add <submodule>
$ git commit

By default, submodules are detached because they point to a specific commit.
Use git checkout to move back to a branch before making changes:

$ cd <submodule>
$ git checkout <branch>
# work as normal; the submodule is a normal repo
$ git commit/push new changes to the repo (submodule)

$ cd <top-level>
$ git add <submodule> # this will record the new commits to the submodule
$ git commit

To switch the repo of a submodule (this should not be a common or normal thing
to do at all), first edit .gitmodules to point to the new location, then:

$ git submodule sync -- <path of the submodule>
$ git submodule update --recursive
$ git checkout <desired new hash or branch>

The desired output diff is a change in .gitmodules to reflect the
change in the remote URL, and a change in / where you see
the desired change in the commit hash.

License

See the LICENSE file for licensing information, and the PATENTS.TXT
file for information about Microsoft’s patent grant.

Mono Trademark Use Policy

The use of trademarks and logos for Mono can be found here.

В мире программирования существует множество различных платформ и технологий, которые в своей основе работают на разных операционных системах. Одной из таких платформ является Mono. Разработанная компанией Xamarin, Mono является свободной и открытой реализацией платформы .NET, и предоставляет разработчикам возможность создавать кросс-платформенные приложения.

Mono поддерживает работу приложений на разных операционных системах, включая Windows. Благодаря этой возможности, разработчики могут создавать приложения, которые работают на всех популярных операционных системах, включая Windows, macOS и Linux. Это позволяет сэкономить время и ресурсы, так как не требуется разрабатывать отдельную версию для каждой операционной системы.

Mono для Windows обладает рядом преимуществ перед другими платформами разработки, такими как удобство использования, открытый исходный код и поддержка широкого спектра языков программирования. С помощью Mono разработчики могут использовать такие языки, как C#, F#, Visual Basic и многое другое. Кроме того, Mono предоставляет богатую библиотеку классов, которая содержит множество полезных функций и возможностей.

Одним из основных преимуществ Mono является его высокая производительность. Mono использует сборку мусора и JIT-компиляцию, что позволяет достичь высокой скорости выполнения программы. Благодаря этой особенности, приложения, созданные с использованием Mono, работают быстро и эффективно.

В заключение, Mono для Windows является мощным инструментом для разработки кросс-платформенных приложений. Он обладает множеством полезных функций и возможностей, а также обеспечивает высокую производительность и удобство использования. Будучи открытой и свободной платформой, Mono предоставляет разработчикам гибкость и свободу выбора, а также позволяет создавать универсальные приложения, которые работают на разных операционных системах.

Установка и настройка Mono для Windows

Для начала работы с Mono на операционной системе Windows необходимо выполнить несколько простых шагов:

1. Скачайте установочный файл Mono для Windows с официального сайта. Для этого перейдите по ссылке [URL] и выберите последнюю доступную версию Mono.
2. Запустите установочный файл и следуйте инструкциям мастера установки. Убедитесь, что выбраны все необходимые компоненты, включая базовую установку Mono и среду выполнения .NET.
3. После завершения установки откройте командную строку Windows и убедитесь, что команды Mono доступны. Для этого введите команду «mono —version» и нажмите Enter. Если вы видите версию Mono и информацию о его установке, значит, установка прошла успешно.
4. Теперь настройте переменные среды, чтобы система могла найти выполнимые файлы Mono. Добавьте путь к исполняемым файлам Mono в переменную среды PATH. Для этого откройте «Панель управления» > «Система» > «Дополнительные параметры системы» > «Переменные среды». В списке переменных среды найдите переменную PATH и откройте ее для редактирования. Добавьте путь к исполняемым файлам Mono (например, C:\Mono\bin) в конец значения переменной PATH, разделяя его от предыдущих путей символом «;».
5. Перезагрузите компьютер, чтобы изменения переменных среды вступили в силу.

После завершения этих шагов у вас будет полностью установленная и настроенная среда Mono на вашем компьютере с операционной системой Windows. Теперь вы можете начать разрабатывать и запускать приложения, используя инструменты и библиотеки, предоставляемые Mono.

Преимущества использования Mono для Windows

1. Кросс-платформенность: Mono позволяет создавать и запускать приложения на различных операционных системах, включая Windows, Linux и macOS. Это дает возможность разработчикам достичь широкой аудитории пользователей, не ограничиваясь только одной платформой.

2. Совместимость: Mono обеспечивает высокую совместимость с .NET фреймворком, что позволяет легко переносить существующий код и использовать существующие библиотеки и инструменты. Это особенно полезно для компаний или разработчиков, которые уже имеют опыт работы с .NET и хотят перейти на кросс-платформенную разработку.

3. Эффективность: Моно обладает хорошей производительностью и малым потреблением ресурсов, что позволяет создавать быстрые и отзывчивые приложения даже на старых или слабых компьютерах.

4. Открытый исходный код: Mono является проектом с открытым исходным кодом, что позволяет разработчикам изучать и модифицировать его с целью улучшения и расширения функциональности. Также это значит, что Mono свободно доступен для использования без лицензионных ограничений.

5. Поддержка новых технологий: Mono активно развивается и поддерживает последние технологии, такие как C# 9, .NET 5 и Xamarin.Forms. Это позволяет разработчикам использовать самые новые инструменты и функции для создания современных приложений.

6. Большое сообщество: Mono имеет широкое сообщество разработчиков, которые готовы помочь и поделиться опытом. Это позволяет быстро решать проблемы и получать поддержку при разработке приложений.

Использование Mono для разработки приложений для Windows является удобным, производительным и гибким вариантом, позволяющим создавать кросс-платформенные приложения и достичь большей аудитории пользователей.

Поддерживаемые языки программирования в Mono для Windows

1. C#: C# является основным языком программирования в Mono. Он предоставляет разработчикам мощные инструменты для создания многофункциональных приложений и веб-сайтов.

2. Visual Basic.NET: Mono также поддерживает VB.NET, язык программирования, который предоставляет удобный синтаксис и богатую функциональность для разработки приложений на платформе Windows.

3. F#: F# — функциональный язык программирования, который также поддерживается в Mono. Он позволяет разработчикам писать эффективный и высокопроизводительный код, основанный на функциях и символах.

4. Java: Mono обеспечивает поддержку языка программирования Java, что позволяет разработчикам запускать Java-приложения на платформе Windows.

5. Python: Python — высокоуровневый язык программирования, широко используемый в науке и разработке приложений. Mono предоставляет возможность использовать Python в среде Windows.

6. Ruby: Ruby — объектно-ориентированный язык программирования, который часто используется для разработки веб-приложений и скриптов. Mono дает возможность использовать Ruby в Windows-среде.

7. PHP: PHP — широко распространенный язык программирования для разработки веб-сайтов и веб-приложений. Mono дает разработчикам возможность использовать PHP в среде Windows.

Это только некоторые из языков программирования, которые поддерживаются в Mono для Windows. Выбор языка программирования обычно зависит от предпочтений и потребностей разработчика или команды разработки.

Инструменты разработки в Mono для Windows

Mono для Windows предоставляет разработчикам широкий выбор инструментов, которые помогают создать высокопроизводительные и масштабируемые приложения. Вот несколько основных инструментов, доступных в Mono:

1. MonoDevelop: интегрированная среда разработки (IDE), которая предоставляет разработчикам все необходимые инструменты для создания, отладки и развертывания приложений на языке C#. MonoDevelop обладает богатым набором функций, включая поддержку автодополнения кода, систему управления версиями, интеграцию с отладчиком и многое другое.
2. Xamarin Studio: платформа разработки мобильных приложений, которая позволяет создавать приложения для iOS, Android и Windows Phone, используя язык C# и фреймворк Mono. Xamarin Studio предоставляет набор инструментов для разработки мобильных приложений, включая среду разработки, отладчик, дизайнер пользовательского интерфейса и многое другое.
3. MonoDevelop Unity: специализированная версия MonoDevelop, разработанная для работы с игровым движком Unity. MonoDevelop Unity предлагает интеграцию с Unity, автоматическое обновление проекта, поддержку юнит-тестирования и другие функции, специально разработанные для разработки игр.

Кроме того, Mono для Windows поддерживает множество других инструментов, таких как MSBuild, NuGet, Roslyn и др. Эти инструменты расширяют возможности разработчиков и позволяют им создавать более сложные и мощные приложения.

Все эти инструменты позволяют разработчикам создавать приложения на языке C# и запускать их на платформах, поддерживаемых Mono. Благодаря обширным возможностям и надежности инструментов разработки в Mono для Windows, разработчики могут легко создавать высококачественные приложения и выполнять быструю отладку и развертывание.

Особенности и характеристики Mono для Windows

Одной из основных особенностей Mono является ее открытый исходный код, который позволяет разработчикам легко участвовать в развитии проекта и внедрять собственные изменения. Благодаря этому, Mono постоянно совершенствуется и расширяет свои возможности.

Mono для Windows поддерживает большое количество библиотек и инструментов .NET Framework, что позволяет переносить существующие приложения на платформу Windows с минимальными затратами.

Благодаря кросс-платформенности Mono для Windows, разработчики могут создавать приложения, которые будут работать на различных операционных системах, включая Windows, macOS и Linux. Это существенно упрощает разработку и поддержку программного обеспечения и позволяет достичь более широкой аудитории пользователей.

Кроме того, Mono для Windows обладает высокой производительностью и эффективностью. Она оптимизирует исполнение кода и уменьшает потребление ресурсов системы, что позволяет приложениям работать быстрее и использовать меньше памяти.

Другим преимуществом Mono является поддержка различных платформ, включая ARM и x86. Это позволяет разрабатывать и запускать приложения на различных типах устройств, от персональных компьютеров до мобильных устройств и встроенных систем.

В целом, Mono для Windows предоставляет разработчикам мощный инструмент для создания кросс-платформенных приложений, обладающих высокой производительностью и эффективностью.

Примеры и успешные проекты, созданные с использованием Mono для Windows

Одним из наиболее известных и успешных проектов, созданных с использованием Mono для Windows, является приложение Banshee. Banshee — это продвинутый медиа-плеер и менеджер аудио-коллекций, который поддерживает большинство популярных аудио-форматов. Благодаря Mono для Windows, была реализована возможность запуска приложения Banshee на различных операционных системах, включая Windows, что значительно расширило круг пользователей данной программы.

Еще одним примером успешного проекта, созданного на основе Mono для Windows, является система управления базами данных под названием NDesk. NDesk представляет собой набор библиотек, позволяющих разработчикам создавать эффективные и масштабируемые приложения для работы с базами данных. Благодаря использованию Mono для Windows, NDesk может успешно работать на различных операционных системах, что позволяет разработчикам выбирать наиболее подходящую для своих нужд платформу.

Кроме вышеупомянутых проектов, с помощью Mono для Windows было создано множество других успешных приложений и проектов. Это свидетельствует о том, что данная платформа является надежным и эффективным инструментом для разработки программного обеспечения на различных операционных системах. Благодаря возможности переноса приложений на разные платформы, разработчики могут достигать гораздо большей аудитории пользователей и увеличивать свою продуктивность.