Updated October 17, 2023
Introduction to C# Versions
C# is a high-level programming language created by Microsoft that offers versatility and power to developers. It has undergone multiple iterations, each bringing improvements and new features to make it more efficient and user-friendly. These changes have helped developers to build modern software applications with ease. From its beginnings with C# 1.0 to the latest version, C# 10.0, this article will guide you through the most significant advancements and their impact on the world of software development. Understanding these changes is essential for developers who want to take advantage of C#’s full potential.
Versions of C#
Here we will discuss the Versions of C#. Given below are the Versions of C#:
1. C# Version 1.0
This version is like java. Its lack in the async capabilities and some functionalities. The major features of this release are below
Classes: It is a blueprint that is used to create the objects.
- There can be only one public class per file.
- Comments can appear at the beginning or end of any line.
- If there is a public class in a file, the name of the file must match the name of the public class.
- If exists, the package statement must be the first line.
- import statements must go between the package statement(if there is one) and the class declaration.
- If there are no package or import statements, the class declaration must be the first line in the source code file.
- import and package statements apply to all classes within a source code file.
- File with no public classes can have a name that need not match any of the class names in the file.
Code:
// declaring public class
public class Test
{
// variable
public int a, b;
// member function
public void display()
{
WriteLine("Class in C#");
}
}Structure: In Struct, we can store different data types under a single variable. We can use user-defined datatype in structs. We have to use the struct keyword to define this.
Code:
using System;
namespace ConsoleApplication {
// structure
public struct Emp
{
// different data types
public string Name;
public int Age;
public int Empno;
}
class Geeks {
// Main Method
static void Main(string[] args)
{
// Declare P1 of type Person
Person P1;
// P1's data
P1.Name = "Ram";
P1.Age = 21;
P1.Empno = 80;
// Displaying the values
Console.WriteLine("Data Stored in P1 is " +
P1.Name + ", age is " +
P1.Age + " and empno is " +
P1.empno);
}
}
}Interfaces:
- The interface is used as a contract for the class.
- All interface methods are implicitly public and abstract.
- All interface variables are public static final.
- static methods not allowed.
- The interface can extend multiple interfaces.
- Class can implement multiple interfaces.
- Class implementing interface should define all the methods of the interface or it should be declared abstract.
Literals: It is a value used by the variable. This is like a constant value.
Code:
class Test {
// Main method
public static void Main(String []args)
{
int a = 102;
// octal-form literal
int b = 0145
;
// Hexa-decimal form literal
int c = 0xFace;
Console.WriteLine(a);
Console.WriteLine(b);
Console.WriteLine(c);
}
}Delegates: This is like a pointer. It is a reference type variable which holds the other methods.
2. C# Version 1.2
In this version, some enhancement has been done. They added for each loop in this version which will execute each block until an expression gets false.
3. C# Version 2.0
In this version, they have added below advance features.
Generics: Generic programming is a style of computer programming in which algorithms are written in terms of types to-be-specified-later that are then instantiated when needed for specific types provided as parameters.
Anonymous Method: This is a blank method. This is defined using the keyword delegate.
- Nullable type: Before this release, we can not define a variable as null. So this release overcomes this.
- Iterators
- Covariance and contravariance
- Getter/setter separate accessibility: We can use a getter setter for getting and setting the values.
4. C# Version 3.0
This version made C# as a formidable programming language.
- Object and collection initializers: With the help of this we can access any field without invoking constructor.
- Partial Method: As the name suggests its signature and implementations defined separately.
- Var: We can define any variable by using the keyword var.
5. C# Version 4.0
The version introduced some interesting features:
Dynamic Binding: This is like method overriding. Here the compiler does not decide the method which to call.
Code:
public class ClassA
{
public static class superclass
{
void print()
{
System.out.println("superclass.");
}
}
public static class subclass extends superclass
{
@Override
void print()
{
System.out.println("subclass.");
}
}
public static void main(String[] args)
{
superclass X = new superclass();
superclass Y= new subclass();
X.print();
Y.print();
}
}- Named/Optional Arguments
- Generic Covariant and Contravariant
- Embedded Interop Types
Here the major feature was keyword dynamic. It overrides the compiler at run time.
6. C# Version 5.0
In this version, they added two new models for asynchronous programming.
async and await
With these, we easily retrieve information about the context. This is very helpful with long-running operations. In this async enables the keyword await. With the help of await keyword, all the things get asynchronous. So it runs synchronously till the keyword await.
7. C# Version 6.0
This version included below functionalities
- Static imports
- Expression bodied members
- Null propagator
- Await in catch/finally blocks
- Default values for getter-only properties
- Exception filters
- Auto-property initializers
- String interpolation
- name of the operator
- Index initializers
8. C# Version 7.0
This version has below advantages
Out Variables: This variable is basically used when the method has to return multiple values. The keyword out is used to pass to the arguments.
Other important aspects are
- Tuples and deconstruction.
- Ref locals and returns.
- Discards: These are write-only ready variables. Basically this is used to ignore local variables.
- Binary Literals and Digit Separators.
- Throw expressions
- Pattern matching: We can use this on any data type.
- Local functions: With the help of this function we can declare the method in the body which is already defined in the method.
- Expanded expression-bodied members.
9. C# Version 8.0
C# 8.0, released in 2019, introduced nullable reference types, a significant feature to enhance code safety. It enables developers to annotate their code to express their intentions about whether a variable can hold a null value, helping to catch null reference exceptions at compile time. Additionally, C# 8.0 brought improvements like asynchronous streams, simplifying the development of asynchronous and reactive applications, and enhancements to pattern matching. These features collectively make code more reliable, readable, and efficient, making C# 8.0 a valuable step in the language’s evolution for modern software development.
10. C# Version 9.0
C# 9.0, released in 2020, brought significant enhancements to the language. Its standout feature was the introduction of record types, simplifying the creation of data classes by providing built-in value equality, immutability, and pattern matching. It also introduced source generators, enabling automatic code generation at compile-time, which enhances code generation and analysis. Additionally, C# 9.0 improved pattern matching with new features and added support for function pointers and top-level statements, making code more concise and readable. These changes enhanced developer productivity and code safety, solidifying C# as a modern, versatile programming language.
11. C# Version 10.0
C# version 10.0 is the latest C# programming language version, released on Nov, 2021. It includes several new features and improvements to make it more efficient and easier to use. Some notable features of C# 10.0 include:
- Global usings: This feature enables developers to define global directives for the entire program.
- File-scoped namespaces: With this feature, developers can define namespaces at the file level, which makes it easier to organize code and avoid naming conflicts.
- Improved lambda support: C# 10.0 introduces improved lambda expressions, allowing developers to write shorter, more concise code.
- Interpolated strings as format strings: This feature allows developers to use interpolated strings as format strings, simplifying the process of formatting strings.
- Improved pattern matching: C# 10.0 includes improvements to pattern matching that make it more powerful and flexible.
- New features in the .NET runtime: C# 10.0 also includes new features in the .NET runtime, such as support for ARM64 and performance improvements for JIT compilation.
12. C# Version 11.0
C# 11 introduced several new features, including raw string literals, generic math support, generic attributes, UTF-8 string literals, newlines in string interpolation expressions, list patterns, file-local types, required members, auto-default structs, pattern matching for Span<char> on a constant string, extended nameof scope, numeric IntPtr, ref fields, scoped ref, improved method group conversion to delegate, and the seventh warning wave. These additions aimed to enhance the language’s versatility, performance, and developer experience, offering improved tools and capabilities for software development.
So every version has included new features in the C# which help the developers to solve the complex problems in efficient manner.
Recommended Articles
We hope that this EDUCBA information on “C# Versions” was beneficial to you. You can view EDUCBA’s recommended articles for more information.
