Coding Solution

QCM C# : 12 questions corrigées (type CodinGame, SkillValue)

QCMC#12 questionsMis à jour le

Ce QCM s'adresse aux développeurs .NET qui préparent un test technique ou un entretien C#. Chaque question reprend un piège classique des plateformes de recrutement, avec la réponse et une explication détaillée.

En bref

Les tests C# de recrutement (SkillValue, CodinGame, HackerRank) sont surtout des questions de lecture de code : on vous montre un programme court et on vous demande ce qu'il affiche. Les thèmes qui reviennent le plus sont la différence entre types valeur et types référence, l'immutabilité des chaînes, l'exécution différée de LINQ, async/await et le boxing. Viennent ensuite les exceptions avec finally et using, les types nullables et les collections génériques (List, Dictionary, HashSet).

Les thèmes qui tombent le plus

Entraînez-vous : 12 questions corrigées

Choisissez une réponse pour voir l'explication.

Qu'affiche ce programme ?
struct Point { public int X; }

class Program
{
    static void Modify(Point p) { p.X = 10; }

    static void Main()
    {
        Point pt = new Point { X = 1 };
        Modify(pt);
        Console.WriteLine(pt.X);
    }
}

Point est un struct, donc un type valeur : Modify reçoit une copie de pt et modifie cette copie. L'original garde X = 1. Si Point avait été déclaré avec class, la référence aurait été partagée et la sortie aurait été 10. Il n'y a pas d'erreur de compilation, le code est valide, et 0 serait la valeur par défaut d'un int non initialisé, ce qui n'est pas le cas ici.

Qu'affiche ce code ?
string s = "hello";
s.ToUpper();
Console.WriteLine(s);

Les string sont immuables en C# : ToUpper() ne modifie pas s, il renvoie une nouvelle chaîne qui est ici ignorée. Pour afficher HELLO il aurait fallu écrire s = s.ToUpper(). Le code compile sans problème (appeler une méthode sans utiliser son résultat est autorisé) et s n'est jamais vidée.

Qu'affiche ce code ?
var d = new Dictionary<string, int>();
d["a"] = 1;
d["a"] = 2;
d.Add("b", 3);
Console.WriteLine(d["a"] + d.Count);

L'indexeur d[clé] = valeur ajoute la clé si elle est absente et remplace la valeur si elle existe : d["a"] vaut donc 2 et le dictionnaire contient 2 entrées (a et b), soit 2 + 2 = 4. C'est la méthode Add qui lève une ArgumentException sur une clé déjà présente, pas l'indexeur. À l'inverse, lire d["clé absente"] lèverait une KeyNotFoundException, d'où l'intérêt de TryGetValue.

Quelle affirmation sur les interfaces et les classes abstraites est vraie en C# ?

C# n'a pas d'héritage multiple de classes : une classe hérite d'au plus une classe (abstraite ou non) mais peut implémenter autant d'interfaces qu'elle veut. Une classe abstraite peut mélanger méthodes abstraites et méthodes implémentées, c'est même son intérêt. Une interface ne peut pas déclarer de champs d'instance (seulement des membres comme méthodes, propriétés, événements). Et une classe marquée abstract ne peut jamais être instanciée directement, même sans membre abstrait.

Qu'affiche ce code ?
var list = new List<int> { 1, 2, 3 };
var query = list.Where(x => x > 1);
list.Add(4);
Console.WriteLine(query.Count());

Where est à exécution différée : la requête n'est évaluée qu'au moment de l'énumération, ici lors du Count(). À ce moment la liste contient 1, 2, 3, 4 et trois éléments sont supérieurs à 1. On aurait obtenu 2 avec un ToList() juste après le Where, qui aurait figé le résultat. L'InvalidOperationException concerne la modification d'une collection pendant une énumération en cours, ce qui n'est pas le cas ici.

Dans quel ordre les lettres sont-elles affichées ?
static async Task Work()
{
    Console.WriteLine("1");
    await Task.Delay(100);
    Console.WriteLine("2");
}

static async Task Main()
{
    Task t = Work();
    Console.WriteLine("3");
    await t;
    Console.WriteLine("4");
}

Une méthode async s'exécute de façon synchrone jusqu'au premier await dont la tâche n'est pas terminée. Work affiche donc 1, rencontre le Task.Delay et rend la main à Main, qui affiche 3. Main attend ensuite t : quand le délai se termine, Work reprend et affiche 2, puis Main reprend et affiche 4. 1 2 3 4 serait le résultat si Main avait écrit await Work() directement.

Que se passe-t-il avec ce code (C# 9 ou plus) ?
class User
{
    public string Name { get; init; }
}

var u = new User { Name = "Ana" };
u.Name = "Bob";
Console.WriteLine(u.Name);

Un accesseur init n'est utilisable que pendant la construction de l'objet : dans un initialiseur d'objet, un constructeur ou une expression with. L'affectation u.Name = "Bob" après la construction est refusée par le compilateur. Avec { get; set; } le programme aurait affiché Bob ; avec { get; } seul, l'initialiseur lui-même aurait échoué à compiler. Il ne s'agit jamais d'une erreur à l'exécution.

Qu'affiche ce programme ?
static int F()
{
    try
    {
        return 1;
    }
    finally
    {
        Console.WriteLine("finally");
    }
}

static void Main()
{
    Console.WriteLine(F());
}

Le bloc finally s'exécute toujours avant que la méthode ne rende la main, même après un return : la valeur de retour 1 est mémorisée, finally affiche son message, puis la méthode retourne et Main affiche 1. Le code compile : seul un return à l'intérieur du finally serait interdit en C#. Le finally ne peut pas être sauté, il est conçu pour libérer des ressources.

Qu'affiche ce code ?
string s = null;
int? len = s?.Length;
Console.WriteLine(len ?? -1);
Console.WriteLine(len.HasValue);

L'opérateur null-conditionnel ?. court-circuite l'appel quand s est null et renvoie null, ce qui impose que len soit un int? (nullable). L'opérateur ?? fournit -1 comme valeur de repli, et HasValue est False puisque len ne contient rien. Il n'y a pas de NullReferenceException : c'est précisément ce que ?. évite. Écrire int len = s?.Length; aurait en revanche provoqué une erreur de compilation.

Qu'affiche ce code ?
object o1 = 5;
object o2 = 5;
Console.WriteLine(o1 == o2);
Console.WriteLine(o1.Equals(o2));

Affecter un int à un object provoque un boxing : chaque affectation crée un nouvel objet sur le tas. L'opérateur == entre deux object compare les références, et o1 et o2 pointent vers deux boîtes différentes, donc False. Equals est redéfini sur Int32 pour comparer les valeurs : 5 vaut 5, donc True. C'est l'un des pièges les plus fréquents des tests C# et la raison pour laquelle on évite == sur des object.

Qu'affiche ce code ?
string a = "hello";
string b = new string("hello".ToCharArray());
Console.WriteLine(a == b);
Console.WriteLine((object)a == (object)b);
Console.WriteLine(ReferenceEquals(a, b));

L'opérateur == sur deux variables typées string est surchargé pour comparer le contenu : True. Dès qu'on caste en object, == redevient une comparaison de références, et b est une nouvelle instance créée avec new, distincte du littéral interné "hello" : False. ReferenceEquals fait la même comparaison : False. Si b avait été écrit b = "hello", les trois lignes auraient affiché True grâce à l'internement des littéraux.

Qu'affiche ce programme ?
class Res : IDisposable
{
    public Res() { Console.WriteLine("open"); }
    public void Dispose() { Console.WriteLine("dispose"); }
}

static void Main()
{
    try
    {
        using (var r = new Res())
        {
            Console.WriteLine("work");
            throw new InvalidOperationException();
        }
    }
    catch (InvalidOperationException)
    {
        Console.WriteLine("catch");
    }
}

Le bloc using est compilé en try/finally : Dispose() est appelé dans le finally, donc à la sortie du bloc, avant que l'exception ne remonte au catch extérieur. L'ordre est donc open, work, dispose, puis catch. Dispose est garanti même en cas d'exception, c'est tout l'intérêt de using par rapport à un appel manuel. L'exception est bien attrapée puisque le using se trouve à l'intérieur du try.

Le jour du test

  1. Face à un extrait de code, repérez d'abord si les types manipulés sont des struct ou des class : la moitié des pièges tiennent à la copie des types valeur.
  2. Quand vous voyez une méthode sur une string dont le résultat n'est pas réaffecté, la chaîne d'origine n'a pas changé.
  3. Sur une requête LINQ, cherchez le moment exact de l'énumération (foreach, ToList, Count, First) : c'est là que la source est lue.
  4. Pour les questions async, lisez le code ligne par ligne jusqu'au premier await non terminé, puis revenez à l'appelant.

S'entraîner avec Coding Solutions

Sur un QCM d'entraînement affiché à l'écran, l'extension Coding Solutions explique la bonne réponse et la règle derrière, dans 29 langages. Pour les exercices de code, voyez aussi nos solutions CodinGame expliquées et les guides par plateforme.

Questions fréquentes

Quelle version de C# faut-il connaître pour un test de recrutement ?

La plupart des questions portent sur des fondamentaux stables depuis C# 2 à C# 6 : génériques, LINQ, async/await, nullables. Les nouveautés récentes qui tombent le plus sont les accesseurs init, les records et le pattern matching.

Combien de temps dure un QCM C# sur SkillValue ou CodinGame ?

Comptez en général 20 à 40 questions en 30 à 60 minutes, soit environ une minute par question. Les questions de lecture de code sont les plus longues : ne restez pas bloqué, passez et revenez si le temps le permet.

Les questions .NET portent-elles aussi sur ASP.NET ou Entity Framework ?

Un QCM généraliste C# reste centré sur le langage et la BCL (collections, string, Task, LINQ). Les frameworks font l'objet de tests séparés, souvent indiqués dans l'intitulé de l'épreuve.

Comment réviser efficacement avant le test ?

Exécutez vous-même chaque extrait de ce QCM dans un projet console ou sur dotnetfiddle et modifiez-le (struct en class, ajout d'un ToList, etc.) pour voir ce qui change. Comprendre le mécanisme vaut mieux que mémoriser la réponse.

Autres langages

★ 5,0 · 16 avis · 928 utilisateurs Ajouter à Chrome