Cheatsheets / Beginner C#

Learn C#: Methods

Optional Parameters
In C#, methods can be given optional parameters. A
parameter is optional if its declaration specifies a default // y and z are optional parameters.
argument. Methods with an optional parameter can be static int AddSomeNumbers(int x, int y
called with or without passing in an argument for that = 3, int z = 2)
parameter. If a method is called without passing in an {
argument for the optional parameter, then the parameter
  return x + y + z;
is initialized with its default value.
}
To define an optional parameter, use an equals sign after
the parameter declaration followed by its default value.
// Any of the following are valid method
calls.
AddSomeNumbers(1); // Returns 6.
AddSomeNumbers(1, 1); // Returns 4.
AddSomeNumbers(3, 3, 3); // Returns 9.

Variables Inside Methods

Parameters and variables declared inside of a method
cannot be used outside of the method’s body. Attempting static void DeclareAndPrintVars(int x)
to do so will cause an error when compiling the program! {
  int y = 3;
  // Using x and y inside the method is
fine.
  Console.WriteLine(x + y);
}

static void Main()

{
  DeclareAndPrintVars(5);
  
  // x and y only exist inside the body of
DeclareAndPrintVars, so we cannot use them
here.
  Console.WriteLine(x * y);
}
Return Keyword
In C#, the return statement can be used to return a
value from a method back to the method’s caller. static int ReturnAValue(int x)
When return is invoked, the current method terminates {
and control is returned to where the method was   // We return the result of computing x *
originally called. The value that is returned by the method
10 back to the caller.
must match the method’s return type, which is specified
  // Notice how we are returning an int,
in the method declaration.
which matches the method's return type.
  return x * 10;
}

static void Main()

{
  // We can use the returned value any way
we want, such as storing it in a variable.
  int num = ReturnAValue(5);
  // Prints 50 to the console.
  Console.WriteLine(num);
}

Void Return Type

In C#, methods that do not return a value have a void
return type. // This method has no return value
void is not an actual data type like int or string , as it static void DoesNotReturn()
represents the lack of an output or value. {
  Console.WriteLine("Hi, I don't return
like a bad library borrower.");
}
// This method returns an int
static int ReturnsAnInt()
{
  return 2 + 3;
}
Out Parameters
return can only return one value. When multiple values
are needed, out parameters can be used. // f1, f2, and f3 are out parameters, so
out parameters are prefixed with out in the method they must be prefixed with `out`.
header. When called, the argument for each out static void GetFavoriteFoods(out string
parameter must be a variable prefixed with out . f1, out string f2, out string f3)
The out parameters become aliases for the variables
{
that were passed in. So, we can assign values to the
  // Notice how we are assigning values to
parameters, and they will persist on the variables we
passed in after the method terminates.
the parameters instead of using `return`.
  f1 = "Sushi";
  f2 = "Pizza";
  f3 = "Hamburgers";
}

static void Main()

{
  string food1;
  string food2;
  string food3;
  // Variables passed to out parameters
must also be prefixed with `out`.
  GetFavoriteFoods(out food1, out food2,
out food3);
  // After the method call, food1
= "Sushi", food2 = "Pizza", and food3
= "Hamburgers".
  Console.WriteLine($"My top 3 favorite
foods are {food1}, {food2}, and {food3}");
}
Method Declaration
In C#, a method declaration, also known as a method
header, includes everything about the method other than // This is an example of a method header.
the method’s body. The method declaration includes: static int MyMethodName(int parameter1,
string parameter2) {
● the method name
  // Method body goes here...
● parameter types }
● parameter order

● parameter names

● return type

● optional modifiers

A method declaration you’ve seen often is the declaration

for the Main method (note there is more than one valid
Main declaration):
static void Main(string[] args)

Expression-Bodied Methods
In C#, expression-bodied methods are short methods
written using a special concise syntax. A method can only static int Add(int x, int y)
be written in expression body form when the method {
body consists of a single statement or expression. If the   return x + y;
body is a single expression, then that expression is used }
as the method’s return value.
The general syntax is returnType funcName(args...) =>
static void PrintUpper(string str)
expression; . Notice how “fat arrow” notation, => , is
{
used instead of curly braces. Also note that the return
keyword is not needed, since the expression is implicitly   Console.WriteLine(str.ToUpper());
returned. }

// The same methods written in expression-

body form.
static int Add(int x, int y) => x + y;

static void PrintUpper(string str) =>

Console.WriteLine(str.ToUpper());
Lambda Expressions
A lambda expression is a block of code that is treated like
any other value or expression. It can be passed into int[] numbers = { 3, 10, 4, 6, 8 };
methods, stored in variables, and created inside methods. static bool isTen(int n) {
In particular, lambda expressions are useful for creating   return n == 10;
anonymous methods, methods with no name, to be }
passed into methods that require method arguments.
Their concise syntax is more elegant than declaring a
// `Array.Exists` calls the method passed
regular method when they are being used as one off
in for every value in `numbers` and
method arguments.
returns true if any call returns true.
Array.Exists(numbers, isTen);

Array.Exists(numbers, (int n) => {

  return n == 10;
});

// Typical syntax
// (input-parameters) => { <statements> }

Shorter Lambda Expressions

There are multiple ways to shorten the concise lambda
expression syntax. int[] numbers = { 7, 7, 7, 4, 7 };

● The parameter type can be removed if it can be

Array.Find(numbers, (int n) => { return n
inferred.
!= 7; });
● The parentheses can be removed if there is only
one parameter. // The type specifier on `n` can be
inferred based on the array being passed
As a side note, the usual rules for expression-bodied
methods also apply to lambdas.
in and the method body.
Array.Find(numbers, (n) => { return n !=
7; });

// The parentheses can be removed since

there is only one parameter.
Array.Find(numbers, n => { return n != 7;
});

// Finally, we can apply the rules for

expression-bodied methods.
Array.Find(numbers, n => n != 7);