You can add the v3 nuget source via the dotnet cli:

```bash
dotnet nuget add source --name nuget.org https://api.nuget.org/v3/index.json
```

If that doesn't work, try running clearing out the local cache:

```bash
dotnet nuget locals all --clear
dotnet restore --force
```

### Further Reading

* [Unable to resolve .NETCoreApp v3.1 Packages][1]
* [Unable to resolve 'Microsoft.EntityFrameworkCore.SqlServer (>= 3.0.0)'][2]

[1]: https://github.com/dotnet/aspnetcore/issues/21920
[2]: https://stackoverflow.com/q/58787682/1366033

I am trying to resolve nugget packages with `dotnet restore`, but am getting the following error: 

> Unable to resolve 'Microsoft.NETCore.App (>= 2.1.0)' for '.NETCoreApp,Version=v2.1'

Here's my `.csproj` file

```xml
<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Autofac" Version="4.5.0" />
    <PackageReference Include="Autofac.Extensions.DependencyInjection" Version="4.1.0" />
    <PackageReference Include="Autofac.Extras.Moq" Version="4.2.0" />
    <PackageReference Include="BCrypt.Net-Core" Version="1.4.0" />
    <PackageReference Include="Easy.MessageHub" Version="3.2.1" />
    <PackageReference Include="hangfire" Version="1.6.17" />
    <PackageReference Include="Hangfire.MemoryStorage" Version="1.5.2" />
    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.1.0-rc1-final" />
    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.1.0-rc1-final" />
    <PackageReference Include="Microsoft.Extensions.Configuration" Version="2.1.0-rc1-final" />
    <PackageReference Include="MongoDB.Driver" Version="2.4.4" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="1.1.0" />
    <PackageReference Include="System.Runtime.Extensions" Version="4.3.0" />
  </ItemGroup>

  <Target Name="ApplyXdtConfigTransform" BeforeTargets="_TransformWebConfig">
    <PropertyGroup>
      <_SourceWebConfig>$(MSBuildThisFileDirectory)Web.config</_SourceWebConfig>
      <_XdtTransform>$(MSBuildThisFileDirectory)Web.$(Configuration).config</_XdtTransform>
      <_TargetWebConfig>$(PublishDir)Web.config</_TargetWebConfig>
    </PropertyGroup>
    <Exec Command="dotnet transform-xdt --xml &quot;$(_SourceWebConfig)&quot; --transform &quot;$(_XdtTransform)&quot; --output &quot;$(_TargetWebConfig)&quot;" Condition="Exists('$(_XdtTransform)')" />
  </Target>
</Project>
```

I have installed dotnet-sdk-2.1.300-rc1-008673-win-x64 and I am using Visual Studio 2017 v15.2



Unable to resolve 'Microsoft.NETCore.App (>= 2.1.0)' for '.NETCoreApp,Version=v2.1'

### Question

Can I dynamically ignore a property from a sealed class using [`System.Text.Json.JsonSerializer`][4]?



### Example Code

**Example class from another library**:

```cs
public sealed class FrozenClass
{
    // [JsonIgnore] <- cannot apply because I don't own this class
    public int InternalId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}
```

**Default Serialization**:

```cs
var person = new FrozenClass() { InternalId = 3, FirstName = "Dorothy", LastName = "Vaughan" };
var jsonString = System.Text.Json.JsonSerializer.Serialize(person);
```

**Actual Outcome**:

```js
{ "InternalId": 3, "FirstName": "Dorothy", "LastName": "Vaughan" }
```

**Expected Outcome**:

```js
{ "FirstName": "Dorothy", "LastName": "Vaughan" }
```


### Alternatives that don't work

There are two other questions on how to [add JsonIgnore at RunTime][1] & [add dynamic property name for serialization][2], but both are targeted at [Newtonsoft's Json.NET][3] - and often reference [this extension method][5]


There are several ways to modify the way a class is serialized with the native `JsonSerializer`, but all seem to rely on modifying the underlying class:

* You can [exclude properties from serialization][6] by adding the [`[JsonIgnore]`][7] attribute to the original class
* You can [register a JsonConverter on a property][8] by adding the [`[JsonConverter]`][9] attribute to the original class

However, in my case, the class is from another library and cannot be extended

### Workarounds

A possible workaround is to create another exportable class and setup a mapper between them

```cs
public class MyFrozenClass
{
    public MyFrozenClass(FrozenClass frozen)
    {
        this.FirstName = frozen.FirstName;
        this.LastName = frozen.LastName;
    }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}
```
```cs
var jsonString = System.Text.Json.JsonSerializer.Serialize(new MyFrozenClass(person));
```

[1]: https://stackoverflow.com/q/25157511/1366033
[2]: https://stackoverflow.com/q/50565358/1366033
[3]: https://www.newtonsoft.com/json
[4]: https://learn.microsoft.com/en-us/dotnet/api/system.text.json.jsonserializer
[5]: https://blog.rsuter.com/advanced-newtonsoft-json-dynamically-rename-or-ignore-properties-without-changing-the-serialized-class/
[6]: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-how-to#exclude-properties-from-serialization
[7]: https://learn.microsoft.com/en-us/dotnet/api/system.text.json.serialization.jsonignoreattribute
[8]: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-converters-how-to#registration-sample---jsonconverter-on-a-property
[9]: https://learn.microsoft.com/en-us/dotnet/api/system.text.json.serialization.jsonconverter-1

Dynamically ignore property on sealed class when serializing JSON with System.Text.Json

In the ternary version, it is interpreting your `default` as `default(DateTimeOffset)`, the other output expression type in the conditional. Then it is interpreting the ternary *as a whole* as a nullable, which will never be null.

In the second case, your return is using `default(DateTimeOffset?)`, from the declared return type.

In this case, you may want to use an explicit type in the `default` expression, or: just use the second form *and add a comment* (and ideally a unit test), so nobody "fixes" it in the future.

In the following example, I'm returning a `DateTimeOffset?` using the [`default` value][1]

```cs
var a = ConvertToDateTimeOffsetA(null); // 1/1/0001 12:00:00 AM +00:00
var b = ConvertToDateTimeOffsetB(null); // null

private static DateTimeOffset? ConvertToDateTimeOffsetA(DateTime? date)
{
	return date != null
		? new DateTimeOffset(date.Value, TimeSpan.Zero)
		: default;
}
private static DateTimeOffset? ConvertToDateTimeOffsetB(DateTime? date)
{
	if (date != null) 
		return new DateTimeOffset(date.Value, TimeSpan.Zero);
	return default;
}
```

Why is there a difference between the returned output in the ternary compared to the if statement?

My guess would be the ternary first coerces the type to `DateTimeOffset` and then inline converts back to `Nullable<DateTimeOffset>`, but I'm not quite sure why?

[1]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/default

Why do ternary operator and if statement return different results?

Unfortunately, there is *no official specification* in [RFC 3986 > Section 3.4][0] detailing how to pass multiple values for a query parameter.

That said, browsers do seem to natively implement the *multi-key approach* when building a query string on their own.  For example, in the following [demo][5]:

```html
<form method="GET">
  <label for="cars">Choose a car:</label>
  <select name="cars" id="cars" multiple>
    <option value="audi" selected>Audi</option>
    <option value="saab" selected>Saab</option>
  </select>
  <button type="submit">Submit</button>
</form>
```

The get request will be sent with `?cars=audi&cars=saab`

In the absence of a spec, with dotnet already supporting the multi-key approach with [your desired result][4], and since browsers use multi-key natively, it may be worth updating the way you build query strings on the client.

Perhaps someone else can add a some clever way to parse in .net, but otherwise you may be fighting uphill against the implementation in dotnet.

### Further Reading:

* [Correct way to pass multiple values for same parameter name in GET request][2]
* [How to pass multiple parameters in a querystring][3]
* [Authoritative position of duplicate HTTP GET query keys][1]

[0]: https://www.rfc-editor.org/rfc/rfc3986#section-3.4
[1]: https://stackoverflow.com/q/1746507/1366033
[2]: https://stackoverflow.com/q/24059773/1366033
[3]: https://stackoverflow.com/q/724526/1366033
[4]: https://dotnetfiddle.net/TzMqVL
[5]: https://jsfiddle.net/KyleMit/2psx1f7m/

I have a .NET Core 6.0 Azure Function HTTP Trigger.

I would it like to handle an array query string parameter in *both* of these common forms:

 - `?param=foo&param=escape%2Ctest`
 - `?param=foo,escape%2Ctest`

In both cases I would like to extract the array **`["foo", "escape,test"]`**.

I was surprised to find that the query string parse options available to me either did not support the comma syntax or URL decoded the query string as part of grouping the parameters. 

I've tried using several different dotnet APIs:

* [<code><i>System.Web.</i><b>HttpUtility.ParseQueryString</b></code>][3]
* [<code><i>Microsoft.AspNetCore.WebUtilities.</i><b>QueryHelpers.ParseQuery</b></code>][2]
* [<code><i>Microsoft.AspNetCore.Http.</i><b>HttpRequest.Query</b></code>][4]

### Here's a [demo in .NET Fiddle][1]:

```cs
var qs = "?param=foo,escape%2Ctest";

var a = httpRequest.Query["param"];
// ["foo,escape,test"]

var b = HttpUtility.ParseQueryString(qs)["param"];
// "foo,escape,test"

var c = QueryHelpers.ParseQuery(qs)["param"];
// ["foo,escape,test"]
```

I am a little surprised that there is no support for the comma separated format. And I am very surprised that there does not seem to be a way to get the segmented query string without also decoding the query string parameters (which prevents distinguishing between `param=foo,escape%2Ctest` and `?param=foo,escape,test`).

I will post my current solution as an "answer" below, but I am hoping that I am missing a simpler solution that uses a .NET library. If anyone can point out what I've missed here, I would appreciate it.

[1]: https://dotnetfiddle.net/dTv236
[2]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.webutilities.queryhelpers.parsequery?view=aspnetcore-6.0
[3]: https://learn.microsoft.com/en-us/dotnet/api/system.web.httputility.parsequerystring?view=net-6.0
[4]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.http.httprequest.query?view=aspnetcore-6.0

Parse query string arrays using either multi-key or comma syntax

When working with the [`dotnet` cli][1], several commands like build, take in an option to pass the release configuration

> `-c|--configuration <CONFIGURATION>`  
> Defines the build configuration. The default for most projects is Debug, but you can override the build configuration settings in your project.

You can see the possible options in Visual Studio:


[![Configuration Manager][2m]][2]


Is there any way to list all to possible release configuration options via CLI?


  [1]: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet
  [2]: https://i.stack.imgur.com/rm3HV.png
  [2m]: https://i.stack.imgur.com/rm3HVm.png