Vérifier si une liste est vide avec LINQ

Quelle est la «meilleure» façon (en tenant compte à la fois de la vitesse et de la lisibilité) pour déterminer si une liste est vide? Même si la liste est de type IEnumerable<T>et n'a pas de propriété Count.

En ce moment, je me balance entre ceci:

if (myList.Count() == 0) { ... }

et ça:

if (!myList.Any()) { ... }

Je suppose que la deuxième option est plus rapide, car elle reviendra avec un résultat dès qu'elle verra le premier élément, tandis que la deuxième option (pour un IEnumerable) devra visiter chaque élément pour renvoyer le décompte.

Cela étant dit, la deuxième option vous paraît-elle aussi lisible? Lequel préférez-vous? Ou pouvez-vous penser à une meilleure façon de tester une liste vide?

La réponse de Edit @ lassevk semble être la plus logique, associée à un peu de vérification à l'exécution pour utiliser un nombre mis en cache si possible, comme ceci:

public static bool IsEmpty<T>(this IEnumerable<T> list)
{
    if (list is ICollection<T>) return ((ICollection<T>)list).Count == 0;

    return !list.Any();
}

Vous pouvez faire ceci:

public static Boolean IsEmpty<T>(this IEnumerable<T> source)
{
    if (source == null)
        return true; // or throw an exception
    return !source.Any();
}

Modifier : notez que la simple utilisation de la méthode .Count sera rapide si la source sous-jacente possède en fait une propriété Count rapide. Une optimisation valide ci-dessus serait de détecter quelques types de base et d'utiliser simplement la propriété .Count de ceux-ci, au lieu de l'approche .Any (), puis de revenir à .Any () si aucune garantie ne peut être faite.

Je ferais un petit ajout au code sur lequel vous semblez avoir choisi: vérifiez également ICollection, car cela est également implémenté par certaines classes génériques non obsolètes (c'est-à-dire Queue<T>et Stack<T>). J'utiliserais également asau lieu de iscar il est plus idiomatique et s'est avéré plus rapide .

public static bool IsEmpty<T>(this IEnumerable<T> list)
{
    if (list == null)
    {
        throw new ArgumentNullException("list");
    }

    var genericCollection = list as ICollection<T>;
    if (genericCollection != null)
    {
        return genericCollection.Count == 0;
    }

    var nonGenericCollection = list as ICollection;
    if (nonGenericCollection != null)
    {
        return nonGenericCollection.Count == 0;
    }

    return !list.Any();
}

LINQ lui-même doit faire une optimisation sérieuse autour de la méthode Count () d'une manière ou d'une autre.

Cela vous surprend-il? J'imagine que pour les IListimplémentations, Countlit simplement le nombre d'éléments directement tout Anyen interrogeant la IEnumerable.GetEnumeratorméthode, créez une instance et appelez MoveNextau moins une fois.

/ EDIT @Matt:

Je ne peux que supposer que la méthode d'extension Count () pour IEnumerable fait quelque chose comme ceci:

Oui, bien sûr. C'est ce que je voulais dire. En fait, il utilise à la ICollectionplace de IListmais le résultat est le même.

Je viens de rédiger un test rapide, essayez ceci:

 IEnumerable<Object> myList = new List<Object>();

 Stopwatch watch = new Stopwatch();

 int x;

 watch.Start();
 for (var i = 0; i <= 1000000; i++)
 {
    if (myList.Count() == 0) x = i; 
 }
 watch.Stop();

 Stopwatch watch2 = new Stopwatch();

 watch2.Start();
 for (var i = 0; i <= 1000000; i++)
 {
     if (!myList.Any()) x = i;
 }
 watch2.Stop();

 Console.WriteLine("myList.Count() = " + watch.ElapsedMilliseconds.ToString());
 Console.WriteLine("myList.Any() = " + watch2.ElapsedMilliseconds.ToString());
 Console.ReadLine();

Le second est presque trois fois plus lent :)

Essayer à nouveau le test du chronomètre avec une pile ou un tableau ou d'autres scénarios, cela dépend vraiment du type de liste qu'il semble - car ils prouvent que Count est plus lent.

Donc je suppose que cela dépend du type de liste que vous utilisez!

(Juste pour souligner, j'ai mis plus de 2000 objets dans la liste et le comptage était encore plus rapide, contrairement aux autres types)

List.Countest O (1) selon la documentation de Microsoft:
http://msdn.microsoft.com/en-us/library/27b47ht3.aspx

alors utilise juste List.Count == 0 c'est beaucoup plus rapide qu'une requête

En effet, il a un membre de données appelé Count qui est mis à jour chaque fois que quelque chose est ajouté ou supprimé de la liste, de sorte que lorsque vous l'appelez, List.Countil n'a pas à parcourir chaque élément pour l'obtenir, il renvoie simplement le membre de données.

La deuxième option est beaucoup plus rapide si vous avez plusieurs éléments.

• Any() retourne dès qu'un article est trouvé.
• Count() doit continuer à parcourir toute la liste.

Par exemple, supposons que l'énumération contienne 1000 éléments.

• Any() vérifierait le premier, puis retournerait vrai.
• Count() retournerait 1000 après avoir parcouru toute l'énumération.

C'est potentiellement pire si vous utilisez l'un des remplacements de prédicat - Count () doit toujours vérifier chaque élément, même s'il n'y a qu'une seule correspondance.

Vous vous habituez à utiliser Any one - cela a du sens et est lisible.

Une mise en garde - si vous avez une liste, plutôt qu'un simple IEnumerable, utilisez la propriété Count de cette liste.

@Konrad ce qui me surprend, c'est que dans mes tests, je passe la liste dans une méthode qui accepte IEnumerable<T>, donc le runtime ne peut pas l'optimiser en appelant la méthode d'extension Count () pour IList<T>.

Je ne peux que supposer que la méthode d'extension Count () pour IEnumerable fait quelque chose comme ceci:

public static int Count<T>(this IEnumerable<T> list)
{
    if (list is IList<T>) return ((IList<T>)list).Count;

    int i = 0;
    foreach (var t in list) i++;
    return i;
}

... en d'autres termes, un peu d'optimisation du runtime pour le cas particulier de IList<T>.

/ EDIT @Konrad +1 compagnon - vous avez raison, il est plus probable que vous soyez allumé ICollection<T>.

Ok, alors qu'en est-il de celui-ci?

public static bool IsEmpty<T>(this IEnumerable<T> enumerable)
{
    return !enumerable.GetEnumerator().MoveNext();
}

EDIT: Je viens de réaliser que quelqu'un a déjà esquissé cette solution. Il a été mentionné que la méthode Any () le fera, mais pourquoi ne pas le faire vous-même? Cordialement

Une autre idée:

if(enumerable.FirstOrDefault() != null)

Cependant, j'aime plus l'approche Any ().

C'était essentiel pour que cela fonctionne avec Entity Framework:

var genericCollection = list as ICollection<T>;

if (genericCollection != null)
{
   //your code 
}

Si je vérifie avec Count () Linq exécute un "SELECT COUNT (*) .." dans la base de données, mais que je dois vérifier si les résultats contiennent des données, j'ai résolu d'introduire FirstOrDefault () au lieu de Count ();

Avant

var cfop = from tabelaCFOPs in ERPDAOManager.GetTable<TabelaCFOPs>()

if (cfop.Count() > 0)
{
    var itemCfop = cfop.First();
    //....
}

Après

var cfop = from tabelaCFOPs in ERPDAOManager.GetTable<TabelaCFOPs>()

var itemCfop = cfop.FirstOrDefault();

if (itemCfop != null)
{
    //....
}

private bool NullTest<T>(T[] list, string attribute)

    {
        bool status = false;
        if (list != null)
        {
            int flag = 0;
            var property = GetProperty(list.FirstOrDefault(), attribute);
            foreach (T obj in list)
            {
                if (property.GetValue(obj, null) == null)
                    flag++;
            }
            status = flag == 0 ? true : false;
        }
        return status;
    }


public PropertyInfo GetProperty<T>(T obj, string str)

    {
        Expression<Func<T, string, PropertyInfo>> GetProperty = (TypeObj, Column) => TypeObj.GetType().GetProperty(TypeObj
            .GetType().GetProperties().ToList()
            .Find(property => property.Name
            .ToLower() == Column
            .ToLower()).Name.ToString());
        return GetProperty.Compile()(obj, str);
    }

Voici ma mise en œuvre de la réponse de Dan Tao, permettant un prédicat:

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null) throw new ArgumentNullException();
    if (IsCollectionAndEmpty(source)) return true;
    return !source.Any(predicate);
}

public static bool IsEmpty<TSource>(this IEnumerable<TSource> source)
{
    if (source == null) throw new ArgumentNullException();
    if (IsCollectionAndEmpty(source)) return true;
    return !source.Any();
}

private static bool IsCollectionAndEmpty<TSource>(IEnumerable<TSource> source)
{
    var genericCollection = source as ICollection<TSource>;
    if (genericCollection != null) return genericCollection.Count == 0;
    var nonGenericCollection = source as ICollection;
    if (nonGenericCollection != null) return nonGenericCollection.Count == 0;
    return false;
}

List<T> li = new List<T>();
(li.First().DefaultValue.HasValue) ? string.Format("{0:yyyy/MM/dd}", sender.First().DefaultValue.Value) : string.Empty;

myList.ToList().Count == 0. C'est tout

Cette méthode d'extension fonctionne pour moi:

public static bool IsEmpty<T>(this IEnumerable<T> enumerable)
{
    try
    {
        enumerable.First();
        return false;
    }
    catch (InvalidOperationException)
    {
        return true;
    }
}