Go vs C#

Goroutines are "lightweight threads" that runs on OS threads. They provide a simple way for concurrent operations — prepending a function with go will execute it concurrently. It utilizes channels for communication between goroutines which aids to prevent races and makes synchronizing execution effortless across goroutines. The maximum number of OS threads goroutines can run on may be defined at compile time with the GOMAXPROCS variable.

The language is designed in a manner that seems logical. Syntax is simplified to reduce burden on the programmer and compiler developers.

Go has a solid team of engineers working on it (some of the best networking engineers in the world are working on Go). Up until now, the great engineering of the language has compensated for its lack of power.

Only features deemed critical are added to the language to prevent cruft from working its way into the language. The language is small enough to fit inside one's head without having to repeatedly open documentation. Documentation is hosted on an official webpage in a manner that is simple to read and understand.

Compiled binaries are fast — about as fast in C in most cases. Compiles on every OS without effort — truly cross-platform compiler. As a result of the fast compilation speed, you can use the gorun program to use go source code as if it was a scripting language.

The idiomatic approach to writing a Go software project is to perform test-driven development with unit testing. Every source code file should have an associated *_test.go file which tests functions in the code.

This helps keep every programmer on the same page in a project and eliminates arguments over formatting styles.

Go software can be immediately installed, regardless of your operating system, package manager, or processor architecture with the go get command. Software is compiled statically by default so there is no need to worry about software dependencies on the client system. Makefiles and headers are no longer necessary, as the package system automatically resolves dependencies, downloads source code and compiles via a single command: go build.

The language promotes programming in a specific idiomatic style, which helps keep every programmer on the same page.

Go was started as a systems language but now it has fully committed in the niche of networking services. This has been a brilliant move by Go because it allows them to capitalize on the immense talent of the Go engineering team (who are in the most part network engineers).

In a world dominated by Java EE and slow scripting language, Go was a breath of fresh air and it continues to be one of the most powerful languages if you want to build networking services.

All types are essentially objects, be they type aliases or structs. The compiler automatically associates types to their methods at compile time. Those methods are automatically associated to all interfaces that match. This allows you to gain the benefits of multiple inheritance without glue code. As a result of the design, classes are rendered obsolete and the resulting style is easy to comprehend.

Godoc is provided to automatically generate API documentation for Go projects. Godoc also hosts its own self-contained web server that will list documentation for all installed packages in your Go path.

This naturally also supports first class and high order functions, so you may pass functions as variables to other functions.

Go is blazing fast, but easier to write than Python, JS, Ruby, or many other dynamic languages.

Every Go source file contains a package line that indicates which package a file belongs to. If the name of the package is 'main', it indicates that this is a program that will be compiled into a binary. Otherwise, it will recognize that it is a package.

As long as every source code file in a directory has the same package name, the compiler will automatically concatenate all of the files together during the compilation process.

This conveniently eliminates the need to create temporary variables.
Fibonacci example: x, y = y, x+y

Any variable, type and function whose name begins with a capital letter will be exported by a project, while all other code remains private. There is no longer a need to signify that a piece of code is 'private' or 'public' manually.

The Visual Studio IDE offers one of the best development environments. The Community Edition can be used for free.

.NET offers rich functionality.

Lot's of tools and libraries available.

with Xamarin for Mobile (ios, android)
with .net core asp for server (linux, windows)
with .net core for desktop (windows, mac)
with mono for desktop (windows, linux)
with blazor for web client with webassembly.

However, it is not considered top for any of those categories

top choice for windows desktop with .net framework
top choice for Unity

.net 5 will unify frameworks similar to JVM (just one)

Runs on Linux, Mac, and Windows

Being a C like language counts in favor for it as a general purpose programming language, given the ease of using existing skills to pick up this language easily.

there are other superior languages that could be used as a general purpose, such as: F#, Haskell, but the complexity of those languages, being functional, make them strange to the usual C Syntax.

C# is better than C whenever garbage collection, Objects, classes, data access, are needed. But C is going to be the choice when hardware access and performance are paramount.

Can be designed visually with the Visual Studio designer for traditional Windows forms, WPF, or Web forms.