[`IEnumerable&lt;T&gt;`][1] represents a series of items that you can iterate over (using foreach, for example), whereas [`IList&lt;T&gt;`][2] is a collection that you can add to or remove from.

Typically you&#39;ll want to be able to modify an Order by adding or removing OrderLines to it, so you probably want Order.Lines to be an `IList&lt;OrderLine&gt;`.

Having said that, there are some framework design decisions you should make. For example, should it be possible to add the same instance of OrderLine to two different orders? Probably not. So given that you&#39;ll want to be able to validate whether an OrderLine should be added to the order, you may indeed want to surface the Lines property as only an `IEnumerable&lt;OrderLine&gt;`, and provide Add(OrderLine) and Remove(OrderLine) methods which can handle that validation.


  [1]: https://msdn.microsoft.com/en-us/library/9eekhta0.aspx &quot;MSDN documentation&quot;
  [2]: https://msdn.microsoft.com/en-us/library/5y536ey6.aspx &quot;MSDN documentation&quot;

Most of the time I end up going with IList over IEnumerable because IEnumerable doesn&#39;t have the Count method and you can&#39;t access the collection through an index (although if you are using LINQ you can get around this with extension methods).

Is there any way to make Visual Studio show the code of a control / form by default instead of the designer? I tend not to be a fan of the designers as they add bloat.

Visual Studio: Make view code default

How do I force Postgres to use an index when it would otherwise insist on doing a sequential scan?

How do I force Postgres to use a particular index?

When I have entities in my domain with lists of things, should they be exposed as ILists or IEnumerables? E.g. Order has a bunch of OrderLines. 

IList vs IEnumerable for Collections on Entities

<p>When I have entities in my domain with lists of things, should they be exposed as ILists or IEnumerables? E.g. Order has a bunch of OrderLines.</p>


I&#39;ve seen them used in a lot of the same ways, and I am worried I&#39;m about to go down a path in design that is irreversible if I don&#39;t understand this better. Also, I am using .NET.

What is the difference between List (of T) and Collection(of T)?

I&#39;m a beginner in Java.  Please suggest which collection(s) can/should be used for maintaining a sorted list in Java. I have tried `Map` and `Set`, but they weren&#39;t what I was looking for.


Sorted collection in Java

What is the best way to convert a JSON code as this:

    { 
        &quot;data&quot; : 
        { 
            &quot;field1&quot; : &quot;value1&quot;, 
            &quot;field2&quot; : &quot;value2&quot;
        }
    }

in a Java Map in which one the keys are (field1, field2) and the values for those fields are (value1, value2).

Any ideas? Should I use Json-lib for that? Or better if I write my own parser?




Convert JSON to Map

Does a `List&lt;T&gt;` always guarantee that items will be returned in the order they were added when enumerated?

***Updated***: Thanks for all the answers folks, puts my mind at ease. I had a quick poke around the `List&lt;T&gt;` class with .NET Reflector (should&#39;ve probably done that in the first place) and indeed the underlying store is an array of `T` (`T[]`).

Does a List&lt;T&gt; guarantee that items will be returned in the order they were added?

I was looking at C# collection initializers and found the implementation to be very pragmatic but also very unlike anything else in C#

I am able to create code like this:

    using System;
    using System.Collections;
    
    class Program
    {
    	static void Main()
    	{
    		Test test = new Test { 1, 2, 3 };
    	}
    }
    
    class Test : IEnumerable
    {
    	public IEnumerator GetEnumerator()
    	{
    		throw new NotImplementedException();
    	}
    
    	public void Add(int i) { }
    }

Since I have satisfied the minimum requirements for the compiler (implemented `IEnumerable` and a `public void Add`) this works but obviously has no value.

I was wondering what prevented the C# team from creating a more strict set of requirements?  In other words why, in order for this syntax to compile, does the compiler not require that the type implement `ICollection`?  That seems more in the spirit of other C# features.
 

Why do C# collection initializers work this way?

Here&#39;s what I&#39;m trying to do. I&#39;m querying an XML file using LINQ to XML, which gives me an IEnumerable`&lt;T`&gt; object, where T is my &quot;Village&quot; class, filled with the results of this query. Some results are duplicated, so I would like to perform a Distinct() on the IEnumerable&lt;Village&gt; object, like so:

    public IEnumerable&lt;Village&gt; GetAllAlliances()
    {
        try
        {
            IEnumerable&lt;Village&gt; alliances =
                 from alliance in xmlDoc.Elements(&quot;Village&quot;)
                 where alliance.Element(&quot;AllianceName&quot;).Value != String.Empty
                 orderby alliance.Element(&quot;AllianceName&quot;).Value
                 select new Village
                 {
                     AllianceName = alliance.Element(&quot;AllianceName&quot;).Value
                 };
                 
            // TODO: make it work...
            return alliances.Distinct(new AllianceComparer());
        }
        catch (Exception ex)
        {
            throw new Exception(&quot;GetAllAlliances&quot;, ex);
        }
    }

As the default comparer would not work for the Village object, I implemented a custom one, as seen here in the AllianceComparer class:

    public class AllianceComparer : IEqualityComparer&lt;Village&gt;
    {
        #region IEqualityComparer&lt;Village&gt; Members
        bool IEqualityComparer&lt;Village&gt;.Equals(Village x, Village y)
        {
            // Check whether the compared objects reference the same data.
            if (Object.ReferenceEquals(x, y)) 
                return true;

            // Check whether any of the compared objects is null.
            if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
                return false;

            return x.AllianceName == y.AllianceName;
        }

        int IEqualityComparer&lt;Village&gt;.GetHashCode(Village obj)
        {
            return obj.GetHashCode();
        }
        #endregion
    }

The Distinct() method doesn&#39;t work, as I have exactly the same number of results with or without it. Another thing, and I don&#39;t know if it&#39;s usually possible, but I cannot step into AllianceComparer.Equals() to see what could be the problem.&lt;br/&gt;
I&#39;ve found examples of this on the Internet, but I can&#39;t seem to make my implementation work.

Hopefully, someone here might see what could be wrong here!
Thanks in advance!

C# Distinct on IEnumerable&lt;T&gt; with custom IEqualityComparer

How can I convert a `List&lt;MyObject&gt;` to an `IEnumerable&lt;MyObject&gt;` and then back again?

I want to do this in order to run a series of LINQ statements on the List, e. g. `Sort()`

Freely convert between List&lt;T&gt; and IEnumerable&lt;T&gt;

Is there any reason to expose an internal collection as a ReadOnlyCollection&lt;T&gt; rather than an IEnumerable&lt;T&gt; if the calling code only iterates over the collection?

    class Bar
    {
        private ICollection&lt;Foo&gt; foos;
        
        // Which one is to be preferred?
        public IEnumerable&lt;Foo&gt; Foos { ... }
        public ReadOnlyCollection&lt;Foo&gt; Foos { ... }
    }


    // Calling code:

    foreach (var f in bar.Foos)
        DoSomething(f);

As I see it IEnumerable is a subset of the interface of ReadOnlyCollection and it does not allow the user to modify the collection. So if the IEnumberable interface is enough then that is the one to use. Is that a proper way of reasoning about it or am I missing something?

Thanks /Erik

ReadOnlyCollection or IEnumerable for exposing member collections?

Can anyone explain `IEnumerable` and `IEnumerator` to me? 

For example, when to use it over foreach? what&#39;s the difference between `IEnumerable` and `IEnumerator`? Why do we need to use it? 

Can anyone explain IEnumerable and IEnumerator to me?

If I have an IEnumerable like:

    string[] items = new string[] { &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; };

I would like to loop thru all the pairs of consecutive items (sliding window of size 2). Which would be 

    (&quot;a&quot;,&quot;b&quot;), (&quot;b&quot;, &quot;c&quot;), (&quot;c&quot;, &quot;d&quot;)


My solution was is this 

        public static IEnumerable&lt;Pair&lt;T, T&gt;&gt; Pairs(IEnumerable&lt;T&gt; enumerable) {
            IEnumerator&lt;T&gt; e = enumerable.GetEnumerator(); e.MoveNext();
            T current = e.Current;
            while ( e.MoveNext() ) {
                T next = e.Current;
                yield return new Pair&lt;T, T&gt;(current, next);
                current = next;
            }
        }
       
     // used like this :
     foreach (Pair&lt;String,String&gt; pair in IterTools&lt;String&gt;.Pairs(items)) {
        System.Out.PrintLine(&quot;{0}, {1}&quot;, pair.First, pair.Second)
     }

When I wrote this code, I wondered if there are already functions in the .NET framework that do the same thing and do it not just for pairs but for any size tuples. 
IMHO there should be a nice way to do this kind of sliding window operations.

I use C# 2.0 and I can imagine that with C# 3.0 (w/ LINQ) there are more (and nicer) ways to do this, but I&#39;m primarily interested in C# 2.0 solutions. Though, I will also appreciate C# 3.0 solutions.

Pair-wise iteration in C# or sliding window enumerator

I have a the following dictionary:

    IDictionary&lt;int, IList&lt;MyClass&gt;&gt; myDictionary 

and I am wanting to get all the values in the dictionary as an IList&lt;MyClass&gt;....


----------


Just to add a bit of a background as to how I&#39;ve gotten into this situation....

I have a method that gets me a list of MyClass. I then have another method that converts that list into a dictionary where they key is the id for MyClass. Later on...and without access to that original list...I&#39;m needing to obtain the original ungrouped list of MyClass.


----------


When I pass myDictionary.Values.ToList() to a method that takes an IList&lt;MyClass&gt; I get a compile error that says that it can&#39;t convert from 

    System.Collections.Generic.List&lt;System.Collections.Generic.IList&lt;MyClass&gt;&gt; 

to:

    System.Collections.Generic.IList&lt;MyClass&gt;

Now, I can understand that its gone and added each of the groups of IList&lt;MyClass&gt; to the new list as separate elements of the list....but in this instance its not really what I&#39;m after. I just want a list of all the values in the entire dictionary.

How then can I get what I&#39;m after without looping through each of the key values in the dictionary and creating the list I want?


How do I get all the values of a Dictionary&lt;TKey, TValue&gt; as an IList&lt;TValue&gt;?

I am trying to cast `IList` type to `List` type but I am getting error every time.

    List&lt;SubProduct&gt; subProducts= Model.subproduct;

`Model.subproduct` returns `IList&lt;SubProduct&gt;`.

Cast IList to List

Can anyone tell me when I should use either.

For example, I think I should use an IList when I want to access the .Count of the collection or an individual item, correct?

Thank you.

What should I use an IEnumerable or IList?

What is the difference between `IEnumerable` and `IEnumerable&lt;T&gt;`? 

I&#39;ve seen many framework classes implementing both these interfaces, therefore I would like to know what advantages one get by implementing both?

Please have a look how they&#39;ve been defined:

    public interface IEnumerable
    {
        [DispId(-4)]
        IEnumerator GetEnumerator();
    }
    public interface IEnumerable&lt;T&gt; : IEnumerable
    {
        IEnumerator&lt;T&gt; GetEnumerator();
    }
 
As we see, `IEnumerable&lt;T&gt;` derives from `IEnumerable`, that means whatever `IEnumerable` has, `IEnumerable&lt;T&gt;` inherits, then why do we implement both instead of just `IEnumerable&lt;T&gt;`? Is implementing `IEnumerable&lt;T&gt;` not enough?

Likewise, there are other similar pairs:

  - `IList` and `IList&lt;T&gt;`  
  - `ICollection` and `ICollection&lt;T&gt;`

I would like to know about these as well.

Difference between IEnumerable and IEnumerable&lt;T&gt;?

See the definition of *System.Array* class

    public abstract class Array : IList, ...
Theoretically, I should be able to write this bit and be happy

    int[] list = new int[] {};
    IList iList = (IList)list;
I also should be able to call any method from the iList

     ilist.Add(1); //exception here
My question is not why I get an exception, but rather **why Array implements IList**?

Content Type	Original Author	Original Content on Stackoverflow
Question	pondermatic	View Question on Stackoverflow
Solution 1 - Collections	Matt Hamilton	View Answer on Stackoverflow
Solution 2 - Collections	JoshSchlesinger	View Answer on Stackoverflow

IList vs IEnumerable for Collections on Entities

Collections Problem Overview

Collections Solutions

Solution 1 - Collections

Solution 2 - Collections

How do I force Postgres to use a particular index?

Visual Studio: Make view code default

Attributions