LinqPad includes references to common .NET assemblies and its namespaces in each query by default, but it doesn't provide a way for users to remove any of these references and/or namespaces, if they don't use or need them.

This causes issues due to name clashing between classes in different namespace.

For example, the sample code below uses Newtonsoft.Json v12.0.2 to format a JSON string:

```csharp
var jsonStringMinified = @"{""x"":100.5,""y"":200.4}";

var parsedJson = JToken.Parse(jsonStringMinified);
var jsonStringIndented = parsedJson.ToString(Formatting.Indented);

jsonStringIndented.Dump();
```

The namespaces imported in this example are:

Newtonsoft.Json
Newtonsoft.Json.Linq


We get a compilation error: "CS0104 'Formatting' is an ambiguous reference between 'Newtonsoft.Json.Formatting' and 'System.Xml.Formatting'which is correct given the compiler cannot choose whichFormatting` enum to use

Unfortunately, it's not possible to remove the namespace using to System.Xml and therefore the only way to make the code above works, is to fully qualify the enum:

```csharp
// ...

var jsonStringIndented = parsedJson.ToString(Newtonsoft.Json.Formatting.Indented);
```

This is not a great experience, as I can have code working in a .NET app within Visual Studio, but after copying and pasting in a LinqPad query, it doesn't work because of these name clashes.

Relates to:
https://linqpad.uservoice.com/forums/18302-linqpad-feature-suggestions/suggestions/2936121-show-the-default-namespaces-and-assembly-reference

When using Util.Dif on two dictionaries, I see that a key that was present in both was shown with a white background, the value was changed, however.

However, small dictionaries tend to keep their order and I created these two dictionaries:

17 -> A
18 -> B

vs.

18 -> B
17 -> A

in other words, the only thing different is the order in which I added the elements. Util.Dif now shows the entire thing as different, since it compares 17 with 18 and then 18 with 17.

For dictionaries it would be better to do a key-based comparison and not an index-based comparison. Keys that are new in the second dictionary could be green, keys that have been removed could be red, and keys present in both could be white, and then the values would follow the normal property-change dif look.

Did that make sense?

I've been using LinqPad's Dump() method from C#.
and showing HTML result using following code.
<https://gist.github.com/altrive/0ce60da4dd58a2d31f4a560c9457bd6f>
It's useful when viewing variable content without debugger.

It' works on .NET runtime, but it does't works under .NET Core runtime.
(because of WinForms/WPF/etc. dependencies exists)

I know it's difficult to LinqPad itself works under .NET Core in near future.
But is there any chance LinqPad's Dump()/Diff() components available to .NET Core?

Possible actions

1. Remove WinForms/LinqThirdParty DLL dependencies from LinqPad's Dump() call paths
   -> I don't sure it's possible or not. but It seem to works if related dependencies are propery resolved.


2. Publish Dump() related features as separate NuGet packages.


3. Open source Dump() related features codes like ExpressionFormatter
   -> <https://github.com/albahari/ExpressionFormatter>

Related Issues

• LinqPad on .NET Core
  <https://linqpad.uservoice.com/forums/18302-linqpad-feature-suggestions/suggestions/16961749-linqpad-on-net-core>


• Add ability to target .NET Core
  <https://linqpad.uservoice.com/forums/18302-linqpad-feature-suggestions/suggestions/17456101-add-ability-to-target-net-core>


• Make Dump() extension method available in Visual Studio
  <https://linqpad.uservoice.com/forums/18302-linqpad-feature-suggestions/suggestions/447166-make-dump-extension-method-available-in-visual-s>

Today when running scripts you can use CTRL+SHIFT+F5 or GUI advanced settings to determine whether you get a new app domain.

The thing is, most of the time I want a new app domain... except when I don't (typically because my script is dynamically loading up a bunch of assemblies that could change out from under me or when I am trying to measure/debug/redo some static initialization).

It would be nice if a script could express it's need for a fresh domain via the XML at the top of the raw script file. That way LinqPad would know how to invoke the script correctly.

At present, the only way to share code across LINQPad queries is to put them in "My Extensions" but this causes the code to be available to ALL queries, and it would be good if this could be specified on a more granular basis, where the code is shared with only a subset of queries.

For example, in my queries folder, if I'm working on ACME API, I'll have a folder called "ACME API" with separate files for whatever I'm working with - eg. get-user.linq, add-product.linq.

It would be good if I could create a file called common.linq (or something similar) and have LINQPad automatically import that for any other queries in the same folder.

I love LINQPad, but I really, really wish it noticed if the files changed on disk while they were being edited. Currently the application will overwrite a changed file on disk when it has been modified by another editor. There are two scenarios where this happens, one is when the file is under version control and I have reverted it to an older version or otherwise changed it using some version control function and the other is when I have used some other editor to edit the file (such as SlickEdit or Visual Studio, both of which detect if LINQPad has changed the file).