Sounds like you just want:

    bool hasSameElements = listA.Intersect(listB).Any();

EDIT: As noted in comments, `Intersect` uses lazy evaluation. It defers *all* execution until the first element is read from the result; at that point it will load *all* of `listB` into a set, and then stream `listA` until it finds a result to yield. At that point, `Any()` will return `true` and so no more work will be done. See my [Edulinq post on `Intersect`][1] for more information.


  [1]: http://codeblog.jonskeet.uk/2010/12/30/reimplementing-linq-to-objects-part-16-intersect-and-build-fiddling

What does the following code do:

    WeatherWidget.prototype = new Widget;

where `Widget` is a constructor, and I want to extend the Widget &#39;class&#39; with a new function `WeatherWidget`.

What is the **`new`** keyword doing there and what would happen if it is left out? 

What is the reason to use the &#39;new&#39; keyword at Derived.prototype = new Base

I have implemented the below quicksort algorithm. Online I&#39;ve read that it has a space requirement of O(log(n)). Why is this the case? I&#39;m not creating any extra data structures.

Is it because my recursion will use some extra space on the stack? If this is the case, is it possible to do it with less memory by not having it be recursive (instead making it iterative)?

    private static void quickSort (int[] array, int left, int right) {
        int index = partition(array, left, right);

        //Sort left half
        if (left &lt; index - 1)
            quickSort(array, left, index - 1);
    
        //Sort right half
        if (index &lt; right)
            quickSort(array, index , right);
    }
        
    private static int partition (int array[], int left, int right) {
        int pivot = array[(left + right) / 2]; //Pick pivot point
        while (left &lt;= right) {
            //Find element on left that should be on right
            while (array[left] &lt; pivot)
                left++;

            //Find element on right that should be on left
            while (array[right] &gt; pivot)
                right--;

            //Swap elements and move left and right indices
            if (left &lt;= right) {
                int temp = array[left];
                array[left] = array[right];
                array[right] = temp;
                left++;
                right--;
            }
        }
        return left;
    }

Why does QuickSort use O(log(n)) extra space?

I&#39;m wondering if Linq has a method to check if two collections have at least a single element in common. I would expect something like this:

    var listA = new List&lt;int&gt;() { some numbers };
    var listB = new List&lt;int&gt;() { some numbers, potentially also in list A };

    bool hasSameElements = listA.hasMatchingElements(listB);

Does it exists in Linq or should I write a custom method for it?

I am aware of the Intersect method, but doesn&#39;t this yield the entire intersection set? I&#39;m only interested in checking IF the two collection intersect, yielding the entire set seems like a waste, especially on larger collections.

Check for any element that exists in two collections

I'm wondering if Linq has a method to check if two collections have at least a single element in common. I would expect something like this:
<pre><code class="hljs language-ini">var listA = new List&#x3C;int>() { some numbers };
var listB = new List&#x3C;int>() { some numbers, potentially also in list A };

bool hasSameElements = listA.hasMatchingElements(listB);
</code></pre>
Does it exists in Linq or should I write a custom method for it?
I am aware of the Intersect method, but doesn't this yield the entire intersection set? I'm only interested in checking IF the two collection intersect, yielding the entire set seems like a waste, especially on larger collections.

Using EF5 with a generic Repository Pattern and ninject for dependency injenction and running into an issue when trying to update an entity to the database utilizing stored procs with my edmx.  

my update in DbContextRepository.cs is:

    public override void Update(T entity)
    {
        if (entity == null)
            throw new ArgumentException(&quot;Cannot add a null entity.&quot;);

        var entry = _context.Entry&lt;T&gt;(entity);

        if (entry.State == EntityState.Detached)
        {
            _context.Set&lt;T&gt;().Attach(entity);
            entry.State = EntityState.Modified;
        }
    }


From my AddressService.cs which goes back to my repository I have:

     public int Save(vw_address address)
    {
        if (address.address_pk == 0)
        {
            _repo.Insert(address);
        }
        else
        {
            _repo.Update(address);
        }

        _repo.SaveChanges();

        return address.address_pk;
    }

When it hits the Attach and EntityState.Modified it pukes with the error:

**An object with the same key already exists in the ObjectStateManager. The ObjectStateManager cannot track multiple objects with the same key.**

I have looked through many of the suggestions in stack and on the Internet and not coming up with anything that resolves it.  Any work arounds would be appreciated.

Thanks!

An object with the same key already exists in the ObjectStateManager. The ObjectStateManager cannot track multiple objects with the same key

    float a = 0;
    while (true)
    {
        a++;
        if (a &gt; 16777216)
            break; // Will never break... a stops at 16777216
    }

Can anyone explain this to me why a float value stops incrementing at 16777216 in this code?

**Edit:**

Or even more simple:

    float a = 16777217; // a becomes 16777216


Why does a float variable stop incrementing at 16777216 in C#?

I&#39;m calling a slow webservice in parallel. Things were great until I realized I need to get some information back from the service. But I don&#39;t see where to get the values back. I can&#39;t write to the database, HttpContext.Current appears to be null inside of a method called using Parallel.ForEach

Below is a sample program (in your mind, please imagine a slow web service instead of a string concatenation)


    using System;
    using System.Threading.Tasks;
    
    class Program
    {
        static void Main(string[] args)
        {
            WordMaker m = new WordMaker();
            m.MakeIt();
        }
        public class WordMaker
        {
            public void MakeIt()
            {
                string[] words = { &quot;ack&quot;, &quot;ook&quot; };
                ParallelLoopResult result = Parallel.ForEach(words, word =&gt; AddB(word));
                Console.WriteLine(&quot;Where did my results go?&quot;);
                Console.ReadKey();
            }
            public string AddB(string word)
            {
                return &quot;b&quot; + word;
            }
        }
    
    }



How do I collect return values from Parallel.ForEach?

I am using entity framework and ASP.NET MVC 4 to build an application

My solution is split into two projects;

- A class library that includes my data model (.edmx) file and a few custom interfaces
- The &#39;container&#39; MVC project that references the class library above

My problem is that when I attempt to use the &#39;MyEntites&#39; **DbContext** I get the the following error:


&gt; No connection string named &#39;MyEntities&#39; could be found in the
&gt; application config file.


I guess the problem has something to do with the fact that connection string lies within the app.config of the class library rather than the MVC project.


Does anyone have any suggestions?



No connection string named &#39;MyEntities&#39; could be found in the application config file

In .NET 4.5 / C# 5, `IReadOnlyCollection&lt;T&gt;` is declared with a `Count` property:

    public interface IReadOnlyCollection&lt;out T&gt; : IEnumerable&lt;T&gt;, IEnumerable
    {
        int Count { get; }
    }

I am wondering, wouldn&#39;t it have made sense for `ICollection&lt;T&gt;` to implement the `IReadOnlyCollection&lt;T&gt;` interface as well:

    public interface ICollection&lt;T&gt; : IEnumerable&lt;T&gt;, IEnumerable, *IReadOnlyCollection&lt;T&gt;*

This would&#39;ve meant that classes implementing `ICollection&lt;T&gt;` would&#39;ve automatically implemented `IReadOnlyCollection&lt;T&gt;`. This sounds reasonable to me.

The `ICollection&lt;T&gt;` abstraction can be viewed as an extension of the `IReadOnlyCollection&lt;T&gt;` abstraction. Note that `List&lt;T&gt;`, for example, implements both `ICollection&lt;T&gt;` and `IReadOnlyCollection&lt;T&gt;`.

However it has not been designed that way. 

What am I missing here? Why would the current implementation have been chosen instead?

----------

**UPDATE**

I&#39;m looking for an answer that uses **Object Oriented design reasoning** to explain why:

 - A concrete class such as `List&lt;T&gt;` implementing both `IReadOnlyCollection&lt;T&gt;` *and* `ICollection&lt;T&gt;`

*is a better design than:*

 - `ICollection&lt;T&gt;` implementing `IReadOnlyCollection&lt;T&gt;` directly

----------

Also please note that this is essentially the same question as:

 1. Why doesn&#39;t `IList&lt;T&gt;` implement `IReadOnlyList&lt;T&gt;`?
 2. Why doesn&#39;t `IDictionary&lt;T&gt;` implement `IReadOnlyDictionary&lt;T&gt;`?

Why doesn&#39;t generic ICollection implement IReadOnlyCollection in .NET 4.5?

I have the following code:

    List&lt;string&gt; test1 = new List&lt;string&gt; { &quot;@bob.com&quot;, &quot;@tom.com&quot; };
    List&lt;string&gt; test2 = new List&lt;string&gt; { &quot;joe@bob.com&quot;, &quot;test@sam.com&quot; };

I need to remove anyone in test2 that has @bob.com or @tom.com.

What I have tried is this:

    bool bContained1 = test1.Contains(test2);
    bool bContained2 = test2.Contains(test1);

`bContained1 = false` but `bContained2 = true`. I would prefer not to loop through each list but instead use a Linq query to retrieve the data. bContained1 is the same condition for the Linq query that I have created below:

    List&lt;string&gt; test3 = test1.Where(w =&gt; !test2.Contains(w)).ToList();

**The query above works on an exact match but not partial matches.**

I have looked at other queries but I can find a close comparison to this with Linq. Any ideas or anywhere you can point me to would be a great help.



LINQ query to find if items in a list are contained in another list

What is the quickest (and least resource intensive) to compare two massive (&gt;50.000 items) and as a result have two lists like the ones below:

1. items that show up in the first list but not in the second
2. items that show up in the second list but not in the first

Currently I&#39;m working with the List&lt;T&gt; or IReadOnlyCollection&lt;T&gt; and solve this issue in a linq query:

    var list1 = list.Where(i =&gt; !list2.Contains(i)).ToList();
    var list2 = list2.Where(i =&gt; !list.Contains(i)).ToList();

But this doesn&#39;t perform as good as i would like.
Any idea of making this quicker and less resource intensive as i need to process a lot of lists?

Quickest way to compare two generic lists for differences

As I understand it, in Linq the method `FirstOrDefault()` can return a `Default` value of something other than null.  What I haven&#39;t worked out is what kind of things other than null can be returned by this (and similar) method when there are no items in the query result.  Is there any particular way that this can be set up so that if there is no value for a particular query some predefined value is returned as the default value?

FirstOrDefault: Default value other than null

I have some list&lt;T&gt; (where T is a custom class, and class has some properties).
I would like to know how to change one or more values inside of it by using Lambda Expressions, so the result will be the same as the foreach loop bellow:


*NOTE: list&lt;T&gt; contains multiple items inside (multiple rows)*

            foreach (MyClass mc in list)  
            {
                if (mc.Name == &quot;height&quot;)
                    mc.Value = 30;
            }

 
And this the the linq query (using Lambda expressions), but its not the same as the upper foreach loop, it only returns 1 item (one row) from the list!

What I want is, that it returns all the items (all rows) and ONLY changes the appropriate one (the items specified in the WHERE extension method(s).

    list = list.Where(w =&gt; w.Name == &quot;height&quot;).Select(s =&gt; { s.Value = 30; return s; }).ToList();

NOTE: these 2 example are not the same! I repeat, the linq only returns 1 item (one row), and this is something I don&#39;t want, I need all items from the list as well (like foreach loop, it only do changes, but it does not remove any item).


Change some value inside the List&lt;T&gt;

Assuming I have the following string array:

    string[] str = new string[] {&quot;max&quot;, &quot;min&quot;, &quot;avg&quot;, &quot;max&quot;, &quot;avg&quot;, &quot;min&quot;}

Is it possbile to use LINQ to get a list of indexes that match one string?

As an example, I would like to search for the string &quot;avg&quot; and get a list containing 

&gt;2, 4

meaning that &quot;avg&quot; can be found at str[2] and str[4].


LINQ to find array indexes of a value

I want to verify whether a collection is empty and `null`. Could anyone please let me know the best practice.
    
Currently, I am checking as below:

    
    if (null == sampleMap || sampleMap.isEmpty()) {
      // do something
    } 
    else {
      // do something else
    }

Best practice to validate null and empty collection in Java

I see people are using `any` to gather another list to see if an item exists in a list, but is there a quick way to just do something like this?

    if list.contains(myItem):
        # do something

Is there a short contains function for lists?

sorry for noobie question. Can you explain please, what is the difference between:

    1. var a = [];
       a[&#39;b&#39;] = 1;

    2. var a = {};
       a[&#39;b&#39;] = 1;

I could not find article in the internet so wrote here.

Javascript collection

There is no `AddRange()` method for `IList&lt;T&gt;`.

How can I add a list of items to an `IList&lt;T&gt;` without iterating through the items and using the `Add()` method?


How to add a range of items to an IList?

Just now I read [some posts about `List&lt;T&gt;` vs `LinkedList&lt;T&gt;`](https://stackoverflow.com/questions/169973/when-should-i-use-a-list-vs-a-linkedlist), so I decided to benchmark some structures myself. I benchmarked `Stack&lt;T&gt;`, `Queue&lt;T&gt;`, `List&lt;T&gt;` and `LinkedList&lt;T&gt;` by adding data and removing data to/from the front/end. Here&#39;s the benchmark result:

&lt;!-- language: lang-none --&gt;

                   Pushing to Stack...  Time used:      7067 ticks
                  Poping from Stack...  Time used:      2508 ticks

                   Enqueue to Queue...  Time used:      7509 ticks
                 Dequeue from Queue...  Time used:      2973 ticks

        Insert to List at the front...  Time used:   5211897 ticks
    RemoveAt from List at the front...  Time used:   5198380 ticks

             Add to List at the end...  Time used:      5691 ticks
      RemoveAt from List at the end...  Time used:      3484 ticks

             AddFirst to LinkedList...  Time used:     14057 ticks
        RemoveFirst from LinkedList...  Time used:      5132 ticks

              AddLast to LinkedList...  Time used:      9294 ticks
         RemoveLast from LinkedList...  Time used:      4414 ticks

Code: 

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Diagnostics;
     
    namespace Benchmarking
    {
        static class Collections
        {
            public static void run()
            {
                Random rand = new Random();
                Stopwatch sw = new Stopwatch();
                Stack&lt;int&gt; stack = new Stack&lt;int&gt;();
                Queue&lt;int&gt; queue = new Queue&lt;int&gt;();
                List&lt;int&gt; list1 = new List&lt;int&gt;();
                List&lt;int&gt; list2 = new List&lt;int&gt;();
                LinkedList&lt;int&gt; linkedlist1 = new LinkedList&lt;int&gt;();
                LinkedList&lt;int&gt; linkedlist2 = new LinkedList&lt;int&gt;();
                int dummy;
     
     
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;Pushing to Stack...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    stack.Push(rand.Next());
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks&quot;, sw.ElapsedTicks);
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;Poping from Stack...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    dummy = stack.Pop();
                    dummy++;
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks\n&quot;, sw.ElapsedTicks);
     
     
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;Enqueue to Queue...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    queue.Enqueue(rand.Next());
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks&quot;, sw.ElapsedTicks);
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;Dequeue from Queue...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    dummy = queue.Dequeue();
                    dummy++;
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks\n&quot;, sw.ElapsedTicks);
     
     
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;Insert to List at the front...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    list1.Insert(0, rand.Next());
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks&quot;, sw.ElapsedTicks);
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;RemoveAt from List at the front...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    dummy = list1[0];
                    list1.RemoveAt(0);
                    dummy++;
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks\n&quot;, sw.ElapsedTicks);
     
     
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;Add to List at the end...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    list2.Add(rand.Next());
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks&quot;, sw.ElapsedTicks);
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;RemoveAt from List at the end...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    dummy = list2[list2.Count - 1];
                    list2.RemoveAt(list2.Count - 1);
                    dummy++;
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks\n&quot;, sw.ElapsedTicks);
     
     
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;AddFirst to LinkedList...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    linkedlist1.AddFirst(rand.Next());
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks&quot;, sw.ElapsedTicks);
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;RemoveFirst from LinkedList...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    dummy = linkedlist1.First.Value;
                    linkedlist1.RemoveFirst();
                    dummy++;
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks\n&quot;, sw.ElapsedTicks);
     
     
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;AddLast to LinkedList...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    linkedlist2.AddLast(rand.Next());
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks&quot;, sw.ElapsedTicks);
                sw.Reset();
                Console.Write(&quot;{0,40}&quot;, &quot;RemoveLast from LinkedList...&quot;);
                sw.Start();
                for (int i = 0; i &lt; 100000; i++)
                {
                    dummy = linkedlist2.Last.Value;
                    linkedlist2.RemoveLast();
                    dummy++;
                }
                sw.Stop();
                Console.WriteLine(&quot;  Time used: {0,9} ticks\n&quot;, sw.ElapsedTicks);
            }
        }
    }

The differences are **so** dramatic!

As you can see, the performance of `Stack&lt;T&gt;` and `Queue&lt;T&gt;` are fast and comparable, that&#39;s expected.

For `List&lt;T&gt;`, using the front and the end has so much differences! And to my surprise, performance of adding/removing from the end is actually comparable to the performance of `Stack&lt;T&gt;`.

For `LinkedList&lt;T&gt;`, manipulating with the front is fast (-er than `List&lt;T&gt;`)&lt;s&gt;, but for the end, it is incredibly slow for removing&lt;/s&gt; manipulating with the end is too.

---
So... can any experts account on:

1. the similarity in performance of using `Stack&lt;T&gt;` and the end of `List&lt;T&gt;`,
2. the differences in using the front and the end of `List&lt;T&gt;`, and&lt;s&gt;
3. the reason that using the end of `LinkedList&lt;T&gt;` is *so* slow&lt;/s&gt; (not applicable as that is a coding error due to the use of Linq&#39;s `Last()`, **thanks to CodesInChaos**)?

I think I know why `List&lt;T&gt;` doesn&#39;t handle the front so well... because `List&lt;T&gt;`needs to move the whole list back and fro when doing that. Correct me if I am wrong.


P.S. My `System.Diagnostics.Stopwatch.Frequency` is `2435947`, and the program is targeted to .NET 4 Client Profile and compiled with C# 4.0, on Windows 7 Visual Studio 2010.

Content Type	Original Author	Original Content on Stackoverflow
Question	zeebonk	View Question on Stackoverflow
Solution 1 - C#	Jon Skeet	View Answer on Stackoverflow

Check for any element that exists in two collections

C# Problem Overview

C# Solutions

Solution 1 - C#

Why does QuickSort use O(log(n)) extra space?

What is the reason to use the 'new' keyword at Derived.prototype = new Base

Attributions