Java interoperability will be available on all platforms.

next release after .NET Core 3.0 will be .NET 5

Java interoperability will be available on all platforms.

Просто задумайтесь...

.NET Framework will get fewer of the newer platform and language features that come to .NET Core moving forward, due to the in-place update nature of .NET Framework and the desire to limit changes there that might break existing applications.
— http://rsdn.org/forum/dotnet/7287981.1

Автор: Qbit86
Дата: 01.11.18

Span<char> stackSpan = stackalloc char[] { 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!' };

// bool DateTime.TryFormat(Span<char> destination, out int charsWritten, ...)
DateTime.Now.TryFormat(stackSpan.Slice(6), out int _, "yyyy");

// void TextWriter.WriteLine(ReadOnlySpan<char> buffer)
Console.Out.WriteLine(stackSpan); // Hello 2019d!

Span<char> buffer = stackalloc char[8];
if (number.TryFormat(buffer, out int charsWritten))
    textWriter.WriteLine(buffer.Slice(0, charsWritten));
else
    textWriter.WriteLine("Failure");

Q>У любой функции можно заигнорить результат

Span<char> buffer = stackalloc char[1];
number.TryFormat(buffer, out int charsWritten);       // oops
textWriter.WriteLine(buffer.Slice(0, charsWritten));

System.FormatException if the format is not valid for this data type.

We are also taking the opportunity to simplify naming. We thought that if there is only one .NET going forward, we don’t need a clarifying term like “Core”. The shorter name is a simplification and also communicates that .NET 5 has uniform capabilities and behaviors. Feel free to continue to use the “.NET Core” name if you prefer it.
— .NET 5 = .NET Core vNext

private const int CharStackBufferSize = 32;

public static bool TryFormatDouble(double value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
{
    Span<char> stackBuffer = stackalloc char[CharStackBufferSize];
    var sb = new ValueStringBuilder(stackBuffer);
    string? s = FormatDouble(ref sb, value, format, info);
    return s != null ?
        TryCopyTo(s, destination, out charsWritten) :
        sb.TryCopyTo(destination, out charsWritten);
}

var t = 1;
Span<char> s;
unsafe 
{ 
  do
  {
    s = new Span<char>(stackalloc char[t],t);
    t++;
  }
  while(!number.TryFormat(s, out int written))
}
Console.WriteLine(s);

With the .NET Core 3.0 release in September 2019 we think that all *new* .NET applications should be based on .NET Core. The primary application types from .NET Framework are supported, and where we did not port something over there is a recommended modern replacement. All future investment in .NET will be in .NET Core. This includes: Runtime, JIT, AOT, GC, BCL (Base Class Library), C#, VB.NET, F#, ASP.NET, Entity Framework, ML.NET, WinForms, WPF and Xamarin.

int size = snprintf(NULL, 0, "%d", 132);
char * a = malloc(size + 1);
sprintf(a, "%d", 132);

.NET Core is an open-source, general-purpose development platform maintained by Microsoft and the .NET community on GitHub. It's cross-platform (supporting Windows, macOS, and Linux) and can be used to build device, cloud, and IoT applications.

Produce a single .NET runtime...

We just blogged about all the performance works we did in .NET Core 3.0

— https://twitter.com/dotnet/status/1128765757175631872

s = new Span<char>(stackalloc char[t],t);

Span<char> s = stackalloc char[t];

{
    NumberBuffer buff = default;
    ReadOnlySpan<byte> digits = Utf8Formatter.Format(ref buff, 42);
    someStream.Write(digits);
}

internal ref struct NumberBuffer {
    public int Scale;
    public bool IsNegative;
    private byte _b0;
    private byte _b1;
    ...
}

Span<byte> s = new Span<char>(stackalloc char[42], 42);

error CS1525: Invalid expression term 'stackalloc'

Span<byte> s;
s = stackalloc byte[42];

error CS8353: A result of a stackalloc expression of type 'Span<byte>' cannot be used in this context because it may be exposed outside of the containing method

The keyword is valid only in local variable initializers.

unsafe {
    byte * bytes = stackalloc byte[42];
    Span<byte> s = new Span<byte>(bytes, 42);
    Proccess(s);
}

{
    Span<byte> s = stackalloc byte[42];
    Proccess(s);
}

V>Span<byte> s = new Span<char>(stackalloc char[42], 42);
V>

V>Span<byte> s;
V>s = stackalloc byte[42];
V>

private static Span<char> Test(int number)
{
  Span<char> s = stackalloc char[number];
  return s;
}

error CS8352: Cannot use local 's' in this context because it may expose referenced variables outside of their declaration scope

        unsafe private static Span<char> Test(int number)
        {
            Span<char> s;
            if (number < 100)
            {
                char* t = stackalloc char[number];
                s = new Span<char>(pointer: t, number);
            }
            else
                s = new char[number];
            return s;
        }