Reference
https://en.wikipedia.org/wiki/C_Sharp_syntax#Object_initializers
https://docs.microsoft.com/en-us/dotnet/csharp/
Variables and Types
C# type keyword | .NET type | Example | Default Value |
---|---|---|---|
Primitive Data Types | |||
bool | System.Boolean | bool myBoolean = true; | false |
byte | System.Byte | 0 | |
sbyte | System.SByte | 0 | |
char | System.Char | char myChar = 'a'; | '\0' (U+0000) |
decimal | System.Decimal | 0 | |
double | System.Double | double myDouble = 1.75; | 0 |
float | System.Single | float myFloat = 1f; | 0 |
int | System.Int32 | int a = 123; System.Int32 b = 123; |
0 |
uint | System.UInt32 | 0 | |
long | System.Int64 | 0 | |
ulong | System.UInt64 | 0 | |
short | System.Int16 | 0 | |
ushort | System.UInt16 | 0 | |
Reference Data Types | null | ||
object | System.Object | ||
string | System.String | string myName = "John"; |
Access Modifier
public protected internal private
protected internal
private protected
Modifier
abstract async await const event
extern in new out override
readonly sealed static unsafe virtual
volatile
Statement Keywords
if else switch case
do for foreach in while
break continue default goto return yield
throw try-catch try-finally try-catch-finally
checked unchecked
fixed
lock
Method Parameters
// Parameters declared for a method without in, ref or out, are passed to the called method by value.
// *params* specifies that this parameter may take a variable number of arguments.
public static void UseParams2(params object[] list)
{
...
UseParams2({ 2, 'b', "test", "again" });
// *in* specifies that this parameter is passed by reference but is only read by the called method.
InArgExample(readonlyArgument);
..
void InArgExample(in int number)
{
// Uncomment the following line to see error CS8331
//number = 19;
}
// *ref* specifies that this parameter is passed by reference and may be read or written by the called method.
void Method(ref int refArgument)
{
refArgument = refArgument + 44;
}
int number = 1;
Method(ref number);
Console.WriteLine(number);
// Output: 45
// *out* specifies that this parameter is passed by reference and is written by the called method.
int initializeInMethod;
OutArgExample(out initializeInMethod);
Console.WriteLine(initializeInMethod); // value is now 44
void OutArgExample(out int number)
{
number = 44;
}
Null Conditional Operator (?.)
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(FirstName)));
Enums
public enum CarType
{
Toyota = 1,
Honda = 2,
Ford = 3,
}
CarType myCarType = CarType.Toyota;
Struct
public struct Coords
{
public Coords(double x, double y)
{
X = x;
Y = y;
}
public double X { get; }
public double Y { get; }
public override string ToString() => $"({X}, {Y})";
}
Strings
string myString = "A string.";
String myString = "A string.";
string emptyString = String.Empty;
string anotherEmptyString = "";
string fullName = firstName + " " + lastName;
sentence += "chess.";
string sumCalculation = String.Format("{0} + {1} = {2}", x, y, sum);
// Use string interpolation to concatenate strings.
string str = $"Hello {userName}. Today is {date}."; // Interpolated string
Arrays
/*
* Single Dimensional Arrays
*/
int[] nums = { 1, 2, 3, 4, 5 };
int[] nums = new int[10];
/*
* Multidimensional Arrays
*/
int[,] matrix = new int[2,2];
matrix[0,0] = 1;
matrix[0,1] = 2;
matrix[1,0] = 3;
matrix[1,1] = 4;
int[,] predefinedMatrix = new int[2,2] { { 1, 2 }, { 3, 4 } };
Lists
List<int> numbers = new List<int>();
int[] array = new int[] { 1, 2, 3 };
numbers.AddRange(array);
Dictionaries
Dictionary<string, long> phonebook = new Dictionary<string, long>();
phonebook.Add("Alex", 4154346543);
phonebook["Jessica"] = 4159484588;
Conditionals
/*
* if-else
*/
if (a == b) {
// We already know this part
} else {
// a and b are not equal... :/
}
/*
* for-loops
*/
for(int i = 0; i < 16; i++)
{
if(i == 12)
{
break;
}
}
/*
* while-loops
*/
while(n == 0)
{
Console.WriteLine("N is 0");
n++;
}
Methods
public static int Multiply(int a, int b)
{
return a * b;
}
Interface
interface ISkills
{
void language();
void sport();
}
Class
abstract class Staff:Object, ISkills // inherits a class and implements an interface
{
public enum StaffType { Teacher, Student }; // enum
private StaffType type;
public StaffType Type { get => type; set => type = value; } // property
/*
* Constructor
*/
public Staff(string name, StaffType type):base() // call parent constructor
{
this.name = name;
this.type = type;
}
abstract public void sayHere(); // abstract method
}
Object Initializer
Person person = new Person {
Name = "John Doe",
Age = 39
}; // Object Initializer
// Equal to
Person person = new Person();
person.Name = "John Doe";
person.Age = 39;
Nullable / Non-nullable reference types
// Nullable
string? name; // ignore the compiler null check with name!.Length;
// Non-nullable
string name;
Lambda expressions
(input-parameters) => expression
(input-parameters) => { <sequence-of-statements> }
Action line = () => Console.WriteLine();
Func<int, int, bool> testForEquality = (x, y) => x == y;
Property
public class Person
{
public string FirstName;
public string FirstName { get; set; }
public string FirstName { get; set; } = string.Empty;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
public string FirstName
{
get => firstName;
set => firstName = value;
}
public string FirstName { get; private set; }
public string FullName => $"{FirstName} {LastName}";
}
Indexers
public int this[string key]
{
get { return storage.Find(key); }
set { storage.SetAt(key, value); }
}
// Multi-Dimensional Maps
public int this [double x, double y]
{
get
{
var iterations = 0;
...
Deconstruction (Tuple and Object)
// _ is a Discards
/*
* Tuple
*/
public static void Main()
{
var (_, _, _, pop1, _, pop2) = QueryCityDataForYears("New York City", 1960, 2010);
...
private static (string, double, int, int, int, int) QueryCityDataForYears(string name, int year1, int year2)
{
...
/*
* Object
*/
public Person(string fname, string mname, string lname, string cityName, string stateName)
{
...
public void Deconstruct(out string fname, out string lname, out string city, out string state)
{
fname = FirstName;
lname = LastName;
city = City;
state = State;
}
var p = new Person("John", "Quincy", "Adams", "Boston", "MA");
// Deconstruct the person object.
var (fName, _, city, _) = p;
...
Generic
// Declare the generic class.
public class Generic<T>
{
public T Field;
}
public static void Main()
{
Generic<string> g = new Generic<string>();
g.Field = "A string";
//...
Console.WriteLine("Generic.Field = \"{0}\"", g.Field);
Console.WriteLine("Generic.Field.GetType() = {0}", g.Field.GetType().FullName);
}
Top comments (0)