Afwijkingen van de C#-standaard

Dit document bevat inconsistenties tussen Roslyn en de C#-standaard waar ze bekend zijn, ingedeeld op standaardsectie.

Conversions

Impliciete enumconversies van nul

Vanaf §10.2.4:

Met een impliciete opsommingsconversie kan een constant_expression (§12,25) met een geheel getal en de waarde nul worden geconverteerd naar een enum_type en naar een nullable_value_type waarvan het onderliggende type een enum_type is.

Roslyn voert impliciete opsommingsconversies uit constante expressies met typen floaten doubledecimal ook:

enum SampleEnum
{
    Zero = 0,
    One = 1
}

class EnumConversionTest
{
    const float ConstFloat = 0f;
    const double ConstDouble = 0d;
    const decimal ConstDecimal = 0m;

    static void PermittedConversions()
    {
        SampleEnum floatToEnum = ConstFloat;
        SampleEnum doubleToEnum = ConstDouble;
        SampleEnum decimalToEnum = ConstDecimal;
    }
}

Conversies zijn (correct) niet toegestaan vanuit constante expressies met een type bool, andere opsommingen of verwijzingstypen.

Opzoeken van leden

Vanaf §12.5.1:

• Ten slotte wordt het resultaat van de zoekactie bepaald nadat verborgen leden zijn verwijderd:
  • Als de set bestaat uit één lid dat geen methode is, is dit lid het resultaat van de opzoekactie.
  • Als de set alleen methoden bevat, is deze groep methoden het resultaat van de opzoekactie.
  • Anders is de zoekactie dubbelzinnig en treedt er een bindingstijdfout op.

Roslyn implementeert in plaats daarvan een voorkeur voor methoden ten opzichte van niet-methodesymbolen:

var x = I.M; // binds to I1.M (method)
x();

System.Action y = I.M; // binds to I1.M (method)

interface I1 { static void M() { } }
interface I2 { static int M => 0;   }
interface I3 { static int M = 0;   }
interface I : I1, I2, I3 { }

I i = null;
var x = i.M; // binds to I1.M (method)
x();

System.Action y = i.M; // binds to I1.M (method)

interface I1 { void M() { } }
interface I2 { int M => 0;   }
interface I : I1, I2 { }

Veronderstellingen over bekende typen/leden

De compiler is vrij om aannames te doen over de vorm en het gedrag van bekende type-elementen. Mogelijk wordt er niet gecontroleerd op onverwachte beperkingen, Obsolete kenmerken of UnmanagedCallersOnly kenmerken. Het kan enkele optimalisaties uitvoeren op basis van de verwachting dat de typen/leden zich goed gedragen. Opmerking: de compiler moet bestand blijven tegen ontbrekende bekende typen/leden.

Gedeeltelijke methoden in een interface

Gedeeltelijke interfacemethoden zijn impliciet niet-virtueel, in tegenstelling tot niet-gedeeltelijke interfacemethoden en andere soorten gedeeltelijke interfaceleden, zie een gerelateerde wijziging die fouten veroorzaken en LDM 2025-04-07.