Résoudre les erreurs et les avertissements dans les constructions de code non sécurisées

Cet article traite des diagnostics du compilateur suivants :

• CS0193 : L’opérateur * ou -> doit être appliqué à un pointeur
• CS0196 : un pointeur doit être indexé par une seule valeur
• CS0208 : Impossible de prendre l’adresse, d’obtenir la taille ou de déclarer un pointeur vers un type managé ('type')
• CS0209 : Le type d’un local déclaré dans une fixed instruction doit être un type de pointeur
• CS0210 : Vous devez fournir un initialiseur dans une fixed ou using instruction de déclaration
• CS0211 : Impossible de prendre l’adresse de l’expression donnée
• CS0212 : Vous ne pouvez prendre l’adresse d’une expression nonfixée qu’à l’intérieur d’un initialiseur d’instruction fixed
• CS0213 : Vous ne pouvez pas utiliser l’instruction fixed pour prendre l’adresse d’une expression déjà fixe
• CS0214 : Les pointeurs et les mémoires tampons de taille fixe peuvent uniquement être utilisés dans un contexte non sécurisé
• CS0227 : Le code non sécurisé peut apparaître uniquement si vous compilez avec /unsafe
• CS0233 : 'identificateur' n’a pas de taille prédéfinie. Par conséquent, la tailleof ne peut être utilisée que dans un contexte non sécurisé
• CS0242 : L’opération en question n’est pas définie sur les pointeurs void
• CS0244 : Ni 'is' ni 'as' n’est valide sur les types de pointeur
• CS0254 : la partie droite d’une assignation d’instruction fixed ne peut pas être une expression de cast
• CS0459 : Impossible de prendre l’adresse d’une variable locale en lecture seule
• CS0821 : Les variables locales implicitement typées ne peuvent pas être corrigées
• CS1641 : Un champ de mémoire tampon de taille fixe doit avoir le spécificateur de taille de tableau après le nom du champ
• CS1642 : Les champs de mémoire tampon de taille fixe peuvent uniquement être membres de structs
• CS1656 : Impossible d’affecter à « variable », car il s’agit d’un « type de variable en lecture seule »
• CS1663 : Type de mémoire tampon de taille fixe doit être l’un des éléments suivants : bool, , byteshort, intlong, , char, sbyte, , ou ushortuintulongfloatdouble
• CS1664 : La mémoire tampon de taille fixe dont la longueur est ’length’ et le type ’type’ est trop volumineuse
• CS1665 : Les mémoires tampons de taille fixe doivent avoir une longueur supérieure à zéro
• CS1666 : Vous ne pouvez pas utiliser de mémoires tampons de taille fixe contenues dans des expressions non corrigées. Essayez d’utiliser l’instruction fixe.
• CS1708 : Les mémoires tampons de taille fixe sont accessibles uniquement par le biais de locaux ou de champs
• CS1716 : N’utilisez pas l’attribut 'System.Runtime.CompilerServices.FixedBuffer'. Utilisez le modificateur de champ « fixe » à la place.
• CS1919 : Le type non sécurisé 'nom de type' ne peut pas être utilisé dans la création d’objets
• CS4004 : Impossible await dans un contexte non sécurisé
• CS7092 : une mémoire tampon fixe ne peut avoir qu’une seule dimension.
• CS8372 : N’utilisez pas l’attribut 'System.Runtime.CompilerServices.FixedBuffer' sur une propriété
• CS8385 : L’expression donnée ne peut pas être utilisée dans une instruction fixe
• CS8500 : Cette opération prend l’adresse d’un type managé (« type »), obtient sa taille ou déclare un pointeur vers celui-ci.
• CS8812 : Impossible de convertir le groupe de méthodes 'method' en type de pointeur non fonction 'type'.
• CS9049 : Un champ fixe ne doit pas être un champ ref.
• CS9123 : L’opérateur '&' ne doit pas être utilisé sur les paramètres ou les variables locales dans les méthodes asynchrones.
• CS9360 : cette opération peut uniquement être utilisée dans un contexte non sécurisé
• CS9361 : stackalloc expression sans initialiseur à l’intérieur SkipLocalsInit peut uniquement être utilisée dans un contexte non sécurisé
• CS9362 : « membre » doit être utilisé dans un contexte non sécurisé, car il est marqué comme «unsafe »
• CS9363 : « membre » doit être utilisé dans un contexte non sécurisé, car il a des pointeurs dans sa signature
• CS9364 : Le membre non sécurisé 'member' ne peut pas remplacer le membre sécurisé 'member'
• CS9365 : Le membre non sécurisé 'member' ne peut pas implémenter implicitement le membre sécurisé 'member'
• CS9366 : Le membre non sécurisé 'member' ne peut pas implémenter le membre sécurisé 'member'
• CS9367 : RequiresUnsafeAttribute ne peut pas être appliqué à ce symbole.
• CS9368 : RequiresUnsafeAttribute est valide uniquement dans les règles de sécurité de mémoire mises à jour.
• CS9376 : Un contexte non sécurisé est requis pour que le constructeur 'constructeur' marqué comme 'unsafe' réponde à la contrainte 'new()' du paramètre de type 'paramètre de type' dans 'type générique ou méthode'
• CS9377 : Le modificateur «unsafe » n’a aucun effet ici dans le cadre des règles de sécurité de mémoire actuelles.
• CS9379 : n’utilisez pas «RequiresUnsafeAttribute » dans la source ; utilisez plutôt le modificateur «unsafe ».
• CS9388 : Le modificateur «safe » peut uniquement être utilisé sur les membres «extern » qui ne sont pas marqués «unsafe ».
• CS9389 : Le membre « extern » doit être déclaré « unsafe » ou « safe ».
• CS9390 : Les deux déclarations partielles de membre doivent être marquées « safe » ou aucune des deux ne doit être marquée « safe »
• CS9392 : Le champ d’un type de disposition explicite ou étendu doit être marqué «unsafe » ou «safe ».
• CS9396 : Impossible de spécifier des modificateurs «unsafe » ou «safe » sur la propriété ou l’indexeur « property » et son accesseur. Supprimez l’une d’entre elles.
• CS9397 : Impossible de spécifier le même modificateur 'unsafe' ou 'safe' sur tous les accesseurs de propriété ou d’indexeur 'property'. Au lieu de cela, placez ce modificateur sur la propriété elle-même.
• CS9398 : Impossible d’utiliser 'await' dans le contexte d’une instruction 'fixed'

Opérations de pointeur et déréférencement

• CS0193 : L’opérateur * ou l’opérateur -> doit être appliqué à un pointeur
• CS0196 : un pointeur doit être indexé par une seule valeur
• CS0242 : L’opération en question n’est pas définie sur les pointeurs void

Pour utiliser correctement les opérations de pointeur, suivez les règles de déreferencing, d’indexation et d’opérations arithmétiques. Pour plus d’informations, consultez Les types de pointeurs et les pointeurs de fonction.

• Appliquez l'opérateur * ou l'opérateur -> uniquement aux pointeurs de données (CS0193). N’utilisez pas ces opérateurs avec des types non-pointeurs ou des pointeurs de fonction. Contrairement à C/C++, vous ne pouvez pas déréférer les pointeurs de fonction en C#.
• Pointeurs d’index avec une seule valeur (CS0196). Les pointeurs ne prennent pas en charge l’indexation multidimensionnelle.
• Évitez les opérations qui ne sont pas définies sur les pointeurs void (CS0242). Par exemple, n’incrémentez pas de pointeur void, car le compilateur ne connaît pas la taille des données vers lesquelles il pointe.

Types de pointeur et types managés

• CS0208 : Impossible de prendre l’adresse, d’obtenir la taille ou de déclarer un pointeur vers un type managé ('type')
• CS0233 : 'identificateur' n’a pas de taille prédéfinie. Par conséquent, la tailleof ne peut être utilisée que dans un contexte non sécurisé
• CS8500 : Cette opération prend l’adresse d’un type managé (« type »), obtient sa taille ou déclare un pointeur vers celui-ci

Pour travailler correctement avec des pointeurs et l’opérateur sizeof , utilisez des types non managés et des contextes appropriés. Pour plus d’informations, consultez Types non managés et sizeof opérateur.

• Utilisez des pointeurs uniquement avec des types non managés (CS0208). Ne prenez pas l’adresse de types managés, n’obtenez pas leur taille et ne déclarez pas de pointeurs vers ceux-ci. Les types managés incluent des types de référence et des structs qui contiennent des champs ou des propriétés de type de référence.
• Utilisez l’opérateur dans un sizeof contexte lors de l’utilisation de types dont la taille n’est pas une constante au moment de la unsafe compilation (CS0233).
• Évitez de prendre l’adresse d’un type managé, d’en obtenir la taille ou de déclarer un pointeur vers celui-ci (CS8500). Cet avertissement (niveau 4) se déclenche lorsque le compilateur détecte les opérations de pointeur sur les types managés. Un type managé est n’importe quel type de référence, ou tout struct qui contient un type de référence en tant que champ ou propriété. Pour plus d’informations, consultez Types non managés.

Utilisation de l’instruction fixed

• CS0209 : Le type d’un local déclaré dans une instruction fixe doit être un type de pointeur
• CS0210: Vous devez fournir un initialiseur dans une déclaration d’instruction fixed ou using
• CS0211 : Impossible de prendre l’adresse de l’expression donnée
• CS0212 : Vous ne pouvez prendre l’adresse d’une expression non fixed qu’à l’intérieur d’un initialiseur d’instruction fixed
• CS0213 : Vous ne pouvez pas utiliser l’instruction fixe pour prendre l’adresse d’une expression déjà fixe
• CS0254 : la partie droite d’une assignation d’instruction fixed ne peut pas être une expression de cast
• CS0459 : Impossible de prendre l’adresse d’une variable locale en lecture seule
• CS0821 : Les variables locales implicitement typées ne peuvent pas être corrigées
• CS1656 : Impossible d’affecter à « variable », car il s’agit d’un « type de variable en lecture seule »
• CS8385 : L’expression donnée ne peut pas être utilisée dans une instruction fixe

Ces erreurs se produisent lorsque vous utilisez l’instructionfixed de manière incorrecte. L’instruction fixed empêche le garbage collector de déplacer une variable mobile et déclare un pointeur vers cette variable. Pour plus d’informations, consultez Code et pointeurs non sécurisés.

Pour utiliser correctement l’instruction fixed :

• Déclarez la variable en tant que type de pointeur (CS0209).
• Fournissez un initialiseur dans la déclaration d’instruction fixed (CS0210).
• Prenez l’adresse uniquement des expressions valides : champs, variables locales et indirection de pointeur (CS0211). Ne prenez pas l’adresse d’expressions calculées, comme la somme de deux variables.
• Utilisez l’opérateur address-of sur les expressions nonfixées uniquement dans l’initialiseur fixed d’instruction (CS0212).
• N’utilisez pas d’instruction fixed sur des expressions déjà fixes (CS0213). Les variables locales et les paramètres d’une méthode unsafe sont déjà positionnés sur la pile.
• N’utilisez pas d’expressions de cast du côté droit d’une instruction d’affectation fixed (CS0254).
• Ne prenez pas l’adresse des variables locales en lecture seule (CS0459). Les variables dans foreach les boucles, using les instructions et fixed les déclarations sont en lecture seule. Cette erreur n’est plus produite par les versions actuelles du compilateur.
• Utilisez des types explicites au lieu de var dans les instructions fixed (CS0821).
• N’assignez pas de variables dans des contextes en lecture seule, tels que les boucles foreach, les instructions if using, ou les instructions for fixed (CS1656).
• Utilisez uniquement des expressions compatibles avec l’épinglage dans une instruction fixed (CS8385). L’expression doit être une variable adressable, une chaîne ou un type qui implémente une méthode appropriée GetPinnableReference .

Exigences de contexte non sécurisées

• CS0214 : Les pointeurs et les mémoires tampons de taille fixe peuvent uniquement être utilisés dans un contexte non sécurisé
• CS0227 : Le code non sécurisé ne peut apparaître que si la compilation se fait avec /unsafe
• CS0244 : Ni 'is' ni 'as' n’est valide sur les types de pointeur
• CS1919 : Le type non sécurisé 'nom de type' ne peut pas être utilisé dans la création d’objets
• CS4004 : Impossible await dans un contexte non sécurisé
• CS9123 : L’opérateur '&' ne doit pas être utilisé sur les paramètres ou les variables locales dans les méthodes asynchrones
• CS9360 : cette opération peut uniquement être utilisée dans un contexte non sécurisé
• CS9361 : stackalloc expression sans initialiseur à l’intérieur SkipLocalsInit peut uniquement être utilisée dans un contexte non sécurisé
• CS9362 : « membre » doit être utilisé dans un contexte non sécurisé, car il est marqué comme «unsafe »
• CS9363 : « membre » doit être utilisé dans un contexte non sécurisé, car il a des pointeurs dans sa signature
• CS9376 : Un contexte non sécurisé est requis pour que le constructeur 'constructeur' marqué comme 'unsafe' réponde à la contrainte 'new()' du paramètre de type 'paramètre de type' dans 'type générique ou méthode'
• CS9398 : Impossible d’utiliser 'await' dans le contexte d’une instruction 'fixed'

Ces diagnostics se produisent lorsque vous utilisez des constructions de code non sécurisées sans contexte requis unsafe ou lorsque vous tentez des opérations qui ne sont pas autorisées avec des types non sécurisés. Pour plus d’informations, consultez Code et pointeurs non sécurisés et motunsafe clé.

• Marquez des méthodes, des types ou des blocs de code qui utilisent des pointeurs ou des mémoires tampons de taille fixe avec le unsafe mot clé (CS0214). Le compilateur nécessite un contexte non sécurisé explicite pour tout code qui fonctionne avec des types de pointeur ou des champs de mémoire tampon de taille fixe.
• Activez l’option du compilateur AllowUnsafeBlocks dans les paramètres de votre projet (CS0227). Sans cette option, le compilateur rejette tous les unsafe blocs même si le code est sinon correct.
• N’utilisez pas les opérateurs is ou as avec des types de pointeur (CS0244). Ces opérateurs de test de type ne sont pas valides pour les pointeurs, car les pointeurs ne participent pas à la hiérarchie de types.
• N’utilisez pas l’opérateur new pour créer des instances de type pointeur (CS1919). Pour créer des objets en mémoire non managée, utilisez l’interopérabilité pour appeler des méthodes natives qui retournent des pointeurs.
• Traitez CS4004 comme une recommandation obsolète. En C# 14 et dans les versions antérieures, await n’est pas autorisé dans un contexte unsafe. Avec les modifications apportées à la sécurité de la mémoire dans la préversion de C# 15, await est autorisé dans un contexte unsafe ; cette restriction générale ne décrit donc plus la règle actuelle.
• N’utilisez pas l’opérateur d’adresse (&) sur les paramètres ou les variables locales dans les méthodes asynchrones (CS9123). La variable peut ne pas exister sur la pile lorsque l’opération asynchrone reprend après un point de suspension.
• Marquez les opérations qui impliquent des constructions unsafe (telles que le déréférencement de pointeurs, la prise d’adresse ou l’utilisation de sizeof sur des types non managés) avec le mot-clé unsafe (CS9360). Sous les règles de sécurité de mémoire mises à jour de C# 15, le compilateur identifie les opérations individuelles qui nécessitent un contexte non sécurisé.
• Utilisez le mot clé unsafe pour les expressions stackalloc qui sont sans initialiseurs lorsque l’attribut SkipLocalsInit est appliqué (CS9361). Sans initialiseur, la mémoire allouée par la pile contient des données non initialisées, ce qui constitue une opération risquée.
• Utilisez un unsafe contexte lors de l’appel de membres marqués unsafe (CS9362), ou de membres dont les signatures contiennent des pointeurs (CS9363). Dans le cadre du modèle de sécurité de la mémoire mis à jour, le compilateur signale CS9362 pour les membres qui propagent explicitement l’obligation de sécurité à l’appelant et CS9363 pour les cas de compatibilité avec les versions héritées où la signature elle-même contient des pointeurs.
• Utilisez un contexte unsafe lorsqu’une contrainte new() nécessite l’appel d’un constructeur marqué unsafe (CS9376). L’instanciation générique appelle implicitement le constructeur, ce qui signifie que le contexte appelant doit être non sécurisé.
• Déplacez await en dehors du corps ou de l’initialiseur de l’instruction fixed (CS9398). La version préliminaire C# 15 autorise await dans un contexte non sécurisé, mais la durée de vie d’épinglage d’une instruction fixed ne peut toujours pas s’étendre sur un point de suspension asynchrone. Attendez la fin de l’opération avant d’entrer dans fixed, ou quittez l’instruction fixed avant d’utiliser await.

Contrats de sécurité des membres dangereux

• CS9364 : Le membre non sécurisé 'member' ne peut pas remplacer le membre sécurisé 'member'
• CS9365: Le membre unsafe « member » ne peut pas implémenter implicitement le membre sûr « member ».
• CS9366: Le membre unsafe « member » ne peut pas implémenter le membre sûr « member ».
• CS9367 : RequiresUnsafeAttribute ne peut pas être appliqué à ce symbole.
• CS9368 : RequiresUnsafeAttribute est valide uniquement dans les règles de sécurité de mémoire mises à jour.
• CS9377 : Le modificateur «unsafe » n’a aucun effet ici dans le cadre des règles de sécurité de mémoire actuelles.
• CS9379 : n’utilisez pas «RequiresUnsafeAttribute » dans la source ; utilisez plutôt le modificateur «unsafe ».
• CS9388 : Le modificateur «safe » peut uniquement être utilisé sur les membres «extern » qui ne sont pas marqués «unsafe ».
• CS9389 : Le membre « extern » doit être marqué « unsafe » ou « safe ».
• CS9390 : Les deux déclarations de membre partielles doivent être marquées « safe » ou aucune des deux ne doit l’être « safe »
• CS9396 : Impossible de spécifier des modificateurs «unsafe » ou «safe » sur la propriété ou l’indexeur « property » et son accesseur. Supprimez l’une d’entre elles.
• CS9397 : Impossible de spécifier le même modificateur 'unsafe' ou 'safe' sur tous les accesseurs de propriété ou d’indexeur 'property'. Au lieu de cela, placez ce modificateur sur la propriété elle-même.

Ces diagnostics appliquent les règles de contrat de sécurité C# 15 pour les membres marqués comme non sécurisés. Le compilateur garantit que les membres non sécurisés ne respectent pas les attentes de sécurité établies par les classes de base et les interfaces. Pour plus d’informations, consultez Code et pointeurs non sécurisés et motunsafe clé.

• Ne remplacez pas un membre de base sécurisé par un membre non sécurisé (CS9364). Une substitution doit préserver le contrat de sécurité du membre de base. Si le membre de base est sécurisé, le remplacement doit également être sécurisé. Supprimez le modificateur unsafe ou RequiresUnsafeAttribute du membre substitué, ou marquez le membre de base comme non sécurisé.
• N’implémentez pas implicitement un membre d’interface sécurisée avec un membre non sécurisé (CS9365). Lorsqu’un type implémente implicitement un membre d’interface, les appelants via l’interface attendent une opération sécurisée. Supprimez l'indication d'insécurité du membre implémentant ou utilisez une implémentation explicite de l'interface.
• N’implémentez pas explicitement un membre d’interface sécurisée avec un membre non sécurisé (CS9366). Même avec une implémentation explicite, le contrat de sécurité du membre de l’interface doit être conservé.
• Appliquez RequiresUnsafeAttribute uniquement aux types de symboles pris en charge (CS9367). Cet attribut peut être appliqué aux méthodes, aux propriétés, aux événements, aux constructeurs et aux types, mais pas à tous les types de symboles qui le prennent en charge.
• Activez les règles de sécurité de mémoire mises à jour pour utiliser RequiresUnsafeAttribute (CS9368). Cet attribut fait partie du modèle de sécurité de mémoire affiné de C# 15 et n’est pas reconnu dans les règles héritées. Vérifiez que votre projet cible une version de langue qui prend en charge les règles mises à jour.
• Supprimez le unsafe modificateur lorsqu’il n’a aucun effet (CS9377). Dans les règles de sécurité de mémoire actuelles, certains contextes ne nécessitent pas ou ne bénéficient pas du unsafe modificateur. Le compilateur avertit lorsque le modificateur n’a pas de signification pour vous permettre de nettoyer les annotations inutiles.
• Utilisez le modificateur unsafe directement sur la déclaration du membre au lieu de l’appliquer RequiresUnsafeAttribute dans le code source (CS9379). L’attribut est destiné uniquement à la représentation des métadonnées ; dans le code source, le unsafe mot clé est le mécanisme correct.
• Appliquez le modificateur safe uniquement aux membres extern qui ne sont pas déjà marqués unsafe (CS9388). Le modificateur safe exclut explicitement un membre externe de la présomption d’insécurité par défaut pour les déclarations externes.
• Marquez chaque extern membre comme unsafe ou safe (CS9389). Dans le cadre des règles de sécurité de mémoire mises à jour, les membres extern doivent déclarer explicitement leur contrat de sécurité, car le compilateur ne peut pas vérifier l’implémentation.
• Assurez-vous que les deux déclarations partielles de membre utilisent le même modificateur safe (CS9390). Si une déclaration partielle est marquée safe, l’autre doit également être marquée safe pour maintenir un contrat de sécurité cohérent.
• Placez safe ou unsafe sur la propriété ou l’indexeur, ou sur un accesseur, mais pas sur les deux (CS9396). Si la propriété définit le contrat pour tous les accesseurs, placez le modificateur sur la propriété elle-même. Si un seul accesseur diffère, placez le modificateur sur cet accesseur et laissez la propriété non modifiée.
• Si chaque accesseur d’une propriété ou d’un indexeur aurait le même unsafe ou safe modificateur, déplacez ce modificateur vers la déclaration de propriété ou d’indexeur (CS9397). Utilisez des modificateurs d’accesseur uniquement lorsque les accesseurs diffèrent intentionnellement.

Champs de disposition explicites ou étendus

• CS9392 : Le champ d’un type de disposition explicite ou étendu doit être marqué «unsafe » ou «safe ».

Ce diagnostic se produit dans le cadre du modèle de sécurité de la mémoire mis à jour lorsqu’un champ d’instance utilise un agencement explicite ou étendu et que la déclaration n’indique pas si le champ est unsafe ou safe. Pour plus d’informations, consultez Code et pointeurs non sécurisés et motsafe clé.

• Marquer chaque champ d’instance d’un type avec [StructLayout(LayoutKind.Explicit)] ou [ExtendedLayout] comme étant soit safe soit unsafe (CS9392). Si le champ est synthétisé pour une propriété automatique, une propriété de champ, un paramètre de constructeur principal ou un événement de type champ, placez le modificateur sur la propriété, le paramètre ou l’événement propriétaire du champ généré.

Mémoires tampons de taille fixe

• CS1641 : Un champ de mémoire tampon de taille fixe doit avoir le spécificateur de taille de tableau après le nom du champ
• CS1642 : Les champs de mémoire tampon de taille fixe peuvent uniquement être membres de structs
• CS1663 : Type de mémoire tampon de taille fixe doit être l’un des éléments suivants : bool, , byteshort, intlong, , char, sbyte, , ou ushortuintulongfloatdouble
• CS1664 : La mémoire tampon de taille fixe de longueur 'length' et de type 'type' est trop grande
• CS1665 : Les mémoires tampons de taille fixe doivent avoir une longueur supérieure à zéro
• CS1666 : Vous ne pouvez pas utiliser de mémoires tampons de taille fixe contenues dans des expressions non corrigées. Essayez d’utiliser l’instruction fixe.
• CS1708 : Les mémoires tampons de taille fixe sont accessibles uniquement par le biais de locaux ou de champs
• CS1716 : N’utilisez pas l’attribut 'System.Runtime.CompilerServices.FixedBuffer'. Utilisez le modificateur de champ « fixe » à la place.
• CS7092 : une mémoire tampon fixe ne peut avoir qu’une seule dimension.
• CS8372 : N’utilisez pas l’attribut 'System.Runtime.CompilerServices.FixedBuffer' sur une propriété
• CS9049 : Un champ fixe ne doit pas être un champ ref.

Ces erreurs se produisent lorsque vous travaillez avec des mémoires tampons de taille fixe. Les mémoires tampons de taille fixe sont des tableaux incorporés directement dans des structs et sont principalement utilisés pour les scénarios d’interopérabilité. Pour plus d’informations, consultez Mémoires tampons de taille fixe.

Pour déclarer et utiliser correctement des mémoires tampons de taille fixe :

• Spécifiez la taille du tableau après le nom du champ à l’aide d’une constante entière positive (CS1641, CS1665). La taille totale de la mémoire tampon (nombre d’éléments multiplié par taille d’élément) ne doit pas dépasser 2^31 octets (CS1664).
• Déclarez les mémoires tampons de taille fixe uniquement dans les structs, et non dans les classes (CS1642). Utilisez un tableau standard si vous avez besoin du champ dans une classe.
• Utilisez l’un des types d’éléments pris en charge : bool, byteshortintlongcharsbyteushortuint, , , ulong, floatou double (CS1663).
• Utilisez une instruction fixed pour épingler la structure englobante avant d’accéder au tampon (CS1666).
• Accédez aux mémoires tampons de taille fixe uniquement par le biais de locaux ou de champs, et non par le biais d’expressions intermédiaires (CS1708).
• Utilisez le fixed modificateur de champ au lieu de l’attribut System.Runtime.CompilerServices.FixedBuffer (CS1716). N’appliquez pas cet attribut aux propriétés (CS8372).
• Déclarez des mémoires tampons fixes avec une seule dimension (CS7092). Les mémoires tampons fixes multidimensionnelles ne sont pas prises en charge.
• Ne déclarez pas de mémoires tampons de taille fixe en tant que ref champs (CS9049). Les mémoires tampons de taille fixe doivent être des champs de valeur.

Pointeurs fonction

• CS8812 : Impossible de convertir le groupe de méthodes 'method' en type pointeur non fonction 'type'.

Pour obtenir un pointeur de fonction, utilisez l’opérateur de prise d’adresse avec un cast explicite vers un type de pointeur de fonction. N'utilisez pas l'opérateur d'adresse & pour affecter des groupes de méthodes à void* ou à d'autres types de pointeurs qui ne sont pas des pointeurs de fonction. Pour plus d’informations, consultez pointeurs de fonction.