unmanaged, notnull et new() (émulation en C# 6)
C# 6 prend en charge les contraintes class/struct/new() ; émulez les contraintes plus récentes notnull/unmanaged avec des contrôles, la forme de l’API et des conventions.
unmanaged, notnull et new() (émulation en C# 6) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Panorama des contraintes
Objectif : utiliser efficacement les contraintes génériques de C# 6.
- Classe ou structure
- new() pour créer des instances sans activateur
- Simuler notnull/unmanaged avec des gardes et la conception de l’API
classe ou structure
La contrainte de classe limite T aux types référence ; la contrainte de structure limite T aux types valeur. Une utilisation incorrecte échoue à la compilation.
using System;
// Works only for reference types
public static class RefBox
{
public static string Show<T>(T value) where T : class
{
return value == null ? "null ref" : "ref: " + value.ToString();
}
}
// Works only for value types
public static class ValBox
{
public static string Show<T>(T value) where T : struct
{
return "value: " + value.ToString();
}
}
public class Program
{
public static void Main(string[] args)
{
string s = "hello";
int n = 42;
Console.WriteLine(RefBox.Show<string>(s)); // OK
Console.WriteLine(ValBox.Show<int>(n)); // OK
// Console.WriteLine(RefBox.Show<int>(n)); // compile-time error (int is struct)
// Console.WriteLine(ValBox.Show<string>(s)); // compile-time error (string is class)
}
}
new() en pratique
new() garantit l’existence d’un constructeur public sans paramètre, afin que le code générique puisse appeler directement new T().
using System;
// Requires public parameterless ctor on T
public static class Factory
{
public static T Create<T>() where T : new()
{
return new T(); // safe in C# 6 with new()
}
}
public sealed class Sample
{
public string Name { get; set; }
public Sample() { Name = "default"; }
}
public class Program
{
public static void Main(string[] args)
{
Sample x = Factory.Create<Sample>();
Console.WriteLine("Created: " + x.Name);
}
}
Simuler notnull
C# 6 ne propose pas notnull. Approximativement, utilisez where T : class ainsi que des gardes explicites contre null dans l’API.
using System;
// C# 6 has no notnull constraint. Use where T : class and guard at runtime.
public static class NotNullApi
{
public static int LengthOf<T>(T x) where T : class
{
if (x == null) throw new ArgumentNullException("x");
return x.ToString().Length; // placeholder usage
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NotNullApi.LengthOf<string>("hi")); // 2
try
{
Console.WriteLine(NotNullApi.LengthOf<string>(null)); // throws
}
catch (Exception ex)
{
Console.WriteLine("Guard fired: " + ex.GetType().Name);
}
}
}
Simuler l’intention unmanaged
C# 6 ne propose pas unmanaged. Vous pouvez utiliser struct et des interfaces (par exemple IComparable) pour cibler des types valeur proches des types numériques.
using System;
// No unmanaged constraint in C# 6.
// Use struct for value types and restrict API usage (document numeric-only intent).
public static class NumericOps
{
public static T Max<T>(T a, T b) where T : struct, IComparable
{
// Works for numeric primitives because they implement IComparable
return (a.CompareTo(b) >= 0) ? a : b;
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NumericOps.Max<int>(3, 9)); // 9
Console.WriteLine(NumericOps.Max<double>(2.5, 2)); // 2.5
}
}
Conseils pratiques
Conseils :
- Choisissez class/struct pour restreindre T dès le début.
- Utilisez new() si vous devez créer une instance de T.
- Simulez notnull avec des gardes à l’exécution.
- Simulez unmanaged avec struct et une utilisation documentée, souvent pour des types numériques primitifs.
Contrainte de constructeur
Récapitulatif
Récapitulatif : utilisez class/struct/new() en C# 6. Simulez notnull avec des vérifications de nullité et l’intention unmanaged avec des bornes struct et d’interface.
Questions Fréquemment Posées
La leçon « unmanaged, notnull et new() (émulation en C# 6) » est-elle gratuite ?
Oui — le texte complet de « unmanaged, notnull et new() (émulation en C# 6) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « unmanaged, notnull et new() (émulation en C# 6) » ?
C# 6 prend en charge les contraintes class/struct/new() ; émulez les contraintes plus récentes notnull/unmanaged avec des contrôles, la forme de l’API et des conventions. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « unmanaged, notnull et new() (émulation en C# 6) » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- unmanaged, notnull et new() (émulation en C# 6)
- Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire)
- Utilitaires génériques réutilisables