C#: A Brief Introduction

This is intended to be a short introduction to the C# language. I won’t go into syntax or cover the principles of Object-Oriented Programming but I will be describing the language through reference to other languages.

Please let me know if there’s any confusion and I will edit the post suitably.

So… you want to learn C#.

Me too!

I’ve started learning C# through Udemy courses and books (links for each at the end of the article) with the intent of developing multi-platform applications. But enough about me, on to what you really care about.

C# (C Sharp)

C# was developed by Microsoft as an Object-Oriented version of the C language for their .NET Framework (be on the lookout for separate posts on OOP and the .NET Framework in the future).

C# is statically-typed (or strongly-typed), which means that every variable and object has a well-defined type (Ky, 2013).

Every variable and constant has a type, as does every expression that evaluates to a value.

Methods have unique signatures which specify the type(s) of input parameters that they can accept and also what type of value they return.

Statically-typed languages check to make sure all operations use the appropriate types at compile time. 

C# is a High-Level Language (HLL)

Programming languages can be categorized based on their level of abstraction from the details of the computer.

Original computers relied on a series of binary switches that were configured manually or according to a program of 0s and 1s or binary digits (bits). This is not always the case with the onset of quantum processors which utilizes a superposition which operates on an entirely different paradigm. While it would be possible to build every program using 0s and 1s, it would be very difficult for most people to read (Vahid & Lysecky, 2017).

This led to the development of assembly language which was a little easier to read, that is closer to the way humans communicate. Assembly language compiles to (translates to) the binary machine code (0s and 1s) which your computer understands.

Assembly language can be thought of as being one level of abstraction from the computer.

Abstraction?

Think of it like your smartphone. It has only a few buttons on it. You know WHAT those buttons do but don’t need to know HOW they do it.

Make sense? Think of it like Back to the Future…

Marty McFly didn’t need to understand how Doc’s Delorean Time-Machine worked or what a Flux Capacitor does. He simply needed to know how to turn it on, put in a date, and floor it until 88mph! The details which made this amazing machine work were abstracted from Marty.

(Gale & Canton, 1985).

/*Abstraction is also a fundamental aspect of Object-Oriented Programming which can be explained in a similar manner. More on this in a later post. This is also how to use a block comment in C#!*/

//This a single-line comment in C#!

As the field of software development evolved, languages like COBOL, Fortran, and others began to crop up with the same intent as the Assembly language. They were easier for people to read and write. C# doesn’t have the programmer directly dealing with details of the computer. The programmer doesn't need to know how what's going on behind the scene that enables her program to work. That said, knowing can be very valuable. 

Languages similar to C#:

• C
• C++
• Java

C# was derived from C and also incorporated some aspects of C++ and Java. If you’ve written code in any of these languages, C# syntax shouldn’t be terribly difficult to pick up on (Ky, 2013).

Unlike C++ and C, C# handles garbage collection for us! This means that memory management or direct memory manipulation isn’t necessary.

You see, processors have limited amounts of memory (cache) and use Random Access Memory (RAM) as a buffer. The more complicated an operation or series of operations is, the more often it needs to use the RAM as a buffer. But the RAM isn’t accessed as quickly as the processor’s cache (Vahid & Lysecky, 2017).

Some languages require the direct manipulation of memory, assigning variable values to specific addresses and more. In C++ raw pointers, variables which hold an address in memory, were often used and required that the pointers be deleted when they were no longer needed. But the ways that values were passed as method arguments often resulted in memory leaks – or loss of access to portions of memory because of declared, unused, un-deleted pointers. The introduction of smart pointers (self-deleting pointers) helped to alleviate this but with C# memory management requires nearly no developer-involvement (Microsoft, 2019).

This memory management is referred to as garbage collection.

Furthermore, where you might see multiple inheritance in other languages like C++, C# does not support multiple inheritance.

In a personnel management software we might have two classes Faculty and Student that have specific characteristics (like PayRate for Faculty and TuitionRate for Students).

But what about a Student Aide that’s on the payroll?

In C++ you could have a StudentAide class which inherits properties from both the Faculty and Student classes.

Not so in C#...

The issue is that multiple inheritance can caused what referred to as the “diamond problem”. Essentially if both the Faculty and Student classes had properties or methods with the same name, the compiler wouldn’t be able to determine which one to use when a new instance of a StudentAide object occurred.

C# Doesn’t Compile to Executable Code – at least not directly

Yep, you read that correctly.

Because C# was designed to work within the .NET Framework, C# doesn’t compile to machine-executable code, at least not directly. The .NET Framework enables a C# developer to code once and push to multiple platforms (Windows, iOS, Android, Xbox, and more). In order to enable this, code written in C# is compiled to Common Intermediate Language (CIL) which can only run on the Common Language Runtime (CLR). 

“The CLR is a native application that interprets CIL code” and then compiles that into the appropriate native code for the platform it’s on (Ky, 2013).

I’ll go into a bit more detail on the .NET Framework, C# syntax, OOP and other topics covered above at a later date. But for now, I hope that this has given you a general idea of what C# is.

Important takeaways:

C# is an Object-Oriented Programming Language (OOP)

C# is statically typed

C# is a high-level language

C# handles garbage collection!

C# doesn't support multiple inheritance

C# doesn't compile to machine-executable code

C# compiles to Common Intermediate Language (CIL)

CIL on runs on Common Language Runtime (CLR)

CLR compiles to the native code for the appropriate platform

References:

Gale, B. & Canton, N. (1985). Back to the Future. Universal Studios.

Ky, J. (2013). C#: A beginner’s tutorial. [Montreal, CAN]: Brainy Software Inc., 2013. Retrieved from https:://search.ebscohost.com.proxy-library.ashford.edu/login.aspx?direct=true&db=ca t02191a&AN=aul.10882077&site=eds-live&scope=site

Microsoft. (4 April 2019). A Tour of the C# Language. Retrieved from https://docs.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/index

Vahid, F., & Lysecky, S. (2017). Computing technology for all. Retrieved from zybooks.zyante.com/