A modern class library should use multiple target frameworks today, which means the options can only be set in project files right now,

    &lt;Project Sdk=&quot;Microsoft.NET.Sdk&quot;&gt;
    
      &lt;PropertyGroup&gt;
        &lt;TargetFrameworks&gt;netstandard1.4;net40;net45&lt;/TargetFrameworks&gt;
      &lt;/PropertyGroup&gt;

https://docs.microsoft.com/en-us/dotnet/standard/frameworks

Visual Studio does not yet have suitable UI elements to reflect the options, and that&#39;s why it is showed the way you saw.

As @Lex Li has pointed out, VS project properties don&#39;t allow you to change the Target Framework, as the project actually targets more than one frameworks.
If, however, you plan to target a single framework, you&#39;ll have to change the &quot;TargetFrameworks&quot; tag to &quot;TargetFramework&quot; and specify only one target framework. Then, VS will allow you to select it from Project properties page again.

The two nodes in the project file, TargetFramework and TargetFramework**s** (plural) are the culprits. While it didn&#39;t help my project by putting net461;net462 into the latter, I tried renaming the nodes to TargetFramework and entered only net461.

The rename logically also gave me back the enabled combobox and that was what Jan was asking.

I changed it back to TargetFrameworks assuming that the other is now decprecated and resolved the &quot;multiple net version&quot;-error by removing the net462-reference and coded a little replacement. I compile but can only target one net-version.

I am using VS2019 and I got the same issue. I used this Microsoft .NET Framework Repair Tool to fix it. You can download the tool here:
https://www.microsoft.com/en-us/download/details.aspx?id=30135
[![enter image description here][1]][1]

Now I am able to see and change my Target Framework. 

[![Now I am able to see and change my Target Framework. ][2]][2]


  [1]: https://i.stack.imgur.com/4gxBl.png
  [2]: https://i.stack.imgur.com/ZrFys.png

In my case deleting the **global.json** from everywhere, was the solution and fixed all the projects in the whole solution.

putting this here as well https://github.com/dotnet/project-system/issues/6180
deleting the global.json file in file explorer (not just from the solution), after restarting vs I was able to change the framework

I have a simple question, where do you declare the base size that `rem` is calculated from?

    &lt;body&gt;
      &lt;h1&gt;Something&lt;/h1&gt;
    &lt;/body&gt;

I can see that the `font-size` is `&lt;body&gt;` is set to 16px and the `&lt;h1&gt;` is set to ` 3rem`, yet the font is rendering at 30px when I&#39;d expect 48px.  Can any parent redefine the base?

How to set base size for rem

I&#39;m trying to use `InkWell` to get a ripple effect on top of an image inside of a `GridTile` when the user taps on the tile.

I believe the image itself is obscuring the ripple because when I remove the image, I see the ripple.

Below is the code for a single GridTile. 

    return new InkWell(
      onTap: () =&gt; debugPrint(s.displayName),
      highlightColor: Colors.pinkAccent,
      splashColor: Colors.greenAccent,
      child: new GridTile(
        footer: new GridTileBar(
          title: new Text(s.displayName),
          subtitle: new Text(s.gameName),
          backgroundColor: Colors.black45,
          trailing: new Icon(
            Icons.launch,
            color: Colors.white,
          ),
        ),
        child: new Image.network( //this is obscuring the InkWell ripple
          s.imageSrc,
          fit: BoxFit.cover,
        ),
       ),
     );

I&#39;ve tried moving the InkWell to different levels of the hierarchy, using `DecorationImage` inside a `Container`, but none of these seem to work to reveal the ripple.

How can I get the ripple to appear on top of the tile/image?

InkWell ripple over top of image in GridTile in Flutter

I came across this problem this morning that I can&#39;t change the target framework of an open source project. The Target framework option drop down is inactive/disabled. How to make it to work with .NET Framework 2.0?

This is the download link: https://dev.mysql.com/downloads/connector/net/6.10.html

By the way, possible duplicate question? The &quot;Another Question&quot; that had linked is for VS2008. I&#39;m using VS2017, and today&#39;s date is 2018. The linked question is about 10 years old. Things changed a lot in 10 years. The solutions provided in that link is almost inapplicable.

[![Cannot Change Target Framework][1]][1]

  [1]: https://i.stack.imgur.com/KuIIf.jpg

Cannot Change Target Framework?

I came across this problem this morning that I can't change the target framework of an open source project. The Target framework option drop down is inactive/disabled. How to make it to work with .NET Framework 2.0?
This is the download link: <a href="https://dev.mysql.com/downloads/connector/net/6.10.html" target="_blank" rel="noopener noreferrer">https://dev.mysql.com/downloads/connector/net/6.10.html</a>
By the way, possible duplicate question? The "Another Question" that had linked is for VS2008. I'm using VS2017, and today's date is 2018. The linked question is about 10 years old. Things changed a lot in 10 years. The solutions provided in that link is almost inapplicable.
<a href="https://i.stack.imgur.com/KuIIf.jpg" target="_blank" rel="noopener noreferrer"><img src="https://i.stack.imgur.com/KuIIf.jpg" alt="Cannot Change Target Framework"></a>

The standard way AFAIK to return data in ASP.NET Core Web Api is by using `IActionResult` and providing e.g. an `OkObject` result. This works fine with objects, but what if I have obtained a JSON string somehow, and I just want to return that JSON back to the caller?

e.g. 


    public IActionResult GetSomeJSON()
    {
        return Ok(&quot;{ \&quot;name\&quot;:\&quot;John\&quot;, \&quot;age\&quot;:31, \&quot;city\&quot;:\&quot;New York\&quot; }&quot;);
    }

What ASP.NET Core does here is, it takes the JSON String, and wraps it into JSON again (e.g. it escapes the JSON)

Returning plain text with `[Produces(&quot;text/plain&quot;)]` does work by providing the &quot;RAW&quot; content, but it also sets the content-type of the response to PLAIN instead of JSON. We use `[Produces(&quot;application/json&quot;)]` on our Controllers.

How can I return the JSON that I have as a normal JSON content-type without it being escaped?

*Note: It doesn&#39;t matter how the JSON string was aquired, it could be from a 3rd party service, or there are some special serialization needs so that we want to do custom serialization instead of using the default JSON.NET serializer.*

Return &quot;raw&quot; json in ASP.NET Core 2.0 Web Api

I have a csv parser that reads in 15+ million rows (with many duplicates), and once parsed into structs, need to be added to a collection.  Each struct has properties Key (int), A(datetime), and B(int) (and others that aren&#39;t relevant here).
 
**Requirement A:** The collection needs to enforce uniqueness by a Key.

**Requirement B:** In a later step, I need the collection sorted by properties A(timestamp) then B(int).

**Constraint:** The structs eventually need to be traversed in order, one by one, with references to neighbors (a LinkedList&lt;T&gt; presents the cleanest solution here); the point of this operation is to partition the set.  Please assume that this is the earliest that partitioning can occur (ie, it cannot be partitioned at the parsing stage).

I&#39;ve found that the SortedSet&lt;T&gt; works quite well for Requirement A, and it&#39;s quite performant as well, even though the O(log n) insertions are much slower than with `HashSet&lt;T&gt;`&#39;s O(1), though I don&#39;t care about sorting on the key.  `HashSet&lt;T&gt;` gets bogged down when the collection gets huge, which apparently is a known issue, while `SortedSet&lt;T&gt;` does not suffer this drawback.

**The problem:** When I get to the step for Requirement B, sorting the collection (a `SortedSet&lt;T&gt;` passed to a method as `IEnumerable&lt;T&gt;`) takes a prohibitive amount of time (20+ minutes of grinding, all in-memory, no page file usage). 

**The question:** Which collection(s) is(are) best suited to address this problem?  One idea is to use two collections: one to enforce uniqueness (like a `HashSet&lt;int&gt;` or `SortedSet&lt;int&gt;` of keys), and a second `SortedSet&lt;T&gt;` to handle sorting at the parsing stage (ie, as far upstream as possible).  But the application is already memory-intensive, and the performance penalties of needing the pagefile is prohibitive.  
What options does that leave me with for a single collection that enforces uniqueness by one characteristic, but sorts by other unrelated characteristics?  `SortedSet&lt;T&gt;` uses `IComparer&lt;T&gt;` (but not both `IComparer&lt;T&gt;` and `IEquitable&lt;T&gt;`), so if it relies on CompareTo to enforce uniqueness, then it doesn&#39;t seem to fit my requirements.  Is subclassing SortedSet&lt;T&gt; the way to go?

**Edit:** The sort code:

    SortedSet&lt;Dto&gt; parsedSet = {stuff};
    var sortedLinkedStructs = new LinkedList&lt;Dto&gt;(parsedSet.OrderBy(t =&gt; t.Timestamp).ThenBy(i =&gt; i.SomeInt));

The struct:

    public readonly struct Dto: IEquatable&lt;Dto&gt;, IComparer&lt;Dto&gt;, IComparable&lt;Dto&gt;
    {
         public readonly datetime Timestamp;
         public readonly int SomeInt;
         public readonly int Key;
         
         ctor(ts, int, key){assigned}
    
         public bool Equals(Dtoother) =&gt; this.Key == other.Key;
         public override int GetHashCode() =&gt; this.Key.GetHashCode();
         public int Compare(Dto x, Dto y) =&gt;  x.Key.CompareTo(y.Key);
         public int CompareTo(Dto other) =&gt; this.Key.CompareTo(other.Key);
    }

Efficiency of very large collections; iteration and sort

Background: [Noda Time](https://nodatime.org) contains many
serializable structs. While I dislike binary serialization, we
received many requests to support it, back in the 1.x timeline.
We support it by implementing the `ISerializable` interface.

We&#39;ve received a recent [issue
report](https://github.com/nodatime/nodatime/issues/1060) of Noda
Time 2.x [failing within .NET
Fiddle](https://dotnetfiddle.net/vTCzMJ). The same code using Noda
Time 1.x works fine. The exception thrown is this:

&gt; Inheritance security rules violated while overriding member:
&#39;NodaTime.Duration.System.Runtime.Serialization.ISerializable.GetObjectData(System.Runtime.Serialization.SerializationInfo,
System.Runtime.Serialization.StreamingContext)&#39;. Security
accessibility of the overriding method must match the security
accessibility of the method being overriden.

I&#39;ve narrowed this down to the framework that&#39;s targeted: 1.x
targets .NET 3.5 (client profile); 2.x targets .NET 4.5. They have
big differences in terms of support PCL vs .NET Core and the
project file structure, but it looks like this is irrelevant.

I&#39;ve managed to reproduce this in a local project, but I haven&#39;t
found a solution to it.

Steps to reproduce in VS2017:

- Create a new solution
- Create a new classic Windows console application targeting .NET
4.5.1. I called it &quot;CodeRunner&quot;.
- In the project properties, go to Signing and sign the assembly with
  a new key. Untick the password requirement, and use any key file name.
- Paste the following code to replace `Program.cs`. This is an
  abbreviated version of the code in [this Microsoft
sample](https://docs.microsoft.com/en-us/dotnet/framework/misc/how-to-run-partially-trusted-code-in-a-sandbox#example).
  I&#39;ve kept all the paths the same, so if you want to go back to the
  fuller code, you shouldn&#39;t need to change anything else.
  
Code:

    using System;
    using System.Security;
    using System.Security.Permissions;
    
    class Sandboxer : MarshalByRefObject  
    {  
        static void Main()  
        {  
            var adSetup = new AppDomainSetup();  
            adSetup.ApplicationBase = System.IO.Path.GetFullPath(@&quot;..\..\..\UntrustedCode\bin\Debug&quot;);  
            var permSet = new PermissionSet(PermissionState.None);  
            permSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));  
            var fullTrustAssembly = typeof(Sandboxer).Assembly.Evidence.GetHostEvidence&lt;System.Security.Policy.StrongName&gt;();  
            var newDomain = AppDomain.CreateDomain(&quot;Sandbox&quot;, null, adSetup, permSet, fullTrustAssembly);  
            var handle = Activator.CreateInstanceFrom(  
                newDomain, typeof(Sandboxer).Assembly.ManifestModule.FullyQualifiedName,  
                typeof(Sandboxer).FullName  
                );  
            Sandboxer newDomainInstance = (Sandboxer) handle.Unwrap();  
            newDomainInstance.ExecuteUntrustedCode(&quot;UntrustedCode&quot;, &quot;UntrustedCode.UntrustedClass&quot;, &quot;IsFibonacci&quot;, new object[] { 45 });  
        }  
    
        public void ExecuteUntrustedCode(string assemblyName, string typeName, string entryPoint, Object[] parameters)  
        {  
            var target = System.Reflection.Assembly.Load(assemblyName).GetType(typeName).GetMethod(entryPoint);
            target.Invoke(null, parameters);
        }  
    }

- Create another project called &quot;UntrustedCode&quot;. This should be a
  Classic Desktop Class Library project.
- Sign the assembly; you can use a new key or the same one as for
  CodeRunner. (This is partially to mimic the Noda Time situation,
  and partly to keep Code Analysis happy.)
- Paste the following code in `Class1.cs` (overwriting what&#39;s there):

Code:

    using System;
    using System.Runtime.Serialization;
    using System.Security;
    using System.Security.Permissions;

    // [assembly: AllowPartiallyTrustedCallers]

    namespace UntrustedCode
    {
        public class UntrustedClass
        {
            // Method named oddly (given the content) in order to allow MSDN
            // sample to run unchanged.
            public static bool IsFibonacci(int number)
            {
                Console.WriteLine(new CustomStruct());
                return true;
            }
        }
    
        [Serializable]
        public struct CustomStruct : ISerializable
        {
            private CustomStruct(SerializationInfo info, StreamingContext context) { }
    
            //[SecuritySafeCritical]
            //[SecurityCritical]
            //[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
            void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
            {
                throw new NotImplementedException();
            }
        }
    }

Running the CodeRunner project gives the following exception (reformatted for readability):

&gt; Unhandled Exception: System.Reflection.TargetInvocationException:  
&gt; Exception has been thrown by the target of an invocation.  
&gt; ---&amp;gt;  
&gt; System.TypeLoadException:  
&gt; Inheritance security rules violated while overriding member:  
&gt; &#39;UntrustedCode.CustomStruct.System.Runtime.Serialization.ISerializable.GetObjectData(...).  
&gt; Security accessibility of the overriding method must match the security  
&gt; accessibility of the method being overriden.

The commented-out attributes show things I&#39;ve tried:

- `SecurityPermission` is recommended by two different MS articles ([first](https://docs.microsoft.com/en-us/dotnet/standard/serialization/serialization-guidelines),
  [second](https://docs.microsoft.com/en-us/dotnet/standard/serialization/custom-serialization)), although
  interestingly they do different things around explicit/implicit interface implementation
- `SecurityCritical` is what Noda Time currently has, and is what [this question&#39;s answer](https://stackoverflow.com/questions/3055792) suggests
- `SecuritySafeCritical` is somewhat suggested by Code Analysis rule messages
- Without *any* attributes, Code Analysis rules are happy - with either `SecurityPermission` or `SecurityCritical`
  present, the rules tell you to remove the attributes - unless you *do* have `AllowPartiallyTrustedCallers`. Following the suggestions in either case doesn&#39;t help.
- Noda Time has `AllowPartiallyTrustedCallers` applied to it; the example here doesn&#39;t work either with or without the attribute applied.

The code runs without an exception if I add `[assembly: SecurityRules(SecurityRuleSet.Level1)]` to the `UntrustedCode` assembly (and uncomment the `AllowPartiallyTrustedCallers` attribute),  but I believe that&#39;s a poor solution to the problem that could hamper other code.

I fully admit to being pretty lost when it comes to this sort of
security aspect of .NET. So what *can* I do to target .NET 4.5 and
yet allow my types to implement `ISerializable` and still be used in
environments such as .NET Fiddle?

(While I&#39;m targeting .NET 4.5, I believe it&#39;s the .NET 4.0 security policy changes that caused the issue, hence the tag.)

How can I implement ISerializable in .NET 4+ without violating inheritance security rules?

### Question

How should I inject (using the standard dependency injection) a `DbContext` instance into a `IHostedService`?

### What have I tried

I currently have my `IHostedService` class take a `MainContext` (deriving from `DbContext`) instance in the constructor.

When I run the application I get:

&gt; Cannot consume scoped service &#39;Microsoft.EntityFrameworkCore.DbContextOptions&#39; from singleton &#39;Microsoft.Extensions.Hosting.IHostedService&#39;.

So I tried to make the `DbContextOptions` transient by specifying:

    services.AddDbContext&lt;MainContext&gt;(options =&gt; 
                    options.UseSqlite(&quot;Data Source=development.db&quot;), ServiceLifetime.Transient);

in my `Startup` class.

But the error remains the same, even though, according to [this solved Github issue](https://github.com/aspnet/EntityFrameworkCore/issues/6863) the `DbContextOptions` passed should have the same lifetime specified in the `AddDbContext` call.

I can&#39;t make the database context a singleton otherwise concurrent calls to it would yield concurrency exceptions (due to the fact that the database context is not guaranteed to be thread safe).

How should I inject a DbContext instance into an IHostedService?

The VS solutions I often work with consist of a **single executable project** (console app, web app) and **many class library projects** that are all referenced by the executable.

When working with NuGet and installing packages, there&#39;s often an `app.config` file created for each project, usually containing nothing else than a list of binding redirects that consolidate versions of referenced assemblies. Sometimes there&#39;s some third-party library-specific content (like Entity Framework config section), but let&#39;s leave that aside for now.

When I build the solution and use the binaries of the main executable project, I see all the class library project assemblies in the build output together with the corresponding `*.config` files (the `app.config` file gets renamed to `AssemblyName.config` when built).

When launching the main executable, do the config files of the class library assemblies take any effect? Or is it just the `app.config` file of the executable that has an effect in this case? What if there are some binding redirects set up on some of the class library projects, and some different binding redirects set up on the main executable project &amp;mdash; How are these combined, which take priority?

I&#39;ve tried to research this online and from what I&#39;ve read, it looks to me like the `app.config` files for non-executable assemblies are useless (with regards to binding redirects). Can someone confirm this or elaborate a bit more on the topic?

If it is that way, is it actually undesirable to have these `app.config` files created by NuGet in class libraries if they contain just the binding redirects? It feels to me that NuGet shouldn&#39;t create those binding redirects for class library projects, as it will only increase the confusion about what settings are actually applied.

---

I found these existing Stack Overflow questions on the topic, but their **accepted answers are actually contradictory even when they&#39;re marked as duplicates of each other**.

- https://stackoverflow.com/questions/22227675/why-nuget-adds-app-config-with-assemblybinding-to-library-projects-during-a-nuge

- https://stackoverflow.com/questions/21795507/is-the-bindingredirect-config-file-needed-or-all-assemblies-in-an-application

[The accepted answer to the first question](https://stackoverflow.com/a/22228738/108374) mentions that app.config files are actually used during compile-time, which means they could have effect. Sources like [MSDN](http://msdn.microsoft.com/en-us/library/7wd6ex19.aspx) and [MSBuild source code](https://github.com/Microsoft/msbuild/blob/5df95761c73cd6b1b2c35a827ed168e32546388e/src/Tasks/AssemblyDependency/ResolveAssemblyReference.cs#L2088-L2100) are cited there as a proof it&#39;s used during compile-time. Unfortunately, I&#39;m not proficient enough in MSBuild to understand how it&#39;s being used, and if it&#39;s really a valid argument.

### Can anybody describe an example scenario to prove that an app.config with binding redirects for a class library can do anything?

Content Type	Original Author	Original Content on Stackoverflow
Question	mjb	View Question on Stackoverflow
Solution 1 - C#	Lex Li	View Answer on Stackoverflow
Solution 2 - C#	Artak	View Answer on Stackoverflow
Solution 3 - C#	Henrik Carlsen	View Answer on Stackoverflow
Solution 4 - C#	Junior Grão	View Answer on Stackoverflow
Solution 5 - C#	Mohamed Mohsen	View Answer on Stackoverflow
Solution 6 - C#	user1375314	View Answer on Stackoverflow

Cannot Change Target Framework?

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Solution 4 - C#

Solution 5 - C#

Solution 6 - C#

InkWell ripple over top of image in GridTile in Flutter

How to set base size for rem

Attributions