Syntactical sugar for common optimization tools/patterns

[dylanrafael05]

As a relatively new programmer the following proposals might be either farfetched or unreasonable.
Similarly, this is my first discussion post on Github, so it may be vague or unclear

Various common optimization techniques require advanced knowledge of the C# language, most notably;
Inlining functions using MethodImpl and
Bit manipulation using pointers

Inlining functions with MethodImpl

A new version of C# could include alternative syntaxes for [MethodImpl(MethodImplOptions.AggresiveInlining)]. One possible shorthand could be a new keyword, similar to the inline keyword in c++. Such a keyword would act as a modifier to any functions, static or otherwise, and possibly for property getter or setters which access only public items.

Theoretical Example Code

public inline static int Bitmask(int bitToMask) => 1 << bitToMask;

public static void Main(string[] args) {
    Console.WriteLine(Bitmask(1)); 
    // Would evaluate to "Console.WriteLine(1 << 1);" or
    // "int _b = 1; Console.WriteLine(1 << b)" before compilation
}

Another possibility would be to simply introduce a new Attribute (or Attribute-like item), simply named Inlined, which is simply syntactical sugar for [MethodImpl(MethodImplOptions.AggresiveInlining)]

Example

[Inlined]
public static int... // Continue as in other example

Bit Manipulation

One of the most "hacky" yet common bit manipulations that can be observed in C# is the conversion of the raw binary of one type to another. The most common way to do this is to use pointer casting; *(long*)&floatvar. In order to retain the spirit of this action, I propose a new form of cast, the raw cast. raw casting can only take place in an unsafe context, and can only be applied to types which can be represented by a pointer (I don't know the precise term, I believe "unmanaged" works but I do not wish to make a mistake in my explanation). Their syntax is very simple: place the contextual keyword raw before the type in a cast operation.

Example

float num = 1;
int numRaw;
unsafe {
    numRaw = (raw int)num;
}
Console.WriteLine(numRaw); // Prints 1065353216, the integer representation of the bytes behind 1f

Thank you so much for reading, hopefully this is at least somewhat well thought-out.

[HaloFour]

Given that these are both relatively advanced topics and should be used sparingly by developers it does not seem appropriate that the language should encourage their use through shorthand, especially since both are solved problems.

[dylanrafael05]

Fair enough, but I personally feel that (at least in the case of bit manipulation), the conventional method is hard to read, and also requires knowledge of relatively advanced pointer operations, where most use cases of such bit manipulation would otherwise require none.

[CyrusNajmabadi]

the conventional method is hard to read, and also requires knowledge of relatively advanced pointer operations, where most use cases of such bit manipulation would otherwise require none.

This seems solvable by putting this sort of code behind a helper method. i.e. GetFloatBitsInterprettedAsInt32(float f). I wouldn't be surprised if this already exists somewhere :)

[ufcpp]

It's a sample code that I wrote a long time ago, and there are only Japanese comments, but...
https://github.com/ufcpp/BitFields
https://github.com/ufcpp/UfcppSample/blob/master/Demo/2017/BitFieldsSample/Program.cs

[Joe4evr]

@CyrusNajmabadi System.BitConverter.SingleToInt32Bits(Single)

[bernd5]

The shorthand for inlining is nice - but it should be done by the compiler automatically...

The second part you can write today as:

using System;
using System.Runtime.CompilerServices;

float num = 1;
var numRaw = Unsafe.As<float, int>(ref num);
Console.WriteLine(numRaw);

[dylanrafael05]

I had no clue that System included an Unsafe utility class! That does make sense, but wouldn't the generic type parameters decrease performance (when bit twiddling is almost always about creating the most optimized code possible)?

P.S, how were you able to get markdown to color your in-comment scripting?
Edit: Nevermind about the P.S! I didn't realize that markdown was the system discord used, so apparently I've been using markdown for years

[bernd5]

Generic type parameters cost nothing - the code is generated on the fly (even more, some of those are "Intrinsics").
You can write "CSharp" at the code block begin.

[orthoxerox]

System.BitConverter is better than Unsafe if you need to convert between int/float and long/double

[HaloFour]

The shorthand for inlining is nice - but it should be done by the compiler automatically...

The compiler doesn't know anything about inlining, or MethodImplAttribute. Those are both runtime concerns.

The issue I take with a compiler keyword for inlining is that it implies any kind of guarantee about how inlining will happen, and that's not possible unless the compiler does the inlining itself. But that doesn't work well across assemblies, especially with the prevalence of reference assemblies which have stubbed bodies and are expected to be replaced by an actual implementation at runtime. IMO it's better to leave optimizations like inlining to the runtime as it has the best information as to what code will be running.

[bernd5]

Of course with "compiler" I mean the whole compiler infrastructure (CSharp and IL).
And System.BitConverter is better because it handles size differences... (but here both are just 4 bytes).