Found answer on [MSDN][1]: Yes.

&gt;The `IGrouping&lt;TKey, TElement&gt;` objects are yielded in an order based on the order of the elements in source that produced the first key of each `IGrouping&lt;TKey, TElement&gt;`. Elements in a grouping are yielded **in the order they appear in source**.


  [1]: http://msdn.microsoft.com/en-us/library/bb534304.aspx

What algorithm is the built in `sort()` method in Python using? Is it possible to have a look at the code for that method?

About Python&#39;s built in sort() method

I&#39;ve gotten quite interested in coding katas in recent months. I believe they are a great way to hone my programming skills and improve the quality of the code I write on the job.

There are numerous places where Katas can be found. like..

http://codekata.pragprog.com/

http://schuchert.wikispaces.com/Katas

http://www.codingdojo.org/

I&#39;ve found these to be excellent repositories of Katas... my attempts at some of them have been been immensely rewarding.

However, I feel that all the Kata&#39;s I&#39;ve seen so far have one short coming. None of them seem to allow me to practice refactoring bad code. It&#39;s great learning how to write clean code the first time around...but in my current job, I don&#39;t have too many opportunities to write new code. Rather I&#39;m often battling against legacy code and trying to figure out how to refactor modules, eliminate dependencies, and reduce coupling.

As such, I&#39;m on the look out for a couple Katas that I can use to hone my skills of refactoring legacy code and turning it into clean code.

Does anyone know of any that already exist? I know I get a lot of practice at it while I&#39;m at work...but I&#39;d like to hone my skills to the point where I&#39;m able to quickly see how to break apart dependencies and separate concerns in classes that do far too much.

Coding Katas for practicing the refactoring of legacy code

Does Enumerable.GroupBy from LINQ to Objects preserve order of elements in the groups?

Linq to Objects: does GroupBy preserve order of elements?

<p>Does Enumerable.GroupBy from LINQ to Objects preserve order of elements in the groups?</p>


I know sometimes innerException is null

So the following might fail:

     repEvent.InnerException = ex.InnerException.Message; 

Is there a quick ternary way to check if innerException is null or not?

Best way to check for inner exception?

I would like to gather as much information as possible regarding API versioning in .NET/CLR, and specifically how API changes do or do not break client applications. First, let&#39;s define some terms:

__API change__ - a change in the publicly visible definition of a type, including any of its public members. This includes changing type and member names, changing base type of a type, adding/removing interfaces from list of implemented interfaces of a type, adding/removing members (including overloads), changing member visibility, renaming method and type parameters, adding default values for method parameters, adding/removing attributes on types and members, and adding/removing generic type parameters on types and members (did I miss anything?). This does not include any changes in member bodies, or any changes to private members (i.e. we do not take into account Reflection).

__Binary-level break__ - an API change that results in client assemblies compiled against older version of the API potentially not loading with the new version. Example: changing method signature, even if it allows to be called in the same way as before (ie: void to return type / parameter default values overloads).

__Source-level break__ - an API change that results in existing code written to compile against older version of the API potentially not compiling with the new version. Already compiled client assemblies work as before, however. Example: adding a new overload that can result in ambiguity in method calls that were unambiguous previous.

__Source-level quiet semantics change__ - an API change that results in existing code written to compile against older version of the API quietly change its semantics, e.g. by calling a different method. The code should however continue to compile with no warnings/errors, and previously compiled assemblies should work as before. Example: implementing a new interface on an existing class that results in a different overload being chosen during overload resolution.

The ultimate goal is to catalogize as many breaking and quiet semantics API changes as possible, and describe exact effect of breakage, and which languages are and are not affected by it. To expand on the latter: while some changes affect all languages universally (e.g. adding a new member to an interface will break implementations of that interface in any language), some require very specific language semantics to enter into play to get a break. This most typically involves method overloading, and, in general, anything having to do with implicit type conversions. There doesn&#39;t seem to be any way to define the &quot;least common denominator&quot; here even for CLS-conformant languages (i.e. those conforming at least to rules of &quot;CLS consumer&quot; as defined in CLI spec) - though I&#39;ll appreciate if someone corrects me as being wrong here - so this will have to go language by language. Those of most interest are naturally the ones that come with .NET out of the box: C#, VB and F#; but others, such as IronPython, IronRuby, Delphi Prism etc are also relevant. The more of a corner case it is, the more interesting it will be - things like removing members are pretty self-evident, but subtle interactions between e.g. method overloading, optional/default parameters, lambda type inference, and conversion operators can be very surprising at times.

A few examples to kickstart this:

Adding new method overloads
---
Kind: source-level break

Languages affected: C#, VB, F#

API before change:

    public class Foo
    {
        public void Bar(IEnumerable x);
    }

API after change:

    public class Foo
    {
        public void Bar(IEnumerable x);
        public void Bar(ICloneable x);
    }

Sample client code working before change and broken after it:

    new Foo().Bar(new int[0]);

Adding new implicit conversion operator overloads
---
Kind: source-level break.

Languages affected: C#, VB

Languages not affected: F#

API before change:

    public class Foo
    {
        public static implicit operator int ();
    }

API after change:


    public class Foo
    {
        public static implicit operator int ();
        public static implicit operator float ();
    }

Sample client code working before change and broken after it:

    void Bar(int x);
    void Bar(float x);
    Bar(new Foo());
    
Notes: F# is not broken, because it does not have any language level support for overloaded operators, neither explicit nor implicit - both have to be called directly as `op_Explicit` and `op_Implicit` methods.

Adding new instance methods
---

Kind: source-level quiet semantics change.

Languages affected: C#, VB

Languages not affected: F#

API before change:

    public class Foo
    {
    }

API after change:

    public class Foo
    {
        public void Bar();
    }

Sample client code that suffers a quiet semantics change:

    public static class FooExtensions
    {
        public void Bar(this Foo foo);
    }

    new Foo().Bar();
    
Notes: F# is not broken, because it does not have language level support for `ExtensionMethodAttribute`, and requires CLS extension methods to be called as static methods. 

A definitive guide to API-breaking changes in .NET

Is it definitely a good practice to use it? 

What are some possible situations in a project that need reflection?

Why is the use of reflection in .NET recommended?

Is it possible to generate short GUID like in YouTube (N7Et6c9nL9w)? 

How can it be done? I want to use it in web app.

YouTube-like GUID

How can I set the `InnerException` property of an `Exception` object, while I&#39;m in the constructor of that object? This boils down to finding and setting the backing field of a property that has no setter.

BTW: I have seen this [evain.net - Getting the field backing a property using Reflection](http://evain.net/blog/articles/2009/05/01/getting-the-field-backing-a-property-using-reflection) but looking for non IL-based solution, if possible.

The constructor of `Exception` is the place where the `Exception` type is created, so I cannot call it using the base class constructor `MyException() :base(...)` etc.

How to set the InnerException of custom Exception class from its constructor

Say I have:

    IList&lt;Person&gt; people = new List&lt;Person&gt;();

And the person object has properties like FirstName, LastName, and Gender.

How can I convert this to a list of properties of the Person object.  For example, to a list of first names.

    IList&lt;string&gt; firstNames = ???

C#: How to convert a list of objects to a list of a single property of that object?

The fact that it is a LINQ result might perhaps not be relevant for the question, but I&#39;m mentioning it anyway - since this is the context which has resulted in this question. 

I run a LINQ query. The result is an; 

    IEnumerable&lt;MyClass&gt; 

I want to put the result into an ObservableCollection; 

    ObservableCollection&lt;MyClass&gt; 

How do I do this cast? (without running through the IEnumerable and copying elements to the ObservableCollection). I notice LINQ has got a few To..() functions, but it doesn&#39;t seem to help me for this cast..? 

Cast LINQ result to ObservableCollection

Just a little niggle about LINQ syntax. I&#39;m flattening an `IEnumerable&lt;IEnumerable&lt;T&gt;&gt;` with `SelectMany(x =&gt; x)`.

My problem is with the lambda expression `x =&gt; x`. It looks a bit ugly. Is there some static &#39;identity function&#39; object that I can use instead of `x =&gt; x`? Something like `SelectMany(IdentityFunction)`?


LINQ identity function

I am having two date values, one already stored in the database and the other selected by the user using DatePicker. The use case is to search for a particular date from the database.

The value previously entered in the database always has time component of 12:00:00, where as the date entered from picker has different time component. 

I am interested in only the date components and would like to ignore the time component. 

What are the ways to do this comparison in C#?

Also, how to do this in LINQ?

UPDATE:
On LINQ to Entities, the following works fine.

    e =&gt; DateTime.Compare(e.FirstDate.Value, SecondDate) &gt;= 0

How to compare only date components from DateTime in EF?

I am often comparing data in tables in different databases.  These databases do **not** have the same schema.  In TSQL, I can reference them with the  `DB&gt;user&gt;table` structure (`DB1.dbo.Stores`, `DB2.dbo.OtherPlaces`) to pull the data for comparison.  I like the idea of LINQPad quite a bit, but I just can&#39;t seem to easily pull data from two different data contexts within the same set of statements.

I&#39;ve seen people suggest simply changing the connection string to pull the data from the other source into the current schema but, as I mentioned, this will not do.  Did I just skip a page in the FAQ?  This seems a fairly routine procedure to be unavailable to me.

In the &quot;easy&quot; world, I&#39;d love to be able to simply reference the typed datacontext that LINQPad creates.  Then I could simply:

```csharp
DB1DataContext db1 = new DB1DataContext();
```

```csharp
DB2DataContext db2 = new DB2DataContext();
```

And work from there.

LINQPad, using multiple datacontexts

I want to list all sales, and group the sum by day.

    Sales (saleID INT, amount INT, created DATETIME)

NOTE: I am using SQL Server 2005.


SQL query to group by day

Oracle&#39;s table server offers a built-in function, `TRUNC(timestamp,&#39;DY&#39;)`. This function converts any timestamp to midnight on the previous Sunday. What&#39;s the best way to do this in MySQL?

Oracle also offers `TRUNC(timestamp,&#39;MM&#39;)` to convert a timestamp to midnight on the first day of the month in which it occurs. In MySQL, this one is straightforward:

    TIMESTAMP(DATE_FORMAT(timestamp, &#39;%Y-%m-01&#39;))

But this `DATE_FORMAT` trick won&#39;t work for weeks. I&#39;m aware of the `WEEK(timestamp)` function, but I really don&#39;t want week number within the year; this stuff is for multiyear work.


How to group by week in MySQL?

Is it possible to `GROUP BY` more than one column in a MySQL `SELECT` query? For example:  

    GROUP BY fV.tier_id AND &#39;f.form_template_id&#39;

Is it possible to GROUP BY multiple columns using MySQL?

What is the correction needed for **example 2** inorder to group by multiple columns

**Example 1**

    var query = from cm in cust
                group cm by new { cm.Customer, cm.OrderDate } into cms
                select
                new 
                { Key1 = cms.Key.Customer,Key2=cms.Key.OrderDate,Count=cms.Count() };

**Example 2 (incorrect)**

       var qry = 
       cust.GroupBy(p =&gt; p.Customer, q =&gt; q.OrderDate, (k1, k2, group) =&gt;
       new { Key1 = k1, Key2 = k2, Count = group.Count() });
            


LINQ Group By Multiple fields -Syntax help

how do I write this query in linq (vb.net)?

    
     select B.Name
     from Company B
     group by B.Name
     having COUNT(1) &gt; 1

Content Type	Original Author	Original Content on Stackoverflow
Question	Konstantin Spirin	View Question on Stackoverflow
Solution 1 - .Net	Konstantin Spirin	View Answer on Stackoverflow

Linq to Objects: does GroupBy preserve order of elements?

.Net Problem Overview

.Net Solutions

Solution 1 - .Net

Coding Katas for practicing the refactoring of legacy code

About Python's built in sort() method

Attributions