`ILookup` entries can contain multiple items per key - each key is mapped to an  `IEnumerable&lt;TElement&gt;`.

Also as hinted to in the comments an `ILookup` is immutable, while you can update values in an `IDictionary` (it exposes an `Add()` method and an indexer that allows getting **and** setting values).

In summary their use case is very different - you use a lookup when you need a 1:N map with values that are fixed and won&#39;t (and can&#39;t) change. A dictionary on the other hand offers a *mutable* 1:1 mapping of key value pairs, so it can be updated to add or remove values.

It is much more simpler than `IDictionary`. It is used by Linq. It only has `Contains`, `Item` and `Count`. `IDictionary` has `Add`, `Remove`, etc.

ILookUp =&gt; Group by key , Enumerable Collection

Single key value refers to enumerable collection where we can iterate through the value collection.

IDictionary =&gt; Group by distinct key , Single value


Using reflection, I&#39;m attempting to find the set of types which inherit from a given base class.  It didn&#39;t take long to figure out for simple types, but I&#39;m stumped when it comes to generics.

For this piece of code, the first IsAssignableFrom returns true, but the second returns false.  And yet, the final assignment compiles just fine.

    class class1 { }
    class class2 : class1 { }
    class generic1&lt;T&gt; { }
    class generic2&lt;T&gt; : generic1&lt;T&gt; { }

    class Program
    {
        static void Main(string[] args)
        {
            Type c1 = typeof(class1);
            Type c2 = typeof(class2);
            Console.WriteLine(&quot;c1.IsAssignableFrom(c2): {0}&quot;, c1.IsAssignableFrom(c2));

            Type g1 = typeof(generic1&lt;&gt;);
            Type g2 = typeof(generic2&lt;&gt;);
            Console.WriteLine(&quot;g1.IsAssignableFrom(g2): {0}&quot;, g1.IsAssignableFrom(g2));

            generic1&lt;class1&gt; cc = new generic2&lt;class1&gt;();
        }
    }

So how do I determine at run time whether one generic type definition is derived from another?

Using IsAssignableFrom with &#39;open&#39; generic types

I see how Xcode 4 splits the info on your targets nicely in one view, but how does one build and run these different builds? All I see are the options to build and to run, and these options to build for running, testing, and profiling. It&#39;s not clear to me how these map to the build configurations, though.

Running a release build with Xcode 4

How does the [`ILookup&lt;key, value&gt;`][1] interface differ from [`IDictionary&lt;key, value&gt;`](http://msdn.microsoft.com/en-us/library/s4ys34ea.aspx)?

I don&#39;t understand what the [`ILookup`][1] interface is meant for.


  [1]: http://msdn.microsoft.com/en-us/library/bb534291.aspx

ILookup interface vs IDictionary

<p>How does the <a href="http://msdn.microsoft.com/en-us/library/bb534291.aspx" target="_blank" rel="noopener noreferrer"><code>ILookup&#x3C;key, value></code></a> interface differ from <a href="http://msdn.microsoft.com/en-us/library/s4ys34ea.aspx" target="_blank" rel="noopener noreferrer"><code>IDictionary&#x3C;key, value></code></a>?</p>
<p>I don't understand what the <a href="http://msdn.microsoft.com/en-us/library/bb534291.aspx" target="_blank" rel="noopener noreferrer"><code>ILookup</code></a> interface is meant for.</p>


I am using Entity framework 4.1 in MVC 3 application. I have an entity where I have primary key consists of two columns ( composite key). And this is being used in another entity as foreign key. How to create the relationship ? In normal scnerios we use :

    public class Category
    {
        public string CategoryId { get; set; }
        public string Name { get; set; }
    
        public virtual ICollection&lt;Product&gt; Products { get; set; }
    }
    
    public class Product
    {
        public int ProductId { get; set; }
        public string Name { get; set; }
        public string CategoryId { get; set; }
    
        public virtual Category Category { get; set; }
    } 

but what if category has two columns key ?



composite key as foreign key

After reading this blog entry : [http://wekeroad.com/post/4069048840/when-should-a-method-be-a-property][1],

I&#39;m wondering why Microsoft choose in C# :

    DateTime aDt = DateTime.Now;

instead of

    DateTime aDt = DateTime.Now();

- Best practices say : Use a method when calling the member twice in succession produces different results
- And &lt;code&gt;DateTime.Now&lt;/code&gt; is perfect example of non-determistic method/property.

Do you know if there any reason for that design ?&lt;br/&gt;
Or if it&#39;s just a small mistake ?


  [1]: https://web.archive.org/web/20110821003841/http://wekeroad.com:80/post/4069048840/when-should-a-method-be-a-property

Why is DateTime.Now a property and not a method?

I&#39;ve seen countless posts on how variable capture pulls in variables for the creation of the closure, however they all seem to stop short of specific details and call the whole thing &quot;compiler magic&quot;.

I&#39;m looking for a clear-cut explanation of:

 1. How local variables are *actually* captured. 
 2. The difference (if any) between capturing value types vs. reference types.
 3. And whether there is any boxing occurring with respect to value types. 

My preference would be for an answer in terms of values and pointers (closer to the heart of what happens internally), though I will accept a clear answer involving values and references as well.

Detailed Explanation of Variable Capture in Closures

How can I add a delay to a program in C#?  

How to add a delay for a 2 or 3 seconds

What is the best way to do a redirect in an &lt;code&gt;ActionFilterAttribute&lt;/code&gt;.  I have an &lt;code&gt;ActionFilterAttribute&lt;/code&gt; called &lt;code&gt;IsAuthenticatedAttributeFilter&lt;/code&gt; and that checked the value of a session variable.  If the variable is false, I want the application to redirect to the login page.  I would prefer to redirect using the route name &lt;code&gt;SystemLogin&lt;/code&gt; however any redirect method at this point would be fine.

Redirect From Action Filter Attribute

I see two means of working with session data in ASP.NET MVC:

* `System.Web.SessionState.HttpSessionState`, available on `HttpApplication`
* `System.Web.HttpSessionStateBase`, available on `Controller`

Data stored in one seems to be available in the other.

Unfortunately the only common ancestor of these two types is `System.Object`, meaning that I can&#39;t create reusable utility code for the abstraction of either.

Why is the API this way?  Is there an important difference between the two that I am missing?

Why are there two incompatible session state types in ASP.NET?

Why does Visual Studio 2005 generate the `.pdb` files when compiling in release?  I won&#39;t be debugging a release build, so why are they generated?

Release generating .pdb files, why?

this might be a trivial question but: Since ADO.NET entity framework automatically tracks changes (in generated entities) and therefore keeps the original values, how can I rollback changes made to the entity objects?

I have a form which allows the user to edit a set of &quot;Customer&quot; entities in a grid view. 

Now I have two buttons &quot;Accept&quot; and &quot;Revert&quot;: if &quot;Accept&quot; is clicked, I call `Context.SaveChanges()` and the changed objects are written back to the database. If &quot;Revert&quot; is clicked, I would like for all objects to get their original property values. What would be the code for that?

Thanks



Content Type	Original Author	Original Content on Stackoverflow
Question	user256034	View Question on Stackoverflow
Solution 1 - C#	BrokenGlass	View Answer on Stackoverflow
Solution 2 - C#	Daniel A. White	View Answer on Stackoverflow
Solution 3 - C#	Magesh	View Answer on Stackoverflow

ILookup interface vs IDictionary

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Running a release build with Xcode 4

Using IsAssignableFrom with 'open' generic types

Attributions