Supposons que nous recevons deux listes (pourrait être n'importe quel type primitif):
private static IList<string> FindMissingRequiredValues(List<string> required, List<string> arguments)
{
var missing = new List<string>();
foreach (var r in required)
{
if (!arguments.Contains(r))
missing.Add(r);
}
if (missing.Count == 0)
missing = null;
return missing;
}
3 Réponses :
Ici, vous voulez vérifier deux conditions contre les listes.
Si tous les éléments de liste requis sont présents dans la liste, retournez S'il y a des champs manquants, vérifiez que la liste manquante contient dupliquer ou non.
ici Vous allez avec votre logique selon votre commentaire si vous souhaitez vérifier les doublons en argument, j'ai ajouté une fonction supplémentaire qui retournera valeur booléenne poc: .NET FIDDLE null
La vérification des valeurs manquantes va bien, mais comment puis-je déclencher une exception si un ou plusieurs des valeurs requises (et seules les valeurs requises) se produisent plusieurs fois?
Le problème reste. Par exemple, cela devrait déclencher l'exception car g oOccurs: var arguments = nouvelle liste var requis = nouvelle liste
OH, vous ne vérifiez pas que vous avez manqué vous voulez vérifier contre l'argument d'exception. Donne moi 1 min je viendrai avec une solution
@ Kyu96, j'ai mis à jour ma réponse, j'y regarde. Maintenant, il soutient votre état mentionné dans votre commentaire
@It ne semble toujours pas déclencher l'exception lorsqu'il y a des duplicats (voir mon exemple d'entrée dans le commentaire 3)
Échanger les conditions fixes le problème.
Toujours utiliser ! Tout () Pour vérifier si un énumérable n'a pas d'éléments non Nombre () == 0 Comme ce dernier nécessite que l'énumération complète doit être traversée du début à la fin. , tandis que tout ait juste besoin d'accéder au premier élément.
Essayez ceci
Cela ne tire pas l'exception si l'une des valeurs requises survient plusieurs fois dans la liste. Vérifiez avec ceci: var arguments = nouvelle liste g se produit deux fois. (Il ne doit que rechercher uniquement les doublons des valeurs requises, les valeurs non requises peuvent survenir plusieurs fois)
@ Kyu96 Modifier à arguments.groupby ... , alors il devrait fonctionner :) ou même arguments.Où (i => requis.contains (i)). Groupby ...
Si vous avez besoin d'une solution générique, j'irais avec quelque chose comme ceci:
static List<T> FindMissingRequiredElements<T>(List<T> required, List<T> arguments)
{
// convert to Dictionary where we store the required item as a key against count for an item
var requiredDict = required.ToDictionary(k => k, v => 0);
foreach(var item in arguments)
{
if (requiredDict.ContainsKey(item)) // now we check each item in arguments
{
requiredDict[item]++; // if we have required, adding to count
if (requiredDict[item] > 1) // if we met required item more than once, throw exception
{
throw new Exception($"Required item {item} appeared more than once!");
}
}
}
var result = new List<T>();
// now we are checking for missing items
foreach (var key in requiredDict.Keys)
{
if (requiredDict[key] == 0)
{
result.Add(key);
}
}
return result.Any() // if there are missing items, return the list, if not - return null
? result
: null;
}
Wow c'est une solution vraiment élégante, j'aime ça!