使用Enumerable.Empty的意外行为 <string> （）

Question

I would expect Enumerable.Empty<string>() to return an empty array of strings. Instead, it appears to return an array with a single null value. This breaks other LINQ operators like DefaultIfEmpty , since the enumerable is not, in fact, empty. This doesn't seem to be documented anywhere, so I'm wondering if I'm missing something (99% probability).

GameObject Class

 public GameObject(string id,IEnumerable<string> keywords) {
        if (String.IsNullOrWhiteSpace(id)) {
            throw new ArgumentException("invalid", "id");
        }
        if (keywords==null) {
            throw new ArgumentException("invalid", "keywords");
        }
        if (keywords.DefaultIfEmpty() == null) { //This line doesn't work correctly.
            throw new ArgumentException("invalid", "keywords");
        }
        if (keywords.Any(kw => String.IsNullOrWhiteSpace(kw))) {
            throw new ArgumentException("invalid", "keywords");
        }

        _id = id;
        _keywords = new HashSet<string>(keywords);
    }

Test

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void EmptyKeywords() {
        GameObject test = new GameObject("test",System.Linq.Enumerable.Empty<string>());
    }

Answer 1

It looks like you expect this condition:

keywords.DefaultIfEmpty() == null

to evaluate to true . However DefaultIfEmpty returns a singleton sequence containing the default for the element type ( string in this case) if the source sequence is empty. Therefore it will return a sequence containing null . This is not itself null however so the condition returns false .

Answer 2

You are misinterpreting the implementation of DefaultIfEmpty , here is it's implementation from the reference source .

public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source) {
    return DefaultIfEmpty(source, default(TSource));
}

public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable<TSource> source, TSource defaultValue) {
    if (source == null) throw Error.ArgumentNull("source");
    return DefaultIfEmptyIterator<TSource>(source, defaultValue);
}

static IEnumerable<TSource> DefaultIfEmptyIterator<TSource>(IEnumerable<TSource> source, TSource defaultValue) {
    using (IEnumerator<TSource> e = source.GetEnumerator()) {
        if (e.MoveNext()) {
            do {
                yield return e.Current;
            } while (e.MoveNext());
        }
        else {
            yield return defaultValue;
        }
    }
}

So what it does is if a IEnumerable<T> is not empty it simply returns the IEnumerable<T> , if the IEnumerable<T> is empty it returns new a IEnumerable<T> with one object in it with the value default(T) . It will never return null which is what your test is testing for. If you wanted to test this you would need to do

if(keywords.DefaultIfEmpty().First() == null)

However this is going to cause the IEnumerable<string> to be evaluated multiple times. I would drop the LINQ and just do like the LINQ method does and do it the long way (this also gets rid of the extra evaluation you had inside new HashSet<string>(keywords) ).

 public GameObject(string id,IEnumerable<string> keywords) 
 {
    if (String.IsNullOrWhiteSpace(id)) {
        throw new ArgumentException("invalid", "id");
    }
    if (keywords==null) {
        throw new ArgumentException("invalid", "keywords");
    }

    _keywords = new HashSet<string>();

    using (var enumerator = keywords.GetEnumerator())
    {
        if (e.MoveNext())
        {
            do 
            {
                if(e.Current == null)
                    throw new ArgumentException("invalid", "keywords");

                _keywords.Add(e.Current);

            } while (e.MoveNext());
        }
        else 
        {
            throw new ArgumentException("invalid", "keywords");
        }
    }

    _id = id;
}

This makes it so you only loop once over the IEnumerable<string> .

Answer 3

Does this solve your problem?

 public GameObject(string id, IEnumerable<string> keywords) {
    if (String.IsNullOrWhiteSpace(id)) {
        throw new ArgumentException("invalid", "id");
    }
    if (keywords == null || !keywords.Any()
            || keywords.Any(k => String.IsNullOrWhiteSpace(k))) {
        throw new ArgumentException("invalid", "keywords");
    }

    _id = id;
    _keywords = new HashSet<string>(keywords);
}

*Improved the code with suggestions from @ScottChamberlain & @ginkner