C# Language
C # 4.0-Funktionen

Optionale Parameter und benannte Argumente

Wir können das Argument in dem Aufruf weglassen, wenn dieses Argument ein optionales Argument ist. Jedes optionale Argument hat seinen eigenen Standardwert. Es wird ein Standardwert verwendet, wenn der Wert nicht angegeben wird. Ein Standardwert eines optionalen Arguments muss ein sein

1. Konstanter Ausdruck.
2. Muss ein Werttyp wie enum oder struct sein.
3. Muss ein Ausdruck des Formularvorschlags sein (valueType)

Sie muss am Ende der Parameterliste gesetzt werden

Methodenparameter mit Standardwerten:

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

Wie von MSDN gesagt, ein benanntes Argument,

Ermöglicht die Übergabe des Arguments an die Funktion durch Zuordnen des Parameternamens. Es ist nicht notwendig, sich die Parameterposition zu merken, die uns nicht immer bekannt ist. In der Parameterliste der aufgerufenen Funktion müssen Sie nicht nach der Reihenfolge der Parameter suchen. Wir können Parameter für jedes Argument anhand seines Namens angeben.

Benannte Argumente:

// 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);

Einschränkung der Verwendung eines benannten Arguments

Benannte Argumentspezifikationen müssen erscheinen, nachdem alle festen Argumente angegeben wurden.

Wenn Sie ein benanntes Argument vor einem festen Argument verwenden, wird ein Fehler beim Kompilieren wie folgt angezeigt.

Benannte Argumentspezifikationen müssen erscheinen, nachdem alle festen Argumente angegeben wurden

Abweichung

Bei generischen Schnittstellen und Delegaten können die Typparameter mit den out und in Schlüsselwörtern als kovariant oder kontravariant markiert werden. Diese Deklarationen werden dann für implizite und explizite Typkonvertierungen sowie sowohl für die Kompilierzeit als auch für die Laufzeit berücksichtigt.

Beispielsweise wurde die vorhandene Schnittstelle IEnumerable<T> als kovariant definiert:

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

Die bestehende Schnittstelle IComparer wurde als kontravariant definiert:

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

Optionales ref-Schlüsselwort bei Verwendung von COM

Das ref-Schlüsselwort für Aufrufer von Methoden ist jetzt optional, wenn in von COM-Schnittstellen bereitgestellte Methoden aufgerufen wird. Gegeben eine COM-Methode mit der Signatur

void Increment(ref int x);

Der Aufruf kann nun als beides geschrieben werden

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

Dynamische Member-Suche

Eine neue Pseudo- dynamic wird in das C # -System eingeführt. Es wird als System.Object behandelt, aber zusätzlich ist jeder Memberzugriff (Methodenaufruf, Feld-, Eigenschafts- oder Indexerzugriff oder ein Delegatenaufruf) oder die Anwendung eines Operators auf einen solchen Wert zulässig, ohne dass eine Typüberprüfung erfolgt und seine Auflösung wird auf die Laufzeit verschoben. Dies ist als Entenschreiben oder spätes Binden bekannt. Zum Beispiel:

// 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 diesem Fall wird der dynamische Typ verwendet, um eine ausführlichere Reflexion zu vermeiden. Es verwendet immer noch Reflection unter der Haube, ist jedoch normalerweise schneller, dank Caching.

Diese Funktion zielt hauptsächlich auf die Interoperabilität mit dynamischen Sprachen ab.

// 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();

Dynamische Typen haben auch in meist statisch typisiertem Code Anwendungen. Beispielsweise ist Doppelversand möglich, ohne das Besuchermuster zu implementieren.