19.01.
2024, 7:55 PM
Cheatsheets / Learn C#
Learn C#: Classes and Objects
C# Classes
In C#, classes are used to create custom types. using System;
The class defines the kinds of information and
methods included in a custom type.
namespace BasicClasses
{
class Forest {
public string name;
public int trees;
}
}
// Here we have the Forest class which
has two pieces of data, called fields.
They are the "name" and "trees" fields.
about:srcdoc Page 1 of 11
19.01.2024, 7:55 PM
C# Constructor
In C#, whenever an instance of a class is // Takes two arguments
created, its constructor is called. Like methods,
public Forest(int area, string country)
a constructor can be overloaded. It must have
the same name as the enclosing class. This is {
useful when you may want to define an this.Area = area;
additional constructor that takes a different
this.Country = country;
number of arguments.
}
// Takes one argument
public Forest(int area)
{
this.Area = area;
this.Country = "Unknown";
}
// Typically, a constructor is used to
set initial values and run any code
needed to “set up” an instance.
// A constructor looks like a method,
but its return type and method name are
reduced to the name of the enclosing
type.
about:srcdoc Page 2 of 11
19.01.2024, 7:55 PM
C# Parameterless Constructor
In C#, if no constructors are specified in a class, public class Freshman
the compiler automatically creates a
{
parameterless constructor.
public string FirstName
{ get; set; }
}
public static void Main (string[] args)
{
Freshman f = new Freshman();
// name is null
string name = f.FirstName;
}
// In this example, no constructor is
defined in Freshman, but a
parameterless constructor is still
available for use in Main().
C# Access Modifiers
In C#, members of a class can be marked with public class Speech
access modifiers, including public and
{
private . A public member can be
accessed by other classes. A private private string greeting =
member can only be accessed by code in the "Greetings";
same class.
By default, fields, properties, and methods are
private, and classes are public. private string FormalGreeting()
{
return $"{greeting} and
salutations";
}
public string Scream()
about:srcdoc Page 3 of 11
19.01.2024, 7:55 PM
{
return FormalGreeting().ToUpper();
}
public static void Main (string[] args)
{
Speech s = new Speech();
//string sfg = s.FormalGreeting(); //
Error!
//string sg = s.greeting; // Error!
Console.WriteLine(s.Scream());
}
// In this example, greeting and
FormalGreeting() are private. They
cannot be called from the Main()
method, which belongs to a different
class. However the code within Scream()
can access those members because
Scream() is part of the same class.
about:srcdoc Page 4 of 11
19.01.2024, 7:55 PM
C# Field
In C#, a field stores a piece of data within an public class Person
object. It acts like a variable and may have a
{
different value for each instance of a type.
A field can have a number of modifiers, private string firstName;
including: public , private , static , private string lastName;
and readonly . If no access modifier is
}
provided, a field is private by default.
// In this example, firstName and
lastName are private fields of the
Person class.
// For effective encapsulation, a field
is typically set to private, then
accessed using a property. This ensures
that values passed to an instance are
validated (assuming the property
implements some kind of validation for
its field).
about:srcdoc Page 5 of 11
19.01.2024, 7:55 PM
C# this Keyword
In C#, the this keyword refers to the current // We can use the this keyword to refer
instance of a class.
to the current class’s members hidden
by similar names:
public NationalPark(int area, string
state)
{
this.area = area;
this.state = state;
}
// The code below requires duplicate
code, which can lead to extra work and
errors when changes are needed:
public NationalPark(int area, string
state)
{
area = area;
state = state;
}
public NationalPark(int area)
{
area = area;
state = "Unknown";
}
// Use this to have one constructor
call another:
public NationalPark(int area) : this
(state, "Unknown")
{ }
about:srcdoc Page 6 of 11
19.01.2024, 7:55 PM
C# Members
In C#, a class contains members, which define class Forest
the kind of data stored in a class and the
{
behaviors a class can perform.
public string name;
public string Name
{
get { return name; }
set { name = value; }
}
}
// A member of a class can be a field
(like name), a property (like Name) or
a method (like get()/set()). It can
also be any of the following:
// Constants
// Constructors
// Events
// Finalizers
// Indexers
// Operators
// Nested Types
C# Dot Notation
In C#, a member of a class can be accessed with string greeting = "hello";
dot notation.
// Prints 5
Console.WriteLine(greeting.Length);
// Returns 8
Math.Min(8, 920);
about:srcdoc Page 7 of 11
19.01.2024, 7:55 PM
C# Class Instance
In C#, an object is an instance of a class. An Burger cheeseburger = new Burger();
object can be created from a class using the
// If a class is a recipe, then an
new keyword.
object is a single meal made from that
recipe.
House tudor = new House();
// If a class is a blueprint, then an
object is a house made from that
blueprint.
about:srcdoc Page 8 of 11
19.01.2024, 7:55 PM
C# Property
In C#, a property is a member of an object that public class Freshman
controls how one field may be accessed and/or
{
modified. A property defines two methods: a
get() method that describes how a field can private string firstName;
be accessed, and a set() method that
describes how a field can be modified.
public string FirstName
One use case for properties is to control access
to a field. Another is to validate values for a field. {
get { return firstName; }
set { firstName = value; }
}
}
public static void Main (string[] args)
{
Freshman f = new Freshman();
f.FirstName = "Louie";
// Prints "Louie"
Console.WriteLine(f.FirstName);
}
// In this example, FirstName is a
property
about:srcdoc Page 9 of 11
19.01.2024, 7:55 PM
C# Auto-Implemented Property
In C#, an auto-implemented property reads and public class HotSauce
writes to a private field, like other properties, but
{
it does not require explicit definitions for the
accessor methods nor the field. It is used with public string Title
the { get; set; } syntax. This helps your { get; set; }
code become more concise.
public string Origin
{ get; set; }
}
// In this example, Title and Origin
are auto-implemented properties. Notice
that a definition for each field (like
private string title) is no longer
necessary. A hidden, private field is
created for each property during
runtime.
about:srcdoc Page 10 of 11
19.01.2024, 7:55 PM
C# Static Constructor
In C#, a static constructor is run once per type, class Forest
not per instance. It must be parameterless. It is
{
invoked before the type is instantiated or a static
member is accessed. static Forest()
{
Console.WriteLine("Type
Initialized");
}
}
// In this class, either of the
following two lines would trigger the
static constructor (but it would not be
triggered twice if these two lines
followed each other in succession):
Forest f = new Forest();
Forest.Define();
C# Static Class
In C#, a static class cannot be instantiated. Its //Two examples of static classes
members are accessed by the class name.
calling static methods:
This is useful when you want a class that
provides a set of tools, but doesn’t need to
maintain any internal data. Math.Min(23, 97);
Math is a commonly-used static class.
Console.WriteLine("Let's Go!");
Print Share
about:srcdoc Page 11 of 11
