These are so called [Reference Assemblies][1] (assemblies that only contain the public interface of an assembly), these help speed up the build process, since projects that depend on this one will be able to see that there is no reason to recompile, even if the innards of the assembly have changed, because outwardly it&#39;s still the same.

These Reference Assemblies need to look the same as the real thing from the outside. Hence, they have the same filename, assembly name, assembly identity and everything. This allows the build system to use them as a substitute for the real thing. And since these assemblies don&#39;t have any of the implementation details, they only change when the interface of the contents changes. Due to these facts, they can&#39;t live in the same folder as the actual build output, and this is the reason for the extra `ref` folder. MsBuild will use these reference assemblies automatically to speed up the build process (at the expense of generating and comparing the reference assembly each time the compiled code results in a new project output and a few files in the output directory).

If your project isn&#39;t referenced by other projects, you don&#39;t get any benefits from these reference assemblies (if you don&#39;t hand them out to 3rd parties that is). And you can turn off this feature by adding this property to the project file:

```
&lt;PropertyGroup&gt;
     &lt;!-- 
     Turns off reference assembly generation 
     See: https://docs.microsoft.com/en-us/dotnet/standard/assembly/reference-assemblies
     --&gt;
     &lt;ProduceReferenceAssembly&gt;false&lt;/ProduceReferenceAssembly&gt;
&lt;/PropertyGroup&gt;
```

After changing the setting, make sure you clean your build outputs.

These reference assemblies can also be used to allow people to compile projects to work with your system, without having to install/redistribute the actual compiled assemblies that run on your server. This way people can develop extensions, plugins, or clients for your application without having to give them access to actual implementation. This can help protect your intellectual property, since .NET assemblies are easy to decompile. 

See also:

 * https://stackoverflow.com/a/58911152/736079

  [1]: https://docs.microsoft.com/en-us/dotnet/standard/assembly/reference-assemblies?WT.mc_id=DOP-MVP-5001511&amp;

Has anyone seen this warning while installing homebrew? What does it mean? Should I be worried?

**Warning**: `/opt/homebrew/bin is not in your PATH`.
[![enter image description here][1]][1]


Some background info:

I read [some blogs][2] about M1 chip and thought I would need to install Rosetta 2 on my mac in order to install homebrew. 

However, before I Rosetta 2, I tried installing the plain old `/bin/bash -c &quot;$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)&quot;`. The went through, and I saw &quot;Installation successful!&quot; 

The only issue is that I saw the following warning. 

&gt;homebrew Warning: /opt/homebrew/bin is not in your PATH.

Should I be worried? What does it mean?




  [1]: https://i.stack.imgur.com/AmI00.png
  [2]: https://medium.com/better-programming/5-things-i-have-learned-when-using-the-m1-chip-macbook-air-a77f93c50381

Getting a warning when installing homebrew on MacOS Big Sur (M1 chip)

I have an app on Google Play but I am trying to upload a new version. I am not familar with Google Play but no matter where I go I can&#39;t seem to see how to add a new version of the app. The best I have got to is here but the Create New Release button is greyed out. Any pointers?

[![goog][1]][1]


  [1]: https://i.stack.imgur.com/XYBoK.png

Create New Release is greyed out in Google Play Console

What is the `ref` folder when compiling .NET 5.0 application? 

I mean this one: 

```plain
[project_path]\bin\Debug\net5.0\ref\
```

Ref folder within .NET 5.0 bin folder

What is the <code>ref</code> folder when compiling .NET 5.0 application?
I mean this one:
<pre><code class="hljs language-csharp">[project_path]\bin\Debug\net5.0\ref\
</code></pre>

I just upgraded my visual studio ***2019*** to latest version ***16.8.3*** and suddenly I am not able to load any C# project and getting the following error for all .NET core projects:

&gt; The project file cannot be opened. Unable to locate the .NET SDK.
&gt; Check that it is installed and that the version specified in
&gt; global.json (if any) matches the installed version.

Microsoft Visual Studio 2019: The project file cannot be opened. Unable to locate the .NET SDK

The following &quot;fix&quot; is very confusing to me; the scenario here is conditionally deciding whether to use the stack vs a leased buffer depending on the size - a pretty niche but sometimes-necessary optimization, however: with the &quot;obvious&quot; implementation (number 3, deferring definite assignment until we actually want to assign it), the compiler complains with CS8353:

&gt; A result of a stackalloc expression of type &#39;Span\&lt;int\&gt;&#39; cannot be used in this context because it may be exposed outside of the containing method

The short repro (a complete repro follows) is:

``` c#
// take your pick of:
// Span&lt;int&gt; s = stackalloc[0]; // works
// Span&lt;int&gt; s = default; // fails
// Span&lt;int&gt; s; // fails

if (condition)
{   // CS8353 happens here
    s = stackalloc int[size];
}
else
{
    s = // some other expression
}
// use s here
```

The only thing I can think here is that the compiler is *really* flagging that the `stackalloc` is escaping the context in which the `stackalloc` happens, and is waving a flag to say &quot;I can&#39;t prove whether this is going to be safe later in the method&quot;, but by having the `stackalloc[0]` at the start, we&#39;re pushing the &quot;dangerous&quot; context scope higher, and now the compiler is happy that it never escapes the &quot;dangerous&quot; scope (i.e. it never actually leaves the method, since we&#39;re declaring at the top scope). Is this understanding correct, and it is just a compiler limitation in terms of what can be proven?

What&#39;s *really* interesting (to me) is that the `= stackalloc[0]` is fundamentally a no-op *anyway*, meaning that *at least in the compiled form* the working number 1 `= stackalloc[0]` is identical to the failing number 2 `= default`.

Full repro (also [available on SharpLab to look at the IL](https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AXEBLANgHwAEAmARgFgAoQgBgAJDSA6AIQFcAzDmKAZwG4qVQgGYGpJA2J0AwlQDeVOsoZjGkwijoBlDAEMwAawCCuXBDAAxNgDsAFNhsY6kWxgCUSlYsoq/dAHoAugBiUjoMAAtsXjoYulwYAHM9XDQ6ACs2XmdHbAxsVOwALxhY2L0KugATGA49NlxnXgAHPRsvfx02mwAeRwwAPjpYgF4R/SNU8zA4pwBtGgBdQV8uuk7/INDpKPj9s2TUkDoeKGhZbQAOEQBWERPjOlheRucIDjo9CYNDaYtTggWi9eNgIB01l1th8IgBPFowOgAcm0PX6TkGSJc7RsEGcwER2Rg1TmEWisUgThgCHxMDADV4iPydAAtnpYZs/NsCYCWhBGSSIGwMKDanQYVFEZT9HkbElWTAohBqpyVNtUe10UMRnRxrV6m9VusNpCtsEQmJKnFYntYnZUrwIHFDik0nFak5sPTcKcoOcoJ5TVzghq+gNhgJVcoo3MMPMluKAG48UGlEnjGyNXBG9YYKAcoPeGN+bCfOyuJx0Xp0ETEQPGvzyNXBGTXO5iSJ6FoImwVZy2n5TMwWYvrMaDv7D2YDeYVjArUfKAC+i9OuEZq58DfWEGTfBKxN1dGMfvZAAUIBBcFrBkxtJ3YNUmAAlGBOctCpzuHPbvzjmwwAA7t0mrhnYu4pge1TpDQ6Rzt+q4roWXQXi0jR6BgMB2LwCHIf4AAiEDaBALKKtEcoAOr5JE2G4caSHGhwjjTAWxpbr+pZ0OBe6poe8S4s4mZmPWv7sb+KgnlA56Xte4Z3g+xIvoqbBQPYEH7mmdG/gx6w6cuQimsC2CJhhiLqAwWioehmF2KGN4jCJXSjMMUTnMBAHAQAcniACSLItIkpFUtUACiCBgDALQFOCdjfoEwSAZ2mF7psRkmZh4gaFohHEaReyUdRdivno1QAPI2LgsJ2eGDkxs5ZJuXQHl0N5GB+QFMBBZhoXhZF0X2HF2yJaZKWmps2wCTAJz3hAgHeaVLQABpfDYJIzXNEALQAmi4JEtHgTIegU3qVZk2RYONwS4NUMx6EwsSwXM+QQMAGQgWGGLpNdMxMDQmzmZoOiRLN81LbFmxif41UYjq4w5L8/zTgsyw/gRREkWRjhJFRUS0ajemZRZQMg5tLRbeDpqQ340PauO+oNE0qN+DlGP5djhU4fjVBLkAA=)).

``` c#
using System;
using System.Buffers;

public static class C
{
    public static void StackAllocFun(int count)
    {
        // #1 this is legal, just initializes s as a default span
        Span&lt;int&gt; s = stackalloc int[0];
        
        // #2 this is illegal: error CS8353: A result of a stackalloc expression
        // of type &#39;Span&lt;int&gt;&#39; cannot be used in this context because it may
        // be exposed outside of the containing method
        // Span&lt;int&gt; s = default;
        
        // #3 as is this (also illegal, identical error)
        // Span&lt;int&gt; s;
        
        int[] oversized = null;
        try
        {
            if (count &lt; 32)
            {   // CS8353 happens at this stackalloc
                s = stackalloc int[count];
            }
            else
            {
                oversized = ArrayPool&lt;int&gt;.Shared.Rent(count);
                s = new Span&lt;int&gt;(oversized, 0, count);
            }
            Populate(s);
            DoSomethingWith(s);
        }
        finally
        {
            if (oversized is not null)
            {
                ArrayPool&lt;int&gt;.Shared.Return(oversized);
            }
        }
    }

    private static void Populate(Span&lt;int&gt; s)
        =&gt; throw new NotImplementedException(); // whatever
    private static void DoSomethingWith(ReadOnlySpan&lt;int&gt; s)
        =&gt; throw new NotImplementedException(); // whatever
    
    // note: ShowNoOpX and ShowNoOpY compile identically just:
    // ldloca.s 0, initobj Span&lt;int&gt;, ldloc.0
    static void ShowNoOpX()
    {
        Span&lt;int&gt; s = stackalloc int[0];
        DoSomethingWith(s);
    }
    static void ShowNoOpY()
    {
        Span&lt;int&gt; s = default;
        DoSomethingWith(s);
    }
}
```


Why does a zero-length stackalloc make the C# compiler happy to allow conditional stackallocs?

I have a simple class like this.

    public class Greeting
    {
        public string From { get; set; }
        public string To { get; set; } 
        public string Message { get; set; }
    }

Strangely I get the following warning. 

    Severity	Code	Description	Project	File	Line	Suppression State
    Warning	CS8618	Non-nullable property &#39;From&#39; must contain a non-null value when exiting constructor. 
    Consider declaring the property as nullable.	MxWork.Elsa2Wf.Tuts.BasicActivities	 
    D:\work\MxWork\Elsa2.0WfLearning\MxWork.Elsa2.0Wf.Tuts\src 
    \MxWork.Elsa2Wf.Tuts.BasicActivities\Messages\Greeting.cs	5	Active

I am baffled. These new kind of messages that it throws pulls down my confidence. 
I got them from all the three properties.
And this has suddenly appeared.

Can some one please suggest how this can be mitigated. 


[![visual studio warning message][1]][1]


## Update

These days I have seen using **default!** like so, and its working.

    public class Greeting
    {
        public string From { get; set; } = default!;
        public string To { get; set; } = default!;
        public string Message { get; set; } = default!;
    }

Also you may put a question mark symbol(?) to indicate that the type is nullable, if you feel appropriate as follows.

```cs
public class Greeting
{
    public string? From { get; set; };
    public string? To { get; set; };
    public string? Message { get; set; };
}
```



  [1]: https://i.stack.imgur.com/0GjVJ.png

Non-nullable property must contain a non-null value when exiting constructor. Consider declaring the property as nullable

I&#39;m trying to access appsettings.json in my Asp.net core v6 application Program.cs file, but in this version of .Net the Startup class and Program class are merged together and the using and another statements are simplified and removed from Program.cs. In this situation, How to access IConfiguration or how to use dependency injection for example ?

&lt;b&gt;Edited :&lt;/b&gt;
Here is my default Program.cs that Asp.net 6 created for me 

    var builder = WebApplication.CreateBuilder(args);
    // Add services to the container.
    builder.Services.AddControllers();
    builder.Services.AddStackExchangeRedisCache(options =&gt;
    {
        options.Configuration = &quot;localhost:6379&quot;;
    });
    
    builder.Services.AddSwaggerGen(c =&gt;
    {
        c.SwaggerDoc(&quot;v1&quot;, new() { Title = &quot;BasketAPI&quot;, Version = &quot;v1&quot; });
    });
    var app = builder.Build();
    // Configure the HTTP request pipeline.
    if (app.Environment.IsDevelopment())
    {
        app.UseSwagger();
        app.UseSwaggerUI(c =&gt; c.SwaggerEndpoint(&quot;/swagger/v1/swagger.json&quot;, &quot;BasketAPI v1&quot;));
    }
    app.UseHttpsRedirection();
    app.UseAuthorization();
    app.MapControllers();
    app.Run();

For example , I want to use appsettings.json instead of hard typed connectionstring in this line :

    options.Configuration = &quot;localhost:6379&quot;;

How to use appsettings.json in Asp.net core 6 Program.cs file

In earlier versions, we had Startup.cs class and we get configuration object as follows in the **Startup** file.

```csharp
public class Startup 
{
    private readonly IHostEnvironment environment;
    private readonly IConfiguration config;

    public Startup(IConfiguration configuration, IHostEnvironment environment) 
    {
        this.config = configuration;
        this.environment = environment;
    }

    public void ConfigureServices(IServiceCollection services) 
    {
        // Add Services
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env) 
    {
        // Add Middlewares
    }

}
```
---
Now in .NET 6 (With Visual Studio 2022), we don&#39;t see the **Startup.cs** class. Looks like its days are numbered. So how do we get these objects like Configuration(IConfiguration) and Hosting Environment(IHostEnvironment)

How do we get these objects, to say read the configuration from appsettings? Currently the Program.cs file looks like this.

```csharp
using Festify.Database;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddRazorPages();

builder.Services.AddDbContext&lt;FestifyContext&gt;();


////////////////////////////////////////////////
// The following is Giving me error as Configuration 
// object is not avaible, I dont know how to inject this here.
////////////////////////////////////////////////


builder.Services.AddDbContext&lt;FestifyContext&gt;(opt =&gt;
		opt.UseSqlServer(
			Configuration.GetConnectionString(&quot;Festify&quot;)));


var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
	app.UseExceptionHandler(&quot;/Error&quot;);
	// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
	app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();
```

I want to know how to read the configuration from appsettings.json ?
 

ASP.NET Core 6 how to access Configuration during startup

While doing a docker build on my .NET Core project, I got the following error on all my NuGets:

&gt; 80.19 /app/GradingTool.Tests/GradingTool.Tests.csproj : error NU3028: Package &#39;Microsoft.EntityFrameworkCore 5.0.0&#39; from source &#39;https://api.nuget.org/v3/index.json&#39;: The author primary signature&#39;s timestamp found a chain building issue: UntrustedRoot: self signed certificate in certificate chain [/app/GradingTool.sln]
&gt;
&gt; #12 80.20 /app/GradingTool.Tests/GradingTool.Tests.csproj : error NU3037: Package &#39;Microsoft.EntityFrameworkCore 5.0.0&#39; from source &#39;https://api.nuget.org/v3/index.json&#39;: The author primary signature validity period has expired. [/app/GradingTool.sln]
&gt;
&gt; #12 80.20 /app/GradingTool.Tests/GradingTool.Tests.csproj : error NU3028: Package &#39;Microsoft.EntityFrameworkCore 5.0.0&#39; from source &#39;https://api.nuget.org/v3/index.json&#39;: The repository countersignature&#39;s timestamp found a chain building issue: UntrustedRoot: self signed certificate in certificate chain [/app/GradingTool.sln]

I never had this error before,
Can someone help me figure out what the problem is?

Dockerfile:

```
FROM mcr.microsoft.com/dotnet/sdk:latest AS build-env
WORKDIR /app
RUN apt-get update -yq \
    &amp;&amp; apt-get install curl gnupg -yq \
    &amp;&amp; curl -sL https://deb.nodesource.com/setup_10.x | bash \
    &amp;&amp; apt-get install nodejs -yq
# Copy csproj and restore as distinct layers
COPY . ./
RUN dotnet restore
RUN dotnet publish -c Release -o out

# Build runtime image
FROM mcr.microsoft.com/dotnet/aspnet:latest
RUN apt-get update \
    &amp;&amp; apt-get install -y --no-install-recommends libgdiplus libc6-dev \
    &amp;&amp; apt-get clean \
    &amp;&amp; rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=build-env /app/out .
ENV ASPNETCORE_URLS=&quot;http://+:4200&quot;
ENV ASPNETCORE_ENVIRONMENT=&quot;Production&quot;
ENV GOOGLE_APPLICATION_CREDENTIALS=&quot;Credentials/SchoolTools-e9f260bdf56e.json&quot;
ENV VIRTUAL_HOST=&quot;eva.schooltools.lu,www.eva.schooltools.lu,schooltools.lu,www.schooltools.lu&quot;
ENV LETSENCRYPT_HOST=&quot;eva.schooltools.lu,www.eva.schooltools.lu,schooltools.lu,www.schooltools.lu&quot;
ENV LETSENCRYPT_EMAIL=&quot;wilson.silva@edutec.lu&quot;
EXPOSE 4200
ENTRYPOINT [&quot;dotnet&quot;, &quot;GradingTool.dll&quot;]
```

The author primary signature&#39;s timestamp found a chain building issue: UntrustedRoot: self signed certificate in certificate chain

Is there anyway to open and work on `.net framework 4.5` project in `visual studio 2022`.

May be problem is not with VS2022 but as `.net framework 4.5` developer pack is not available any more .. my project can not be changed target version .. Is there any workaround?

[![enter image description here][1]][1]
[![enter image description here][2]][2]


  [1]: https://i.stack.imgur.com/924BM.png
  [2]: https://i.stack.imgur.com/mJrjt.png

Open .net framework 4.5 project in VS 2022. Is there any workaround?

I have this code that checks the references of two variables,
I came across this case which is a bit confusing : 

```c#
string first = &quot;10&quot;;
object second = 10.ToString();
dynamic third = second;

Console.WriteLine($&quot;{first == second}   {first == third}&quot;);
```

The result is : `False   True`

My first question is why are the first and third references equal? If the third variable is equal to the second it should be `False` because their object references aren&#39;t equal.

And I got confused when I changed the values to `&quot;1&quot;` like below:

```c#
string first = &quot;1&quot;;
object second = 1.ToString();
dynamic third = second;

Console.WriteLine($&quot;{first == second}   {first == third}&quot;);
```

Then the result becomes: `True     True`

Why does this happen?

Content Type	Original Author	Original Content on Stackoverflow
Question	Alek Depler	View Question on Stackoverflow
Solution 1 - C#	jessehouwing	View Answer on Stackoverflow

Ref folder within .NET 5.0 bin folder

C# Problem Overview

C# Solutions

Solution 1 - C#

Create New Release is greyed out in Google Play Console

Getting a warning when installing homebrew on MacOS Big Sur (M1 chip)

Attributions