C# Language
C # 4.0 Caratteristiche

Parametri opzionali e argomenti con nome

Possiamo omettere l'argomento nella chiamata se quell'argomento è un argomento facoltativo Ogni argomento facoltativo ha il proprio valore predefinito Prenderà il valore predefinito se non forniamo il valore Un valore predefinito di un argomento facoltativo deve essere un

1. Espressione costante
2. Deve essere un tipo di valore come enum o struct.
3. Deve essere un'espressione di default del modulo (valueType)

Deve essere impostato alla fine dell'elenco dei parametri

Parametri del metodo con valori predefiniti:

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

Come detto da MSDN, un argomento con nome,

Consente di passare l'argomento alla funzione associando il nome del parametro Non è necessario per ricordare la posizione dei parametri che non siamo a conoscenza di sempre. Non c'è bisogno di guardare l'ordine dei parametri nella lista dei parametri della funzione chiamata. Possiamo specificare il parametro per ogni argomento in base al suo nome.

Argomenti con nome:

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

Limitazione dell'uso di un argomento con nome

La specifica dell'argomento con nome deve apparire dopo che sono stati specificati tutti gli argomenti fissi.

Se si usa un argomento con nome prima di un argomento fisso, si otterrà un errore in fase di compilazione come segue.

La specifica dell'argomento con nome deve apparire dopo che sono stati specificati tutti gli argomenti fissi

Varianza

Interfacce e delegati generici possono avere i loro parametri di tipo contrassegnati come covarianti o controvarianti usando rispettivamente le parole chiave out e in . Queste dichiarazioni vengono quindi rispettate per le conversioni di tipo, sia implicite che esplicite, e compilano sia il tempo che il tempo di esecuzione.

Ad esempio, l'interfaccia esistente IEnumerable<T> è stata ridefinita come covariante:

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

L'interfaccia esistente IComparer è stata ridefinita come controvariante:

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

Parola chiave ref opzionale quando si utilizza COM

La parola chiave ref per i chiamanti di metodi è ora facoltativa quando si chiama nei metodi forniti dalle interfacce COM. Dato un metodo COM con la firma

void Increment(ref int x);

ora l'invocazione può essere scritta come entrambi

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

Ricerca dinamica dei membri

Una nuova dynamic pseudo-tipo viene introdotta nel sistema di tipo C #. Viene trattato come System.Object , ma in aggiunta, qualsiasi accesso membro (chiamata di metodo, campo, proprietà o accesso dell'indicizzatore o invocazione di un delegato) o applicazione di un operatore su un valore di tale tipo è consentito senza alcun tipo di controllo, e la sua risoluzione è posticipata fino al momento dell'esecuzione. Questo è noto come digitazione anatra o rilegatura tardiva. Per esempio:

// 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 questo caso, viene utilizzato il tipo dinamico per evitare riflessioni più dettagliate. Usa ancora Reflection sotto il cofano, ma di solito è più veloce grazie al caching.

Questa funzionalità è principalmente rivolta all'interoperabilità con linguaggi dinamici.

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

Il tipo dinamico ha applicazioni anche nel codice per lo più tipizzato staticamente, per esempio rende possibile la doppia spedizione senza implementare il pattern Visitor.