This is the final significant update to LINQPad 6.

New Features

• LINQPad's handling of .txt, .json, .xml and .sql files has improved. These file types now show in the My Queries tree, and are enabled for syntax highlighting and outlining. Auto-formatting also now works for .json and .xml files, and can be triggered either via Ctrl+E,Ctrl+D or the new toolbar button.
• There's a new option in the EF Core connection dialog to ignore column default values when inserting rows.
• LINQPad's setup and automatic updater now populates the version for the benefit of Windows Add/Remove programs and winget.
• You can now consume NuGet packages with "net5.0-windows" targets.
• LINQPad's Dump pipeline now recognizes JsonNode objects.
• Tables created by SQL Server when a merge conflict occurs during replication are now recognized by LINQPad as system tables.
• You can now permanently suppress the "// You can include other methods and classes" comment when switching to C# Program mode, via a smart-tag.
• When dumping images, you can now specify a size for the image as follows:

  // Assuming myBitmap is a System.Drawing.Image:
  myBitmap.Dump (Util.ScaleMode.ResizeTo (100, 100));    // Scale to 100x100 on browser

  You can specify just the width or height if you want to preserve the aspect ratio. You can also use ScaleMode when calling Util.Image:

  Util.Image ("http://www.linqpad.net/images/LINQPad.png", Util.ScaleMode.ResizeTo (100, 100)).Dump();

  Specifying Util.ScaleMode.Unscaled attempts to bypass local DPI settings and render the image pixel-to-pixel.
• For methods and constructors that are overloaded, overloads marked with [EditorBrowsable (EditorBrowsableState.Never)] now show in gray in parameter completion listings.

Bug Fixes

• The Generate Method code fix now works in Statements mode.
• A bug in the autocompletion listing when accessing an indexer that follows an invocation has been fixed.
• When selecting members for an object initializer, choosing * no longer duplicates members.
• A bug in LINQPad's HTML controls where text could be wrongly escaped has been fixed.
• A memory leak when updating complex content inside DumpContainers has been fixed.
• An error when expanding LINQ-to-SQL connections with multiple databases containing table-valued stored procedure parameters has been fixed.

New Features: IL translation tab

• The contents of the IL tab now update as you type.
• Decompilation to C# 1.0 now appears alongside the IL. This is useful in seeing how the compiler implements modern C# features at a high level. And by hoving or clicking on the code, you can see the corresponding IL instructions.
• X64/X86 native disassembly is also now displayed. This synchronizes with the IL when you hover or click, and refreshes immediately when you toggle the Optimize button on the toolbar or change the target framework.

Other New Features

• LINQPad now supports F# 5.
• LINQPad's built-in ILSpy has been updated to V7.1.
• LINQPad's Control class now has a CssClass property, and a new static UnhandledException event which fires when an event handler throws an unhandled exception.

Bug Fixes

• LINQPad's debugger now properly handles value-typed constant fields.
• LINQPad's editor outlining now works consistently in C# Statements mode.
• Execution times are now displayed for asynchronous queries that fault.
• When an asynchronous sequence is cancelled, it now shows as faulted.
• Table headers in IObservables and IAsyncEnumerables now appear again when dumped.

New Features

• There's now a dedicated LINQPad Help button on the main menu to search the LINQPad Tutorial and Reference.
• (Experimental) LINQPad can now use Edge's Chromium engine to render results. To enable, go to Edit | Preferences > Results. Benefits include sticky table headers, correct double/triple click behavior, and the ability to emit custom HTML and JavaScript that leverages the latest standards. Note that to use the Chromium engine, you must either have a relatively recent version of Edge installed, or install the WebView2 runtime.
• (Experimental) LINQPad 6 now lets you target the .NET 6 preview. (Full support for .NET 6 RTM will ship in LINQPad 7.)
• Live execution tracking is back! LINQPad now tracks asynchronous operations and worker threads, as well as the main thread. You can enable/disable live execution tracking via an option on the Query menu. Pressing Shift+Ctrl+J jumps to the currently executing code. Click the Ctrl+F1 Help button and type 'execution tracking' to see demos.
• LINQPad's Util.Compile method now performs better when a compilation is cached and Run is called concurrently. It also now faults anystanding tasks when disposed.
• The code editor's split button above the vertical scrollbar is now larger and better rendered.
• You can now view all queries in the Navigate To dialog (Ctrl+,), by clearing the search box.
• By setting the LINQPAD_LOCALAPPDATA and LINQPAD_TEMP environment variables, you can now override the %LocalAppData% and %Temp% folders that LINQPad uses for compiling queries and executing updates. This can be useful if Windows group policy prevents applications or assemblies from loading from the %LocalAppData% or %Temp% folders.
• There's a new sample on how to use Bing Maps with HTML. Click the Ctrl+F1 Help button and type 'maps' to see a sample.

New Features - Database Querying

• LINQPad's EF Core driver now supports EF Core 5 with Oracle, PostgreSQL and MySQL, and the EF Core 6 preview with SQL Server and SQLite.
• The EF Core driver for Oracle now lets you map NUMBER(1) to Int32 instead of bool, via a new checkbox on the connection dialog.
• The EF Core driver for MySQL now supports the JSON data type.
• The EF Core driver for SQLite now lets you map DateTime and bool types via new checkboxes on the connection dialog.

Bug Fixes

• An obscure bug that could prevent you from querying a linked SQL Server with a lower feature set than the main server has been fixed.
• When a custom EF Core assembly file is locked, LINQPad now avoids generating IOException errors except when a query is run, or a schema is expanded.
• A memory leak that could occur when nesting DumpContainers has been fixed.
• The LINQ-to-SQL driver now correctly maps columns whose names contain square brackets.
• When connecting to custom Pomelo.MySQL 3.x data contexts, a "cannot locate type" error that would sometimes appear has been fixed.
• You can now reference NuGet packages and assemblies whose filenames end in .resources, whether or not they are satellite assemblies.
• Moving the instruction pointer when debugging is now more reliable.

New Features

• (Experimental) To help you share code between Visual Studio and LINQPad, you can now #load .cs files (as well as .linq files):

  #load "c:\source\MyLib\Utils\LinqExtensions.cs"
  

  Relative paths are also supported:

  #load "..\..\source\shared\*.cs"
  

  You can even use a wildcard:

  #load "c:\source\MyLib\Utils\*.cs"
  

  LINQPad can handle a maximum of 250 .cs files. Subject to this, you can also walk subdirectories:

  #load "c:\source\MyLib\Utils\*.cs /s"
  

  The "Navigate to Definition" (F12) feature works with .cs file references, and will locate and open the .cs file in LINQPad for editing.
• You can now open .txt, .json and .csv files in LINQPad's editor, as well as .cs, .xml and .config files.
• The Navigate to Query dialog (Ctrl+,) now includes a clickable Last Modified column.
• A query can now include module attributes (as well as assembly attributes).
• You can now specify an encoding when calling Util.Cmd.
• The editor now performs symbol matching for return, break and continue.
• You can now call LINQPad6.exe with arguments to instruct LINQPad to open and run a query with results expanded and the code editor hidden:

  LINQPad6.exe myQuery.linq -run -hideeditor

• LINQPad's EF Core driver now supports MySQL for EF Core 5.
• You can now call Util.Run on a query that returns anonymous types to the caller, and the anonymous types will be serialized as ExpandoObjects.

Fixes

• The integrated debugger now correctly handles equality comparisons with reference types.
• C#'s code-fix providers now work in C# Statements mode.
• The closing brace works correctly again with Italian keyboards.
• A race when dumping Task<Task<T>> has been fixed.
• LINQPad now correctly recognizes 'await using' statements in statements-based queries.
• The editor no longer adds spaces to blank lines when indenting a block.
• A potential deadlock in Util.Run, which could cause it to hang, has been fixed.

New Features - C# 9 and .NET 5

• Support for C# 9 is now built-in and feature-complete, and no longer requires the 'Language Preview' option. For a demonstration of what's new in C# 9, go to the Samples TreeView.
• Your queries can now target the release and RC versions of .NET 5, as well as .NET Core 3.1 and 3.0 (via the dropdown the toolbar). You can specify a default in Edit | Preferences > Query. Note that while C# 9 is designed for .NET 5, LINQPad will also allow you to use almost all C# 9's features (including records) under .NET Core 3.1 and .NET Core 3.0.
• Your queries can now define classes and namespaces in 'C# Statements' mode (as well as 'C# Program' mode). Note that in Statements mode, classes and namespace definitions cannot appear before top-level statements (as required by the C# language).
• You can also now add 'using' directives directly to the top of your scripts to import namespaces, as an alternative to using the Properties dialog. This works in both statements and program mode.

New Features - General

• There are two new options on the connection treeview's context menu: Collapse all but this and Re-authenticate. The latter clears the cached token when interactive multi-factor authentication is selected.
• There are now shortcuts for Add Connection (Alt+Shift+N) and Reset editor font size (Alt+Scrollwheel).
• When you dump 2D arrays with non-simple element types, LINQPad now renders each element recursively rather than calling ToString() on the elements.
• LINQPad now warns you when you reference an assembly in a folder with multiple .deps.json files, unless there's a .deps.json for that assembly.
• LINQPad now requires a minimum of .NET Core 3.1 to start up. However, your queries can still target .NET Core 3.0 (via the dropdown on the toolbar) as well as .NET Core 3.1 and .NET 5.

Fixes

• Data grids with 3-state checkboxes now export correctly to Excel with "True" and "False".
• A partially installed 3.0 version of .NET Core will no longer upset data context generation.
• A bug that could cause the Oracle driver to crash with oddly-named columns (such as '|1') has been fixed.
• A bug that could cause licensing activations to be lost on Azure virtual machines after shutdown has been fixed.
• A race condition in the NuGet parallel dependency resolver that could occur when multiple package sources report different latest package versions has been fixed.

What's New - General

• LINQPad 6 now supports .NET 5 release-candidates. You can also now choose what runtime to use per-query via new dropdown in the toolbar, as well as setting a default in Edit | Preferences > Query.
• The "Roslyn Daily" download is no longer required to enable C# 9 preview features. Just go to Edit | Preferences > Query and tick the Enable C# 9 Preview checkbox.
• LINQPad now includes a built-in method to perform Active Directory interactive and MFA authentication under .NET Core, so that you can script Azure management tasks without storing passwords or access tokens:

  string tenantID = "(your Azure tenant ID)";
  
  string token = Util.ActiveDirectory.AcquireTokenAsync (
      $"https://login.microsoftonline.com/{tenantID}",
      "https://management.core.windows.net/",
      "user@domain.com").Result.AccessToken;
  

  This returns an access token which can then be used with the Microsoft.Azure.Management.Fluent NuGet package to script Azure management tasks:

  var tokenCredentials = new TokenCredentials (token);
  var azureCredentials = new AzureCredentials (tokenCredentials, tokenCredentials, tenantID,
                                               AzureEnvironment.AzureGlobalCloud);
  	
  RestClient client = RestClient.Configure()
                                .WithEnvironment (AzureEnvironment.AzureGlobalCloud)
                                .WithCredentials (azureCredentials)
                                .Build();
  
  string subscriptionID = "(your Azure subscription ID)";
  IAzure managementAPI = Azure.Authenticate (client, tenantID).WithSubscription (subscriptionID);
  

  Access tokens are cached within the LINQPad host process, so you should never have to re-authenticate (unless you restart LINQPad). Click here for a complete example, demonstrating how to use this API to configure an Azure firewall.
• Customizations to the results style sheet can now be portablized.
• There's a new hotkey Alt+Shift+Y to toggle the enabling of 'My Extensions' for a query.
• LINQPad can now dump objects with exception-throwing type or property attributes.
• LINQPad now ships with ILSpy 6.1.
• Pointer-type fields or properties are now automatically dereferenced when dumping.
• A bug in Util.Dif with extra list elements not highlighting has been fixed.
• The hotkeys for Copy/plain and Copy/markdown down work reliably.

What's New - Database Querying

• Stored Procedures with table-type parameters are now supported by LINQPad's default LINQ-to-SQL driver.
• You can now update temporal tables in SQL Server and SQL Azure.
• LINQPad now supports Azure Synapse Analytics databases (including the recent preview).
• The Oracle EF Core driver now filters non-user-generated columns, and can use the latest Oracle provider beta.
• You can now enable SQL-translation logging in EF Core DbContexts that you explicitly instantiate by calling the extension method EnableLINQPadLogging.

What's New - General:

• You can now play with the very latest features planned for C# 9! Go to Edit | Preferences > Query and enable the Roslyn Daily Build. You don't need to install anything - not even .NET 5 - and you'll see features that aren't even showing in the Visual Studio 2019 Preview. Samples for what's new in C# 9 will appear automatically after you re-start.
• (Experimental) LINQPad can now use the .NET 5 preview runtime to execute queries. To enable this feature, go to Edit | Preferences > Query. Enabling the .NET 5 runtime also lets you consume NuGet packages built specifically for .NET 5.
• You can now add xunit test support to your query via new option on the Query menu. This adds the required references, a runner, and a sample test method to get you started. There's also a option on the Query menu Alt+Shift+T to execute all tests.
• LINQPad includes a new API to fluently access private members of any object or type. The simplest way to invoke it via the Uncapsulate() extension method:

  new StringBuilder().Uncapsulate().m_ChunkChars.Dump();

  Interfaces, static members and object construction is also supported. Click here to jump to the built-in interactive samples.
• When using SQL Azure with Universal/MFA Authentication, you can now specify an Active Directory Domain / Tenant ID, via a new textbox, to override the domain specified in the username. This allows Universal Authentication to work with guest logins - and logins imported from another domain such as outlook.com or gmail.com. LINQPad's Universal/MFA Authentication also now supports other public clouds, including those for Germany, China and the US military.
• You can now define up to 9 additional entry points in a program, named Main1(), Main2(), ... Main9(). To invoke them, press Alt+Shift+1 through Alt+Shift+9.

Editor and Autocompletion:

• You can now shelve unsaved changes when exiting LINQPad, either with the Shelve button or by exiting with Ctrl+Alt+F4. There's also a checkbox in Edit | Preferences to make this the default. When LINQPad restores your queries, it also restores the Undo/Redo buffer, so you can review the changes you made in your last session with Ctrl+Z and Ctrl+Y.
• The editor supports a new outlining action: Toggle Top-Level Outlining Ctrl+M,comma. This is a great way to collapse/expand just classes and regions without affecting other constructs. There's also now a new Collapse to Definitions action Ctrl+M,O which matches the behavior of Visual Studio.
• The editor's Navigate Back feature Ctrl+Minus is now robust to text changes.
• Autocompletion listings inside object initializers now include a * option to select all members.
• Autocompletion tips on extension methods now include markup for the receiver.
• Parameter autocompletion now provides listings when calling base() and this() from the constructor.
• There's a new option on the File menu to revert a query to its saved version.

Dumping and Output:

• You can now dump IAsyncEnumerables to data grids.
• The Dump extension method has a new includePrivate optional parameter, wiich includes private/protected/internal properties and fields in the output.
• You can now use Util.Highlight and Util.HighlightIf to highlight entire rows. For example:

  from file in new DirectoryInfo (Util.LINQPadFolder).GetFiles()
  select Util.HighlightIf (
      file.Extension == ".exe",    // Highlight the entire row if the file is an executable.
      new
      {
          file.Name,
          file.Length,
          file.LastWriteTime
      })

• DumpContainer has two new methods: AppendContent and ClearContent. AppendContent adds additional material to a DumpContainer and has an efficient internal implementation that avoids re-rendering existing data.
• LPRun and Util.Cmd now always use UTF-8 text encoding instead of the Windows default.

EF Core:

• (Experimental) LINQPad now supports the EF Core 5.x previews for SQL Server and SQLite. To enable, click the Version dropdown box in the connection dialog and choose the 5.x option. Note that right now, EF Core 5.x can run on both .NET Core 3.1 and .NET 5 - you don't have to install the .NET 5 preview.
• LINQPad's database driver for EF Core now supports SQL Server's spatial types. To enable, tick the checkbox on the connection properties dialog.
• Oracle: You can now choose Oracle's new EF Core 3 provider beta when creating EF Core connections. Among other benefits, the new provider supports querying tables without a primary key. To enable it, click the Version dropdown box in the connection dialog and choose "3.19 beta".

Bug Fixes:

• ILSpy integration now works when pressing F12 on a member of an constructed generic type.
• An assembly resolution bug when using ASP.NET assemblies has been fixed.
• Obscure bugs in the SQL batch parser and XML parser have been fixed.
• The debugger's Watch window now correctly handles implicit primitive conversions.

New features

• LINQPad's NuGet download engine has been rewritten for better performance and compliance with the latest versioning rules. Dependency graphs now resolve in parallel, and when multiple sources are enabled, package restoration can still succeed if some sources are unavailable.
• You can now dump WPF/WinForms controls from worker threads (or after awaiting), without first needing to call Util.CreateSynchronizationContext.
• The LPRun command-line utility now works with SQL-type queries. It also now sets the errorlevel when an exception is thrown, and writes the exception to stderr instead of stdout.
• C# Attributes are now syntax-highlighted when resolved.
• An assembly resolution bug when working with ASP.NET assemblies has been fixed.
• You can now query EF Core 5 (preview) contexts that you create in Visual Studio (tested up to preview 3).

New features

• (Developer/Premium edition users): You can now directly edit SQL table data in DataGrid mode with connections that use the EF Core driver. This means that the feature now works with MySQL, Oracle, Postgres and SQLite - as well as SQL Server.
• There's a new Util.WithHeading method to let you dump non-toplevel objects with headings.
• The SelectedIndexes and SelectedOptions properties of LINQPad's SelectBox HTML control are now writable.
• LINQPad 6's EF Core drivers now use EF Core 3.1.2.
• A StringBuilder fragmentation issue that can lead to poor editor performance after a long series of edits has been fixed.
• LINQPad now lets you search for prerelease packages in custom ProGet feeds.

New features

• LINQPad 6's EF Core drivers now use EF Core 3.1.
• You can now inject styles and JavaScript functions into the output via the following new methods:

  Util.HtmlHead.AddStyles (string css)             // Adds custom CSS
  Util.HtmlHead.AddCssLink (string uri)            // Adds custom CSS from a URI
  Util.HtmlHead.AddScript (string javaScript)      // Adds a <script> containing JavaScript functions
  Util.HtmlHead.AddScriptFromUri (string uri)      // Adds a <script> from a URI
  

  These methods append to the <head> rather than the <body> (unlike when you dump a Util.RawHtml). For example:

  Util.HtmlHead.AddStyles ("body, p, pre { font-family: Consolas }");     // Use fixed-pitch font throughout
  Util.HtmlHead.AddScript ("function foo(x) { alert(x) }");               // Define a function
  

  The Util.InvokeScript method calls a JavaScript function:

  Util.InvokeScript (false, "foo", "test");
  

  You can also call JavaScript functions from the LINQPad Controls API, and use the Literal control as a low-level means of injecting any HTML into the header:

  new LINQPad.Controls.Literal ("script", "function foo(x) { alert(x) }").DumpToHtmlHead();
  

  The AddScriptFromUri method can be used to install JQuery:

  Util.HtmlHead.AddScriptFromUri ("https://code.jquery.com/jquery-3.4.1.min.js");
  

  To help with debugging, you can write to LINQPad's output window from a script as follows:

  external.log('message')

• Query tabs now have a tooltip indicating the folder where they reside.
• When using Entity Framework to automatically build a data context, the built-in scaffolder is now better at handling foreign key data types that are inconsistent with the primary key.

Bug Fixes

• Automatic async detection has been improved with statements-based queries.
• When dumping objects with reimplemented interface members, the interface that you cast to is now honored.
• Hyperlinqs in data grid mode now work with files whose name contains spaces.
• When using the #load directive, autocompletion entries now always omit the optional .linq extension.
• A bug which would sometimes cause the 'Add Namespace' and 'Implement Interface' code fixes to fail has been fixed.
• The 'Open in SSMS' feature is now more robust and works with the latest SSMS versions.

This release supports the .NET Core 3.1 RTM runtime. Other new features:

• LINQPad 6 now works with the Office Interop COM libraries. Just press F4 and click Add Office Interop - this will add the necessary references and namespace imports. You can reference other COM interop libraries via NuGet packages.
• You can now dump Span and ReadOnlySpan instances.
• Util.ReadLineAsync now supports cancellation tokens.
• You can now collapse C# looping and if/else constructs.
• You can now use [DllImport] on transitively loaded native dependencies.

New features:

• You can now add '#LINQPad admin' to the top of your scripts to run code with administrative elevation
• LINQPad 6 is now compatible with Serilog and Microsoft.Extensions.DependencyModel
• LINQPad 6 now uses the FSharp.Compiler.Service V32
• The debugger now supports rectangular arrays
• You can now download unlisted NuGet packages, by using 'ID=' to search by ID
• The EF Core driver now allows the querying (but not updating) of tables with computed primary key columns

Bug fixes:

• SQL Aliases are now supported, as in LINQPad 5
• The MySQL driver now correctly maps tinyint(1) to bool, and the SQLite driver is more robust in processing relationships
• Assembly references now have their relative paths correctly encoded
• A bug in the LINQ-to-SQL driver that could result in duplicate property names has been fixed
• Auto-format and same-symbol lookup is now more robust
• EF Core connections that rely on an appsettings.json file now work correctly
• LPRun error reporting has been improved, and it now works with the PowerAssert library
• The NuGet package manager now correctly passes credentials to ProGet servers
• A bug preventing the downloading of sample query libraries has been fixed
• The editor is now better at handling surrogate-pair Unicode characters
• You can now execute SQL queries over SQL CE connections
• Util.HorizontalRun now properly resets the layout for subsequent content

New features:

• Your queries can now optionally target .NET Core 3.1 preview. To enable, go to Edit | Preferences > Query.
• You can now enable nullable reference types by default for C# queries in Edit | Preferences > Query.
• Alt+Backspace now maps to Undo.
• LINQPad now special-cases System.Reactive to work around its strange NuGet package structure.
• LINQPad now automatically adds the 'unsafe' modifier to C# statements-based queries.

Bug fixes:

• The alphabetical column ordering option, when dumping to Data Grids, now works properly.
• Association properties on 1:1 relationships in LINQ-to-SQL data contexts, when queried, now generate an outer rather than an inner join.
• Queries now compile correctly with all imported namespaces removed.
• Error reporting in the NuGet package manager has been improved.
• The EF Core dynamic driver for SQL Server can now handle the Sql_Variant type.

• You can now include namespace declarations in queries of type 'C# Program', so you can paste entire .cs files from Visual Studio into LINQPad.
• LINQPad's editor now supports bookmarks, to help with navigating around large documents. The shortcut keys are the same as the defaults in Visual Studio, and ReSharper's ergonomic shortcut keys are also supported (Shift+Ctrl+1 through Shift+Ctrl+9 to set a numbered bookmark, and Ctrl+1 through Ctrl+9 to jump to a numbered bookmark).
• You can now add references to other .linq files, via the new #load directive.
• You can now connect to Oracle, MySQL, SQLite and PostgreSQL databases via a new built-in driver that leverages Entity Framework Core. The new driver generates data contexts with table and property names similar to the built-in LINQ-to-SQL driver (as well as LINQPad 5's IQ driver), so that queries can be easily ported. It also supports SQL Server, so for SQL Server you can now choose between LINQ-to-SQL and Entity Framework Core.
• The default namespace imports for each query can now be viewed and edited. This can be useful in avoiding conflicts with other APIs.
• The extensibility model for writing custom data context drivers has been updated for LINQPad 6. Creating a project is now as simple as running a LINQPad script, and publishing it is as simple as publishing a NuGet package.
• When executing a selection in 'C# Program' mode, the selected text can now call other methods in the query.
• The 'Go to definition' shortcut (F12) now works for symbols defined in My Extensions (as well as #load-ed queries).
• The command-line runner and Util.Run are now available in LINQPad 6. The command-line runners are called LPRun6 (64-bit) and LPRun6-x86 (32-bit).
• Charting is back, as is the Roslyn syntax tree visualizer. And Roslyn Quoter is now integrated! To activate, either right-click from the editor, or click the new button on the syntax tree visualizer.
• Outlining now works in statements mode, too, if you have #regions or methods defined.
• If you hold down the control key anywhere in the editor, it will display the quick-info tooltip, as well as any errors or warnings on that line.
• If you type /// before a member, LINQPad will now expand it into a simple (one-line) XML summary. These summaries are picked up from #load-ed queries, as well as My Extensions.
• The back-end for the NuGet Package Manager has been re-written to be faster and more reliable. It now works directly from the local user cache, and recognizes reference assemblies and native dependencies in line with .NET Core protocols. When restoring packages, LINQPad 6 searches all enabled package sources.
• Queries now automatically re-load when the file is changed externally.
• When calling file-based methods such as File.Open, the editor now offers autocompletion on the file path.
• There are new options available when calling Dump - to suppress column totals, control repeating headers, and specify a depth at which to initially collapse the results.
• When compiling your queries, LINQPad 6 preferences reference assemblies over runtime assemblies. If the reference assemblies for the current .NET Core runtime version have not been installed, LINQPad will offer to download the appropriate NuGet package.
• LINQPad 6 supports soft cancellation. By monitoring this.QueryCancelToken, your query can respond to the Cancel button, and elect to end early without the underlying process being killed.
• You can now connect to SQL CE databases without installing SQL CE. LINQPad will automatically download the NuGet package as required.
• There's now a checkbox in the Query Properties dialog to include references to ASP.NET Core assemblies.
• You can now rename a query tab (without saving it) by pressing Shift+F2, or via the option on the query tab's context menu.

Things that behave differently in LINQPad 6

• When you referenced an .NET Framework assembly in LINQPad 5, any dependencies located in the same folder would automatically load. To support .NET Core and .NET Standard assemblies built by Visual Studio, LINQPad 6 goes further and parses the .deps.json file, automatically resolving all of the assembly's NuGet dependencies, combining them into a compatible set (along with any other NuGet packages that your query has referenced). Any packages that are missing for the current .NET Core version or architecture are automatically restored.
• There are no options for specifying an app.config in LINQPad 6, because the app.config model is not applicable to .NET Core. Instead, you can ask LINQPad to copy .json configuration files in the application base directory, by adding references to those files (just as you would with DLLs).
• There's no longer an option to add Framework assembly references. In keeping with Visual Studio, all .NET Core Framework assemblies are referenced automatically.
• The built-in LINQ-to-SQL driver uses another (almost-identical) branch of LINQ-to-SQL that runs on .NET Core.
• Live execution tracking is not supported in .NET Core.

Running LINQPad 5 and 6 side-by-side

If you're running LINQPad 5 and 6 side-by-side, you can share the same queries with some provisos:

• Any .NET Framework assembly references are ignored in LINQPad 6.
• Other assembly references may cause difficulties unless they are to .NET Standard libraries. NuGet package references are the best option.
• For conditional compilation, the NETCORE symbol is defined in LINQPad 6 but not LINQPad 5.
• My Extensions is separate for LINQPad 5 and 6, so each can have different implementations and dependencies. As long as you provide textually similar methods in both, queries will work with both.

X64 vs X86

LINQPad 6 ships with launchers for both X64 and X86:

• LINQPad6.exe runs LINQPad in 64-bit mode
• LINQPad6-x86.exe runs LINQPad in 32-bit mode

64-bit mode is recommended unless you need to interoperate with 32-bit unmanaged DLLs.