Learn C#

This error usually means you labeled a static constructor as public or private, which is not allowed

This usually means you tried to reference a non-static member from a class, instead of from an instance

This usually means that you tried to reference a static member from an instance, instead of from the class

while (playerIsAlive) 
{ 
// this code will keep running
 
  if (playerIsAlive == false) 
  { 
    // eventually if this stopping condition is true, 
    // it will break out of the while loop
    break; 
   } 
 } 

class MainClass {
 public static void Main (string[] args) {
   UnlockDoor();
 
  // after it hits the return statement, it will move on to this method
   PickUpSword();
 }
 
 static bool UnlockDoor()
 {
   bool doorIsLocked = true;
 
   // this code will keep running
   while (doorIsLocked)
   {
     bool keyFound = TryKey();
 
      // eventually if this stopping condition is true,
      // it will break out of the while loop
     if (keyFound)
     {
      // this return statement will break out of the entire method
      return true;
     }
   }
   return false;
 }
}

int bats = 10;
 
for (int i = 0; i <= 10; i++)
{
  if (i < 9)
  {  
    continue;
  }
  // this will be skipped until i is no longer less than 9
  Console.WriteLine(i);
}

public int Area
{
  get { return area; }
  set 
  { 
    if (value < 0) { area = 0; }
    else { area = value; }
  }
}

// instead of :
public string size;
public string Size
{
  get { return size; }
  set { size = value; }
}
// use:
public string Size
{ get; set; }

// assume you have a private variable,
// we make it private cause we just don't want other classes
// to be able to set this property withous certain validation
// , other classes just can read this property
private double balance;
// now to be able to read this from other class and also do a
// certain validation before any kind of seting a new value for
// it, we can make a property for it:
// so final code looks like this:
private double balance;
public double Balance
{
    get
    {
        return balance;
    }
    set
    {
        // do some validation, e.g. convert negative numbers to
        // positive ones, value is a keyword which refers to the
        // value that we give to this property
        balance = value;
    }
}

class Forest
{
  public int Area;
 
  public Forest(int area)
  {
    Area = area;
  }
}

// e.g: in following example Definition of Forest class is static:
class Forest
{
  private static string definition;
  public static string Definition
  { 
    get { return definition; }
    set { definition = value; }
  }
}
// so you can not use e.g: f.Definition but can use Forest.Definition

answer 1:
Typically we use static constructors to set values to static fields and properties. like:

class Forest 
{
  static Forest()
  { /* ... */ }
}

in other word, if you want e.g. use a method from a class instatiated object you shouldn’t use static keyword for it, otherwise you must
e.g. you never gona use Porgram p = new Program() and then sth like p.Main() !!! so you will use static for your Main method 🙂

answer 2:

• Before an object is made from the type.
  Forest f  = new Forest();
• Before a static member is accessed.
  Forest.Define();

These two common classes are static because they are just tools — they don’t need specific instances and they don’t store new information.

Math.Min(34, 54);
Console.WriteLine("yeehaw!");
// these are two static classes calling two static methods.

sets of actions and values that describe how a class can be used. e.g.:

interface IAutomobile
{
  string Id { get; }
  void Vroom(); // we don’t need body  of methods in interfaces
}

// Interface vs Class infographic:
Class       | | | |
Interface     | |
// indeed, when we implement an interface for a class
// we are telling that class, you must have all of these
// properties/methods but you can have more
// e.g. you shoudld have wheels and body but you can also
// have headsup displayer

//For example, in Sedan:

base.SpeedUp();
//refers to the SpeedUp() method in Vehicle.

//There’s special syntax for calling the superclass constructor:

class Sedan : Vehicle
{
  public Sedan (double speed) : base(speed)
  {
  }
}

// In the superclass, we mark the method in question as virtual, which tells the computer “this member might be overridden in subclasses”:

public virtual void SpeedUp()
// In the subclass, we mark the method as override, which tells the computer “I know this member is defined in the superclass, but I’d like to override it with this method”:

public override void SpeedUp()
// As an aside: there’s another way to solve this problem. Instead of using virtual and override to override a member, we can define a new member with the same name. Essentially, the inherited member still exists, but it is “hidden” by the member in the subclass.

Dissertation diss1 = new Dissertation();
Dissertation diss2 = diss1;
diss1.CurrentPage = 0;
diss2.CurrentPage = 16;
Console.WriteLine(diss1.CurrentPage);
Console.WriteLine(diss2.CurrentPage);
// above code will print 16, 16 not 0, 16

Classes are reference types. That means that when we create a new instance of a class and store it in a variable, the variable is a reference to the object.

Since it is a class, it is a reference type. In some cases its behavior looks like a value type:

• A string reference will always point to the original object, so “modifying” one reference to a string will not affect other references
  

  // Example 1
  string dog = "chihuahua";
  string tinyDog = dog;
  dog = "dalmation";
  Console.WriteLine(dog);
  // Output: "dalmation"
  Console.WriteLine(tinyDog);
  // Output: "chihuahua"

• Comparing strings with the equality operator (==) performs a value, not referential, comparison
  

  string s = "hello";
  string t = "hello";
  // b is true
  bool b = (s == t);

• Like other reference types, string references can be null or unassigned. They can also have a third value: empty.
  

  string s; // Unassigned
  string s2 = null; // Null
  string s3 = ""; // Empty string
  string s4 = String.Empty; // Also empty string
  Console.WriteLine(s3 == s4); // This prints true

   

• unassigned means that the programmer did not give the variable any value
• null means that the programmer intentionally made the variable refer to no object
• an empty string signifies a piece of text with zero characters. This is often used to represent a blank text field. It can be represented by "" or String.Empty

The Microsoft Programming Guide suggests using String.Empty or "" instead of null to avoid NullReferenceException errors.

We can check for null OR empty strings using the static String method IsNullOrEmpty(). It’s explained in more detail in the documentation.

// value comparison
int int1 = 6;
int int2 = 6;
Console.WriteLine(int1 == int2); // Output: true

// referential comparison
Dissertation d1 = new Dissertation(50);
Dissertation d2 = new Dissertation(50);
Console.WriteLine(d1 == d2); // Output: false

When we compare reference types with ==, the C# compiler performs a referential comparison, which means it checks if two variables refer to the same memory location. For example, this prints false because d1 and d2 refer to two different locations in memory (even though they contain objects with the same values)

References of Different Types

Before going any further, let’s remind ourselves that Dissertation implements IFlippable, which has the CurrentPage property and Flip() method. You’ll need this info in a minute.

In our previous example both references to the Dissertation object were of type Dissertation:

Dissertation diss1 = new Dissertation();
Dissertation diss2 = diss1;

Whenever we use diss1 and diss2 we can handle the Dissertation object as if it were a Dissertation type. Since Dissertation also implements the IFlippable interface, we can reference it that way too:

Dissertation diss = new Dissertation(50);
IFlippable fdiss = diss;

Now diss and fdiss refer to the same object, but fdiss is an IFlippable reference, so it can ONLY use IFlippable functionality:

diss.Flip();
fdiss.Flip();
Console.WriteLine(diss.Define());
// This causes an error!
Console.WriteLine(fdiss.Define());

This last line causes an error because Define() is not a method in the IFlippable interface. The other lines do NOT cause errors because they use members that both IFlippable and Dissertation have.

This rule also applies to base classes too, so we can refer to a Dissertation object as Book.

Dissertation diss = new Dissertation(50);
Book bdiss = diss;
Console.WriteLine(diss.Title);
Console.WriteLine(bdiss.Title);
diss.Define();
// This causes an error!
bdiss.Define();

Title is defined for Book, so no error is thrown there. Define(), however, is not defined for the Book class, so we can’t use it with Book references.

to have the same interface for multiple data types. This is a common concept across many programming languages, and it’s called polymorphism.

The concept really includes two related ideas. A programming language supports polymorphism if:

1. Objects of different types have a common interface (interface in the general meaning, not just a C# interface), and
2. The objects can maintain functionality unique to their data type

Object

so Objects are the most top superClass for all classes

so we can have:

Object o1 = new Dissertation();
Object o2 = new Diary();
Object o3 = new Random();
Object o4 = new Forest("Amazon");

but if we do so, we will loose 2 things:
1- We lose all of a specific type’s specific functionality when we reference it as an Object type.
2- We would also lose the automatic type-checking that saves us from type errors

class Book
{}

class Book : Object
{}

Object o5 = 21;
Object o6 = false;
Object o7 = "Hello you!";

• They have a limited length
• You have to keep track of the number of elements in the array using a separate index
• You can only edit one element at a time

Formally, .NET is “an open source developer platform, created by Microsoft, for building many different types of applications. You can write .NET apps in C#, F#, Visual C++, or Visual Basic.”

Informally, .NET is the tool that lets you build and run C# programs (we’ll avoid F#, Visual C++, Visual Basic for now)
in other words: To build programs with C#, you need the .NET platform

When you download .NET, you’re really downloading a bunch of programs that:

• Translate your C# code into instructions that a computer can understand
• Provide utilities for building software, like tools for printing text to the screen and finding the current time
• Define a set of data types that make it easier for you to store information in your programs, like text, numbers, and dates

• .NET Framework is the original version of .NET that only runs on Windows computers.
• .NET Core is the new, cross-platform version of .NET that runs on Windows, MacOS, and Linux computers. Since it’s more flexible and Microsoft is actively enhancing this version, we’ll be using this one throughout the path.
  
  

Conveniently, Microsoft itself plans to rename .NET Core to .NET towards the end of 2020.

The Razor Pages architecture goes like this: Every page of our website is represented by two files:

• A view page, that displays information, and
• A page model, which handles the accessing and processing of information.

Razor Pages can also be used to make things other than web pages, like APIs and microservices. In those cases we wouldn’t need a view page, we’d just use page models.

<Grid Margin="10">
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*"/>
        <ColumnDefinition Width="*"/>
        <ColumnDefinition Width="*"/>
        <ColumnDefinition Width="*"/>
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="2*"/>
        <RowDefinition Height="*"/>
        <RowDefinition Height="*"/>
        <RowDefinition Height="*"/>
        <RowDefinition Height="*"/>
        <RowDefinition Height="*"/>
    </Grid.RowDefinitions>
    <Label Content="0" 
           Grid.ColumnSpan="4"
           VerticalContentAlignment="Bottom"
           HorizontalContentAlignment="Right"
           Background="white"/>
    <Button Margin="10"
            Background="Red"
            Content="1"
            Grid.Row="1"/>
</Grid>

<StackPanel VerticalAlignment="Center" Margin="40,10">
            <Label Content="Paradise-hub" Margin="0,0,0,10" Foreground="white" HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="72" FontFamily="Cambria"/>
            <TextBox Text="0" Margin="0,0,0,10"/>
            <TextBox Text="0" Margin="0,0,0,10"/>
            <Button Content="Calculate" Background="DodgerBlue" Foreground="White" Padding="10"/>
        </StackPanel>

 <TextBlock Text="Line1&#x0a;Line 2"/>

or:

<TextBlock>
    Lorem <LineBreak/>
    Ipsum
</TextBlock>

// approach 1:
var filteredList = contacts.Where(c => c.Name.ToLower().Contains(searchTextBox.Text.ToLower())).ToList();
// approach 2:
var filteredList2 = (from c2 in contacts
                                   where c2.Name.ToLower().Contains(searchTextBox.Text.ToLower())
                                   select c2.Id).ToList();

// instead of :
using(SQLiteConnection conn = new(App.DbPath))
{
    conn.CreateTable<Contact>();
    contacts = conn.Table<Contact>().ToList();
}
// we can use :
using SQLiteConnection conn = new(App.DbPath);
conn.CreateTable<Contact>();
contacts = conn.Table<Contact>().ToList();

// because It tells the compiler that the variable being
// declared should be disposed at the end of the enclosing scope