Tự học ngôn ngữ lập trình C# (C Sharp) cơ bản đến nâng cao

₵# là một ngôn ngữ lập trình đa chức năng, hiện đại & là loại ngôn ngữ lập trình hướng đối tượng được phát âm là “C Sharp”. Nó được lớn mạnh bởi Microsoft do Anders Hejlsberg & nhóm của ông đi đầu trong ý tưởng ​​.NET & đã được Hiệp hội các nhà cung cấp laptop Châu Âu (ECMA) & Tổ chức Tiêu chí Quốc tế (ISO) chứng nhận. ₵# là một trong những ngôn ngữ giành riêng cho cơ sở hạ tầng ngôn ngữ chung. ₵# rất giống với Java về mặt cú pháp & rất đơn giản dàng học & ứng dụng so với người dùng có kiến ​​thức về ₵, ₵ ++ hoặc Java.

Hiện tại, ngôn ngữ lập trình ₵# đã trở nên phổ cập & có thể sử dụng được cho nhiều áp dụng khác nhau như: lập trình áp dụng di động, lớn mạnh trò chơi hay lớn mạnh software công ty. Trong công nghiệp, ngôn ngữ ₵# được sử dụng trong các áp dụng lập trình nhúng, lập trình cho các bộ điều khiển (PLC, RTU, PAC,..) hay lập trình cho các software công nghiệp. Biết ₵# mở ra cho bạn rất là nhiều cánh cửa lớn khi bạn xác nhận là một nhà lớn mạnh, một lập trình viên trong tương lai.

Học phải đi đôi với hành, một mớ lý thuyết sẽ khiến bạn chán ngấy, khó hiểu, khó nhớ, khó đủ đường & sẽ làm bạn đơn giản bỏ cuộc. Vậy tất cả chúng ta hãy bắt tay vào vừa học vừa thực hành ngay từ những thứ cơ bản (tạo chương trình Hello World trước nhất) cho đến những tri thức nâng cao nhé!

Hello World

Write Line

Console.WriteLine("Hello, world!");

// Prints: Hello, world!

Cú pháp Console.WriteLine() được sử dụng để viết, in “text – văn bản” trong bảng điều khiển. Nó cũng có thể được sử dụng để in các kiểu dữ liệu & giá trị khác được lưu trữ trong các biến.

Read Line

Console.WriteLine("Enter your name: ");

name = Console.ReadLine();

Cú pháp Console.ReadLine() được sử dụng để lấy thông tin đầu vào của người dùng. Đầu vào của người dùng có thể được lưu trữ trong một biến. Cú pháp này cũng có thể được sử dụng để nhắc người dùng nhấn ENTER trên keyboard.

Comments

// This is α single line phản hồi

/* This is α multi-line phản hồi and continues
until the end of phản hồi symbol is reached */

Chú giải (“nhận xét”, “bình luận”) là các đoạn văn bản không được thực thi. Những dòng này có thể được sử dụng nhằm để lại chú thích với mục đích tăng tính dễ đọc cho chương trình.

  • Chú thích dòng đơn được tạo với hai dấu gạch chéo về phía trước //.
  • Chú thích nhiều dòng được tạo khởi đầu với /* & chấm dứt với */. Nó rất hữu dụng cho việc chú thích các khối mã lớn.

.NET Platform

.NET là một mã nguồn mở, Free, đa nền móng, được các nhà lớn mạnh sử dụng để xây dựng nhiều áp dụng khác nhau.

Với .NET, bạn có thể sử dụng đa ngôn ngữ, trình căn chỉnh & các thư viện có sẵn để xây dựng áp dụng cho website, thiết bị di động, laptop máy tính, trò chơi hay IoT. Cho dù bạn đang sử dụng ngôn ngữ ₵#, ₣# hay Visual Basic để làm việc thì code của các bạn sẽ chạy nguyên bản trên bất kỳ HĐH nào tương thích với nền móng .NET & sẽ giúp bạn giải quyết các công việc nặng nhọc một cách đơn giản hơn.

Biến & kiểu dữ liệu trong ₵#

Write Line

Console.WriteLine("Hello, world!");

// Prints: Hello, world!

Cú pháp Console.WriteLine() được sử dụng để viết, in “text – văn bản” trong bảng điều khiển. Nó cũng có thể được sử dụng để in các kiểu dữ liệu & giá trị khác được lưu trữ trong các biến.

Biến & loại biến trong ₵#

string foo = "Hello";
string bar = "How are you?";

int Ҳ = 5;
Console.WriteLine(foo);
// Prints: Hello

Trong ngôn ngữ lập trình ₵# (₵ Sharp), một biến là một phương pháp để lưu trữ dữ liệu trong bộ nhớ lưu trữ của sản phẩm tính để được sử dụng sau này (tái sử dụng) trong chương trình. ₵# là một ngôn ngữ tường minh, nghĩa là khi các biến được khai báo thì cần phải xác nhận kiểu dữ liệu của chúng..

Việc khai báo các loại biến cho phép trình biên dịch dừng chương trình đang chạy khi các biến được sử dụng sai, tức là một lệnh int được sử dụng thì cần sử dụng một string hoặc trái lại..

Toán tử số học

int result; 

result = 10 + 5; // 15
result = 10 - 5; // 5
result = 10 * 5; // 50
result = 10 / 5; // 2
result = 10 % 5; // 0

Toán tử số học được sử dụng để sửa đổi các giá trị số:

  • + cộng toán tử
  • - trừ toán tử
  • * nhân toán tử
  • / chia toán tử
  • % toán tử modulo (trả lại phần còn sót lại)

Phối hợp toán tử (Unary Operator)

int α = 10;
α++;

Console.WriteLine(α);
// Prints: 11

Các toán tử có thể được phối hợp để tạo thành các câu lệnh ngắn hơn nhằm sửa đổi các biến hiện có lập tức hơn. Hai chẳng hạn thông dụng:

  • ++ tăng một giá trị toán tử.
  • -- giảm một giá trị toán tử.

Tìm căn bậc 2 trong ₵#

// Input positive value, Output square root of Ҳ

Console.Write(Math.Sqrt(Ҳ));
//OUTPUT: 9

Trong ngôn ngữ lập trình ₵#, Math.Sqrt() là hàm được sử dụng để tính căn bậc 2 của giá trị được chỉ định.

Math.Pow() trong ₵#

// Find power using Math.Pow
// 6 is base and 2 is power or
// index or exponent of α number

double pow_ab = Math.Pow(6, 2);
// Print the result

Console.WriteLine(pow_ab);
//OUTPUT: 36

Trong ₵#, Math.Pow() là hàm được sử dụng để nâng một số lên lũy thừa xác nhận. Nó sẽ trả về một số loại kép.

Nối chuỗi ký tự trong ₵#

// Declare strings
string firstName = "Divyesh";
string lastName = "Goardnan";

// Concatenate two string variables
string name = firstName + " " + lastName;
Console.WriteLine(name);
//Ths code will output Divyesh Goardnan

Nối chuỗi là quá trình nối một chuỗi vào một chuỗi khác. Mẹo dễ dàng nhất để nối hai chuỗi trong ₵ # là sử dụng toán tử +.

Ký tự tự thoát trong ₵#

Trong ngôn ngữ lập trình ₵ # (₵ Sharp), một chuỗi thoát đề cập đến một tổ hợp các ký tự khởi đầu bằng dấu gạch chéo ngược “” & theo sau là các chữ cái hoặc chữ số. Nó được sử dụng để bảo đảm rằng chương trình đọc các ký tự khẳng định như một phần của chuỗi. Chẳng hạn, nó có thể được sử dụng để lấy các ký tự trong dấu ngoặc kép trong một chuỗi mà bạn mong muốn in ra bảng điều khiển. Chuỗi tự thoát cũng có thể làm những việc khác bằng cách dùng các ký tự rõ ràng và cụ thể. Chẳng hạn: ɳ được sử dụng để tạo thành một dòng mới.

Nội suy chuỗi trong ₵#

int id = 100
// We can use an expression with α string interpolation.
string multipliedNumber = $"The multiplied ID is {id * 10}.";

Console.WriteLine(multipliedNumber);
// This code would output "The multiplied ID is 1000."

Nội suy chuỗi là sử dụng các cú pháp dễ đọc & thuận lợi hơn để tạo thành chuỗi được định dạng. Nó cho phép chèn các giá trị & biểu thức biến vào giữa một chuỗi & không phải lo ngại về dấu chấm câu hoặc dấu cách.

String New-Line

Console.WriteLine("HellonWorld");

// The console output will look like:
// Hello
// World

Sự phối hợp ký tự ɳ đại diện cho một mẹo tạo một dòng ký tự mới bên trong string của ngôn ngữ ₵#.

Chẳng hạn như: "HellonWorld" trong Console.WriteLine() sẽ in ra dòng Hello & World trên các dòng biệt lập trong bảng điều khiển.

.toUpper() trong ₵#

string str2 = "This is C# Program xsdd_$#%";
// string converted to Upper case

string upperstr2 = str2.ToUpper();
//upperstr2 contains "THIS IS C# PROGRAM XSDD_$#%"

Trong ₵#, .ToUpper() được sử dụng để chuyển hóa mọi ký tự trong chuỗi thành chữ hoa. Nếu một ký tự không có chữ hoa tương tự thì nó sẽ không bao giờ thay đổi. Chẳng hạn, các ký hiệu đặc biệt không bao giờ thay đổi.

.ToLower() trong ₵#

string mixedCase = "This is a MIXED case string.";
// Call ToLower instance method, which returns α new sao chép.

string lower = mixedCase.ToLower();
//variable lower contains "this is a mixed case string."

Trong ₵#, .ToLower() được sử dụng để chuyển hóa mọi ký tự trong chuỗi thành chữ thường. Nếu một ký tự không có chữ thường tương tự thì nó sẽ không bao giờ thay đổi. Chẳng hạn, các ký hiệu đặc biệt không bao giờ thay đổi.

Độ dài chuỗi (String Length) trong ₵#

string α = "One example";

Console.WriteLine("LENGTH: " + α.Length);
// This code outputs 11

Trong hàm string có lớp tính chất Length, tính chất này trả về số ký tự trong chuỗi.

IndexOf() trong ₵#

string str = "Divyesh";
// Finding the index of character
// which is present in string and
// this will show the value 5

int index1 = str.IndexOf('s');
Console.WriteLine("The Index Value of character 's' is " + index1);
//The Index Value of character 's' is 5

Trrong ₵#, IndexOf() được sử dụng để tìm địa điểm chỉ mục của một ký tự được chỉ định trong một chuỗi. Kết quả trả về -1 nếu như không tìm ra ký tự.

Substring() trong ₵#

string myString = "Divyesh";
string test1 = myString.Substring(2);

Trong ngôn ngữ lập trình ₵# (₵ Sharp), Substring() được sử dụng để truy xuất một phần của chuỗi trong lúc vẫn giữ nguyên dữ liệu gốc. Chuỗi con mà bạn truy xuất có thể được lưu trữ trong một biến để sử dụng ở những nơi khác trong chương trình của các bạn.

Ký hiệu dấu ngoặc []

// Get values from this string.
string value = "Dot Net Perls";

//variable first contains letter ?
char first = value[0];

//Second contains letter σ
char second = value[1];

//last contains letter s
char last = value[value.Length - 1];

Chuỗi chứa các ký tự. Một cách có thể truy vấn được các giá trị char đó là bằng ký hiệu dấu ngoặc […]. Thậm chí có thể lưu trữ các ký tự này trong các biến biệt lập.

Truy cập một ký tự rõ ràng và cụ thể bằng cách dùng dấu ngoặc vuông […] trên chuỗi, đặt địa điểm chỉ mục của ký tự mong đợi giữa các dấu ngoặc. Chẳng hạn, để lấy ký tự trước nhất, bạn có thể chỉ định là  variable[0]. Để lấy ký tự cuối cùng, bạn lấy độ dài của chuỗi trừ đi một ký tự .

Read Line

Console.WriteLine("Enter your name: ");
name = Console.ReadLine();

Lệnh Console.ReadLine() được sử dụng để lấy thông tin đầu vào của người dùng. Đầu vào của người dùng có thể được lưu trữ trong một biến. Cú pháp này cũng có thể được sử dụng để nhắc người dùng nhấn ENTER trên keyboard.

Comment trong ₵#

// This is α single line phản hồi
/* This is α multi-line phản hồi and continues
until the end of phản hồi symbol is reached */

Chú giải (“nhận xét”, “bình luận”) là các đoạn văn bản không được thực thi. Những dòng này có thể được sử dụng nhằm để lại chú thích với mục đích tăng tính dễ đọc cho chương trình.

  • Chú thích dòng đơn được tạo với hai dấu gạch chéo về phía trước //.
  • Chú thích nhiều dòng được tạo khởi đầu với /* & chấm dứt với */. Nó rất hữu dụng cho việc chú thích các khối mã lớn.

Logic & Điều kiện

Bảng Logic (Truth Table)

Bảng Logic là một phương pháp để đơn giản hình dung logic boolean. Vì boolean chỉ có hai giá trị khả dụng, điều đó có nghĩa là tất cả chúng ta có thể liệt kê một cách ngăn nắp trong bảng toàn bộ các cặp đầu vào & đầu ra có thể xảy ra cho toán tử boolean đơn phân & nhị phân.

Hình ảnh dưới đây trổ tài Bảng Logic cho các toán tử NOT, AND, NAND, OR, NOR, XOR & XNOR. So với mỗi hàng, cột cuối cùng đại diện cho đầu ra & các cột khác là đầu vào cho toán tử tương ứng.

Kiểu Boolean

bool skyIsBlue = true;
bool penguinsCanFly = false;

Console.WriteLine($"True or false, is the sky blue? {skyIsBlue}.");
/* This simple program illustrates how booleans are declared.
However, the real power of booleans requires additional programming
constructs such as conditionals.*/

Cú pháp bool trả về kiểu dữ liệu true hoặc false & sẽ dựa theo tính hợp lệ của toàn bộ các câu lệnh logic phải là đúng hoặc sai.

Mã hóa Boolean vào laptop, cho phép tự suy luận logic trong các chương trình. Hiểu theo nghĩa rộng, laptop có thể mã hóa tính trung thực hay sai lệch của một dữ liệu được chỉ định & dựa theo thông tin đó, hoàn toàn biến đổi hoạt động của chương trình.

Biểu thức Boolean

// These expressions all evaluate to α boolean value.
// Therefore their values can be stored in boolean variables.
bool α = (2 > 1);
bool ɓ = α && true;
bool ͼ = !false || (7 < 8);

Biểu thức boolean là những biểu thức bất kỳ nào được nhìn nhận hoặc trả về giá trị boolean.

Toán tử so sánh trong ₵#

int Ҳ = 5;
Console.WriteLine(Ҳ < 6);
// Prints "True" because 5 is less than 6.

Console.WriteLine(Ҳ > 8);
// Prints "False" because 5 is not greater than 8.

string foo = "foo";
Console.WriteLine(foo == "bar");
// Prints "False" because "foo" does not equal "bar".

Một toán tử so sánh, như tên của nó, so sánh hai biểu thức & trả về true hoặc false  tùy thuộc vào vào kết quả của phép so sánh. Chẳng hạn: nếu tất cả chúng ta so sánh hai giá trị int, tất cả chúng ta có thể kiểm soát xem một số có to hơn số kia hay không hoặc cả hai số đều bằng nhau. Tương đương, tất cả chúng ta có thể kiểm soát một  string  có bằng nhau với một  string khác không.

Toán tử Logic trong ₵#

// These variables equal true.
bool α = true && true;
bool ɓ = false || true;
bool ͼ = !false;

// These variables equal false.
bool {d} = true && false;
bool e = false || false;
bool ƒ = !true;

Toán tử logic nhận biểu thức boolean làm đầu vào & trả về giá trị boolean.

Toán tử && nhận 2 biểu thức boolean & chỉ trả về giá trị true nếu cả 2 đều được nhìn nhận là true.

Toán tử || nhận 2 biểu thức boolean & trả về giá trị là true nếu 1 trong 2 biểu thức được nhìn nhận là true.

Toán tử ! nhận 1 biểu thức boolean & trả về giá trị trái lại.

Luồng điều khiển (Control Flow)

Trong lập trình, luồng điều khiển là thứ tự thực hiện các câu lệnh & lệnh. Người lập trình có thể biến đổi luồng điều khiển của chương trình bằng cách dùng các kết cấu điều khiển có điều kiện.

Khả năng biến đổi quy trình & kiểm tra của chương trình rất khỏe mạnh vì nó cho phép tất cả chúng ta bố trí hoạt động của chương trình đang chạy tùy thuộc vào vào tình trạng của chương trình. Chẳng hạn: giả sử một người dùng đang sử dụng áp dụng bank & mong muốn rút 1.000.000 VND. Tất cả chúng ta chắc nịch mong muốn áp dụng hoạt động với các cơ chế khác nhau tùy thuộc vào vào việc người dùng có 20.000 VND hay 50.000.000 VND trong account bank của họ!

Điều khiển có điều kiện (Conditional Control)

Câu lệnh điều kiện hoặc kết cấu điều khiển có điều kiện cho phép một chương trình có các hành động khác nhau tùy thuộc vào vào các điều kiện khẳng định được thỏa mãn.

Về mặt trực quan, điều này bắt chiếc cách nhân loại đề ra các quyết định & hành động theo chúng. Chẳng hạn, lý luận về việc đi ra ngoài có thể như sau:

  • Điều kiện: bên ngoài trời có mưa không?
    • Nếu trời đang mưa, hãy đưa theo ô.
    • Nếu trời không mưa, thì không đưa theo ô.

Tất cả chúng ta có thể tiếp tục thêm các mệnh đề để khiến cho lập luận trở nên cầu kỳ hơn, ví dụ như “Nếu trời nắng thì hãy bôi kem chống nắng”.

Câu lệnh If (nếu-thì) trong ₵#

if (true) {
// This code is executed.
Console.WriteLine("Hello User!");
}

if (false) {
// This code is skipped.
Console.WriteLine("This won't be seen :(");
}

Trong ngôn ngữ lập trình ₵ # (₵ Sharp), câu lệnh if thực thi một tính năng dựa theo việc biểu thức boolean được phân phối trong dấu ngoặc đơn có “phải” hay “không” <=> true hay false.

Nếu là “phải” tức là true thì sẽ thực hiện tiếp các mã, khối lệnh trong dấu ngoặc {}, nếu “không” thì sẽ bỏ qua.

Câu lệnh Else (không thì) trong ₵#

if (true) {
// This block will run.
Console.WriteLine("Seen!");
} else {
// This will not run.
Console.WriteLine("Not seen!");
}

if (false) {
// Conversely, this will not run.
Console.WriteLine("Not seen!");
} else {
// Instead, this will run.
Console.WriteLine("Seen!");
}

Một lệnh else theo sau sẽ là dấu ngoặc {} chứa một khối mã lệnh. Trước lệnh else thì cần có mệnh đề khác đặt trước câu lệnh if .

Khối bên trong dấu ngoặc của lệnh else chỉ được thực hiện khi điều kiện của câu lệnh iffalse. Tức là khối mã lệnh trong câu lệnh if không được thực thi thì khi đó mới đến khối mã lệnh trong câu lệnh else.

If & Else If (nếu-nếu không thì) trong ₵#

int Ҳ = 100, y = 80;
if (Ҳ &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; y)
{
Console.WriteLine("x is greater than y");
}
else if (Ҳ &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt; y)
{
Console.WriteLine("x is less than y");
}
else
{
Console.WriteLine("x is equal to y");
}

Một mã câu lệnh thông dụng khi viết nhiều câu lệnh if & else là có một khối lệnh else được lồng câu lệnh if, & có thể chứa thêm lệnh else khác, etc. Một cách tốt hơn để trổ tài những tính năng này trong ₵# là sử dụng lệnh else if . Điều kiện trước nhất được nhìn nhận là true thì sẽ chạy khối mã được link của nó. Nếu được nhìn nhận là false, thì các khối mã lệnh else sẽ được chạy (nếu tồn tại).

Lệnh Switch trong ₵#

// The expression to match goes in parentheses.
switch (fruit) {
case "Banana":
// If fruit == "Banana", this block will run.
Console.WriteLine("Peel first.");
break;
case "Durian":
Console.WriteLine("Strong smell.");
break;
default:
// The default block will catch expressions that did not match any above.
Console.WriteLine("Nothing to say.");
break;
}

// The switch statement above is equivalent to this:
if (fruit == "Banana") {
Console.WriteLine("Peel first.");
} else if (fruit == "Durian") {
Console.WriteLine("Strong smell.");
} else {
Console.WriteLine("Nothing to say.");
}

Lệnh switch là một kết cấu luồng điều khiển nhận xét một biểu thức & quyết định khối mã nào sẽ chạy bằng cách xét độ khớp kết quả của biểu thức với từng trường hợp case. Nói chung, một khối mã được thực thi khi giá trị cho case bằng với biểu thức được nhìn nhận, tức là khi sử dụng toán tử so sánh == giữa hai giá trị trả về true. Lệnh switch thường được dùng để thay thế cho kết cấu lệnh if else khi điều kiện kiểm soát đều là sự so sánh bằng hay không bằng một giá trị.

Lệnh ngắt (Break) trong ₵#

string color = "blue";

switch (color) {
case "red":
Console.WriteLine("I don't like that color.");
break;
case "blue":
Console.WriteLine("I like that color.");
break;
default:
Console.WriteLine("I feel ambivalent about that color.");
break;
}
// Regardless of where the break statement is in the above switch statement,
// breaking will resume the program execution here.
Console.WriteLine("- Steve");

Một trong những tác dụng của lệnh break trong ₵# là để thoát ra khỏi khối lệnh switch/case & sau đó tiếp tục thực thi các chương trình sau khối mã lệnh switch . Trong ₵#, mỗi khối mã case trong một câu lệnh switch cần được thoát ra bằng lệnh break (hoặc bằng một số câu lệnh jump khác), nếu như không thì chương trình sẽ chẳng thể biên dịch. Nó sẽ được gọi ra sau khoảng thời gian toàn bộ các chương trình rõ ràng và cụ thể trong case đã được thực thi.

Toán tử bậc 3 (Ternary Operator)

bool isRaining = true;
// This sets umbrellaOrNot to "Umbrella" if isRaining is true,
// and "No Umbrella" if isRaining is false.
string umbrellaOrNot = isRaining ? "Umbrella" : "No Umbrella";

// "Umbrella"
Console.WriteLine(umbrellaOrNot);

Trong ₵ #, toán tử bậc ba là một cú pháp đặc biệt có dạng: condition ? expression1 : expression2.

Nó nhận một điều kiện boolean & hai biểu thức làm đầu vào. Không giống như câu lệnh if statement, toán tử bậc ba tự nó là một biểu thức. Nó nhận xét biểu thức đầu vào trước nhất hoặc biểu thức đầu vào thứ hai tùy thuộc vào vào điều kiện tương ứng là đúng hay sai tức là true hay false.

Công thức (Methods)

Công thức bên trong các biến

static void DeclareAndPrintVars(int Ҳ)
{
int y = 3;
// Using Ҳ and y inside the method is fine.
Console.WriteLine(Ҳ + y);
}

static void Main()
{
DeclareAndPrintVars(5);

// Ҳ and y only exist inside the body of DeclareAndPrintVars, so we cannot use them here.
Console.WriteLine(Ҳ * y);
}

Chẳng thể sử dụng các tham số & biến được khai báo bên trong một mẹo bên ngoài phần thân của mẹo. Nỗ lực làm như thế sẽ gây ra lỗi khi biên dịch chương trình!

Các tham số tùy chọn trong ₵#

// y and z are optional parameters.
static int AddSomeNumbers(int Ҳ, int y = 3, int z = 2)
{
return Ҳ + y + z;
}

// Any of the following are valid method calls.
AddSomeNumbers(1); // Returns 6.
AddSomeNumbers(1, 1); // Returns 4.
AddSomeNumbers(3, 3, 3); // Returns 9.

Trong ₵ #, các mẹo có thể được phân phối các tham số tùy chọn. Một tham số là tùy chọn nếu khai báo của nó chỉ định một đối số mặc định. Các mẹo với một tham số tùy chọn có thể được gọi có hoặc không có truyền vào một đối số cho tham số đó. Nếu một mẹo được gọi mà không truyền đối số cho tham số tùy chọn, thì tham số được khởi tạo với giá trị mặc định của nó.

Để xác nhận một tham số tùy chọn, hãy sử dụng dấu bằng sau phần khai báo tham số, theo sau là giá trị mặc định của nó.

Lệnh trả về (Return) trong ₵#

static int ReturnAValue(int Ҳ)
{
// We return the result of computing Ҳ * 10 back to the caller.
// Notice how we are returning an int, which matches the method's return type.
return Ҳ * 10;
}

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

Trong ₵ #, câu lệnh return có thể được sử dụng để trả về một giá trị từ một mẹo & trở lại trình gọi của mẹo đó.

Khi lệnh return được gọi, mẹo bây giờ chấm dứt & sẽ điều khiển được trả về nơi mẹo ban đầu được gọi. Giá trị được mẹo trả về phải khớp với kiểu trả về của mẹo, được chỉ định trong khai báo mẹo.

Kiểu trả về Void (Void Return Type)

// This method has no return value
static void DoesNotReturn()
{
Console.WriteLine("Hi, I don't return like a bad library borrower.");
}
// This method returns an int
static int ReturnsAnInt()
{
return 2 + 3;
}

Trong ₵ #, các mẹo không return một giá trị có một kiểu trả về void.

void không phải là một kiểu dữ liệu thực tiễn như int hay string, vì nó đại diện cho việc thiếu đầu ra hoặc giá trị.

Tham số Out

// f1, f2, and f3 are out parameters, so they must be prefixed with `out`.
static void GetFavoriteFoods(out string f1, out string f2, out string f3)
{
// Notice how we are assigning values to 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}");
}

return chỉ có thể trả về một giá trị. Khi cần nhiều giá trị thì có thể sử dụng tham số out.

Tham số out được khởi đầu bằng out trong tiêu đề mẹo. Khi được gọi, đối số cho mỗi tham số out phải là một biến có tiền tố out.

Tham số out số trở thành bí danh (tên thứ 2) cho các biến được chuyển vào. Vì thế, tất cả chúng ta có thể gán giá trị cho các tham số & chúng sẽ tồn tại trên các biến mà tất cả chúng ta đã truyền vào sau khoảng thời gian mẹo chấm dứt.

Khai báo mẹo

// This is an example of α method header.
static int MyMethodName(int parameter1, string parameter2) {
// Method body goes here...
}

Trong ₵ #, một khai báo mẹo, có cách gọi khác là tiêu đề mẹo, bao gồm mọi thứ về mẹo ngoài phần thân của mẹo. Khai báo mẹo bao gồm:

  • tên mẹo
  • kiểu tham số
  • thứ tự tham số
  • tên tham số
  • kiểu trả về
  • bổ ngữ tùy chọn

Khai báo mẹo thường thấy là khai báo cho mẹo Main (có thể khai báo nhiều Main): static void Main(string[] args)

Phần thân của mẹo

static int Add(int Ҳ, int y)
{
return Ҳ + y;
}

static void PrintUpper(string str)
{
Console.WriteLine(str.ToUpper());
}

// The same methods written in expression-body form.
static int Add(int Ҳ, int y) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; Ҳ + y;

static void PrintUpper(string str) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; Console.WriteLine(str.ToUpper());

Trong ₵ #, thân mẹo là các biểu thức ngắn được viết bằng một cú pháp ngắn gọn đặc biệt. Một mẹo chỉ có thể được viết ở dạng thân biểu thức khi thân mẹo bao gồm một câu lệnh hoặc biểu thức duy nhất. Nếu phần thân là một biểu thức đơn lẻ, thì biểu thức đó được sử dụng làm giá trị trả về của mẹo.

Cú pháp chung là returnType funcName(args...) => expression;. Cảnh báo cách ký hiệu =>, được sử dụng thay cho dấu ngoặc nhọn. Cũng chú ý rằng lệnh return là không thiết yếu, vì biểu thức được trả về ngầm định.

Biểu thức Lambda

int[] numbers = { 3, 10, 4, 6, 8 };
static bool isTen(int ɳ) {
return ɳ == 10;
}

// `Array.Exists` calls the method passed in for every value in `numbers` and returns true if any call returns true.
Array.Exists(numbers, isTen);

Array.Exists(numbers, (int ɳ) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; {
return ɳ == 10;
});

// Typical syntax
// (input-parameters) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; { &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;statementsvàamp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; }

Biểu thức lambda là một khối mã được giải quyết giống như bất kỳ giá trị hoặc biểu thức nào khác. Nó có thể được truyền vào các mẹo, được lưu trữ trong các biến & được tạo thành bên trong các mẹo.

Đặc biệt, các biểu thức lambda rất hữu dụng để tạo các mẹo ẩn danh, các mẹo không có tên, để được truyền vào các mẹo yêu cầu đối số mẹo. Cú pháp ngắn gọn của chúng thanh tao hơn đối với khai báo một mẹo thông thường khi chúng được sử dụng như một đối số mẹo riêng rẽ.

Biểu thức Lambda ngắn gọn (Shorter Lambda)

int[] numbers = { 7, 7, 7, 4, 7 };

Array.Find(numbers, (int ɳ) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; { return ɳ != 7; });

// The type specifier on `ɳ` can be inferred based on the array being passed in and the method body.
Array.Find(numbers, (ɳ) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; { return ɳ != 7; });

// The parentheses can be removed since there is only one parameter.
Array.Find(numbers, ɳ =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; { return ɳ != 7; });

// Finally, we can apply the rules for expression-bodied methods.
Array.Find(numbers, ɳ =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; ɳ != 7);

Có nhiều phương pháp để rút ngắn cú pháp biểu thức lambda cho ngắn gọn.

  • Kiểu tham số có thể được loại bỏ nếu nó có thể được suy ra.
  • Dấu ngoặc đơn có thể được loại bỏ nếu chỉ có một tham số.

Cảnh báo thêm, các nguyên tắc thông thường cho các mẹo trổ tài biểu thức cũng vận dụng cho  biểu thức lambda.

Mảng & vòng lặp (Arrays & Loops)

Mảng (Arrays) trong ₵#

// `numbers` array that stores integers
int[] numbers = { 3, 14, 59 };

// 'characters' array that stores strings
string[] characters = new string[] { "Huey", "Dewey", "Louie" };

Trong ₵ #, một mảng là một kết cấu đại diện cho một tập hợp các giá trị hoặc đối tượng có cùng kiểu theo thứ tự có độ dài cố định.

Mảng giúp đơn giản tổ chức & vận hành trên một lượng lớn dữ liệu. Chẳng hạn: thay vì tạo 100 biến số nguyên, bạn chỉ cần tạo một mảng lưu trữ toàn bộ các số nguyên đó!

Khai báo mảng trong ₵#

// Declare an array of length 8 without setting the values.
string[] stringArray = new string[8];

// Declare array and set its values to 3, 4, 5.
int[] intArray = new int[] { 3, 4, 5 };

Biến mảng trong ₵ # được khai báo cũng giống như một biến không phải là mảng, với việc bổ sung dấu ngoặc vuông ([]) sau mã lệnh định dạng kiểu để biểu thị nó là một mảng.

Lệnh new được sử dụng khi khởi tạo một mảng mới để gán cho biến, cũng như độ dài mảng trong dấu ngoặc vuông. Mảng cũng có thể được khởi tạo bằng các giá trị bằng dấu ngoặc nhọn ({}). Trong trường hợp này, độ dài mảng là không thiết yếu.

Khai báo & khởi tạo mảng cùng một lúc

// `numbers` and `animals` are both declared and initialized with values.
int[] numbers = { 1, 3, -10, 5, 8 };
string[] animals = { "shark", "bear", "dog", "raccoon" };

Trong ₵ #, một cách được sử dụng để một mảng có thể được khai báo & khởi tạo cùng một lúc là gán mảng mới khai báo vào danh mục các giá trị được phân chia bằng dấu phẩy bao quanh bởi dấu ngoặc nhọn ({}). Cảnh báo cách tất cả chúng ta có thể bỏ qua kiểu định dạng & từ new ở phía bên phải của bài tập khi sử dụng cú pháp này. Điều này chỉ có thể thực hiện được trong lúc khai báo mảng.

Truy cập phần tử mảng

// Initialize an array with 6 values.
int[] numbers = { 3, 14, 59, 26, 53, 0 };

// Assign the last element, the 6th number in the array (currently 0), to 58.
numbers[5] = 58;

// Store the first element, 3, in the variable `first`.
int first = numbers[0];

Trong ngôn ngữ lập trình ₵# (₵ Sharp), các phần tử của một mảng được gắn nhãn tăng dần, khởi nguồn từ 0 cho phần tử trước nhất. Chẳng hạn: phần tử thứ 3 của một mảng sẽ được lập chỉ mục ở số 2 & phần tử thứ 6 của mảng sẽ được lập chỉ mục ở số 5 của mảng.

Một phần tử rõ ràng và cụ thể có thể được truy cập bằng cách dùng toán tử dấu ngoặc vuông, bao quanh chỉ mục bằng dấu ngoặc vuông. Sau thời điểm được truy cập, phần tử có thể được sử dụng trong một biểu thức hoặc được sửa đổi như một biến thông thường.

Độ dài mảng (Array Length) trong ₵#

int[] someArray = { 3, 4, 1, 6 };
Console.WriteLine(someArray.Length); // Prints 4

string[] otherArray = { "foo", "bar", "baz" };
Console.WriteLine(otherArray.Length); // Prints 3

Tính chất Length của một mảng ₵ # có thể được sử dụng để lấy số phần tử trong một mảng rõ ràng và cụ thể.

Vòng lặp For trong ₵#

// This loop initializes ι to 1, stops looping once ι is greater than 10, and increases ι by 1 after each loop.
for (int ι = 1; ι &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;= 10; ι++) {
Console.WriteLine(ι);
}

Console.WriteLine("Ready or not, here I come!");

Vòng lặp for trong ₵# dùng thực hiện một tập hợp các lệnh cho một số lần xác nhận, dựa theo ba biểu thức được phân phối. Ba biểu thức được phân chia bằng dấu chấm phẩy & theo thứ tự là:

  • Khởi tạo: Điều này được chạy chuẩn xác một lần khi khởi đầu vòng lặp, hay được dùng để khởi tạo biến cho biến lặp của vòng lặp.
  • Điều kiện dừng: Biểu thức boolean này được kiểm soát trước mỗi lần lặp để xem nó có chạy tiếp hay không.
  • Câu lệnh lặp: Được thực hiện sau mỗi lần lặp của vòng lặp, hay được dùng để update biến trình lặp.

Vòng lặp For Each trong ₵#

string[] states = { "Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado" };

foreach (string state in states) {
// The `state` variable takes on the value of an element in `states` and updates every iteration.
Console.WriteLine(state);
}
// Will print each element of `states` in the order they appear in the array. 

Một vòng lặp foreachtrong ₵ # dùng để chạy một tập hợp các lệnh một lần cho mỗi phần tử trong một tập hợp khẳng định.  Chẳng hạn: nếu một mảng có 200 phần tử, thì phần thân của vòng lặp foreach sẽ thực thi 200 lần. Khi khởi đầu mỗi lần lặp, một biến được khởi tạo cho phần tử bây giờ đang được giải quyết.

Nó được khai báo bằng lệnh foreach. Kế tiếp, trong dấu ngoặc đơn, một loại biến & tên biến theo sau là từ in & tập hợp để lặp lại.

Vòng lặp While trong ₵#

string guess = "";
Console.WriteLine("What animal am I thinking of?");

// This loop will keep prompting the user, until they type in "dog".
while (guess != "dog") {
Console.WriteLine("Make a guess:");
guess = Console.ReadLine();
}
Console.WriteLine("That's right!");

Trong ₵ #, vòng lặp while thực thi một tập hợp các lệnh liên tục trong lúc biểu thức boolean đã cho nhận xét là true hoặc một trong các lệnh bên trong thân vòng lặp, ví dụ như lệnh break chấm dứt vòng lặp.

Cảnh báo rằng phần thân của vòng lặp có thể hoàn toàn không chạy, vì điều kiện boolean được nhìn nhận trước lần lặp trước nhất của vòng lặp while.

Cú pháp khai báo vòng lặp while dễ dàng là từ while theo sau là điều kiện boolean trong ngoặc đơn.

Vòng lặp Do While trong ₵#

do {
DoStuff();
} while(boolCondition);

// This do-while is equivalent to the following while loop.

DoStuff();
while (boolCondition) {
DoStuff();
}

Trong ₵ #, vòng lặp do while chạy một tập các lệnh một lần & sau đó tiếp tục chạy miễn là điều kiện boolean đã nghĩ rằng true. Cảnh báo rằng quá trình này gần giống với vòng lặp while, với điểm nhấn là do while chạy một hoặc nhiều lần & vòng lặp while không chạy hoặc chạy nhiều lần.

Cú pháp khai báo do while là từ do kế tiếp là khối mã, sau này là từ while với điều kiện boolean trong ngoặc đơn. Cảnh báo rằng dấu chấm phẩy là thiết yếu để chấm dứt vòng lặp do while.

Vòng lặp vô hạn trong ₵#

while (true) {
// This will loop forever unless it contains some terminating statement such as `break`.
}

Vòng lặp vô hạn là vòng lặp không khi nào chấm dứt vì điều kiện dừng của nó luôn false. Một vòng lặp vô hạn có thể hữu dụng nếu một chương trình bao gồm liên tục thực thi một đoạn mã. Bên cạnh đó, một vòng lặp vô hạn không chủ ý có thể khiến một chương trình bị treo & không bình luận do bị mắc kẹt trong vòng lặp.

Một chương trình đang chạy trong một trình bao hoặc thiết bị đầu cuối bị mắc kẹt trong một vòng lặp vô hạn có thể được chấm dứt bằng cách chấm hết quá trình.

Lệnh Jump trong ₵#

while (true) {
Console.WriteLine("This prints once.");
// ? `break` statement immediately terminates the loop that contains it.
break;
}

for (int ι = 1; ι &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;= 10; ι++) {
// This prints every number from 1 to 10 except for 7.
if (ι == 7) {
// ? `continue` statement skips the rest of the loop and starts another iteration from the start.
continue;
}
Console.WriteLine(ι);
}

static int WeirdReturnOne() {
while (true) {
// Since `return` exits the method, the loop is also terminated. Control returns to the method's caller.
return 1;
}
}

Câu lệnh nhảy được sử dụng để phân phối cho lập trình viên quyền kiểm tra bổ sung so với luồng điều khiển của chương trình. Chúng rất hay được dùng trong ngữ cảnh của các vòng lặp để thoát khỏi vòng lặp hoặc để bỏ qua các phần của vòng lặp.

Các lệnh kiểm tra luồng bao gồm breakcontinue, & return.

Lớp & đối tường (Class & Object)

Class trong ₵#

using System;

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.

Trong ₵ #, các lớp được sử dụng để tạo các kiểu tùy chỉnh. Lớp khái niệm các loại thông tin & mẹo có trong một loại tùy chỉnh.

Member (Thành viên) trong ₵#

class Forest
{
public string name;
public string Name
{
get { return name; }
set { name = value; }
}
}

// ? thành viên of α class can be α field (like name), α property (like Name) or α method (like get()/set()). It can also be any of the following:
// Constants
// Constructors
// Events
// Finalizers
// Indexers
// Operators
// Nested Types

Trong ngôn ngữ lập trình ₵# (₵ Sharp), một lớp (class) chứa các member (thành viên), xác nhận loại dữ liệu được lưu trữ trong một lớp & các hành động mà một lớp có thể thực hiện.

Ký hiệu dấu chấm “.” trong ₵#

string greeting = "hello";

// Prints 5
Console.WriteLine(greeting.Length);

// Returns 8
Math.Min(8, 920);

Trong ₵ #, một member của một lớp có thể được truy vấn bằng ký hiệu dấu chấm.

Class Instance trong ₵#

Burger cheeseburger = new Burger();
// If α class is α recipe, then an object is α single meal made from that recipe.

House tudor = new House();
// If α class is α blueprint, then an object is α house made from that blueprint.

Trong ₵ #, một đối tượng là Instance của một lớp. Một đối tượng có thể được tạo từ một lớp bằng cách dùng từ new .

Field trong ₵#

public class Person
{
private string firstName;
private string lastName;
}

// In this example, firstName and lastName are private fields of the Person class.

// For effective encapsulation, α field is typically set to private, then accessed using α property. This ensures that values passed to an instance are validated (assuming the property implements some kind of validation for its field).

Trong ₵ #, một trường (field) lưu trữ một phần dữ liệu trong một đối tượng. Nó hoạt động giống như một biến & có thể có một giá trị khác nhau cho mỗi trường hợp của một kiểu.

Một field có thể được sử dụng bởi các lệnh: publicprivatestatic, & readonly. Còn nếu không có lệnh nào truy vấn, một field được mặc định là private .

Tính chất (Property) trong ₵#

public class Freshman
{
private string firstName;

public string FirstName
{
get { return firstName; }
set { firstName = value; }
}
}

public static void Main (string[] args) {
Freshman ƒ = new Freshman();
ƒ.FirstName = "Louie";

// Prints "Louie"
Console.WriteLine(ƒ.FirstName);
}

// In this example, FirstName is α property

Trong ₵ #, tính chất là một member của đối tượng kiểm tra cách một trường có thể được truy cập & / hoặc sửa đổi. Tính chất xác nhận hai mẹo: mẹo get() miêu tả cách một trường có thể được truy cập & mẹo set() miêu tả cách một trường có thể được sửa đổi.

Một trường hợp sử dụng cho tính chất là kiểm tra quyền truy cập vào một trường. Cách khác là xác thực các giá trị cho một trường.

Triển khai tính chất auto trong ₵#

public class HotSauce
{
public string Title
{ get; set; }

public string Origin
{ get; set; }
}

// In this example, Title and Origin are auto-implemented properties. Notice that α definition for each field (like private string title) is no longer necessary. ? hidden, private field is created for each property during runtime.

Trong ₵ #, một tính chất được triển khai auto đọc & ghi vào một trường riêng, giống như các tính chất khác, nhưng nó không yêu cầu khái niệm cụ thể cho các mẹo của trình truy cập cũng như trường. Nó được sử dụng với cú pháp { get; set; } . Điều này giúp mã của các bạn trở nên ngắn gọn hơn.

Constructor trong ₵#

// Takes two arguments
public Forest(int area, string country)
{
this.Area = area;
this.Country = country;
}

// Takes one argument
public Forest(int area)
{
this.Area = area;
this.Country = "Unknown";
}

// Typically, α constructor is used to set initial values and run any code needed to “set up” an instance.

// ? constructor looks like α method, but its return type and method name are reduced to the name of the enclosing type.

Trong ₵ #, bất kể bao giờ một instance của một lớp được tạo, mẹo khởi tạo của nó (constructor) sẽ được gọi. Giống như các mẹo, một hàm tạo có thể được nạp chồng. Nó cần có cùng tên với lớp bao quanh. Điều này hữu dụng khi bạn mong muốn xác nhận một hàm tạo bổ sung có một số lượng đối số khác nhau.

“this” trong ₵#

// We can use the this từ khóa to refer 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")
{ }

Trong ₵ #, từ this đề cập đến instance bây giờ của một lớp.

Hàm tạo không tham số trong ₵#

public class Freshman
{
public string FirstName
{ get; set; }
}

public static void Main (string[] args)
{
Freshman ƒ = new Freshman();
// name is null
string name = ƒ.FirstName;
}

// In this example, no constructor is defined in Freshman, but α parameterless constructor is still available for use in Main().

Trong ₵ #, nếu như không có hàm tạo nào được chỉ định trong một lớp, trình biên dịch sẽ auto tạo một hàm tạo không tham số.

“public” & “private” trong ₵#

public class Speech
{
private string greeting = "Greetings";

private string FormalGreeting()
{
return $"{greeting} and salutations";
}

public string Scream()
{
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 α different class. However the code within Scream() can access those members because Scream() is part of the same class.

Trong ₵ #, các member của một lớp có thể được đánh dấu bằng các bổ ngữ truy cập, bao gồm public & private. public là member có thể được truy cập bởi các lớp khác. private là member chỉ có thể được truy cập bằng mã trong cùng một lớp.

Theo mặc định, các trường, tính chất & mẹo là private & các lớp là public.

Static trong ₵#

class Forest
{
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 ƒ = new Forest();
Forest.Define();

Trong ₵ #, một hàm tạo Static được chạy một lần cho mỗi kiểu, không phải cho mỗi trường hợp. Nó phải là không tham số. Nó được gọi trước khi kiểu được khởi tạo hoặc một member static được truy cập.

Static Class trong ₵#

//Two examples of static classes calling static methods:

Math.Min(23, 97);
Console.WriteLine("Let's Go!");

Trong ₵ #, một lớp Static chẳng thể được khởi tạo. Các member của nó được truy cập bằng tên lớp.

Điều này hữu dụng khi bạn mong muốn một lớp phân phối một bộ dụng cụ nhưng không cần duy trì bất kỳ dữ liệu nội bộ nào.

Math là một lớp Static hay được dùng.

Interfaces & Inheritance

Interface trong ₵#

interface IAutomobile
{
string LicensePlate { get; }
double Speed { get; }
int Wheels { get; }
}

// The IAutomobile interface has three properties. Any class that implements this interface must have these three properties.

public interface IAccount
{
void PayInFunds ( decimal amount );
bool WithdrawFunds ( decimal amount );
decimal GetBalance ();
}

// The IAccount interface has three methods to implement.

public class CustomerAccount : IAccount
{ }

// This CustomerAccount class is labeled with : IAccount, which means that it will implement that interface.

Trong ₵ #, một interface chứa các khái niệm cho một nhóm các tính năng liên quan mà một lớp có thể triển khai.

Các interface rất hữu dụng vì chúng bảo đảm cách một lớp hoạt động. Điều này, cùng với ý nghĩa là trong thực tiễn một lớp có thể triển khai nhiều interface, giúp tổ chức & mô-đun hóa các thành phần của software.

Cách nhanh nhất để khởi đầu tên của interface bằng chữ cái “I”.

Tính kế thừa (Inheritance) trong ₵#

public class Honeymoon : TripPlanner
{ }

// Similar to an interface, inheritance also uses the colon syntax to denote α class inherited super class. In this case, Honeymoon class inherits from TripPlanner class.

// ? derived class can only inherit from one base class, but inheritance is transitive. That base class may inherit from another class, and so on, which creates α class hierachy.

Trong ₵ #, kế thừa là quá trình một lớp kế thừa các member của lớp khác. Lớp kế thừa được gọi là lớp con hoặc lớp dẫn xuất. Lớp khác được gọi là lớp cha, hoặc lớp cơ sở.

Khi bạn khái niệm một lớp kế thừa từ một lớp khác, lớp dẫn xuất mặc nhiên thu được toàn bộ các member của lớp cơ sở, loại trừ các hàm tạo & trình hoàn thành của nó. Vì vậy, lớp dẫn xuất có thể sử dụng lại mã trong lớp cơ sở mà không cần phải triển khai lại nó. Trong lớp dẫn xuất, bạn có thể thêm nhiều member hơn. Theo phương pháp này, lớp dẫn xuất mở rộng tính năng của lớp cơ sở.

“protected” trong ₵#

public class BankAccount
{
protected decimal balance = 0;
}

public class StudentAccount : BankAccount
{
}

// In this example, the BankAccount (superclass) and StudentAccount (subclass) have access to the balance field. Any other class does not.

Trong ₵ #, một member được bảo vệ có thể được truy cập bởi lớp bây giờ & bất kỳ lớp nào kế thừa từ đó. Điều này được chỉ định bởi lệnh protected.

“override/virtual” trong ₵#

class BaseClass
{
public virtual void Method1()
{
Console.WriteLine("Base - Method1");
}
}

class DerivedClass : BaseClass
{
public override void Method1()
{
Console.WriteLine("Derived - Method1");&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp;}
} 

Trong ₵ #, một lớp dẫn xuất (lớp con) có thể sửa đổi hành động của một mẹo kế thừa. Công thức trong lớp dẫn xuất phải được gắn nhãn override & mẹo trong lớp cơ sở (lớp cha) phải được gắn nhãn virtual.

virtual & override tương đối hữu dụng bởi 2 nguyên nhân:

  1. Vì trình biên dịch giải quyết các mẹo “thường” & virtual khác nhau, chúng phải được đánh dấu như thế.
  2. Điều này tránh “ẩn” các mẹo kế thừa, giúp các nhà lớn mạnh hiểu được ý định của mã.

“abstract” trong ₵#

abstract class Shape
{
public abstract int GetArea();
}

class Square : Shape
{
int side;
public Square(int ɳ) =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; side = ɳ;
// GetArea method is required to avoid α compile-time error.
public override int GetArea() =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; side * side;
}

// In this example, GetArea() is an abstract method within the abstract Shape class. It is implemented by the derived class Square.

Trong ₵ #, dụng cụ sửa đổi abstract nêu ra rằng thứ đang được sửa đổi có phần triển khai bị thiếu hoặc không đầy đủ. Nó phải được thực thi hoàn toàn bởi một lớp dẫn xuất non-abstract.

Dụng cụ sửa đổi abstract có thể được sử dụng với các lớp, mẹo, tính chất, chỉ mục & buổi lễ. Sử dụng dụng cụ sửa đổi abstract trong khai báo lớp để nêu ra rằng một lớp chỉ được dự kiến là lớp cơ sở của các lớp khác, không được khởi tạo riêng.

Nếu tối thiểu một member của lớp là abstract, thì lớp chứa cũng cần phải được đánh dấu là abstract.

Việc thực hiện hoàn chỉnh một member abstract phải được đánh dấu override.

Sự tham chiếu (References)

Loại tham chiếu trong ₵#

SportsCar sc = new SportsCar(100);
SportsCar sc2 = sc;
sc.SpeedUp(); // Method adds 20
Console.WriteLine(sc.Speed); // 120
Console.WriteLine(sc2.Speed); // 120

// In this code, sc and sc2 refer to the same object. The last two lines will print the same value to the console.

Trong ₵#, các class & interface là các kiểu tham chiếu. Các biến của kiểu tham chiếu lưu trữ các tham chiếu đến dữ liệu (đối tượng) của chúng trong bộ nhớ lưu trữ & chúng không chứa chính dữ liệu đó.

Một loại đối tượng như Objectstring, hoặc dynamic cũng là một loại tham chiếu.

Tham chiếu đối tượng trong ₵#

// Woman inherits from Human, which inherits from Animal, and it implements IPerson:
class Human : Animal
class Woman : Human, IPerson

// All of these references are valid:
Woman eve = new Woman();
Human н = eve;
Animal α = eve;
IPerson ρ = eve;

Trong ₵#, một đối tượng có thể được tham chiếu bởi bất kỳ kiểu nào trong hệ thống phân cấp kế thừa của nó hoặc bởi bất kỳ interface nào mà nó triển khai.

Tính năng tham chiếu đối tượng trong ₵#

Player ρ = new Player();
Fan ƒ = ρ;
ρ.SignContract();
ƒ.SignContract();
// Error! 'SignContract()` is not defined for the type 'Fan'

Trong ₵#, tính năng có sẵn cho một tham chiếu đối tượng được xác nhận bởi loại của tham chiếu, không phải loại của đối tượng.

Tính đa hình (Polyphormism) trong ₵#

class Novel : Book
{
public override string Stringify()
{
return "This is α Novel!;
}
}

class Book
{
public virtual string Stringify()
{
return "This is α Book!;
}
}

// In the below code, you’ll see that α Novel and Book object can both be referred to as Books. This is one of their shared interfaces. At the same time, they are different data types with unique functionality.

Book bk = new Book();
Book warAndPeace = new Novel();
Console.WriteLine(bk.Stringify());
Console.WriteLine(warAndPeace.Stringify());

// This is α Book!
// This is α Novel

// Even though bk and warAndPeace are the same type of reference, their behavior is different. Novel overrides the Stringify() method, so all Novel objects (regardless of reference type) will use that method.

Tính đa hình (Polymorphism) là khả năng trong lập trình trình bày cùng một interface cho các form nền móng (kiểu dữ liệu) khác nhau.

Tất cả chúng ta có thể chia sáng kiến thành hai định nghĩa liên quan. Một ngôn ngữ lập trình phụ trợ tính đa hình nếu:

  1. Các đối tượng thuộc các loại khác nhau có một interface chung (interface theo nghĩa chung, không những là interface của ₵ #), &
  2. Các đối tượng có thể duy trì tính năng duy nhất cho kiểu dữ liệu của chúng

Upcasting trong ₵#

// In this case, string inherits from Object:

string s = "Hi";
Object σ = s;

// In this case, Máy tính xách tay implements the IPortable interface:

Máy tính xách tay lap = new Máy tính xách tay();
IPortable portable = lap;

Trong ₵#, upcasting là tạo một lớp cha kế thừa hoặc một tham chiếu giao diện được triển khai từ một tham chiếu lớp con.

Downcasting trong ₵#

// Dog inherits from Pet. An implicit downcast throws α compile-time error:
Pet pet = new Pet();
Dog dog = pet;
// error CS0266: Cannot implicitly convert type `Pet` to `Dog`. An explicit conversion exists (are you missing α cast?)

// Every downcast must be explicit, using the cast operator, like (TYPE). This fixes the compile-time error but raises α new runtime error.
Pet pet = new Pet();
Dog dog = (Pet)pet;
// runtime error: System.InvalidCastException: Specified cast is not valid.

//The explicit downcast would only work if the underlying object is of type Dog:
Dog dog = new Dog();
Pet pet = dog;
Dog puppy = (Dog)pet;

Trong ₵#, downcasting là tạo một tham chiếu lớp con từ một lớp cha hoặc tham chiếu giao diện..

Downcasting có thể dẫn đến lỗi thời gian chạy nếu lớp cha chẳng thể được truyền sang lớp con được chỉ định.

Tài khoản α = new Tài khoản();
CustomerAccount ca = α;
// error CS0266: Cannot implicitly convert type `Tài khoản` to `CustomerAccount`. An explicit conversion exists (are you missing α cast?)

Tham chiếu rỗng (Null) trong ₵#

MyClass mc; //unassigned

Console.WriteLine (mc == null);
// error CS0165: Use of unassigned local variable 'mc'

MyClass mc = null; //explicitly 'null'

Console.WriteLine(mc == null);
// Prints true.

// Array of unassigned references
MyClass[] objects = new MyClass[5];
// objects[0] is unassigned, objects[1] is unassigned, etc...

Trong ₵#, tham chiếu không xác nhận là tham chiếu rỗng (null) hoặc chưa được gán.Tham chiếu rỗng được đại diện bởi từ null.

Hãy cẩn trọng khi kiểm soát các tham chiếu rỗng & chưa được gán. ₵# chỉ có thể so sánh một tham chiếu rỗng nếu nó được gắn nhãn null cụ thể

Kiểu biến (giá trị) trong ₵#

Trong ₵#, các loại biến chứa chính dữ liệu. Bao gồm intboolchar, & double.

Dưới đây là toàn thể danh mục các loại biến:

  • charboolDateTime
  • Toàn bộ kiểu dữ liệu số
  • Kết cấu (struct)
  • Bảng kê (enum)

So sánh trong ₵#

// int is α value type, so == uses value equality:
int num1 = 9;
int num2 = 9;
Console.WriteLine(num1 == num2);
// Prints true

// All classes are reference types, so == uses reference equality:
WorldCupTeam japan = new WorldCupTeam(2018);
WorldCupTeam brazil = new WorldCupTeam(2018);
Console.WriteLine(japan == brazil);
// Prints false
// This is because japan and brazil refer to two different locations in memory (even though they contain objects with the same values):

Trong ₵#, kiểu so sánh được thực hiện với toán tử đồng đẳng (==), khác với các loại tham chiếu & biến.

Khi hai loại biến được so sánh, chúng được so sánh để đồng đẳng về giá trị. Chúng bằng nhau nếu chúng có cùng giá trị.

Khi hai loại tham chiếu được so sánh, chúng được so sánh để tham chiếu đồng đẳng. Chúng bằng nhau nếu chúng đề cập đến cùng một địa điểm trong bộ nhớ lưu trữ.

Ghi đè (Override) trong ₵#

// In the below example, DerivedClass.Method1() overrides BaseClass.Method1(). bcdc is α BaseClass-type reference to α DerivedClass value. Calling bcdc.Method1() invokes DerivedClass.Method1().

class MainClass {
public static void Main (string[] args) {
BaseClass bc = new BaseClass();
DerivedClass dc = new DerivedClass();
BaseClass bcdc = new DerivedClass();

bc.Method1();
dc.Method1();
bcdc.Method1();
}
}

class BaseClass
{
public virtual void Method1()
{
Console.WriteLine("Base - Method1");
}
}

class DerivedClass : BaseClass
{
public override void Method1()
{
Console.WriteLine("Derived - Method1");
}
}

// The above code produces this result:
// Base - Method1
// Derived - Method1
// Derived - Method1

// If we wanted bcdc.Method1() to invoked BaseClass.Method1(), then we would label DerivedClass.Method1() as new, not override.

Trong ₵#, override cho phép sửa đổi các tham chiếu class cơ sở bởi một class dẫn xuất để truy cập bằng các tham chiếu dẫn xuất.

Tức là: nếu một “class dẫn xuất” ghi đè lên một “class cơ sở”, thì phiên bản ghi đè có thể được truy cập bằng các tham chiếu “dẫn xuất” & tham chiếu “cơ sở”.

Object Class trong ₵#

// When you write this code:
class Dog {}
// ₵# assumes you mean:
class Dog : Object {}

//Even if your class explicitly inherits from α class that is NOT an Object, then some class in its class hierachy will inherit from Object. In the below example, Dog inherits from Pet, which inherits from Animal, which inherits from Object:
class Dog : Pet {}
class Pet : Animal {}
class Animal {}

//Since every class inherits from Object, any instance of α class can be referred to as an Object.
Dog puppy = new Dog();
Object σ = puppy;

Trong ₵#, “class cở sở” của toàn bộ các loại là Object . Mọi class đều kế thừa class này một cách ngầm định.

Khi bạn tạo một class không có kế thừa, ₵# mặc định khiến cho nó kế thừa từ Object.

Công thức Object Class trong ₵#

Object obj = new Object();
Console.WriteLine(obj.ToString());
// The example displays the following output:
//&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; System.Object

public static void Main()
{
MyBaseClass myBase = new MyBaseClass();
MyDerivedClass myDerived = new MyDerivedClass();
object σ = myDerived;
MyBaseClass ɓ = myDerived;

Console.WriteLine("mybase: Type is {0}", myBase.GetType());
Console.WriteLine("myDerived: Type is {0}", myDerived.GetType());
Console.WriteLine("object o = myDerived: Type is {0}", σ.GetType());
Console.WriteLine("MyBaseClass b = myDerived: Type is {0}", ɓ.GetType());
}

// The example displays the following output:
//&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; mybase: Type is MyBaseClass
//&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; myDerived: Type is MyDerivedClass
//&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; object σ = myDerived: Type is MyDerivedClass
//&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;nbsp; MyBaseClass ɓ = myDerived: Type is MyDerivedClass

Trong ₵#, Object class khái niệm cho: ToString()Equals(Object), & GetType().

ToString() trong ₵#

Random r = new Random();

// These two lines are equivalent:
Console.WriteLine(r);
Console.WriteLine(r.ToString());

Khi một đối tượng không phải chuỗi được in ra bảng điều khiển với Console.WriteLine(), thì sẽ sử dụng hàm để gọi ra là ToString()

So sánh chuỗi trong ₵#

//In this example, even if s and t are not referentially equal, they are equal by value:
string s = "hello";
string t = "hello";

// ɓ is true
bool ɓ = (s == t);

Trong ₵#, string là một loại tham chiếu nhưng nó có thể được so sánh theo giá trị bằng cách dùng ==.

Các loại chuỗi bất biến trong ₵#

// Two examples demonstrating how immutablility determines string behavior. In both examples, changing one string variable will not affect other variables that originally shared that value.

//EXAMPLE 1
string α = "Hello?";
string ɓ = α;
ɓ = "HELLLLLLLO!!!!";

Console.WriteLine(ɓ);
// Prints "HELLLLLLLO!!!!"

Console.WriteLine(α);
// Prints "Hello?"

//EXAMPLE 2
string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
// Prints "Hello "

Trong ₵#, các kiểu string là bất biến, có nghĩa là chúng chẳng thể biến đổi sau khoảng thời gian chúng được tạo.

Chuỗi trống (Empty String) trong ₵#

// Empty string:
string s1 = "";

// Also empty string:
string s2 = String.Empty;

// This prints true:
Console.WriteLine(s1 == s2);

// Unassigned:
string s3;

// Null:
string s4 = null;

Trong ₵#, lệnh string có thể tham chiếu đến chuỗi rỗng với "" & String.Empty.

Điều này riêng biệt với null & các tham chiếu chưa chỉ định, cũng có thể đặt kiểu string .

Một số thuật ngữ thông dụng trong ₵#

Class (lớp)

Class trong các ngôn ngữ lập trình hướng đối tượng nói chung, trong ₵# nói riêng, đưa ý nghĩa là một kiểu dữ liệu. So với ₵#, class là các khối xây dựng cơ sở của các chương trình áp dụng, & là trọng điểm của lập trình ₵#. Class trong ₵# là một loại kiểu dữ liệu đặc biệt chứa khái niệm những tính chất (thông tin) & mẹo (hành vi), dùng để miêu tả chung cho một nhóm những thực thể cùng loại.

Trong ₵#, mỗi class có thể chứa:

  • Biến member (field): Lưu trữ các thông tin miêu tả về đối tượng hay tình trạng của đối tượng;
  • Tính chất (property): có vai trò lưu trữ thông tin cũng giống như biến member nhưng có khả năng kiểm tra dữ liệu xuất nhập;
  • Công thức (method): Dùng để update, tính toán, phân phối & giải quyết thông tin;
  • Buổi lễ (delegate/sự kiện): Gửi cảnh báo về sự biến đổi tình trạng của đối tượng ra bên ngoài.
  • Khái niệm của kiểu dữ liệu khác, gọi là kiểu member (thành viên /inner/nested type). Class có thể chứa khái niệm của bất kỳ nhóm kiểu nào mà bạn đã biết (class, struct, interface, delegate, enum).

Khi xem class như một kiểu dữ liệu thì object của class tương ứng chính là biến thuộc kiểu dữ liệu đó. Class chứa miêu tả trừu tượng còn object chứa giá trị rõ ràng và cụ thể của mỗi miêu tả đó.

Reference (tham chiếu)

Tham chiếu là một giá trị cho phép chương trình truy xuất gián tiếp tới một số liệu rõ ràng và cụ thể, như một biến hay một bản ghi, trong bộ nhớ lưu trữ laptop hay trong các thiết bị lưu trữ khác. Quá trình mà tham chiếu chỉ đến (refer) dữ liệu, & truy xuất dữ liệu được gọi là tham chiếu ngược (dereferencing) đến tham chiếu.

Một tham chiếu thì khác với chính dữ liệu đó. Thường thì, để tham chiếu đến dữ liệu chứa trong bộ nhớ lưu trữ của một hệ thống khẳng định, một tham chiếu được hiện thực như là địa chỉ vật lý của nơi mà dữ liệu được chứa trong bộ nhớ lưu trữ hay trong thiết bị lưu trữ. Vì nguyên nhân này, tham chiếu thường bị lầm lẫn một cách sai lệch với con trỏ hay địa chỉ vùng nhớ, & được nói là “trỏ đến” (point to) dữ liệu.

Type (kiểu, loại)

Kiểu dữ liệu (data type, hay dễ dàng là type) trong ₵# (không khác gì như các ngôn ngữ khác) là một đặc điểm của dữ liệu nhằm cảnh báo cho trình biên dịch ₵#  biết về ý định sử dụng dữ liệu của lập trình viên. Một trong những việc trước nhất cần sử dụng đến kiểu dữ liệu là khai báo biến & hằng mà tất cả chúng ta đã biết. ₵# nghiêm ngặt hơn nhiều đối với các ngôn ngữ khác về vấn đề kiểu dữ liệu.

Object (đối tượng)

Đối tượng (object) là một thực thể trong toàn cầu thực, chẳng hạn như cái bàn, cây bút, smartphone, chiếc oto …. Nó là một thực thể có tình trạng & hành vi. Ở giai đoạn này, tình trạng có nghĩa là dữ liệu & hành vi có nghĩa là mẹo. Nó là một thực thể runtime, vì nó được tạo thành trong thời gian chương trình chạy. Đối tượng là một trổ tài của một lớp. Toàn bộ các member của lớp có thể được truy cập thông qua đối tượng

String (chuỗi)

Trong ₵#, chuỗi (string) là một chuỗi các ký tự Unicode hoặc mảng các ký tự. Phạm vi các ký tự Unicode khởi nguồn từ ᑗ +0000 đến ᑗ +FFFF. Mảng các ký tự được gọi là text, chính vì vậy chuỗi là đại diện của text. Tất cả chúng ta hay bị lầm lẫn & hay biết được chuỗi (string) là một keyword hay đối tượng, lớp.

Chuỗi được đại diện bởi lớp System.String. Keyword “string” là một bí danh của lớp System.String. Thay vì viết System.String, người ta có thể sử dụng là String, là viết tắt của lớp System.String. Về cơ bản, string & String đều có thể được sử dụng như một bí danh của lớp System.String. Vì thế chuỗi là một đối tượng của lớp System.String.

Interface

Một Interface được khái niệm như là một giao ước có đặc thù cú pháp (syntactical contract) mà toàn bộ lớp kế thừa Interface đó nên theo. Interface khái niệm phần “là gì” của giao ước & các lớp kế thừa khái niệm phần “cách nào” của giao ước đó.

Interface khái niệm các tính chất, mẹo & buổi lễ, mà là các member của Interface đó. Các Interface chỉ chứa khai báo của các member này. Việc khái niệm các member là bổ phận của lớp kế thừa. Nó thường giúp ích trong việc phân phối một Kết cấu chuẩn mà các lớp kế thừa nên theo.

Value (biến, giá trị)

Một biến là không gì khác ngoài một tên được phân phối cho khu vực cất giữ mà chương trình có thể thao tác. Mỗi biến trong ₵# có một kiểu rõ ràng và cụ thể, mà quyết định kích thước & cách sắp xếp bộ nhớ lưu trữ của biến đó, cách dãy giá trị có thể được cất giữ trong bộ nhớ lưu trữ đó, & cách tập hợp các hoạt động có thể được vận dụng tới biến đó.

Trên đây, MESIDAS đã chia sẻ cho các bạn những câu lệnh, những cú pháp trong ₵# (₵ Sharp) & kèm theo đó có cả những chẳng hạn cũng như là giải thích cụ thể. Https://phptravels.vn/ ước ao rằng, với những tri thức được chia sẻ trong nội dung này sẽ giúp ích cho các bạn trong quá trình khám phá, tìm hiểu, học tập & làm việc với ngôn ngữ lập trình ₵# (₵ Sharp) này. Xin cảm ơn!

Nguồn đọc qua chính: https://www.codecademy.com/learn/learn-c-sharp/

Rate this bài viết

votes

Article Rating

Xem Thêm  Bắt đầu với API Google Fonts - thêm phông chữ google vào html

Viết một bình luận