They have totally different semantics.

AddRange modifies the list by adding the other items to it.

Concat returns a new sequence containing the list and the other items, without modifying the list.

Choose whichever one has the semantics you want.

The big difference is that `AddRange` mutates that list against which it is called whereas `Concat` creates a new List.  Hence they have different uses. 

Also `Concat` is an extension method that applies to any `IEnumerable&lt;T&gt;` and returns an `IEnumerable&lt;T&gt;` you need a `.ToList()` to result in a new List.

If you want to extend the content of an existing list use `AddRange`.

If you are creating a new list from two `IEnumerable&lt;T&gt;` sources then use `Concat` with `.ToList`.  This has the quality that it does not mutate either of sources.

If you only ever need to enumerate the contents of two Lists (or any other IEnumerable) then simply use `Concat` each time, this has the advantage of not actually allocating new memory to hold the unified list.


I found this interesting article talking about the difference between these 2 structures and comparing their performance...

The main idea is that AddRange is way much faster when its about big size collections.

Here is the [Link][1]

Hope this helps,


  [1]: https://www.tabsoverspaces.com/232514-collection-type-result-whats-faster-ilist-add-or-ienumerable-concat

lsof is an increadibly powerful command-line utility for unix systems. It lists open files, displaying information about them. And since most everything is a file on unix systems, lsof can give sysadmins a ton of useful diagnostic data.

What are some of the most common and useful ways of using lsof, and which command-line switches are used for that? 

lsof survival guide

I teach a sort of &quot;lite&quot; C++ programming course to novices (&quot;lite&quot; meaning no pointers, no classes, just plain old C, plus references and STL string and vectors). Students have no previous experience in programming, so I believe that using an interactive debugger would help them understand program flow, variables, and recursion.

The course is taught in Linux. Teaching them to use gdb is just overkill (they will not use nor understand most features). I just need something simple but easy to use: to see at which line the program is now, what is in the stack (local variables, previous calls, etc.). I look something similar to old Turbo Pascal or Turbo C++ Borland&#39;s debugger, or Visual Studio debugger.

Thank you,

Which is the best Linux C/C++ debugger (or front-end to gdb) to help teaching programming?

What is the difference between the [AddRange][1] and [Concat][2] functions on a generic List? Is one recommended over the other?


  [1]: https://msdn.microsoft.com/en-us/library/z883w3dc(v=vs.110).aspx
  [2]: https://msdn.microsoft.com/en-us/library/bb302894(v=vs.110).aspx

.NET List&lt;T&gt; Concat vs AddRange

<p>What is the difference between the <a href="https://msdn.microsoft.com/en-us/library/z883w3dc(v=vs.110).aspx" target="_blank" rel="noopener noreferrer">AddRange</a> and <a href="https://msdn.microsoft.com/en-us/library/bb302894(v=vs.110).aspx" target="_blank" rel="noopener noreferrer">Concat</a> functions on a generic List? Is one recommended over the other?</p>


&gt; **Possible Duplicate:**  
&gt; [What is the best way to parse html in C#?](https://stackoverflow.com/questions/56107/what-is-the-best-way-to-parse-html-in-c)  

&lt;!-- End of automatically inserted text --&gt;

I would like to extract the structure of the HTML document - so the tags are more important than the content.  Ideally, it would be able to cope reasonably with badly-formed HTML to some extent also.

Anyone know of a reliable and efficient parser?

Looking for C# HTML parser

Inspired by another question asking about the missing `Zip` function:

Why is there no `ForEach` extension method on the `IEnumerable` interface? Or anywhere? The only class that gets a `ForEach` method is `List&lt;&gt;`. Is there a reason why it&#39;s missing, maybe performance?

Why is there no ForEach extension method on IEnumerable?

I am looking for a .NET implementation of a priority queue or heap data structure

&gt; Priority queues are data structures that provide more flexibility than simple sorting, because they allow new elements to enter a system at arbitrary intervals. It is much more cost-effective to insert a new job into a priority queue than to re-sort everything on each such arrival.
&gt;
&gt; The basic priority queue supports three primary operations:
&gt;
&gt; * Insert(Q,x). Given an item x with key k, insert it into the priority queue Q.
&gt; * Find-Minimum(Q). Return a pointer to the item
whose key value is smaller than any other key in the priority queue
Q.
&gt; * Delete-Minimum(Q). Remove the item from the priority queue Q whose key is minimum


Unless I am looking in the wrong place, there isn&#39;t one in the framework. Is anyone aware of a good one, or should I roll my own?

Priority queue in .Net

What&#39;s the best way to shut down the computer from a C# program?

I&#39;ve found a few methods that work - I&#39;ll post them below - but none of them are very elegant. I&#39;m looking for something that&#39;s simpler and natively .net.

How to shut down the computer from C#

Some things are easier to implement just by hand (code), but some are easier through WF. It looks like WF can be used to create (almost) any kind of algorithm. So (theoretically) I can do all my logic in WF, but it&#39;s probably a bad idea to do it for all projects.

In what situations is it a good idea to use WF and when will it make things harder then they have to be? What are pros and cons/cost of WF vs. coding by hand?

When to use Windows Workflow Foundation?

When I enter an object into the DB with Linq-to-SQL can I get the id that I just inserted without making another db call?  I am assuming this is pretty easy, I just don&#39;t know how.  

Can I return the &#39;id&#39; field after a LINQ insert?

How can I perform list comprehensions in C#?

Introduction to C# list comprehensions

I am looking for a way in LINQ to match the follow SQL Query.

    Select max(uid) as uid, Serial_Number from Table Group BY Serial_Number

Really looking for some help on this one.  The above query gets the max uid of each Serial Number because of the `Group By` Syntax.

How do I get the MAX row with a GROUP BY in LINQ query?

I am wondering if it is possible to use LINQ to pivot data from the following layout:

    CustID | OrderDate | Qty
    1      | 1/1/2008  | 100
    2      | 1/2/2008  | 200
    1      | 2/2/2008  | 350
    2      | 2/28/2008 | 221
    1      | 3/12/2008 | 250
    2      | 3/15/2008 | 2150

into something like this:


    CustID  | Jan- 2008 | Feb- 2008 | Mar - 2008 |
    1       | 100       | 350       |  250
    2       | 200       | 221       | 2150



Is it possible to Pivot data using LINQ?

I have two collections which have property `Email` in both collections. I need to get a list of the items in the first list where `Email` does not exist in the second list. With SQL I would just use &quot;not in&quot;, but I do not know the equivalent in LINQ. How is that done?

So far I have a join, like...

    var matches = from item1 in list1
    join item2 in list2 on item1.Email equals item2.Email
    select new { Email = list1.Email };

But I cannot join since I need the difference and the join would fail. I need some way of using Contains or Exists I believe. I just have not found an example to do that yet.


How would you do a &quot;not in&quot; query with LINQ?

I could swear I&#39;ve seen the function (or method) that takes a list, like this `[3, 7, 19]` and makes it into iterable list of tuples, like so: `[(0,3), (1,7), (2,19)]` to use it instead of:

    for i in range(len(name_of_list)):
        name_of_list[i] = something

but I can&#39;t remember the name and googling &quot;iterate list&quot; gets nothing.


Iterate a list with indexes in Python

It&#39;s clear that a search performance of the generic `HashSet&lt;T&gt;` class is higher than of the generic `List&lt;T&gt;` class. Just compare the hash-based key with the linear approach in the `List&lt;T&gt;` class.

However calculating a hash key may itself take some CPU cycles, so for a small amount of items the linear search can be a real alternative to the `HashSet&lt;T&gt;`.

My question: where is the break-even?

To simplify the scenario (and to be fair) let&#39;s assume that the `List&lt;T&gt;` class uses the element&#39;s `Equals()` method to identify an item.

HashSet vs. List performance

If I have a sorted list (say quicksort to sort), if I have a lot of values to add, is it better to suspend sorting, and add them to the end, then sort, or use binary chop to place the items correctly while adding them. Does it make a difference if the items are random, or already more or less in order?

Is it faster to sort a list after inserting items or adding them to a sorted list

If you are creating a 1d array, you can implement it as a List, or else use the &#39;array&#39; module in the standard library.  I have always used Lists for 1d arrays.

What is the reason or circumstance where I would want to use the array module instead?
  
Is it for performance and memory optimization, or am I missing something obvious?

Python List vs. Array - when to use?

Given a list `[&quot;foo&quot;, &quot;bar&quot;, &quot;baz&quot;]` and an item in the list `&quot;bar&quot;`, how do I get its index `1`?

Finding the index of an item in a list

I&#39;m attempting to use extension methods to add an operater overload to the C# `StringBuilder` class.  Specifically, given `StringBuilder` `sb`, I&#39;d like `sb += &quot;text&quot;` to become equivalent to `sb.Append(&quot;text&quot;)`.

Here&#39;s the syntax for creating an extension method for `StringBuilder`:

    public static class sbExtensions
    {
        public static StringBuilder blah(this StringBuilder sb)
        {
            return sb;
        }
    } 
It successfully adds the `blah` extension method to the `StringBuilder`.

Unfortunately, operator overloading does not seem to work:

    public static class sbExtensions
    {
        public static StringBuilder operator +(this StringBuilder sb, string s)
        {
            return sb.Append(s);
        }
    } 
Among other issues, the keyword `this` is not allowed in this context.

Are adding operator overloads via extension methods possible?  If so, what&#39;s the proper way to go about it?

Operator Overloading with C# Extension Methods

I came across an issue that makes me think there is bug in the 3.0 framework. When I try to use extension methods I get the following error: 

    Missing compiler required member
    &#39;System.Runtime.CompilerServices.ExtensionAttribute..ctor&#39;

When using this simple code:
  

    public static class StringUtils {
        static void TestExtension(this String targetString) {
                
        }
    }


The only way to make this compile error go away is to add the following code:

    namespace System.Runtime.CompilerServices {
        public class ExtensionAttribute : Attribute { }
    }

It&#39;s been a few months since I have used extensions methods, but I&#39;m pretty sure I didn&#39;t have to do this. Has anyone else come across this issue?

Error when using extension methods in C#

We&#39;re all familiar with the horror that is C# event declaration.  To ensure thread-safety, [the standard is to write something like this][1]:

    public event EventHandler SomethingHappened;
    protected virtual void OnSomethingHappened(EventArgs e)
    {            
        var handler = SomethingHappened;
        if (handler != null)
            handler(this, e);
    }

Recently in some other question on this board (which I can&#39;t find now), someone pointed out that extension methods could be used nicely in this scenario.  Here&#39;s one way to do it:

    static public class EventExtensions
    {
        static public void RaiseEvent(this EventHandler @event, object sender, EventArgs e)
        {
            var handler = @event;
            if (handler != null)
                handler(sender, e);
        }
        static public void RaiseEvent&lt;T&gt;(this EventHandler&lt;T&gt; @event, object sender, T e)
            where T : EventArgs
        {
            var handler = @event;
            if (handler != null)
                handler(sender, e);
        }
    }

With these extension methods in place, all you need to declare and raise an event is something like this:

    public event EventHandler SomethingHappened;

    void SomeMethod()
    {
        this.SomethingHappened.RaiseEvent(this, EventArgs.Empty);
    }

My question: Is this a good idea?  Are we missing anything by not having the standard On method?  (One thing I notice is that it doesn&#39;t work with events that have explicit add/remove code.)

  [1]: http://blogs.msdn.com/brada/archive/2005/01/14/353132.aspx

Raising C# events with an extension method - is it bad?

Evil or not evil?

    public static void Raise(this EventHandler handler, object sender, EventArgs args)
    {
       if (handler != null)
       {
          handler(sender, args);
       }
    }
    
    // Usage:
    MyButtonClicked.Raise(this, EventArgs.Empty);

    // This works too! Evil?
    EventHandler handler = null;
    handler.Raise(this, EVentArgs.Empty);

Note that due to the nature of extension methods, MyButtonClicked.Raise will not throw a NullReferenceException if MyButtonClicked is null. (E.g. there are no listeners to MyButtonClicked event).

Evil or not?

Content Type	Original Author	Original Content on Stackoverflow
Question	johnc	View Question on Stackoverflow
Solution 1 - .Net	Greg Beech	View Answer on Stackoverflow
Solution 2 - .Net	AnthonyWJones	View Answer on Stackoverflow
Solution 3 - .Net	Haithem KAROUI	View Answer on Stackoverflow

.NET List<T> Concat vs AddRange

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

Solution 2 - .Net

Solution 3 - .Net

Which is the best Linux C/C++ debugger (or front-end to gdb) to help teaching programming?

lsof survival guide

Attributions