C# Language
C # 4.0 Kenmerken

Optionele parameters en benoemde argumenten

We kunnen het argument in de aanroep weglaten als dat argument een optioneel argument is. Elk optioneel argument heeft zijn eigen standaardwaarde. Er is een standaardwaarde nodig als we niet de waarde opgeven. Een standaardwaarde van een optioneel argument moet een

1. Constante uitdrukking.
2. Moet een waardetype zijn, zoals enum of struct.
3. Moet een uitdrukking zijn van de standaardinstelling (valueType)

Het moet worden ingesteld aan het einde van de parameterlijst

Methode parameters met standaardwaarden:

public void ExampleMethod(int required, string optValue = "test", int optNum = 42)
{
    //...
}

Zoals gezegd door MSDN, A benoemd argument,

Hiermee kunt u het argument doorgeven aan de functie door de parameternaam te koppelen. Het is niet nodig om de parameterpositie te onthouden waarvan we ons niet altijd bewust zijn. Het is niet nodig om de volgorde van de parameters te zoeken in de parameterlijst van de opgeroepen functie. We kunnen de parameter voor elk argument opgeven aan de hand van de naam.

Genoemde argumenten:

// required = 3, optValue = "test", optNum = 4
ExampleMethod(3, optNum: 4);
// required = 2, optValue = "foo", optNum = 42
ExampleMethod(2, optValue: "foo");
// required = 6, optValue = "bar", optNum = 1
ExampleMethod(optNum: 1, optValue: "bar", required: 6);

Beperking van het gebruik van een benoemd argument

Benoemde argumentspecificatie moet verschijnen nadat alle vaste argumenten zijn opgegeven.

Als u een genoemd argument gebruikt vóór een vast argument, krijgt u als volgt een compilatietijdfout.

Benoemde argumentspecificatie moet verschijnen nadat alle vaste argumenten zijn opgegeven

variance

Voor generieke interfaces en gedelegeerden kunnen hun typeparameters worden gemarkeerd als covariant of contravariant met behulp van respectievelijk de zoekwoorden out en in . Deze verklaringen worden vervolgens gerespecteerd voor typeconversies, zowel impliciet als expliciet, en zowel compileertijd als uitvoeringstijd.

De bestaande interface IEnumerable<T> is bijvoorbeeld opnieuw gedefinieerd als covariant:

interface IEnumerable<out T>
{
    IEnumerator<T> GetEnumerator();
}

De bestaande interface IComparer is opnieuw gedefinieerd als zijnde contravariant:

public interface IComparer<in T>
{
    int Compare(T x, T y);
}

Optioneel ref-trefwoord bij gebruik van COM

Het ref-trefwoord voor bellers van methoden is nu optioneel bij het aanroepen van methoden geleverd door COM-interfaces. Gegeven een COM-methode met de handtekening

void Increment(ref int x);

de aanroep kan nu als een van beide worden geschreven

Increment(0); // no need for "ref" or a place holder variable any more

Dynamisch zoeken van leden

Een nieuwe pseudo-type dynamic wordt geïntroduceerd in het C # type systeem. Het wordt behandeld als System.Object , maar daarnaast is elke ledertoegang (methodeaanroep, veld-, eigenschaps- of indexeringstoegang of een gedelegeerde aanroeping) of toepassing van een operator op een dergelijke waarde toegestaan zonder enige typecontrole, en de resolutie wordt uitgesteld tot runtime. Dit staat bekend als eenden typen of laat binden. Bijvoorbeeld:

// Returns the value of Length property or field of any object
int GetLength(dynamic obj)
{
    return obj.Length;
}
  
GetLength("Hello, world");        // a string has a Length property,
GetLength(new int[] { 1, 2, 3 }); // and so does an array,
GetLength(42);                    // but not an integer - an exception will be thrown
                                  // in GetLength method at run-time

In dit geval wordt het dynamische type gebruikt om meer uitgebreide reflectie te voorkomen. Het gebruikt nog steeds Reflection onder de motorkap, maar het is meestal sneller dankzij caching.

Deze functie is vooral gericht op interoperabiliteit met dynamische talen.

// Initialize the engine and execute a file
var runtime = ScriptRuntime.CreateFromConfiguration();
dynamic globals = runtime.Globals;
runtime.ExecuteFile("Calc.rb");

// Use Calc type from Ruby
dynamic calc = globals.Calc.@new();
calc.valueA = 1337;
calc.valueB = 666;
dynamic answer = calc.Calculate();

Dynamisch type heeft toepassingen, zelfs in meestal statisch getypte code, het maakt bijvoorbeeld dubbele verzending mogelijk zonder het bezoekerspatroon te implementeren.