Added the Update connection strings for CI
Merge branch 'hotfix-6.0.1'

Conflicts:
	tools/UpdateTestConnectionStrings.ps1
Fix for #1611 - Code First Table Splitting issue when validating a foreign key mapping

Problem: View gen validation logic in FindEntitySetForColumnsMappedToEntityKeys was not accounting for table-splitting. Specifically, it was returning only the first EntitySet matching the supplied columns.
Solution: Have FindEntitySetForColumnsMappedToEntityKeys return all matching EntitySets.

Work Item: 1611
Remember My Name (1751: Unable to cast Anonymous Type from 'System.Linq.IQueryable' to 'System.Data.Entity.Core.Objects.ObjectQuery')

This was a regression from EF5 caused by the fix to 396: Handle closures containing DbSet/DbQuery members. However, this fix wasn't really the problem, it just exposed another existing bug that would previously only manifest in less common cases. This is because the fix for 396 used the type of the IQueryable as the type of the IQueryable, whereas before the type of the expression tree was used. In the common case (anonymous projection with no casting) for this scenario the type of the expression tree was IQueryable while the type of the IQueryable was actually ObjectQuery. Later on we made the assumption that the type would be IQueryable and not ObjectQuery. This was a false assumption as sometimes the expression tree type could also be ObjectQuery (see some tests) and so this would then fail. The fix is to treat ObjectQuery, IQueryable, and IOrderedQueryable the same as far as CQT generation is concerned instead of attempting to introduce an unnecessary cast, which then fails.
Merge branch 'master' of https://git01.codeplex.com/entityframework
1. SetReadOnly is overriden in mapping classes to call SetReadOnly on child mapping items. Also, TrimExcess is called on lists to reduce memory usage.
2. Public API on AssociationSetModificationFunctionMapping and EntityTypeModificationFunctionMapping (I missed these two with the previous checkins)
3. Made DbDatabaseMapping.EntityContainerMappings return an IList instead of ReadOnlyCollection as requested in CodePlex #1422.
Fix for code asserting on debug: ItemCollection.AddInternal has assert that checks if item to be added is read only. The assert failed because in a previous check-in I changed the default constructor of Map to not set the read-only flag in order to be able to call Add/Remove methods on EntityContainerMapping which derives from Map. Added a different Map constructor and using it in EntityContainerMapping without setting the read only flag (this is necessary because Map is also used by ObjectTypeMapping). The read only flag is now set for the container mapping in StorageMappingCollection.AddInternal. Also updated a test that called RemoveEntitType because everything in an ItemCollection is read only.
Revert assembly versions to 6.0.0.0
Work Item: 1753
Update NuGet package URLs
The Underground in November 1970 (765: Consider generalized mechanism for registering services in config file)

DbConfiguration has a Loaded event which is fired when the configuration has been loaded and is just about to be locked. This is very useful for third-party utilities who need to wrap or modify configuration as EF is initializing. However, it is not always easy for third-party code to find a place to run the code that will register the event. This change allows Loaded event handlers to be registered in the app.config or web.config, which is a place that third-party code can easily change, especially if installed by NuGet.
Lazy<T>.Value calls Debugger.NotifyOfCrossThreadDependency which causes the slowdown. The sample model contains about 100 entities with around 30 properties each. During the execution there are close to 1000000 instances of Lazy<T> created only by the usage of MetadataCollection<T>. The least risky fix would be to copy the Lazy<T> implementation, remove the NotifyOfCrossThreadDependency and use instead of the System one. The proposed solution here goes a step forward and removes Lazy<T>, while keeping the lazy intialization of the identity dictionary, thus also reducing the footprint of the in memory model by over 1 MB.
Reverted previous tiny change that sneaked in by mistake.
Your Public Image is Limited (Fix for 997: TypeLoadException thrown for a class nested in an internal class)

This was an issue with proxy creation of nested types. The proxy factory would check the visibility of the class in order to determine whether or not a new class in a different assembly is able to derive from it. Given a nested class like so:

internal class Outer
{
  public class Inner
  {
  }
}

Reflection returned the visibility of Inner as "PublicNested". We were therefore trying to derive from it to create the proxy. But even though Reflection says the class is public for all intents and purpose it is actually internal since it is nested inside an internal class. Therefore we cannot derive from it.

The fix is to correctly detect, despite what Reflection says, that types nested inside non-public types are not, practically speaking, public. We therefore do not attempt to create proxies for them.
CodePlex 1698: The input contains property mappings for an entity type in C space, but only those matching the table name of the current EntityMappingConfiguration are supposed to be configured at that stage (for entity splitting scenarios). The problem was that a table name may not be set or it may be set on the parent EntityTypeConfiguration for all its mapping configurations, in which cases TableName was null, and TableName.Equals threw NullReferrenceException.
HoneyIShrunkThePackage
Removing EntityFramework.PowerShell.dll from the EntityFramework.SqlServerCompact Nuget package
Remember My Name (1751: Unable to cast Anonymous Type from 'System.Linq.IQueryable' to 'System.Data.Entity.Core.Objects.ObjectQuery')

This was a regression from EF5 caused by the fix to 396: Handle closures containing DbSet/DbQuery members. However, this fix wasn't really the problem, it just exposed another existing bug that would previously only manifest in less common cases. This is because the fix for 396 used the type of the IQueryable as the type of the IQueryable, whereas before the type of the expression tree was used. In the common case (anonymous projection with no casting) for this scenario the type of the expression tree was IQueryable while the type of the IQueryable was actually ObjectQuery. Later on we made the assumption that the type would be IQueryable and not ObjectQuery. This was a false assumption as sometimes the expression tree type could also be ObjectQuery (see some tests) and so this would then fail. The fix is to treat ObjectQuery, IQueryable, and IOrderedQueryable the same as far as CQT generation is concerned instead of attempting to introduce an unnecessary cast, which then fails.
DisorderlyConduct - fixing bug https://entityframework.codeplex.com/workitem/1735: Designer: Can not reverse engineer EDMX when FKs in different order than PKs (composite keys)

When validating the model we assumed that the order of primary key columns of the principal entity is the same as the order of the foreign key columns of the dependent entity. This is true for models built using Code First but does not have to be true for database first models where the order of columns is already defined in the database. Fixing validation to look the PK properties up by name based on the values specified in ReferentialConstraint for the prinicpal entity.
Small fix for merge issue bringing changes into 6.0.2.
Version bump to 6.0.2
Lazy<T>.Value calls Debugger.NotifyOfCrossThreadDependency which causes the slowdown. The sample model contains about 100 entities with around 30 properties each. During the execution there are close to 1000000 instances of Lazy<T> created only by the usage of MetadataCollection<T>. The least risky fix would be to copy the Lazy<T> implementation, remove the NotifyOfCrossThreadDependency and use instead of the System one. The proposed solution here goes a step forward and removes Lazy<T>, while keeping the lazy intialization of the identity dictionary, thus also reducing the footprint of the in memory model by over 1 MB.

Conflicts:
	src/EntityFramework/Core/Metadata/Edm/MetadataCollection.cs