CoreStrings Classe

Le fournisseur de base de données actuel n’a pas implémenté la méthode « CanConnect ».

Impossible de convertir une méthode interrogeable en méthode énumérable. Il s’agit probablement d’un problème dans Entity Framework. Veuillez déposer un problème à l’adresse https://go.microsoft.com/fwlink/?linkid=2142044.

Une deuxième opération a été démarrée sur ce contexte instance avant la fin d’une opération précédente. Cela est généralement dû à différents threads qui utilisent simultanément le même instance de DbContext. Pour plus d’informations sur la façon d’éviter les problèmes de thread avec DbContext, consultez https://go.microsoft.com/fwlink/?linkid=2097913.

Impossible d’accéder à un instance de contexte supprimé. Une cause courante de cette erreur est la suppression d’un contexte instance qui a été résolu à partir de l’injection de dépendances, puis la tentative ultérieure d’utiliser le même contexte instance ailleurs dans votre application. Cela peut se produire si vous appelez « Dispose » sur le contexte instance ou si vous l’encapsulez dans une instruction using. Si vous utilisez l’injection de dépendances, vous devez laisser le conteneur d’injection de dépendances prendre en charge la suppression des instances de contexte.

Les appels de convention ont atteint la limite de récursivité. Il s’agit probablement d’un problème dans Entity Framework. Signalez un problème à l’adresse https://go.microsoft.com/fwlink/?linkid=2142044.

La liaison de données directement à « DbSet.Local » n’est pas prise en charge, car elle ne fournit pas de classement stable. Pour WPF, liez à « DbSet.Local.ToObservableCollection ». Pour WinForms, liez à « DbSet.Local.ToBindingList ». Pour ASP.NET WebForms, liez à « DbSet.ToList » ou utilisez la liaison de modèle.

La liaison de données directement à une requête de magasin n’est pas prise en charge. Au lieu de cela, renseignez un DbSet avec des données, par exemple en appelant « Load » sur le DbSet, puis liez aux données locales pour éviter d’envoyer une requête à la base de données chaque fois que le contrôle de trafic de données itère les données. Pour WPF, liez à « DbSet.Local.ToObservableCollection ». Pour WinForms, liez à « DbSet.Local.ToBindingList ». Pour ASP.NET WebForms, liez à « DbSet.ToList » ou utilisez la liaison de modèle.

The EF. La propriété T> par défaut<ne peut être utilisée que dans la méthode Entity Framework ExecuteUpdate.

L’attribut [DeleteBehavior] ne peut être spécifié que sur les propriétés de navigation et n’est pas pris en charge sur les propriétés constituant la clé étrangère.

L’attribut [DeleteBehavior] ne peut être spécifié que sur le côté dépendant de la relation.

Impossible de réinitialiser cet énumérateur.

Impossible d’utiliser plusieurs instances de contexte au sein d’une seule exécution de requête. Vérifiez que la requête utilise un seul instance de contexte.

Une exception s’est produite lors de la lecture d’une valeur de base de données. Pour plus d'informations, consultez l'exception interne.

Une exception a été levée lors de la tentative d’évaluation d’une expression de paramètre de requête LINQ. Pour plus d'informations, consultez l'exception interne. Pour afficher des informations supplémentaires, appelez « DbContextOptionsBuilder.EnableSensitiveDataLogging ».

La taille de bloc utilisée pour la génération de valeur Hi-Lo n’est pas positive. Le générateur Hi-Lo est généralement soutenu par une séquence SQL, ce qui signifie que l’incrément de séquence doit être positif.

L’étendue de la convention immédiate ne peut pas être réexécuter.

Sources incompatibles utilisées pour l’opération de définition.

Une erreur précédente a laissé le DbContext dans un état non valide. Les applications ne doivent pas continuer à utiliser un instance DbContext une fois qu’une exception InvalidOperationException a été levée.

Opération non gérée : la liaison MemberInitExpression n’est pas un MemberAssignment

Le poolSize spécifié doit être supérieur à 0.

Le fournisseur de la source « IQueryable » n’implémente pas « IAsyncQueryProvider ». Seuls les fournisseurs qui implémentent « IAsyncQueryProvider » peuvent être utilisés pour les opérations asynchrones Entity Framework.

Les modifications des métadonnées d’exécution ne sont pas autorisées lorsque le modèle n’a pas été marqué comme étant en lecture seule.

Les modifications de métadonnées ne sont pas autorisées lorsque le modèle a été marqué comme en lecture seule.

La génération de modèles n’est pas prise en charge lors de la publication avec NativeAOT. Utilisez un modèle compilé.

Les services Entity Framework n’ont pas été ajoutés au fournisseur de services interne. Supprimez l’appel à « UseInternalServiceProvider » afin qu’Entity Framework gère ses propres services internes, ou utilisez la méthode de votre fournisseur de base de données pour ajouter les services requis au fournisseur de services (par exemple, « AddEntityFrameworkSqlServer »).

La séquence ne contient aucun élément.

'InterceptionResult.Result' a été appelé lorsque 'InterceptionResult.HasResult' est false.

Aucun fournisseur de base de données n’a été configuré pour ce DbContext. Un fournisseur peut être configuré en remplaçant la méthode « DbContext.OnConfiguring » ou en utilisant « AddDbContext » sur le fournisseur de services d’application. Si « AddDbContext » est utilisé, assurez-vous également que votre type DbContext accepte un objet TContext DbContextOptions<> dans son constructeur et le transmet au constructeur de base pour DbContext.

L’élément « IQueryable » donné ne prend pas en charge la génération de chaînes de requête.

L’objet a été supprimé du modèle.

Une requête de suivi tente de projeter une entité détenue sans propriétaire correspondant dans son résultat, mais les entités détenues ne peuvent pas être suivies sans leur propriétaire. Incluez l’entité propriétaire dans le résultat ou effectuez le non-suivi de la requête à l’aide de « AsNoTracking ».

« OnConfiguring » ne peut pas être utilisé pour modifier DbContextOptions lorsque le regroupement DbContext est activé.

The EF. La méthode T> de propriété<ne peut être utilisée que dans les requêtes LINQ Entity Framework.

La méthode « InitializeStateManager » a été appelée plusieurs fois sur le contexte de requête actuel. Cette méthode est destinée à être appelée une seule fois avant le début de l’énumération de requête.

La traduction de « Select » qui contient le paramètre de regroupement sans composition n’est pas prise en charge.

Traduction de la chaîne . La surcharge égale à un paramètre « StringComparison » n’est pas prise en charge. Consultez la rubrique https://go.microsoft.com/fwlink/?linkid=2129535 (éventuellement en anglais) pour plus d'informations.

Une tentative d’utilisation du contexte instance lors de sa configuration. Une instance DbContext ne peut pas être utilisée dans « OnConfiguring », car elle est toujours en cours de configuration à ce stade. Cela peut se produire si une deuxième opération est démarrée sur ce contexte instance avant la fin d’une opération précédente. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Une tentative d’utilisation du modèle a été effectuée lors de sa création. Une instance DbContext ne peut pas être utilisée à l’intérieur de « OnModelCreating » d’une manière qui utilise le modèle en cours de création.

Le principal et les extrémités dépendantes de la relation ne peuvent pas être modifiés une fois que les propriétés de clé étrangère ou de clé principale ont été spécifiées. Supprimez la configuration en conflit.

'ObservableCollection<T>. Clear » n’est pas pris en charge, car il utilise l’opération « INotifyCollectionChanged » « Reset », qui ne fournit pas les éléments supprimés. Utilisez plusieurs appels à « Remove », ou utilisez une collection de notification qui prend en charge « Clear », telle que « Microsoft.EntityFrameworkCore.ChangeTracking.ObservableHashSet<T> ».

La configuration demandée n’est pas stockée dans le modèle en lecture optimisée. Utilisez « DbContext.GetService<IDesignTimeModel>(). Model'.

Lors de l’inscription d’un paramètre runtime, l’expression lambda ne doit avoir qu’un seul paramètre qui doit être identique à l’expression « QueryCompilationContext.QueryContextParameter ».

Les points d’enregistrement ne sont pas pris en charge par le fournisseur de base de données en cours d’utilisation.

Pour afficher des informations supplémentaires, appelez « DbContextOptionsBuilder.EnableSensitiveDataLogging ».

La séquence contient plusieurs éléments.

La séquence ne contient aucun élément.

Impossible de traduire l’opération de jeu, car les deux opérandes ont des opérations « Include » différentes. Envisagez d’appliquer le même « Include » des deux côtés.

Le fournisseur actuel ne prend pas en charge System.Transaction.

Le type CLR correspondant pour le type d’entité « {entityType} » ne peut pas être instancié et il n’existe aucun type d’entité dérivé dans le modèle qui correspond à un type CLR concret.

Impossible d’ajouter le type « {typeName} » au modèle, car il s’agit d’un type proxy généré dynamiquement.

Le type d’entité « {entityType} » utilise un type partagé et l’entité fournie est actuellement référencée à partir de plusieurs entités propriétaires. Pour accéder à l’entrée d’une référence particulière, appelez « {targetEntryCall} » sur l’entrée propriétaire.

La clé étrangère {foreignKeyProperties} sur le type d’entité « {entityType} » ne peut pas être configurée comme ayant un dépendant obligatoire, car le côté dépendant ne peut pas être déterminé. Pour identifier le côté dépendant de la relation, configurez la propriété de clé étrangère dans « OnModelCreating ». Consultez https://go.microsoft.com/fwlink/?LinkId=724062 pour plus d’informations.

Navigation « {entityType}. {navigation} ' ne peut pas être configuré comme requis, car le côté dépendant de la clé étrangère sous-jacente {foreignKeyProperties} ne peut pas être déterminé. Pour identifier le côté dépendant de la relation, configurez la propriété de clé étrangère dans « OnModelCreating ». Consultez https://go.microsoft.com/fwlink/?LinkId=724062 pour plus d’informations.

La clé étrangère {foreignKeyProperties} sur le type d’entité « {entityType} » ne peut pas être inversée par le type d’entité « {principalEntityType} », car elle a été configurée comme nécessaire avant la configuration du côté dépendant. Configurez la propriété de clé étrangère ou la clé principale avant de configurer la clé étrangère en fonction des besoins. Consultez https://go.microsoft.com/fwlink/?LinkId=724062 pour plus d’informations.

Les relations entre « {firstDependentToPrincipalNavigationSpecification} » et « {firstPrincipalToDependentNavigationSpecification} » et entre « {secondDependentToPrincipalNavigationSpecification} » et « {secondPrincipalToDependentNavigationSpecification} » peuvent utiliser {foreignKeyProperties} comme clé étrangère. Pour résoudre ce problème, configurez explicitement les propriétés de clé étrangère dans « OnModelCreating » sur au moins une des relations.

Le côté dépendant n’a pas pu être déterminé pour la relation un-à-un entre « {dependentToPrincipalNavigationSpecification} » et « {principalToDependentNavigationSpecification} ». Pour identifier le côté dépendant de la relation, configurez la propriété de clé étrangère. Si ces navigations ne doivent pas faire partie de la même relation, configurez-les indépendamment via des chaînes de méthode distinctes dans « OnModelCreating ». Consultez https://go.microsoft.com/fwlink/?LinkId=724062 pour plus d’informations.

Impossible de déterminer le propriétaire de la relation entre « {entityTypeNavigationSpecification} » et « {otherEntityType} », car les deux types ont été marqués comme appartenant. Configurez manuellement la propriété ou ignorez les navigations correspondantes à l’aide de l’attribut [NotMapped] ou en utilisant « EntityTypeBuilder.Ignore » dans « OnModelCreating ». Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

La propriété de service « {propriété} » du type « {serviceType} » ne peut pas être ajoutée au type d’entité « {entityType} », car il existe une autre propriété du même type. Ignorez l’une des propriétés à l’aide de l’attribut [NotMapped] ou « EntityTypeBuilder.Ignore » dans « OnModelCreating ».

Le type d’entité de type partagé « {entityType} » ne peut pas être ajouté au modèle, car son nom est identique au nom du type CLR. Cela indique généralement une erreur, soit en l’ajoutant en tant que type d’entité non partagé, soit en choisissant un autre nom.

L’annotation « {annotation} » est introuvable. Vérifiez que l’annotation a été ajoutée.

L’annotation « {annotation} » est introuvable. Vérifiez que l’annotation a été ajoutée à l’objet {annotatable}

La propriété « {property} » de l’argument « {argument} » ne peut pas être null.

L’attribut [{attribute}] ne peut être spécifié que sur les propriétés de type d’entité. Supprimez l’attribut de « {type} ». {propertyName}'.

Cycle détecté lors de l’inclusion automatique des navigations : {cycleNavigations}. Pour résoudre ce problème, ne configurez pas au moins une navigation dans le cycle comme étant automatiquement incluse dans OnModelCreating ou appelez la méthode « IgnoreAutoInclude » sur la requête.

Impossible de définir le champ de stockage « {field} » pour la propriété d’indexeur « {entityType} ». {property}'. Vérifiez qu’aucun champ de stockage n’est spécifié pour les propriétés de l’indexeur.

Le champ « {field} » spécifié de type « {fieldType} » ne peut pas être utilisé pour la propriété « {entityType} ». {property}' de type « {propertyType} ». Seuls les champs de stockage de types compatibles avec le type de propriété peuvent être utilisés.

Le type de dépendances de service « {dependenciesType} » a été inscrit de manière incorrecte dans la collection de services. Les types de dépendances de service doivent uniquement être inscrits par Entity Framework ou par des fournisseurs de base de données.

La valeur « {enumValue} » n’a pas pu être analysée en tant que valeur d’énumération {enumType}.

L’expression de filtre « {filter} » ne peut pas être spécifiée pour le type d’entité « {entityType} ». Un filtre ne peut être appliqué qu’au type d’entité racine dans une hiérarchie.

L’expression de filtre « {filter} » ne peut pas être spécifiée pour le type d’entité « {entityType} ». Un filtre ne peut être appliqué qu’au type d’entité racine « {rootType} ».

L’expression de filtre « {filter} » spécifiée pour le type d’entité « {entityType} » n’est pas valide. L’expression doit accepter un seul paramètre de type « {clrType} » et retourner bool.

L’expression de filtre « {filter} » ne peut pas être spécifiée pour le type d’entité « {entityType} ». Un filtre ne peut être appliqué qu’à un type d’entité qui n’est pas détenu. Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

Le type « {givenType} » ne peut pas être utilisé comme « JsonValueReaderWriter », car il n’hérite pas de la valeur générique « JsonValueReaderWriter<TValue> ». Veillez à hériter du lecteur/enregistreur json de « JsonValueReaderWriter<TValue> ».

Le type « {givenType} » ne peut pas être utilisé comme collection primitive, car il ne s’agit pas d’un tableau et n’implémente pas « {listType} ». Les collections de types primitifs doivent être des tableaux ou des listes triées.

Le type « {givenType} » ne peut pas être utilisé comme comparateur de valeurs, car il n’hérite pas de « {expectedType} ». Veillez à hériter des comparateurs de valeurs de « {expectedType} ».

Le type « {givenType} » ne peut pas être utilisé comme convertisseur de valeurs, car il n’hérite pas de « {expectedType} ». Veillez à hériter des convertisseurs de valeurs de « {expectedType} ».

Le type « {givenType} » ne peut pas être utilisé comme générateur de valeurs, car il n’hérite pas de « {expectedType} ». Veillez à hériter des générateurs de valeurs de « {expectedType} ».

Propriété « {1_entityType}. {0_property}' ne peut pas être marqué comme nullable/facultatif, car le type de la propriété est « {propertyType} » qui n’est pas un type nullable. Toutes les propriétés peuvent être marquées comme non nullables/obligatoires, mais seules les propriétés de types nullables peuvent être marquées comme nullables/facultatives.

Type d’élément de la propriété « {entityType}. {property}' ne peut pas être marqué comme nullable/facultatif, car le type de l’élément est « {elementType} », qui n’est pas un type nullable. N’importe quel type d’élément peut être marqué comme non nullable/obligatoire, mais seuls les éléments de types nullables peuvent être marqués comme nullables/facultatifs.

Propriété « {1_entityType}. {0_property}' ne peut pas être marqué comme nullable/facultatif, car la propriété fait partie d’une clé. Toute propriété peut être marquée comme non nullable/obligatoire, mais seules les propriétés de types nullables et qui ne font pas partie d’une clé peuvent être marquées comme nullables/facultatives.

Impossible de convertir la valeur de chaîne « {valeur} » de la base de données en valeur dans l’énumération « {enumType} » mappée.

Impossible de créer un instance de type reade/writer « {readerWriterType} ». Assurez-vous que le type peut être instancié et qu’il possède un constructeur sans paramètre public, ou qu’il dispose d’un champ statique public « Instance » qui retourne le singleton instance à utiliser.

Impossible de créer une instance du type de comparateur de valeurs « {generatorType} ». Vérifiez que le type peut être instancié et possède un constructeur sans paramètre, ou utilisez la surcharge de « {method} » qui accepte un délégué.

Impossible de créer un instance de type de convertisseur de valeurs « {generatorType} ». Vérifiez que le type peut être instancié et possède un constructeur sans paramètre, ou utilisez la surcharge de « {method} » qui accepte un délégué.

Impossible de créer une instance de type générateur de valeurs « {generatorType} ». Vérifiez que le type peut être instancié et possède un constructeur sans paramètre, ou utilisez la surcharge de « HasValueGenerator » qui accepte un délégué.

Impossible de créer une instance de type générateur de valeurs « {generatorType} ». Vérifiez que le type peut être instancié et possède un constructeur sans paramètre, ou utilisez la surcharge de « {method} » qui accepte un délégué.

Navigation « {1_entityType}. {0_navigation}' ne peut pas être chargé, car l’entité n’est pas suivie. Les navigations ne peuvent être chargées que pour les entités suivies.

Navigation « {1_entityType}. {0_navigation}' ne peut pas être chargé, car une ou plusieurs des propriétés de clé ou de clé étrangère sont des propriétés d’ombre et l’entité n’est pas suivie. Les relations utilisant des valeurs d’ombre ne peuvent être chargées que pour les entités suivies.

Le type « {type} » ne peut pas être marqué comme un type non partagé, car un type d’entité de type partagé avec ce type CLR existe dans le modèle.

Le type « {type} » ne peut pas être marqué comme un type partagé, car un type d’entité avec le même type CLR existe déjà dans le modèle.

Impossible de créer une instance de type d’entité « {entityType} », car elle est abstraite. Envisagez de le rendre non abstrait ou de mappage au moins un type dérivé.

Navigation '{1_entityType}. {0_navigationName}' est introuvable. Ajoutez la navigation au type d’entité avant de le configurer.

Le type d’entité « {entityType} » est configuré pour utiliser la stratégie de suivi des modifications « {changeTrackingStrategy} », mais n’implémente pas l’interface « {notificationInterface} » requise. Implémentez « {notificationInterface} » sur « {entityType} » ou utilisez une autre stratégie de suivi des modifications.

Impossible d’enregistrer les modifications, car une dépendance circulaire a été détectée dans les données à enregistrer : « {cycle} ».

Le type d’entité « {entityType} » ne peut pas hériter de « {baseEntityType} », car « {baseEntityType} » est un descendant de « {entityType} ». Passez en revue la configuration de votre modèle.

Impossible d’ajouter le type d’entité de type partagé « {entityType} », car le modèle contient déjà un type d’entité portant le même nom, mais avec un type CLR différent « {otherClrType} ». Vérifiez que tous les noms de type d’entité sont uniques.

Un type d’entité nommé « {ownedTypeName} » a déjà été ajouté au modèle. Utilisez un nom différent lors de la configuration de la propriété « {ownerEntityType}. {navigation} » dans « OnModelCreating ». Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

Le type d’entité « {entityType} » ne peut pas être marqué comme appartenant, car le type d’entité dérivé « {derivedType} » a été configuré comme non détenu. Ne configurez pas « {derivedType} » en tant que non-propriétaire, ou appelez « HasBaseType(null) » pour celui-ci dans « OnModelCreating ». Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

Le type d’entité « {entityType} » ne peut pas être configuré en tant que propriété, car il a déjà été configuré en tant qu’entité non détenue. Si vous souhaitez remplacer la configuration précédente, supprimez d’abord le type d’entité du modèle en appelant « Ignore ». Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

Le type d’entité de type partagé « {entityType} » avec le type CLR « {type} » ne peut pas être ajouté au modèle, car il existe déjà un type d’entité non partagé avec le même type CLR.

Le type d’entité « {entityType} » avec une navigation de définition ne peut pas être ajouté au modèle, car un type d’entité portant le même nom existe déjà.

Le type d’entité « {entityType} » ne peut pas être marqué comme étant non détenu, car le type d’entité dérivé « {derivedType} » a été configuré comme appartenant. Ne configurez pas « {derivedType} » comme propriété ou appelez « HasBaseType(null) » dans « OnModelCreating ». Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

Le type d’entité « {entityType} » ne peut pas être configuré comme étant non détenu, car il a déjà été configuré en tant que propriété. Utilisez le générateur imbriqué dans OwnsOne ou OwnsMany sur le générateur de type d’entité propriétaire pour configurer davantage ce type. Si vous souhaitez remplacer la configuration précédente, supprimez d’abord le type d’entité du modèle en appelant « Ignore ». Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

Le type d’entité « {entityType} » ne peut pas être ajouté au modèle, car son type CLR a été configuré en tant que type partagé.

Impossible d’ajouter le type d’entité « {entityType} » au modèle, car il existe déjà un type d’entité avec une navigation de définition portant le même nom.

La projection cliente contient une référence à une expression constante de « {constantType} » qui est passée en tant qu’argument à la méthode « {nom_méthode} ». Cela peut potentiellement provoquer une fuite de mémoire ; envisagez d’affecter cette constante à une variable locale et d’utiliser la variable dans la requête à la place. Pour plus d’informations et d’exemples, consultez https://go.microsoft.com/fwlink/?linkid=2103067.

La projection cliente contient une référence à une expression constante de « {constantType} » par le biais de la méthode instance « {methodName} ». Cela peut potentiellement provoquer une fuite de mémoire ; envisagez de rendre la méthode statique afin qu’elle ne capture pas la constante dans le instance. Pour plus d’informations et d’exemples, consultez https://go.microsoft.com/fwlink/?linkid=2103067.

La projection cliente contient une référence à une expression constante de « {constantType} ». Cela peut potentiellement provoquer une fuite de mémoire ; envisagez d’affecter cette constante à une variable locale et d’utiliser la variable dans la requête à la place. Pour plus d’informations et d’exemples, consultez https://go.microsoft.com/fwlink/?linkid=2103067.

La propriété « {property} » ne peut pas exister sur le type « {entityType} », car le type est marqué comme état d’ombre alors que la propriété ne l’est pas. Les types d’état d’ombre ne peuvent contenir que des propriétés d’état d’ombre.

Propriété « {1_entityType}. {0_property} » est accessible à l’aide de « {collectionMethod} », mais est défini dans le modèle comme une navigation de référence non-collection. Utilisez « {referenceMethod} » pour accéder aux navigations de référence.

Le comparateur pour le type « {type} » ne peut pas être utilisé pour « {entityType} ». {propertyName} », car son type est « {propertyType} ».

Le comparateur pour le type d’élément « {type} » ne peut pas être utilisé pour « {entityType} ». {propertyName}', car son type d’élément est '{elementType}'.

Le mappage de type utilisé n’est pas compatible avec un modèle compilé. Le type de mappage doit avoir un « public static readonly {typeMapping} {typeMapping}. Default', propriété.

La requête compilée « {queryExpression} » a été exécutée avec un modèle différent de celui sur lequel elle a été compilée. Les requêtes compilées ne peuvent être utilisées qu’avec un seul modèle.

Impossible d’ajouter la propriété complexe de la collection « {property} » au type « {type} », car son type CLR « {clrType} » n’implémente pas « IEnumerable<{targetType}> ». La propriété complexe de collection doit implémenter IEnumerable<> du type complexe.

Ajout de la propriété complexe de la collection « {type} ». {property}' n’est pas pris en charge. Consultez la rubrique https://github.com/dotnet/efcore/issues/31237 (éventuellement en anglais) pour plus d'informations.

Ajout de la propriété complexe « {type} ». {property}' en tant que propriété d’indexeur n’est pas prise en charge. Consultez la rubrique https://github.com/dotnet/efcore/issues/31244 (éventuellement en anglais) pour plus d'informations.

Propriété complexe « {type}. {property}' est introuvable. Vérifiez que la propriété existe et qu’elle a été incluse dans le modèle en tant que propriété complexe.

Configuration de la propriété complexe « {type} ». {property} » comme facultatif n’est pas pris en charge, appelez « IsRequired() ». Consultez la rubrique https://github.com/dotnet/efcore/issues/31376 (éventuellement en anglais) pour plus d'informations.

Configuration de la propriété complexe « {type} ». {property}' dans l’état d’ombre n’est pas pris en charge. Consultez la rubrique https://github.com/dotnet/efcore/issues/31243 (éventuellement en anglais) pour plus d'informations.

Impossible d’ajouter la propriété complexe « {property} » au type « {type} », car son type CLR « {clrType} » ne correspond pas au type CLR attendu « {targetType} ».

« {service} » ne prend actuellement pas en charge les types complexes.

Il existe plusieurs propriétés avec l’attribut [ForeignKey] pointant vers la navigation « {1_entityType}. {0_navigation}'. Pour définir une clé étrangère composite à l’aide d’annotations de données, utilisez l’attribut [ForeignKey] sur la navigation.

Le type d’entité « {entityType} » a plusieurs propriétés avec l’attribut [Key]. Clés primaires composites configurées en plaçant l’attribut [PrimaryKey] sur la classe de type d’entité ou en utilisant « HasKey » dans « OnModelCreating ».

Propriété « {1_entityType}. {0_property} » correspond à « {field1} » et « {field2} » par convention. Spécifiez explicitement le champ de stockage à utiliser avec « HasField » dans « OnModelCreating ».

Membre « {type} ». {property} » ne peut pas utiliser le champ « {field} », car il est déjà utilisé par « {conflictingType} ». {conflictingProperty}'.

Il existe plusieurs ForeignKeyAttributes qui pointent vers le même ensemble de propriétés : « {propertyList} » sur le type d’entité « {entityType} ».

Plusieurs attributs [ForeignKey] pointent vers le même ensemble de propriétés « {propertyList} » sur le type d’entité « {entityType} » et ciblent le type d’entité principal « {principalEntityType} ».

Le type d’entité « {entity} » a à la fois des attributs [Keyless] et [PrimaryKey] ; il faut en supprimer un.

Impossible d’ajouter la propriété ou la navigation « {member} » au type « {type} », car une propriété ou une navigation portant le même nom existe déjà sur le type « {conflictingType} ».

Impossible de créer une relation entre « {newPrincipalNavigationSpecification} » et « {newDependentNavigationSpecification} », car une relation existe déjà entre « {existingPrincipalNavigationSpecification} » et « {existingDependentNavigationSpecification} ». Les navigations ne peuvent participer qu’à une seule relation. Si vous souhaitez remplacer une relation existante, appelez « Ignore » dans la navigation « {newDependentNavigationSpecification} » dans « OnModelCreating ».

Impossible de créer une relation entre « {newPrincipalEntityType}. {newPrincipalNavigation}' et '{newDependentEntityType}. {newDependentNavigation}', car il existe déjà une relation entre « {existingPrincipalEntityType}. {existingPrincipalNavigation}' et '{existingDependentEntityType}. {existingDependentNavigation}'. Les propriétés de navigation ne peuvent participer qu’à une seule relation.

Impossible de lier « {failedBinds} » dans « {parameters} »

Les constructeurs « {firstConstructor} » et « {secondConstructor} » ont le même nombre de paramètres et peuvent tous deux être utilisés par Entity Framework. Le constructeur à utiliser doit être configuré dans « OnModelCreating ».

Aucun constructeur approprié n’a été trouvé pour le type d’entité « {entityType} ». Les constructeurs suivants avaient des paramètres qui ne pouvaient pas être liés aux propriétés du type d’entité : {constructeurs}Notez que seules les propriétés mappées peuvent être liées aux paramètres du constructeur. Les navigations vers les entités associées, y compris les références aux types détenus, ne peuvent pas être liées.

Le convertisseur de valeur « {converter} » ne peut pas être utilisé avec le type « {type} ». Ce convertisseur ne peut être utilisé qu’avec {allowed}.

Le convertisseur pour le type de modèle « {converterType} » ne peut pas être utilisé pour « {entityType} ». {propertyName} », car son type est « {propertyType} ».

Le convertisseur pour le type d’élément « {converterType} » ne peut pas être utilisé pour « {entityType} ». {propertyName}', car son type d’élément est '{elementType}'.

Impossible de composer le convertisseur de « {typeOneIn} » en « {typeOneOut} » avec le convertisseur de « {typeTwoIn} » en « {typeTwoOut} », car le type de sortie du premier convertisseur ne correspond pas au type d’entrée du deuxième convertisseur.

La méthode d’extension « {method} » est utilisée avec une implémentation personnalisée de « {interfaceType} ». L’utilisation d’implémentations personnalisées des interfaces de métadonnées Entity Framework n’est pas prise en charge. Envisagez plutôt de dériver de « {concreteType} ». Contactez l’équipe Entity Framework si vous avez des arguments convaincants pour une implémentation personnalisée des interfaces de métadonnées afin que nous puissions envisager des moyens d’y parvenir.

« AddDbContext » a été appelé avec la configuration, mais le type de contexte « {contextType} » déclare uniquement un constructeur sans paramètre. Cela signifie que la configuration passée à « AddDbContext » ne sera jamais utilisée. Si la configuration est passée à « AddDbContext », « {contextType} » doit déclarer un constructeur qui accepte un DbContextOptions<{contextType}> et doit le transmettre au constructeur de base pour DbContext.

Impossible de créer DbSet pour le type d’entité « {entityType} », car il est de type « {entityClrType} », mais le type générique fourni est de type « {genericType} ».

La vue Debug a été supprimée {message}. Veuillez le signaler à l’adresse https://github.com/dotnet/efcore

Erreur lors de la création de l’expression de requête : {message}.

Erreur lors de la création de la chaîne de requête : {message}.

Le type d’entité « {entityType} » ne peut pas utiliser « ToQuery » pour créer une requête de définition, car il définit également une clé primaire. La définition de requêtes ne peut être utilisée que pour sauvegarder des types d’entités sans clés.

L’attribut [DeleteBehavior] ne peut être spécifié que sur les propriétés de navigation et n’est pas pris en charge sur les propriétés qui composent la clé étrangère. Supprimez l’attribut de « {type} ». {propertyName}'.

L’attribut [DeleteBehavior] ne peut être spécifié que sur le côté dépendant de la relation. Supprimez l’attribut de « {entityType}. {navigationName}'.

Vous configurez une relation entre « {dependentEntityType} » et « {principalEntityType} », mais vous avez spécifié une clé étrangère sur « {entityType} ». La clé étrangère doit être définie sur un type qui fait partie de la relation.

Impossible de définir un type de base pour le type d’entité « {entityType} », car il a été configuré comme sans clé. Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

Impossible de définir un type de base pour le type d’entité « {entityType} », car une ou plusieurs clés sont définies. Seuls les types racines peuvent avoir des clés.

Impossible de définir « {baseEntityType} » comme type de base pour le type d’entité « {derivedEntityType} », car « {ownedEntityType} » est configuré en tant que propriété, tandis que « {nonOwnedEntityType} » n’appartient pas. Tous les types d’entités d’une hiérarchie doivent avoir la même propriété status. Pour plus d’informations et d’exemples, consultez https://aka.ms/efcore-docs-owned.

« {derivedType} » ne peut pas être configuré comme sans clé, car il s’agit d’un type dérivé ; le type racine « {rootType} » doit être configuré comme sans clé à la place. Si vous n’avez pas prévu d’inclure « {rootType} » dans le modèle, vérifiez qu’il n’est pas référencé par une propriété DbSet dans votre contexte, référencée dans un appel de configuration à ModelBuilder dans « OnModelCreating », ou référencée à partir d’une navigation sur un type inclus dans le modèle. Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

Une clé ne peut pas être configurée sur « {derivedType} », car il s’agit d’un type dérivé. La clé doit être configurée sur le type racine « {rootType} ». Si vous n’avez pas l’intention d’inclure « {rootType} » dans le modèle, vérifiez qu’il n’est pas référencé par une propriété DbSet dans votre contexte, référencée dans un appel de configuration à ModelBuilder ou référencée à partir d’une navigation sur un type inclus dans le modèle.

Le type d’entité « {entityType} » ne peut pas avoir de requête de définition, car il est dérivé de « {baseType} ». Seuls les types d’entités de base peuvent avoir une requête de définition.

Impossible de configurer la valeur du discriminateur pour le type d’entité « {entityType} », car elle ne dérive pas de « {rootEntityType} ».

Une propriété de discriminateur ne peut pas être définie pour le type d’entité « {entityType} », car elle n’est pas la racine d’une hiérarchie d’héritage.

Impossible de définir la propriété « {propriété} » comme discriminateur pour le type d’entité « {entityType} », car il ne s’agit pas d’une propriété de « {entityType} ».

La valeur du discriminateur « {value} » pour le type d’entité « {entityType} » ne peut pas être définie, car elle n’est pas assignable à la propriété de discrimination de type « {discriminatorType} ».

Impossible d’ajouter l’annotation « {annotation} », car une annotation portant le même nom existe déjà.

Impossible d’ajouter l’annotation « {annotation} », car une annotation portant le même nom existe déjà sur l’objet {annotatable}

Le type complexe « {complexType} » ne peut pas être ajouté au modèle, car un type complexe portant le même nom existe déjà.

La valeur du discriminateur pour « {entityType1} » est « {discriminatorValue} », qui est la même pour « {entityType2} ». Chaque type d’entité concrète dans la hiérarchie doit avoir une valeur de discriminateur unique.

Le type d’entité « {entityType} » ne peut pas être ajouté au modèle, car un type d’entité portant le même nom existe déjà.

La clé étrangère {foreignKeyProperties} ne peut pas être ajoutée au type d’entité « {entityType} », car une clé étrangère sur les mêmes propriétés existe déjà sur le type d’entité « {duplicateEntityType} » et cible également la clé {keyProperties} sur « {principalType} ».

Impossible d’ajouter l’index {indexProperties} au type d’entité « {entityType} », car un index sans nom sur les mêmes propriétés existe déjà sur le type d’entité « {duplicateEntityType} ». Envisagez d’ajouter un nom pour l’un des index dans « OnModelCreating ».

La clé {keyProperties} ne peut pas être ajoutée au type d’entité « {entityType} », car une clé sur les mêmes propriétés existe déjà sur le type d’entité « {duplicateEntityType} ».

L’index nommé « {indexName} » défini sur les propriétés {indexProperties} ne peut pas être ajouté au type d’entité « {entityType} », car un index portant le même nom existe déjà sur le type d’entité « {duplicateEntityType} ».

Le type « {entityType} » ne peut pas avoir de type de base « {baseType} », car les deux types incluent les navigations : {navigations}.

Le type « {entityType} » ne peut pas avoir le type de base « {baseType} », car les propriétés « {derivedPropertyType} ». {derivedProperty}' et '{basePropertyType}. {baseProperty}' sont en conflit.

Les propriétés {propertyList} ne peuvent pas être utilisées pour une clé étrangère, car elles contiennent un doublon : « {property} ».

Les propriétés {propertyList} ne peuvent pas être utilisées pour un index, car elles contiennent un double : « {property} ».

Les propriétés {propertyList} ne peuvent pas être utilisées pour une clé, car elles contiennent un doublon : « {property} ».

La liste de propriétés {propertyList} ne peut pas être utilisée, car elle contient un doublon « {property} ».

La propriété de service « {propriété} » du type « {serviceType} » ne peut pas être ajoutée au type d’entité « {entityType} », car la propriété de service « {duplicateName} » du même type existe déjà sur le type d’entité « {duplicateEntityType} ».

Impossible d’ajouter le déclencheur « {trigger} » au type d’entité « {entityType} », car un autre déclencheur portant le même nom existe déjà sur le type d’entité « {conflictingEntityType} ».

Le type complexe « {complexType} » n’a aucune propriété définie. Configurez au moins une propriété ou n’incluez pas ce type dans le modèle.

Impossible de traduire un opérateur Contains() sur l’entité « {entityType} », car il a une clé composite.

Impossible de traduire « {comparisonOperator} » sur une expression de sous-requête de type d’entité « {entityType} », car elle a une clé primaire composite. Consultez https://go.microsoft.com/fwlink/?linkid=2141942 pour plus d’informations sur la réécriture de votre requête.

La comparaison du type d’entité « {entityType} » n’est pas prise en charge, car il s’agit d’une entité sans clé.

Impossible de traduire le « {comparisonOperator} » sur une expression de type d’entité « {entityType} », car il s’agit d’une entité sans clé. Envisagez plutôt d’utiliser des propriétés d’entité. Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

Cette requête entraînerait plusieurs évaluations d’une sous-requête, car l’entité « {entityType} » a une clé composite. Réécrire votre requête en évitant la sous-requête.

Le type d’entité « {entityType} » nécessite la définition d’une clé primaire. Si vous avez l’intention d’utiliser un type d’entité sans clé, appelez « HasNoKey » dans « OnModelCreating ». Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

Impossible de supprimer le type d’entité « {entityType} », car « {derivedEntityType} » en est dérivé. Avant de pouvoir supprimer le type d’entité, tous les types d’entités dérivés doivent être supprimés ou configurés pour utiliser un autre type d’entité de base.

Impossible de supprimer le type d’entité « {entityType} », car il fait référence à « {referencedEntityType} » par la clé étrangère {foreignKey}. Toutes les clés étrangères doivent être supprimées avant que le type d’entité puisse être supprimé.

Impossible de supprimer le type d’entité « {entityType} », car il est référencé par la clé étrangère {foreignKeyProperties} sur « {referenceingEntityType} ». Pour que le type d’entité puisse être supprimé, toutes les clés étrangères référençant doivent être supprimées.

Impossible de supprimer le type d’entité « {entityType} », car il est référencé par la navigation « {skipNavigation} » sur « {referenceingEntityType} ». Pour que le type d’entité puisse être supprimé, toutes les navigations skip de référence doivent être supprimées.

Les types d’entités « {firstEntityType} » et « {secondEntityType} » n’appartiennent pas au même modèle.

Le type d’entité « {entityType} » est introuvable. Vérifiez que le type d’entité a été ajouté au modèle.

Le type d’entité spécifié « {entityType} » n’est pas valide. Il doit s’agir du type d’entité dépendante « {dependentType} », du type d’entité principal « {principalType} » ou d’un type d’entité dérivé de l’un d’eux.

Le type d’entité spécifié « {entityType} » n’est pas valide. Il doit s’agir du type d’entité dépendante « {dependentType} » ou du type d’entité principale « {principalType} ».

Les types d’entités fournis « {invalidDependentType} » et « {invalidPrincipalType} » ne sont pas valides. Spécifiez « {dependentType} » et « {principalType} », ou les types d’entités dans la même hiérarchie.

Une exception s’est produite lors de la lecture d’une valeur de base de données pour la propriété « {entityType}. {property}'. Pour plus d'informations, consultez l'exception interne.

Une erreur s’est produite lors de la lecture d’une valeur de base de données pour la propriété « {entityType} ». {property}'. Le type attendu était « {expectedType} », mais la valeur réelle était de type « {actualType} ».

Une exception s’est produite lors de la lecture d’une valeur de base de données pour la propriété « {entityType}. {property}'. Le type attendu était « {expectedType} », mais la valeur réelle était null.

Une exception s’est produite lors de la lecture d’une valeur de base de données. Le type attendu était « {expectedType} », mais la valeur réelle était de type « {actualType} ».

Une exception s’est produite lors de la lecture d’une valeur de base de données. Le type attendu était « {expectedType} », mais la valeur réelle était null.

La stratégie d’exécution configurée « {stratégie} » ne prend pas en charge les transactions initiées par l’utilisateur. Utilisez la stratégie d’exécution retournée par « {getExecutionStrategyMethod} » pour exécuter toutes les opérations de la transaction en tant qu’unité retenable.

Une exception a été levée lors de la tentative d’évaluation de l’expression de paramètre de requête LINQ « {expression} ». Pour plus d'informations, consultez l'exception interne.

Le champ spécifié « {field} » ne peut pas être utilisé pour la propriété « {entityType} ». {property}', car il ne correspond pas au nom de la propriété. Les propriétés de type d’entité qui ne sont pas associées à une propriété CLR doivent correspondre exactement au nom du champ.

Le type d’entité « {entityType} » est défini avec une propriété de clé unique, mais les valeurs {valuesCount} ont été passées à la méthode « Find ».

Le type d’entité « {entityType} » est défini avec une clé composite en partie {propertiesCount}, mais les valeurs {valuesCount} ont été passées à la méthode « Find ».

Valeur de clé à la position {index} de l’appel à 'DbSet<{entityType}>. Find » était de type « {valueType} », qui ne correspond pas au type de propriété « {propertyType} ».

Les valeurs {values} ont été passées à la méthode « FindEntry » ou « GetEntries » pour les propriétés {properties}. Le nombre de valeurs doit correspondre au nombre de propriétés.

La méthode « FindEntry » ou « GetEntries » a obtenu une valeur « {valueType} » pour la propriété « {propertyName} », quand une valeur « {propertyType} » était attendue.

L’attribut [ForeignKey] pour la navigation « {navigation} » ne peut pas être spécifié sur le type d’entité « {principalType} », car il représente une relation un-à-plusieurs. Déplacez l’attribut [ForeignKey] vers une propriété sur « {dependentType} ».

Les attributs [ForeignKey] de la propriété « {propriété} » et la navigation « {navigation} » dans le type d’entité « {entityType} » ne pointent pas l’un vers l’autre. Assurez-vous que la valeur de l’attribut [ForeignKey] sur la propriété correspond au nom de navigation et que la valeur de l’attribut [ForeignKey] sur la navigation correspond au nom de la propriété de clé étrangère ou supprimez l’un d’entre eux.

L’attribut [ForeignKey] ne peut pas être spécifié sur le saut de navigation « {entityType} ». {navigation}'. Configurez les propriétés de clé étrangère dans « OnModelCreating » à la place.

Le nombre de propriétés spécifiées pour la clé étrangère {foreignKeyProperties} sur le type d’entité « {dependentType} » ne correspond pas au nombre de propriétés dans la clé principale {principalKeyProperties} sur le type d’entité « {principalType} ».

Impossible de supprimer la clé étrangère {foreignKeyProperties} du type d’entité « {entityType} », car elle est référencée par un saut de navigation « {navigation} » sur le type d’entité « {navigationEntityType} ». Toutes les navigations de référence doivent être supprimées pour que la clé étrangère référencée puisse être supprimée.

Les propriétés de clé étrangère spécifiées {foreignKeyProperties} ne sont pas déclarées sur le type d’entité « {entityType} ». Vérifiez que les propriétés de clé étrangère sont déclarées sur le type d’entité cible.

La propriété « {propriété} » ne peut pas faire partie d’une clé étrangère sur « {entityType} », car elle a une valeur générée par le magasin et est contenue dans la clé {keyProperties} définie sur un type d’entité de base « {baseEntityType} ». Configurez « {property} » avec « ValueGeneratedNever » ou définissez la clé étrangère sur « {entityType} » à la place.

La clé principale fournie {principalKeyProperties} n’est pas une clé sur le type d’entité « {principalEntityType} ». Fournissez une clé définie sur le type d’entité principal.

Les clés étrangères sur le type d’entité « {dependentType} » ne peuvent pas cibler le même type d’entité, car elles ont une navigation définissante.

Les types des propriétés spécifiées pour la clé étrangère {foreignKeyProperties} sur le type d’entité « {dependentType} » ne correspondent pas aux types des propriétés dans la clé principale {principalKeyProperties} sur le type d’entité « {principalType} ». Fournissez des propriétés qui utilisent les mêmes types dans le même ordre.

La clé étrangère {foreignKeyProperties} ciblant la clé {keyProperties} sur « {principalType} » ne peut pas être supprimée du type d’entité « {entityType} », car elle est définie sur le type d’entité « {otherEntityType} ».

Le type d’entité « {entityType} » est configuré pour utiliser la stratégie de suivi des modifications « {changeTrackingStrategy} » lorsque des notifications complètes de suivi des modifications sont requises. Utilisez « ModelBuilder.HasChangeTrackingStrategy » dans « OnModelCreating » pour configurer tous les types d’entités du modèle afin d’utiliser la stratégie « {fullStrategy} » ou « {fullPlusStrategy} ».

La méthode « {methodName} » n’est pas prise en charge, car la requête est passée à l’évaluation du client. Cela se produit généralement lorsque les arguments de la méthode ne peuvent pas être traduits en serveur. Réécrire la requête pour éviter l’évaluation des arguments par le client afin que la méthode puisse être traduite en serveur.

Impossible d’ajouter l’arête fournie, car le graphique ne contient pas le vertex « {vertex} ».

Un cycle de relation impliquant les clés primaires des types d’entités suivants a été détecté : « {entityType} ». Cela empêcherait l’insertion d’une entité sans violer les contraintes du magasin. Passez en revue les clés étrangères définies sur les clés primaires et supprimez ou utilisez d’autres propriétés pour au moins l’une d’entre elles.

Le instance de type d’entité « {entityType} » ne peut pas être suivi, car un autre instance avec la même valeur de clé pour {keyProperties} est déjà suivi. Lors de l’attachement d’entités existantes, assurez-vous qu’une seule entité instance avec une valeur de clé donnée est attachée. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir les valeurs de clé en conflit.

Le instance de type d’entité « {entityType} » ne peut pas être suivi, car un autre instance avec la même valeur de clé pour {keyProperties} est déjà suivi. Lorsque vous remplacez des entités détenues, modifiez les propriétés sans modifier le instance ou détachez d’abord l’entrée d’entité détenue précédente. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir les valeurs de clé en conflit.

Le instance de type d’entité « {entityType} » ne peut pas être suivi, car un autre instance avec la valeur de clé « {keyValue} » est déjà suivi. Lorsque vous remplacez des entités détenues, modifiez les propriétés sans modifier le instance ou détachez d’abord l’entrée d’entité détenue précédente.

Le instance de type d’entité « {entityType} » ne peut pas être suivi, car un autre instance avec la valeur de clé « {keyValue} » est déjà suivi. Lors de l’attachement d’entités existantes, assurez-vous qu’une seule entité instance avec une valeur de clé donnée est attachée.

Le type d’implémentation pour l’inscription du service « {service} » n’a pas pu être déterminé. Des types d’implémentation spécifiques doivent être utilisés pour les services qui attendent plusieurs inscriptions afin d’éviter les doublons.

La propriété « {property} » n’est pas une propriété de navigation de type d’entité « {entityType} ». La méthode « Include(string) » ne peut être utilisée qu’avec une liste séparée « . » de noms de propriétés de navigation.

L’opération Include « {include} » n’est pas prise en charge. « {invalidNavigation} » doit être une propriété de navigation définie sur un type d’entité.

Include n’est pas pris en charge pour les entités avec définition de requête. Type d’entité : « {entityType} »

L’opération « Include » avec l’argument « {expression} » n’est pas prise en charge sur le type d’entité « {entityType} », car elle comporte une requête de définition.

Impossible d’appliquer l’opération « Include » avec l’argument « {expression} ». Soit la source n’est pas interrogeable d’un type d’entité connu, soit « Include » a été appliqué après la méthode « Select » qui projette un autre type d’entité via la navigation. Envisagez d’appliquer « Include » avant l’appel de méthode « Select ».

Le chemin d’accès Include « {navigationName}->{inverseNavigationName} » entraîne un cycle. Les cycles ne sont pas autorisés dans les requêtes sans suivi ; utilisez une requête de suivi ou supprimez le cycle.

Le type d’entité « {entityType} » doit dériver de « {baseEntityType} » pour refléter la hiérarchie des types CLR correspondants.

Le type d’entité « {entityType} » est configuré comme dérivé de « {baseEntityType} », mais selon la hiérarchie des types CLR correspondants, il doit dériver de « {clrBaseEntityType} ». Configurez « {entityType} » en ayant « {baseEntityType} » ou « null » comme type de base.

Le type d’entité « {ownedEntityType} » est configuré en tant que propriété, mais le type d’entité « {nonOwnedEntityType} » ne l’est pas. Configurez tous les types d’entités en définissant des navigations partageant un type CLR comme appartenant à « OnModelCreating ».

« {method} » a été appelé avec des arguments {argumentCount}, mais a des paramètres {parameterCount}.

Les propriétés d’index spécifiées {indexProperties} ne sont pas déclarées sur le type d’entité « {entityType} ». Vérifiez que les propriétés d’index sont déclarées sur le type d’entité cible.

L’index {index} ne peut pas être supprimé du type d’entité « {entityType} », car il est défini sur le type d’entité « {otherEntityType} ».

La propriété « {propriété} » ne peut pas être ignorée sur le type « {type} », car elle est déclarée sur le type de base « {baseType} ». Pour exclure cette propriété de votre modèle, utilisez l’attribut [NotMapped] ou « Ignore » sur le type de base dans « OnModelCreating ».

Propriété « {entityType}. {navigation}' est d’un type d’interface (« {propertyType} »). S’il s’agit d’une navigation, configurez manuellement la relation pour cette propriété en la cassant dans un type d’entité mappé. Sinon, ignorez la propriété à l’aide de l’attribut [NotMapped] ou « Ignore » dans « OnModelCreating ».

Impossible de déterminer le type d’entité lié à « {entityType} », car la clé étrangère spécifiée {foreignKeyProperties} fait référence au type d’entité « {principalEntityType} », qui se trouve dans la même hiérarchie que le type d’entité déclaré sur « {dependentEntityType} ».

Impossible de suivre une entité de type « {entityType} », car la propriété de clé de remplacement « {keyProperty} » a la valeur Null. Si l’autre clé n’est pas utilisée dans une relation, envisagez plutôt d’utiliser un index unique. Les index uniques peuvent contenir des valeurs Null, tandis que d’autres clés peuvent ne pas contenir.

Le type spécifié « {type} » doit être un type non-interface avec un constructeur public à utiliser comme type complexe.

Le type spécifié « {type} » doit être un type de référence non-interface à utiliser comme type d’entité.

La configuration du type d’entité de type « {entityTypeConfigurationType} » n’est pas valide. La configuration spécifiée à l’aide d’EntityTypeConfigurationAttribute doit implémenter « IEntityTypeConfiguration<{entityType}> ».

La valeur fournie pour l’argument « {argumentName} » doit être une valeur valide de type enum « {enumType} ».

La valeur « {valeur} » fournie pour l’argument « {argumentName} » doit être une valeur valide de type enum « {enumType} ».

L’expression « {expression} » n’est pas valide à l’intérieur d’une opération « Include », car elle ne représente pas un accès à la propriété : « t => t.MyProperty ». Pour cibler les navigations déclarées sur des types dérivés, utilisez le cast ('t => ((Derived)t). MyProperty') ou l’opérateur 'as' ('t => (t as Derived). MyProperty'). L’accès à la navigation dans les collections peut être filtré en composant les opérations Where, OrderBy(Descending), ThenBy(Descending), Skip ou Take. Pour plus d’informations sur l’inclusion de données associées, consultez https://go.microsoft.com/fwlink/?LinkID=746393.

L’expression lambda de la propriété {methodName} « {includeLambdaExpression} » n’est pas valide. L’expression doit représenter un accès à la propriété : 't => t.MyProperty'. Pour cibler les navigations déclarées sur des types dérivés, spécifiez un paramètre lambda explicitement typé du type cible, par exemple « (Dérivé d) => d.MyProperty ». Pour plus d’informations sur l’inclusion de données associées, consultez http://go.microsoft.com/fwlink/?LinkID=746393.

Impossible de suivre une entité de type « {entityType} », car sa propriété de clé primaire « {keyProperty} » est null.

L’expression « {expression} » n’est pas une expression d’accès aux membres valide. L’expression doit représenter une propriété ou un accès au champ simple : 't => t.MyProperty'.

L’expression « {expression} » n’est pas une expression d’accès aux membres valide. L’expression doit représenter une propriété ou un accès au champ simple : 't => t.MyProperty'. Lorsque vous spécifiez plusieurs propriétés ou champs, utilisez un type anonyme : 't => new {{ t.MyProperty, t.MyField }}'.

Attribut [InverseProperty] sur la propriété « {1_entityType} ». {0_property}' n’est pas valide. La propriété « {referencedProperty} » n’est pas une navigation valide sur le type associé « {referencedEntityType} ». Vérifiez que la propriété existe et qu’elle est une référence ou une navigation de collection valide.

Nombre non valide de valeurs d’ordre de tri d’index fournies pour {indexProperties} : les valeurs {numValues} ont été fournies, mais l’index a des propriétés {numProperties}.

L’expression de propriétés « {expression} » n’est pas valide. L’expression doit représenter un accès à la propriété simple : 't => t.MyProperty'. Lorsque vous spécifiez plusieurs propriétés, utilisez un type anonyme : 't => new {{ t.MyProperty1, t.MyProperty2 }}'.

L’expression « {expression} » n’est pas une expression de propriété valide. L’expression doit représenter un accès à la propriété simple : 't => t.MyProperty'.

Liste de propriétés spécifiée à l’aide de l’attribut [ForeignKey] sur la navigation « {1_entityType}. {0_navigation}' est incorrect. La valeur de l’attribut doit être une liste de noms de propriétés séparés par des virgules.

Liste de propriétés spécifiée à l’aide de l’attribut [ForeignKey(« {2_properties} »)] sur la navigation '{1_entityType}. {0_navigation}' est incorrect. Fournissez une liste de noms de propriétés séparés par des virgules.

Une relation non valide a été spécifiée à l’aide des attributs [InverseProperty] et [ForeignKey]. Navigations « {1_entityType}. {0_navigation} » et « {3_referencedEntityType} ». {2_referencedNavigation}' sont liés par l’attribut [InverseProperty], mais les attributs [ForeignKey] spécifiés pour les deux navigations ont des valeurs différentes. Spécifiez les mêmes propriétés ou supprimez l’un des attributs.

Un appel a été effectué à « {replaceService} », mais Entity Framework ne crée pas son propre fournisseur de services internes. Autorisez Entity Framework à créer le fournisseur de services en supprimant l’appel à « {useInternalServiceProvider} », ou générez des services de remplacement dans le fournisseur de services avant de le transmettre à « {useInternalServiceProvider} ».

La méthode appelée ne peut pas être utilisée pour le type d’entité « {entityType} », car elle n’a pas de clé primaire. Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

Impossible de créer un DbSet pour « {typeName} », car ce type n’est pas inclus dans le modèle pour le contexte. Toutefois, le modèle contient un type d’entité portant le même nom dans un espace de noms différent : « {entityTypeName} ».

Impossible de créer un DbSet pour « {typeName} », car il est configuré en tant que type d’entité de type partagé. Accédez au type d’entité via la surcharge de méthode « Set » qui accepte un nom de type d’entité.

Impossible de créer un DbSet pour « {typeName} », car ce type n’est pas inclus dans le modèle pour le contexte.

Impossible de créer un DbSet pour « {typeName} », car il est configuré en tant que type d’entité détenu et doit être accessible via son type d’entité propriétaire.

Impossible de créer un DbSet pour « {typeName} », car il est configuré en tant que type d’entité détenu et doit être accessible via son type d’entité propriétaire « {ownerType} ». Consultez la rubrique https://aka.ms/efcore-docs-owned (éventuellement en anglais) pour plus d'informations.

Impossible de créer un DbSet pour « {typeName} », car il est mappé à plusieurs types d’entités avec des navigations de définition et doit être accessible via les entités propriétaires.

{name} non valide : {value}

Valeur de la propriété « {1_entityType}. {0_property} » ne peut pas être défini sur une valeur de type « {valueType} », car son type est « {propertyType} ».

Impossible d’inclure la chaîne de navigation « {includeExpression} » spécifiée par l’opération « Include » car le type converti « {type} » ne fait pas partie du modèle.

Un appel a été effectué à « {useService} », mais Entity Framework ne crée pas son propre fournisseur de services interne. Autorisez Entity Framework à créer le fournisseur de services en supprimant l’appel à « {useInternalServiceProvider} », ou générez les services « {service} » à utiliser dans le fournisseur de services avant de le passer à « {useInternalServiceProvider} ».

La propriété « {factory} » ne peut pas créer de générateur de valeurs pour la propriété « {2_entityType} ». {1_property}'. Seules les propriétés entières sont prises en charge.

Attributs [InverseProperty] sur la navigation « {1_entityType}. {0_navigation} » et sur la navigation « {3_referencedEntityType}. {2_referencedNavigation}' ne pointent pas vers l’autre. Modifiez les attributs pour utiliser les noms correspondants ou supprimez l’un d’entre eux.

Navigation « {principalEntityType}. {navigation} ' n’est pas pris en charge, car elle pointe vers un type d’entité « {ownedType} ». Seule la navigation de propriété à partir du type d’entité « {ownerType} » peut pointer vers le type d’entité détenue. Consultez la rubrique https://aka.ms/efcore-docs-owned (éventuellement en anglais) pour plus d'informations.

La source « IQueryable » n’implémente pas « IAsyncEnumerable<{genericParameter}> ». Seules les sources qui implémentent « IAsyncEnumerable » peuvent être utilisées pour les opérations asynchrones Entity Framework.

Le type dérivé « {derivedType} » ne peut pas avoir l’attribut [Key] sur la propriété « {property} », car les clés primaires ne peuvent être déclarées que sur le type racine.

Le type dérivé « {derivedType} » ne peut pas avoir l’attribut [Key] sur la propriété « {property} », car les clés primaires ne peuvent être déclarées que sur le type racine. Déplacez la propriété « {property} » vers « {rootType} » ou supprimez « {rootType} » du modèle en utilisant l’attribut [NotMapped] ou en appelant « EntityTypeBuilder.Ignore » sur le type de base dans « OnModelCreating ».

Impossible de supprimer la clé {key} du type d’entité « {entityType} », car elle est référencée par une clé étrangère dans le type d’entité « {dependentType} ». Toutes les clés étrangères doivent être supprimées ou redéfinies pour que la clé référencée puisse être supprimée.

Impossible de supprimer la clé {keyProperties} du type d’entité « {entityType} », car elle est référencée par une clé étrangère {foreignKeyProperties} définie sur le type d’entité « {dependentType} ». Supprimez ou modifiez la clé principale pour toutes les clés étrangères référençant avant de supprimer la clé.

Le type d’entité « {entityType} » ne peut pas être marqué comme sans clé, car il contient une clé.

Le type d’entité « {entityType} » ne peut pas être marqué comme sans clé, car il contient une clé {keyProperties}.

Impossible de suivre un instance de type « {type} », car il n’a pas de clé primaire. Seuls les types d’entités avec une clé primaire peuvent être suivis.

La clé {keyProperties} ne peut pas être ajoutée au type sans clé « {entityType} ».

Les propriétés de clé spécifiées {keyProperties} ne sont pas déclarées sur le type d’entité « {entityType} ». Vérifiez que les propriétés de clé sont déclarées sur le type d’entité cible.

Propriété « {1_entityType}. {0_property}' ne peut pas être marqué comme nullable/facultatif, car il a été inclus dans la clé {keyProperties}.

La propriété « {property} » ne peut pas faire partie d’une clé sur « {entityType} », car la génération de valeur est activée et est contenue dans une clé étrangère définie sur un type d’entité dérivé.

Propriété « {1_entityType}. {0_property}' doit être marqué en lecture seule après son enregistrement, car il fait partie d’une clé. Les propriétés de clé sont toujours en lecture seule une fois qu’une entité a été enregistrée pour la première fois.

Propriété « {1_entityType}. {0_property}' fait partie d’une clé et ne peut donc pas être modifié ou marqué comme modifié. Pour modifier le principal d’une entité existante avec une clé étrangère d’identification, supprimez d’abord le dépendant et appelez « SaveChanges », puis associez le dépendant au nouveau principal.

La clé {keyProperties} ne peut pas être supprimée du type d’entité « {entityType} », car elle est définie sur le type d’entité « {otherEntityType} ».

Le mappage de type pour « {type} » n’a pas implémenté la génération de littéraux de code.

Navigation « {entityType}. {navigation}' ne peut pas être utilisé pour les deux côtés d’une relation plusieurs-à-plusieurs. Les relations plusieurs-à-plusieurs doivent utiliser deux propriétés de navigation distinctes.

Le champ « {field} » spécifié est introuvable pour la propriété « {2_entityType} ». {1_property}'.

Impossible de configurer une relation plusieurs-à-plusieurs entre les types d’entités « {principalEntityType} » et « {declaringEntityType} », car l’une des navigations n’a pas été spécifiée. Fournissez une navigation dans l’appel « HasMany » dans « OnModelCreating ». Envisagez d’ajouter une propriété privée pour cela.

Le modèle doit être finalisé et ses dépendances d’exécution doivent être initialisées avant que « {method} » puisse être utilisé. Vérifiez que « OnModelCreating » est terminé ou, si vous utilisez un « ModelBuilder » autonome, que « IModelRuntimeInitializer.Initialize(model). FinalizeModel())' a été appelé.

Impossible de commencer le suivi d’InternalEntityEntry pour le type d’entité « {entityType} », car un autre InternalEntityEntry effectue déjà le suivi de la même entité.

Les filtres « {filter1} » et « {filter2} » ont tous deux été configurés sur la même navigation incluse. Un seul filtre unique par navigation est autorisé. Pour plus d’informations sur l’inclusion de données associées, consultez https://go.microsoft.com/fwlink/?LinkID=746393.

Il existe plusieurs navigations dans le type d’entité « {entityType} » qui pointent vers le même ensemble de propriétés à l’aide d’un attribut [ForeignKey] : « {propertyList} »

Il existe plusieurs navigations dans le type d’entité « {entityType} » qui pointent vers le même ensemble de propriétés « {properties} » à l’aide d’un attribut [ForeignKey] : {navigations}.

Le type d’entité « {entityType} » est la cible de plusieurs relations de propriété.

Le type d’entité « {entityType} » est la cible de plusieurs relations de propriété : {navigations}.

Les services pour les fournisseurs de base de données {storeNames} ont été inscrits dans le fournisseur de services. Un seul fournisseur de base de données peut être inscrit dans un fournisseur de services. Si possible, assurez-vous qu’Entity Framework gère son fournisseur de services en supprimant l’appel à « UseInternalServiceProvider ». Sinon, envisagez d’inscrire de manière conditionnelle le fournisseur de base de données ou de maintenir un fournisseur de services par fournisseur de base de données.

Lorsqu’elle est appelée à partir de « {caller} », la réécriture d’un nœud de type « {type} » doit retourner une valeur non null du même type. Vous pouvez également remplacer « {appelant} » et le modifier pour ne pas visiter les enfants de ce type.

La propriété « {keyProperty} » ne peut pas être configurée en tant que « ValueGeneratedOnUpdate » ou « ValueGeneratedOnAddOrUpdate », car elle fait partie d’une clé et sa valeur ne peut pas être modifiée une fois l’entité ajoutée au magasin.

L’index « {indexName} » spécifié via l’attribut [Index] sur le type d’entité « {entityType} » avec les propriétés {indexProperties} n’est pas valide. La propriété « {propertyName} » a été marquée comme démapped via l’attribut [NotMapped] ou l’API Fluent « EntityTypeBuilder.Ignore ». Un index ne peut pas utiliser de propriétés non mappées.

Un index « {indexName} » spécifié via l’attribut [Index] sur le type d’entité « {entityType} » fait référence aux propriétés {indexProperties}, mais aucune propriété portant le nom « {propertyName} » n’existe sur ce type d’entité ou l’un de ses types de base.

L’index portant le nom {indexName} ne peut pas être supprimé du type d’entité « {entityType} », car aucun index de ce type n’existe sur ce type d’entité.

Type de navigation « {1_entityType}. {0_navigation} » est « {foundType} », qui est un type de tableau. Les navigations de collection ne peuvent pas être des tableaux.

Type de navigation « {1_entityType}. {0_navigation} » est « {foundType} » qui n’implémente pas « ICollection<{targetType}> ». Les navigations de collection doivent implémenter « ICollection<> » du type cible.

Type de navigation « {1_entityType}. {0_navigation} » est « {foundType} » pour lequel il n’a pas été possible de créer une instance concrète. Initialisez la propriété avant de l’utiliser, ajoutez un constructeur sans paramètre public au type ou utilisez un type auquel peut être attribué un « HashSet<> » ou « List<> ».

La navigation de collection « {navigation} » ne peut pas être ajoutée au type d’entité « {entityType} », car son type CLR « {clrType} » n’implémente pas « IEnumerable< {targetType}> ». Les navigations de collection doivent implémenter IEnumerable<> de l’entité associée.

Navigation « {1_entityType}. {0_navigation}' ne peut pas être associé à la clé étrangère {targetForeignKeyProperties}, car il a été créé pour la clé étrangère {actualForeignKeyProperties}.

La navigation « {navigation} » ne peut pas être ajoutée au type d’entité « {entityType} », car elle est définie à l’état d’ombre et les propriétés de navigation ne peuvent pas provenir d’entités d’état d’ombre.

Propriété « {1_entityType}. {0_property} » est accessible à l’aide de la méthode « {referenceMethod} » ou « {collectionMethod} », mais est défini dans le modèle comme une méthode de non-navigation. Utilisez la méthode « {propertyMethod} » pour accéder aux propriétés autres que de navigation.

La relation entre « {principalEntityType} » et « {dependentEntityType} » ne peut pas être configurée en tant que propriété, car aucune navigation n’est associée au type détenu. Une propriété doit toujours avoir une navigation associée. Consultez la rubrique https://aka.ms/efcore-docs-owned (éventuellement en anglais) pour plus d'informations.

Navigation « {1_entityType}. {0_navigation}' n’a pas de setter et aucun champ de stockage accessible en écriture n’a été trouvé ou spécifié. Les navigations de collection en lecture seule doivent être initialisées avant utilisation.

Impossible de déterminer la relation représentée par la navigation « {entityType}. {navigation} » de type « {propertyType} ». Configurez manuellement la relation ou ignorez cette propriété à l’aide de l’attribut « [NotMapped] » ou en utilisant « EntityTypeBuilder.Ignore » dans « OnModelCreating ».

Propriété « {entityType}. {navigation}' de type '{propertyType}' semble être une navigation vers un autre type d’entité. Les navigations ne sont pas prises en charge lors de l’utilisation de « SqlQuery ». Incluez ce type dans le modèle et utilisez « FromSql » pour la requête, ou ignorez cette propriété à l’aide de l’attribut « [NotMapped] ».

Impossible de configurer la navigation « {complexType}. {navigation} » de type « {propertyType} », car les types complexes ne prennent pas en charge les navigations. Ignorez cette propriété à l’aide de l’attribut « [NotMapped] » ou de « EntityTypeBuilder.Ignore » dans « OnModelCreating ».

La navigation « {navigation} » ne peut pas être ajoutée au type d’entité « {entityType} », car son type CLR « {clrType} » ne correspond pas au type CLR attendu « {targetType} ».

Impossible d’ajouter la navigation « {navigation} », car elle cible le type d’entité sans clé « {entityType} ». Les navigations peuvent cibler uniquement les types d’entités avec des clés. Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

La navigation « {navigation} » ne peut pas être ajoutée au type d’entité « {entityType} », car le type d’entité cible « {targetType} » est défini à l’état d’ombre et les propriétés de navigation ne peuvent pas pointer vers des entités d’état d’ombre.

Aucun champ de stockage n’a été trouvé pour la propriété « {1_entityType}. {0_property}'. Nommez le champ de stockage afin qu’il soit découvert par convention, configurez le champ de stockage pour l’utiliser ou utilisez un autre « {propertyAccessMode} ».

Aucun champ de stockage n’a été trouvé pour la propriété « {1_entityType}. {0_property}'. Les navigations paresseuse doivent avoir des champs de stockage. Nommez le champ de stockage afin qu’il soit découvert par convention ou configurez le champ de stockage à utiliser.

La navigation « {navigation} » ne peut pas être ajoutée au type d’entité « {entityType} », car il n’existe aucune propriété CLR correspondante sur le type sous-jacent et les propriétés de navigation ne peuvent pas être ajoutées à l’état d’ombre.

Le materializer d’entité CLR ne peut pas être utilisé pour le type d’entité « {entityType} », car il s’agit d’un type d’entité d’état fantôme. La matérialisation en type CLR n’est possible que pour les types d’entités qui ont un type CLR correspondant.

La navigation « {navigation} » utilisée pour définir le type d’entité « {entityType} » n’est pas présente sur « {defineEntityType} ».

Impossible de définir la valeur du discriminateur pour le type d’entité « {entityType} », car le type d’entité racine « {rootEntityType} » n’a pas de propriété de discriminateur configurée.

Le type d’entité « {entityType} » fait partie d’une hiérarchie, mais n’a pas de propriété de discriminateur configurée.

Le type d’entité « {entityType} » a une propriété de discriminateur, mais n’a pas de valeur de discriminateur configurée.

Aucun champ de stockage n’est trouvé pour la propriété « {1_entityType}. {0_property}' et la propriété n’a pas de getter.

Aucun champ de stockage n’est trouvé pour la propriété « {1_entityType}. {0_property}' et la propriété n’a pas de setter.

Propriété « {1_entityType}. {0_property}' n’a pas de getter. Rendre la propriété lisible ou utiliser un autre « {propertyAccessMode} ».

Une propriété indexée a été ajoutée au type d’entité « {entity} ». Mais il n’existe aucun indexeur public sur « {entity} » prenant un seul argument de type « string » et renvoyant le type « object ».

Aucune navigation sur le type d’entité « {entityType} » n’est associée à la clé étrangère {foreignKeyProperties}.

Le type d’entité « {entityType} » ne peut pas hériter de « {baseEntityType} », car « {baseEntityType} » est un type d’entité d’état d’ombre alors que « {entityType} » ne l’est pas.

Propriété « {entityType}. {property} » ne peut pas être utilisé comme clé, car elle a le type « {providerType} » qui n’implémente pas « IComparable<T> », « IComparable » ou « IStructuralComparable ». Utilisez « HasConversion » dans « OnModelCreating » pour encapsuler « {providerType} » avec un type qui peut être comparé.

Propriété « {entityType}. {property} » ne peut pas être utilisé comme clé, car elle a le type « {modelType} » et le type de fournisseur « {providerType} », qui n’implémentent pas « IComparable<T> », « IComparable » ou « IStructuralComparable ». Faites en sorte que « {modelType} » implémente l’une de ces interfaces pour l’utiliser comme clé.

Navigation « {1_entityType}. {0_navigation} » doit être configuré dans « OnModelCreating » avec un nom explicite pour le type d’entité de type partagé cible, ou exclu en appelant « EntityTypeBuilder.Ignore ».

Le type d’entité « {2_entityType} » appartenant à « {0_ownershipNavigation} » doit utiliser la définition de la navigation « {1_definingNavigation} » pour .

Les DbContextOptions passés au constructeur {contextType} doivent être un DbContextOptions<{contextType}>. Lors de l’inscription de plusieurs types DbContext, assurez-vous que le constructeur de chaque type de contexte possède un paramètre TContext DbContextOptions<> plutôt qu’un paramètre DbContextOptions non générique.

Impossible d’ajouter la propriété d’indexeur « {propriété} », car il n’y a pas d’indexeur sur « {entityType} » prenant un argument unique de type assignable à partir de « {type} ».

Type de collection utilisé pour la navigation « {1_entityType}. {0_navigation} » n’implémente pas « INotifyCollectionChanged ». Tout type d’entité configuré pour utiliser la stratégie de suivi des modifications « {changeTrackingStrategy} » doit utiliser des collections qui implémentent « INotifyCollectionChanged ». Envisagez d’utiliser « ObservableCollection<T> » pour cela.

Type de collection « {2_collectionType} » utilisé pour la navigation « {1_entityType} ». {0_navigation} » n’implémente pas « INotifyCollectionChanged ». Tout type d’entité configuré pour utiliser la stratégie de suivi des modifications « {changeTrackingStrategy} » doit utiliser des collections qui implémentent « INotifyCollectionChanged ». Envisagez d’utiliser « ObservableCollection<T> » pour cela.

Le type d’entité « {entityType} » ne peut pas hériter de « {baseEntityType} », car « {entityType} » est un type d’entité d’état d’ombre alors que « {baseEntityType} » ne l’est pas.

La clé étrangère {foreignKeyProperties} sur le type d’entité « {declaringEntityType} » ne peut pas avoir d’extrémité dépendante requise, car elle n’est pas unique.

« {principalEntityType}. {principalNavigation}' ne peut pas être configuré comme requis, car il a été configuré en tant que collection.

Un constructeur sans paramètre est introuvable sur le type d’entité « {entityType} ». Pour créer un instance de « {entityType} », Entity Framework exige qu’un constructeur sans paramètre soit déclaré.

Aucune propriété n’a été associée au champ « {field} » du type d’entité « {entity} ». Configurez une propriété ou utilisez une autre propriété « {propertyAccessMode} ».

La propriété « {propriété} » ne peut pas être ajoutée au type « {type} », car aucun type de propriété n’a été spécifié et il n’existe aucune propriété ou champ CLR correspondant. Pour ajouter une propriété d’état d’ombre, le type de propriété doit être spécifié.

Impossible de résoudre le service pour le type « {service} ». Cela est souvent dû au fait qu’aucun fournisseur de base de données n’a été configuré pour ce DbContext. Un fournisseur peut être configuré en remplaçant la méthode « DbContext.OnConfiguring » ou en utilisant « AddDbContext » sur le fournisseur de services d’application. Si « AddDbContext » est utilisé, vérifiez également que votre type DbContext accepte un objet TContext> DbContextOptions<dans son constructeur et le transmet au constructeur de base pour DbContext.

Propriété « {1_entityType}. {0_property}' n’a pas de setter. Rendez la propriété accessible en écriture ou utilisez un « {propertyAccessMode} » différent.

Le fournisseur de base de données a tenté d’inscrire une implémentation du service « {service} ». Il ne s’agit pas d’un service défini par Entity Framework et, en tant que tel, doit être inscrit en tant que service spécifique au fournisseur à l’aide de la méthode « TryAddProviderSpecificServices ».

Le fournisseur de base de données a tenté d’inscrire une implémentation du service « {service} ». Il s’agit d’un service défini par Entity Framework et, en tant que tel, ne doit pas être inscrit à l’aide de la méthode « TryAddProviderSpecificServices ».

Le type d’entité « {entityType} » ne peut pas hériter de « {baseEntityType} », car « {clrType} » n’est pas un descendant de « {baseClrType} ».

Propriété « {entityType}. {property}' ne peut pas être mappé en tant que collection, car elle n’implémente pas 'IEnumerable<T>'.

Propriété « {1_entityType}. {0_property}' n’a pas de valeur définie et aucun générateur de valeurs n’est disponible pour les propriétés de type « {propertyType} ». Définissez une valeur pour la propriété avant d’ajouter l’entité ou configurez un générateur de valeurs pour les propriétés de type « {propertyType} » dans « OnModelCreating ».

Une clé sur le type d’entité « {entityType} » ne peut pas contenir la propriété « {property} », car elle est nullable/facultative. Toutes les propriétés sur lesquelles une clé est déclarée doivent être marquées comme non nullable/obligatoire.

Propriété de type complexe « {type} ». {property}' est configuré comme requis (non nullable), mais a une valeur Null lors de l’enregistrement des modifications. Seules les propriétés complexes non null sont prises en charge par EF Core 8.

Propriété de la collection primitive « {type} ». {property}' est configuré comme requis (non nullable), mais a une valeur Null lors de l’enregistrement des modifications. Marquez la propriété comme facultative (nullable) ou définissez une valeur non null.

Extension d’options de type « {optionsExtension} » introuvable.

Valeur d’origine de la propriété « {1_entityType}. {0_property}' est inaccessible, car il n’est pas suivi. Les valeurs d’origine ne sont pas enregistrées pour la plupart des propriétés des entités lorsque la stratégie « ChangingAndChangedNotifications » est utilisée. Pour accéder à toutes les valeurs d’origine, utilisez une stratégie de suivi des modifications différente, telle que « ChangingAndChangedNotificationsWithOriginalValues ».

Le type d’entité « {entityType} » ne peut pas avoir de type de base. Consultez la rubrique https://aka.ms/efcore-docs-owned (éventuellement en anglais) pour plus d'informations.

Le type d’entité « {ownedType} » a été marqué comme appartenant et doit être référencé à partir d’un autre type d’entité via une navigation. Ajoutez une navigation à un type d’entité qui pointe vers « {ownedType} » ou ne le configurez pas comme appartenant.

Impossible de modifier la navigation « {navigation} », car la clé étrangère entre « {principalEntityType} » et « {dependentEntityType} » est une propriété. Pour modifier la navigation vers le type d’entité détenu, supprimez la propriété.

Le DbContext de type « {contextType} » ne peut pas être mis en pool, car il n’a pas de constructeur public acceptant un seul paramètre de type DbContextOptions ou a plusieurs constructeurs.

Le type dérivé « {derivedType} » ne peut pas avoir l’attribut [PrimaryKey], car les clés primaires ne peuvent être déclarées que sur le type racine. Déplacez l’attribut vers « {rootType} » ou supprimez « {rootType} » du modèle en utilisant l’attribut [NotMapped] ou en appelant « EntityTypeBuilder.Ignore » sur le type de base dans « OnModelCreating ».

L’attribut [PrimaryKey] sur le type d’entité « {entityType} » n’est pas valide, car la propriété « {propertyName} » a été marquée comme non mappée par l’attribut [NotMapped] ou « Ignore() » dans « OnModelCreating ». Une clé primaire ne peut pas utiliser les propriétés non mappées.

L’attribut [PrimaryKey] sur le type d’entité « {entityType} » fait référence aux propriétés {properties}, mais aucune propriété portant le nom « {propertyName} » n’existe sur ce type d’entité ou sur l’un de ses types de base.

Lors de la création de la relation entre « {navigationSpecification1} » et « {navigationSpecification2} », le type d’entité « {targetEntityType} » ne peut pas être défini comme principal.

Vous configurez une relation entre « {dependentEntityType} » et « {principalEntityType} », mais vous avez spécifié une clé principale sur « {entityType} ». La clé étrangère doit cibler un type qui fait partie de la relation.

Le type d’entité sans clé « {entityType} » ne peut pas se trouver à l’extrémité principale de la relation entre « {firstNavigationSpecification} » et « {secondNavigationSpecification} ». Le type d’entité principal doit avoir une clé. Pour plus d’informations sur les types d’entités sans clé, consultez https://go.microsoft.com/fwlink/?linkid=2141943.

La relation entre « {referenceingEntityTypeOrNavigation} » et « {referencedEntityTypeOrNavigation} » n’est pas prise en charge, car le type d’entité « {ownedType} » ne peut pas se trouver du côté principal d’une relation de non-propriété. Supprimez la relation ou configurez la clé étrangère sur « {ownedType} ».

« {property} » ne peut pas être utilisé en tant que propriété sur le type d’entité « {entityType} », car il est configuré en tant que navigation.

Impossible d’ajouter la propriété d’indexeur « {property} » au type « {type} », car le type CLR contient un membre portant le même nom. Spécifiez un autre nom ou configurez « {property} » en tant que propriété non indexeur.

Propriété « {1_entityType}. {0_property}' contient null, mais la propriété est marquée comme obligatoire. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour afficher les valeurs de clé.

La propriété « {property} » contient null sur l’entité « {entityType} » avec la valeur de clé « {keyValue} », mais la propriété est marquée comme obligatoire.

La propriété « {property} » appartient au type « {expectedType} », mais elle est utilisée avec un instance de type « {actualType} ».

Impossible de supprimer la propriété « {propriété} » du type « {type} », car elle est utilisée dans la clé étrangère {foreignKeyProperties} sur « {foreignKeyType} ». Toutes les clés étrangères contenant doivent être supprimées ou redéfinies pour que la propriété puisse être supprimée.

Impossible de supprimer la propriété « {propriété} » du type « {entityType} », car elle est utilisée dans l’index {index} sur « {indexType} ». Tous les index contenant doivent être supprimés ou redéfinis avant que la propriété puisse être supprimée.

Impossible de supprimer la propriété « {propriété} » du type « {entityType} », car elle est utilisée dans la clé {keyProperties}. Toutes les clés contenant doivent être supprimées ou redéfinies pour que la propriété puisse être supprimée.

Propriété « {1_entityType}. {0_property} » est accessible à l’aide de la méthode « {propertyMethod} », mais est défini dans le modèle en tant que navigation. Utilisez la méthode « {referenceMethod} » ou « {collectionMethod} » pour accéder aux navigations.

Propriété « {entityType}. {property}' n’a pas pu être mappé, car il est de type « {propertyType} », qui n’est pas un type primitif pris en charge ou un type d’entité valide. Mappez explicitement cette propriété ou ignorez-la à l’aide de l’attribut « [NotMapped] » ou en utilisant « EntityTypeBuilder.Ignore » dans « OnModelCreating ».

Propriété « {entityType}. {property}' n’a pas pu être mappé, car il est de type « {propertyType} », qui n’est pas un type primitif pris en charge ou un type d’entité valide. La propriété peut être ignorée à l’aide de l’attribut « [NotMapped] ».

Propriété « {1_entityType}. {0_property}' est introuvable. Vérifiez que la propriété existe et qu’elle a été incluse dans le modèle.

Propriété « {propertyType} » « {entityType} ». {property}' n’a pas pu être mappé, car le fournisseur de base de données ne prend pas en charge ce type. Envisagez de convertir la valeur de propriété en un type pris en charge par la base de données à l’aide d’un convertisseur de valeur. Consultez la rubrique https://aka.ms/efcore-docs-value-converters (éventuellement en anglais) pour plus d'informations. Vous pouvez également exclure la propriété du modèle à l’aide de l’attribut « [NotMapped] » ou de « EntityTypeBuilder.Ignore » dans « OnModelCreating ».

Propriété « {1_entityType}. {0_property}' est défini en lecture seule après son enregistrement, mais sa valeur a été modifiée ou marquée comme modifiée.

Propriété « {1_entityType}. {0_property}' est défini en lecture seule avant son enregistrement, mais sa valeur a été définie sur autre chose qu’une valeur temporaire ou par défaut.

Impossible d’ajouter la propriété « {property} » au type « {type} », car le type de la propriété ou du champ CLR correspondant « {clrType} » ne correspond pas au type spécifié « {propertyType} ».

La propriété « {property} » ne peut pas être ajoutée au type « {type} », car elle est déclarée sur le type CLR « {clrType} ».

La propriété « {property} » ne peut pas être ajoutée au type « {type} », car elle ne correspond pas au nom de la propriété CLR ou du champ « {clrName} » fourni. Utilisez le même nom ou spécifiez un autre membre CLR.

Impossible de supprimer la propriété « {property} » du type « {type} », car elle est déclarée sur le type « {otherType} ».

La condition de matérialisation passée pour le modélisateur d’entité de type d’entité « {entityType} » n’est pas de la forme correcte. Une condition de matérialisation doit être une « LambdaExpression » de « Func<ValueBuffer, IEntityType> ».

Le traitement de l’expression LINQ « {expression} » par « {visitor} » a échoué. Cela peut indiquer un bogue ou une limitation dans Entity Framework. Pour plus d’informations, consultez https://go.microsoft.com/fwlink/?linkid=2101433 .

La requête contient une projection « {projection} » de type « {queryableType} ». Les collections de la projection finale doivent être de type « IEnumerable<T> » tel que « List<T> ». Envisagez d’utiliser « ToList » ou un autre mécanisme pour convertir « IQueryable<T> » ou « IOrderedEnumerable<T> » en « IEnumerable<T> ».

Le type d’entité de remplacement : {entityType} n’a pas le même nom et le même type CLR que le type d’entité que représente cette racine de requête.

La traduction de « {expression} » a échoué. Soit la source de requête n’est pas un type d’entité, soit la propriété spécifiée n’existe pas sur le type d’entité.

La traduction du membre « {member} » sur le type d’entité « {entityType} » a échoué. Cela se produit généralement lorsque le membre spécifié est non mappé.

Traduction de la méthode « {declaringTypeName}. {methodName} ' a échoué. Si cette méthode peut être mappée à votre fonction personnalisée, consultez https://go.microsoft.com/fwlink/?linkid=2132413 pour plus d’informations.

La racine de la requête de type « {type} » n’a pas été gérée par le code du fournisseur. Ce problème se produit lors de l’utilisation d’une méthode spécifique au fournisseur sur un autre fournisseur où elle n’est pas prise en charge.

Le type « {givenType} » ne peut pas être utilisé comme collection primitive, car il est en lecture seule. Les collections en lecture seule de types primitifs ne sont pas prises en charge.

La relation entre « {referenceingEntityTypeOrNavigation} » et « {referencedEntityTypeOrNavigation} » avec les propriétés de clé étrangère {foreignKeyPropertiesWithTypes} ne peut pas cibler la clé primaire {primaryKeyPropertiesWithTypes} car elle n’est pas compatible. Configurez une clé principale ou un ensemble de propriétés de clé étrangère avec des types compatibles pour cette relation.

Propriété « {1_entityType}. {0_property} » est accessible à l’aide de la méthode « {referenceMethod} », mais est défini dans le modèle en tant que navigation de collection. Utilisez la méthode « {collectionMethod} » pour accéder aux navigations de collection.

Navigation « {1_entityType}. {0_navigation} » ne peut pas avoir « IsLoaded » défini sur false, car l’entité référencée n’est pas null et est donc chargée.

L’association entre les types d’entités « {firstType} » et « {secondType} » a été rompue, mais la relation est marquée comme obligatoire ou implicitement requise, car la clé étrangère n’est pas nullable. Si l’entité dépendante/enfant doit être supprimée lorsqu’une relation requise est rompue, configurez la relation pour utiliser des suppressions en cascade. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir les valeurs de clé.

L’association entre les entités « {firstType} » et « {secondType} » avec la valeur de clé « {secondKeyValue} » a été rompue, mais la relation est marquée comme obligatoire ou implicitement requise, car la clé étrangère n’est pas nullable. Si l’entité dépendante/enfant doit être supprimée lorsqu’une relation requise est rompue, configurez la relation pour utiliser des suppressions en cascade.

Cycle de relation impliquant la propriété « {entityType}. {property}' a été détecté. Cela empêche Entity Framework de déterminer la configuration correcte. Passez en revue les clés étrangères définies sur la propriété et la propriété principale correspondante, puis supprimez l’une d’elles ou spécifiez explicitement « {configuration} » sur l’une des propriétés.

« {entityType}. {navigation} ' ne peut pas être configuré comme requis, car il représente un saut de navigation.

Le nombre maximal de nouvelles tentatives ({retryLimit}) a été dépassé lors de l’exécution des opérations de base de données avec « {stratégie} ». Consultez l’exception interne pour l’échec le plus récent.

Le même paramètre instance avec le nom « {parameterName} » a été utilisé dans plusieurs lambdas dans l’arborescence des requêtes. Chaque lambda doit avoir ses propres instances de paramètre.

Impossible d’enregistrer instance de « {entityType} », car il s’agit d’une entité détenue sans référence à son propriétaire. Les entités détenues ne peuvent être enregistrées que dans le cadre d’un agrégat, y compris l’entité propriétaire.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car la propriété complexe « {propriété} » est définie. Les propriétés complexes ne sont actuellement pas prises en charge dans l’amorçage. Consultez la rubrique https://github.com/dotnet/efcore/issues/31254 (éventuellement en anglais) pour plus d'informations. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir les valeurs de propriété impliquées.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} » avec la valeur de clé « {keyValue} », car la propriété complexe « {propriété} » est définie. Les propriétés complexes ne sont actuellement pas prises en charge dans l’amorçage. Consultez la rubrique https://github.com/dotnet/efcore/issues/31254 (éventuellement en anglais) pour plus d'informations.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car une valeur par défaut a été fournie pour la propriété requise « {propriété} ». Indiquez une valeur différente de « {defaultValue} ».

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car la valeur fournie est d’un type dérivé « {derivedType} ». Ajoutez les entités initiales dérivées au type d’entité correspondant.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car une autre entité initiale avec la même valeur de clé pour {keyProperties} a déjà été ajoutée. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir les valeurs de clé en conflit.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car une autre entité initiale avec la valeur de clé « {keyValue} » a déjà été ajoutée.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car la valeur fournie pour la propriété « {propriété} » n’est pas compatible avec le type de propriété « {type} ». Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir la valeur de la propriété impliquée.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car la valeur « {valeur} » fournie pour la propriété « {propriété} » n’est pas compatible avec le type de propriété « {type} ».

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car aucune valeur n’a été fournie pour la propriété requise « {propriété} ».

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car la navigation « {navigation} » est définie. Pour les relations initiales, ajoutez le seed d’entité à « {relatedEntityType} » et spécifiez les valeurs de clé étrangère {foreignKeyProperties}. Envisagez d’utiliser « DbContextOptionsBuilder.EnableSensitiveDataLogging » pour voir les valeurs de propriété impliquées.

L’entité initiale pour le type d’entité « {entityType} » avec la valeur de clé « {keyValue} » ne peut pas être ajoutée, car la navigation « {navigation} » est définie. Pour les relations initiales, ajoutez le seed d’entité à « {relatedEntityType} » et spécifiez les valeurs de clé étrangère {foreignKeyProperties}.

Impossible d’ajouter l’entité initiale pour le type d’entité « {entityType} », car une valeur autre que zéro est requise pour la propriété « {propriété} ». Envisagez de fournir une valeur négative pour éviter les collisions avec des données non initiales.

L’entité initiale pour le type d’entité « {entityType} » ne peut pas être ajoutée, car les types d’entités sans clé ne sont pas pris en charge. Envisagez de fournir une clé ou de supprimer les données initiales.

Inverse de la navigation « {entityType}. {property}' ne peut pas être la même navigation. Remplacez la valeur de l’attribut [InverseProperty] par une autre navigation.

Impossible d’établir une relation à partir de la propriété « {1_entityType}. {0_property}' à la propriété « {3_referencedEntityType}. {2_referencedProperty}'. Vérifiez les valeurs de l’attribut [InverseProperty] pour vous assurer que les définitions de relation sont uniques et qu’elles font référence d’une navigation à sa navigation inverse correspondante.

configuration ajoutée pour « {key} »

configuration modifiée pour « {key} »

configuration supprimée pour « {key} »

Le type d’entité « {entityType} » est à l’état d’ombre. Un modèle valide nécessite que tous les types d’entités aient un type CLR correspondant.

Impossible de configurer une relation plusieurs-à-plusieurs entre « {leftEntityType}. {leftNavigation}' et '{rightEntityType}. {rightNavigation}', car l’une des navigations ou les deux n’ont pas de propriété CLR correspondante. Envisagez d’ajouter une propriété privée correspondante au type d’entité CLR.

Le type d’entité de type partagé « {entityType} » ne peut pas avoir de type de base.

Un appel a été passé à « {optionCall} » qui a modifié une option qui doit être constante au sein d’un fournisseur de services, mais Entity Framework ne crée pas son propre fournisseur de services interne. Autorisez Entity Framework à créer le fournisseur de services en supprimant l’appel à « {useInternalServiceProvider} », ou assurez-vous que la configuration de « {optionCall} » ne change pas pour toutes les utilisations d’un fournisseur de services donné passée à « {useInternalServiceProvider} ».

Une tentative d’inscription d’un instance pour le service « {scope} » « {service} » a été effectuée. Les instances ne peuvent être inscrites que pour les services « Singleton ».

La clé étrangère {foreignKeyProperties} ne peut pas être définie pour ignorer la navigation « {navigation} », car elle utilise le type d’entité de jointure « {joinType} », tandis que la navigation inverse « {inverse} » est associée à une clé étrangère à l’aide du type d’entité de jointure « {inverseJoinType} ». La navigation inverse doit utiliser le même type d’entité de jointure.

Le saut de navigation « {inverse} » à l’aide du type d’entité de jointure « {inverseJoinType} » ne peut pas être défini comme inverse de « {navigation} », qui utilise le type d’entité de jointure « {joinType} ». La navigation inverse doit utiliser le même type d’entité de jointure.

La clé étrangère {foreignKeyProperties} ne peut pas être utilisée pour ignorer la navigation « {entityType}. {navigation} », car elle est déclarée sur le type d’entité « {dependentEntityType} », mais une clé étrangère sur « {entityType} » est attendue.

La clé étrangère {foreignKeyProperties} ne peut pas être utilisée pour ignorer la navigation « {entityType}. {navigation} », car elle est déclarée sur le type d’entité « {entityType} », mais une clé étrangère sur « {principalEntityType} » est attendue.

Impossible de supprimer la navigation « {skipNavigation} », car elle est définie comme inverse de la navigation « {inverseSkipNavigation} » sur « {referenceingEntityType} ». Toutes les navigations d’ignorer de référence doivent être supprimées avant que cette navigation d’ignorer puisse être supprimée.

Ignorer la navigation « {entityType}. {skipNavigation} » ne peut pas être supprimé, car il est configuré comme l’inverse de la navigation « {referenceingEntityType}. {inverseSkipNavigation}'. Toutes les navigations d’ignorer de référence doivent être supprimées avant que cette navigation d’ignorer puisse être supprimée.

Ignorer la navigation « {1_entityType}. {0_navigation}' n’a pas de clé étrangère associée. Chaque navigation d’évitement doit avoir une clé étrangère configurée.

Ignorer la navigation « {1_entityType}. {0_navigation}' n’a pas de navigation inverse configurée. Chaque navigation d’ignorer doit avoir une navigation d’évitement inverse.

Ignorer la navigation « {1_entityType}. {0_navigation}' n’est pas une collection. Seules les navigations d’évitement de collecte sont actuellement prises en charge.

Le saut de navigation « {inverse} » déclaré sur le type d’entité « {inverseEntityType} » ne peut pas être défini comme inverse de « {navigation} », qui cible « {targetEntityType} ». La navigation inverse doit être déclarée sur le type d’entité cible.

Le saut de navigation « {navigation} » ne peut pas être supprimé du type d’entité « {entityType} », car il est défini sur le type d’entité « {otherEntityType} ».

Propriété « {1_entityType}. {0_property}' ne peut pas être affecté à une valeur générée par la base de données. Les valeurs générées par le magasin ne peuvent être attribuées qu’aux propriétés configurées pour utiliser des valeurs générées par le magasin.

Propriété « {1_entityType}. Une valeur temporaire ne peut pas être attribuée à {0_property}'. Les valeurs temporaires ne peuvent être attribuées qu’aux propriétés configurées pour utiliser des valeurs générées par le magasin.

Propriété « {1_entityType}. {0_property}' a une valeur temporaire lors de la tentative de modification de l’état de l’entité en « {state} ». Définissez une valeur permanente explicitement ou vérifiez que la base de données est configurée pour générer des valeurs pour cette propriété.

Le instance de type d’entité « {runtimeEntityType} » ne peut pas être suivi en tant que type d’entité « {entityType} », car les deux types ne se trouvent pas dans la même hiérarchie.

L’expression LINQ « {expression} » n’a pas pu être traduite. Réécrire la requête dans un formulaire qui peut être traduit, ou basculer vers l’évaluation du client explicitement en insérant un appel à « AsEnumerable », « AsAsyncEnumerable », « ToList » ou « ToListAsync ». Consultez la rubrique https://go.microsoft.com/fwlink/?linkid=2101038 (éventuellement en anglais) pour plus d'informations.

L’expression LINQ « {expression} » n’a pas pu être traduite. Informations supplémentaires : {details} Réécrire la requête dans un formulaire qui peut être traduit, ou basculer vers l’évaluation du client explicitement en insérant un appel à « AsEnumerable », « AsAsyncEnumerable », « ToList » ou « ToListAsync ». Consultez la rubrique https://go.microsoft.com/fwlink/?linkid=2101038 (éventuellement en anglais) pour plus d'informations.

Le type « {type} » a été configuré comme « {typeConfiguration} », ce qui est en conflit avec le type « {otherType} » configuré comme « {otherTypeConfiguration} ». Tous les types de base et les interfaces implémentées doivent avoir le même type de configuration.

Le type « {type} » n’a pas été configuré en tant que type partagé dans le modèle. Avant d’appeler « UsingEntity », ajoutez le type d’entité dans le modèle en tant qu’entité partagée.

Impossible de matérialiser l’instance d’entité de type « {entityType} ». Aucun discriminateur ne correspondait à la valeur du discriminateur « {discriminator} ».

Impossible de définir « IsUnique » sur « {isUnique} » sur la relation associée à la navigation « {2_entityType} ». {1_navigationName}', car la navigation a la multiplicité opposée.

Le type « {type} » ne peut pas être configuré comme « {configuration} », car la génération de modèle suppose qu’il est configuré comme « {expectedConfiguration} ». Supprimez la configuration non prise en charge pour « {configurationType} ».

Le mappage de type par défaut ne peut pas être configuré pour le type « {type} », car il ne s’agit pas d’un type scalaire valide. Supprimez la configuration non prise en charge.

Type de nœud d’expression non pris en charge « {nodeType} ».

Type de liaison membre non pris en charge « {bindingType} ».

« INavigationBase » non pris en charge de type « {type} ».

{entity} non pris en charge rencontré.

Valeur de « {entityType}. {property}' est inconnu lors de la tentative d’enregistrement des modifications. En effet, la propriété fait également partie d’une clé étrangère pour laquelle l’entité principale dans la relation n’est pas connue.

Valeur de la propriété de touche d’ombre « {entityType}. {property}' est inconnu lors de la tentative d’enregistrement des modifications. Cela est dû au fait que les valeurs de propriété d’ombre ne peuvent pas être conservées lorsque l’entité n’est pas suivie. Envisagez d’ajouter la propriété au type .NET de l’entité. Consultez la rubrique https://aka.ms/efcore-docs-owned-collections (éventuellement en anglais) pour plus d'informations.

L’index sans nom spécifié via l’attribut [Index] sur le type d’entité « {entityType} » avec les propriétés {indexProperties} n’est pas valide. La propriété « {propertyName} » a été marquée comme démapped par l’attribut [NotMapped] ou « Ignore() » dans « OnModelCreating ». Un index ne peut pas utiliser de propriétés non mappées.

Un index sans nom spécifié via l’attribut [Index] sur le type d’entité « {entityType} » fait référence aux propriétés {indexProperties}, mais aucune propriété portant le nom « {propertyName} » n’existe sur ce type d’entité ou sur l’un de ses types de base.

Le type d’entité « {entityType} » utilise un type partagé et l’entité fournie n’est actuellement pas suivie. Pour commencer à suivre cette entité, appelez « {referenceCall} » ou « {collectionCall} » sur l’entrée propriétaire.

Valeur de la propriété « {1_entityType} ». {0_property} » ne peut pas être défini sur null, car son type est « {propertyType} », qui n’est pas un type nullable.

La génération de valeur n’est pas prise en charge pour la propriété « {entityType}. {property} », car un convertisseur « {converter} » est configuré. Configurez la propriété pour ne pas utiliser la génération de valeurs à l’aide de « ValueGenerated.Never » ou « DatabaseGeneratedOption.None » et spécifiez des valeurs explicites à la place.

L’appel « {visitMethodName} » n’est pas autorisé. Visitez l’expression manuellement pour la partie appropriée dans le visiteur.

Une erreur a été générée pour l’avertissement « {eventName} » : {message} Cette exception peut être supprimée ou consignée en passant l’ID d’événement « {eventId} » à la méthode « ConfigureWarnings » dans « DbContext.OnConfiguring » ou « AddDbContext ».

Le type « {entityType} » ne peut pas avoir le type d’entité « {baseType} » comme type de base, car ce dernier a une navigation définissante.

Le type d’entité « {entityType} » ne peut pas avoir de type de base, car il a une navigation définissante.

Propriété « {1_entityType}. {0_property} » est de type « {actualType} », mais le type générique fourni est de type « {genericType} ».

Impossible de commencer à suivre l’entrée pour le type d’entité « {entityType} », car elle a été créée par un autre instance StateManager.