C# Basic: Aus Sicht eines Javascript-Entwicklers

Als Junior-Entwickler hatte ich immer Angst davor, eine „alte“ Programmiersprache zu lernen, die hauptsächlich das OOP-Paradigma verwendet. Heute habe ich jedoch beschlossen, es auszuprobieren und es zumindest auszuprobieren. Es ist nicht so schlimm, wie ich denke, es gibt Ähnlichkeiten, die es mit Javascript überträgt. Lassen Sie uns zunächst die Grundlagen durchgehen.

Dieser Blog setzt Kenntnisse von Javascript voraus

---

Das Grundlegende

Datentypen

Im Gegensatz zu Javascript, einer dynamisch typisierten Sprache, ist C# eine statisch typisierte Sprache: Der Datentyp einer Variablen ist zum Zeitpunkt der Kompilierung bekannt, was bedeutet, dass der Programmierer den Datentyp einer Variablen zum Zeitpunkt der Kompilierung angeben muss Erklärung.

int: number (32bit)
decimal: number (128bit)
string: string
bool: Boolean
list[]: Array
dictionary{}: Object

-------------- Declaration ----------------
int myInt = 2147483647;
decimal myDecimal = 0.751m; // The m indicates it is a decimal
string myString = "Hello World"; // Notice the double-quotes
bool myBool = true;

Liste/Array

Hinweis: Sie können die Länge nicht hinzufügen oder verlängern, wenn Sie Methode 1 und 2 verwenden
Listenmethode 1 deklarieren und zuweisen

string[] myGroceryArray = new string[2]; // 2 is the length
myGroceryArray[0] = "Guacamole";

Listenmethode 2 deklarieren und zuweisen

string[] mySecondGroceryArray = { "Apples", "Eggs" };

Listenmethode 3 deklarieren und zuweisen

List<string> myGroceryList = new List<string>() { "Milk", "Cheese" };
Console.WriteLine(myGroceryList[0]); //"Milk"
myGroceryList.Add("Oranges"); //Push new item to array

Mehrdimensionale Liste deklarieren und zuweisen

Die Anzahl der „,“ bestimmt die Abmessungen

string[,] myTwoDimensionalArray = new string[,] {
    { "Apples", "Eggs" },
    { "Milk", "Cheese" }
};

IEnumerable/Array

Ein Array, das speziell zum Aufzählen oder Durchlaufen verwendet wird.

Sie fragen sich vielleicht: „Was ist der Unterschied zur Liste?“ Die Antwort lautet:

Ein wichtiger Unterschied zwischen IEnumerable und List (neben einer Schnittstelle und einer konkreten Klasse) besteht darin, dass IEnumerable schreibgeschützt ist und List nicht.

List<string> myGroceryList = new List<string>() { "Milk", "Cheese" };

IEnumerable<string> myGroceryIEnumerable =  myGroceryList;

Wörterbuch/Objekt

Dictionary<string, string[]> myGroceryDictionary = new Dictionary<string, string[]>(){
    {"Dairy", new string[]{"Cheese", "Milk", "Eggs"}}
};

Console.WriteLine(myGroceryDictionary["Dairy"][2]);

Betreiber

Operatoren in C# verhalten sich sehr ähnlich wie Javascript, daher werde ich es hier nicht beschreiben

Bedingungen

//Logic gate
  //There's no === in C#
myInt == mySecondInt 
myInt != mySecondInt 

myInt >= mySecondInt
myInt > mySecondInt
myInt <= mySecondInt 
myInt < mySecondInt 

// If Else
if () {}
else if () {}
else () {}

// Switch
switch (number)
{
    case 1:
        Console.WriteLine("lala");
        break;
    default:
        Console.WriteLine("default");
        break;
}

Schleifen

? Die Verwendung von foreach ist viel schneller als die normale for-Schleife

int[] intArr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

int totalValue = 0;

for (int i = 0; i < intArr.Length; i++)
{
    totalValue += intArr[i];
}

int forEachValue = 0;

foreach (int num in intArr)
{
    forEachValue += num;
}

Verfahren

C# ist in erster Linie eine OOP-orientierte Sprache.

namespace HelloWorld
{
    internal class Program
    {
        static void Main()
        {
            int[] numArr = [1, 2, 3, 4, 5];
            int totalSum = GetSum(numArr);
        }

        static private int GetSum(int[] numArr)
        {
            int totalValue = 0;
            foreach (var item in numArr)
            {
                totalValue += item;
            }
            return totalValue;
        }
    }
}

Namespace und Modell deklarieren

Namespace wird zu Organisationszwecken verwendet, typischerweise zum Organisieren von Klassen

namespace HelloWorld.Models
{
    public class Computer
    {
        public string Motherboard { get; set; } = "";
        public int CPUCores { get; set; }
        public bool HasWIfi { get; set; }
        public bool HasLTE { get; set; }
        public DateTime ReleaseDate { get; set; }
        public decimal Price { get; set; }
        public string VideoCard { get; set; } = "";
    };
}

Ab C# 10 können wir Namespace auch als solchen deklarieren

namespace SampleNamespace;

class AnotherSampleClass
{
    public void AnotherSampleMethod()
    {
        System.Console.WriteLine(
            "SampleMethod inside SampleNamespace");
    }
}

Namensraum importieren

using HelloWorld.Models;

Das obige ist der detaillierte Inhalt vonC# Basic: Aus Sicht eines Javascript-Entwicklers. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!