Please work with Xamarin to make Mono for UE a reality

[Shadowriver]

@Sammy;326247

, can you stop with the “It’s the C++ way or the highway” with every thread that wants to discuss alternative language use in UE! Esp. since you obviously don’t use both languages.

Pro C#:

garbage collection
array bounds checking
huge .NET-Framework library
types have a defined size (e.g. a long is 64Bit)
strings are encoded in UTF/16
autoboxing – every type can be treated as if it inherits from object
supports constructor-chaining (one constructor can call another constructor from the same class)
when a virtual method is called in a constructor, the method in the most derived class is used
static constructors (run before the first instance of the class is created)
exceptions have access to a stack trace
advanced runtime type information and reflection
supports variadic functions nicely
built-in support for threads
no need for header files and #includes
no fall-through on switch-statements
arithmetic operations can be checked for overflow if required
objects must have a definite value before being used
attributes can be attached to classes and retrieved at runtime
no forward declarations required, classes can be arranged at will
access to class members / functions is done only by the dot (no more -> or :
conditional functions (e.g. for debugging)
structs and classes are actually different (structs are value types, have no default constructor in general cannot be derived from)
supports properties
readonly members are const, but can be changed in the constructor
finally block for exceptions
arrays are objects
support for anonymous functions
supports the base keyword for calling the overridden base class

Pro C++

better performance
portability
multiple inheritance
deterministic destruction (allows RAII)
any type can be thrown as exception (only classes derived from System.Exception in C#)
ability to enforce const-correctness
implicit interfaces on generics (in C#, generics must be constrained with an interface)
offers pointers (C# only offers pointers in unsafe mode)
support for macros
support for global variables, functions, constants
allows default arguments on function parameters
STL
supports bitfields

IMHO, C# is the better language, productivity is the key, it’s easier program in, faster to get things done in general and less prone to bugs due to its more modern design.

The way UE4 is constructed, you will find lot of those features useless or unusable in UE4 envriament, because whatever you gonna implement C#, you will be still using UE4 APIs with it’s limitations which sometimes limits C++ too. For example you won’t have all constructor features, because UE4 has it’s own object deployment systems which makes constructors useless even in C++, they just default variable setter. UE4 also don’t use any exceptions support, just series of check() functions that crashes application, so your C# code would go with it. It will also have problem with invoking properties, but i’m note sure about that. UE4 also has implmented some of those features already, UE4 has garbage collection, UE4 has it’s own reflection system, which see classes and struct differently (but in C++ you can normally treat them as classes), UE4 has large collection of APIs making thigns a lot easier, it also own multithreading system, so some features of .NET might be conflicting with UE4.

Also C++ is not portable at all, yes .NET requires ported runtime, but the code running on it will work everywhere, where C++ need to be revised on each platfrom or requires wrappers… UE4 APIs do that for you and .NET/Mono currently supports more platforms then UE4 does (most notably Windows Phone). Ofcorse C# won’t fix that problem in UE4