Ngôn ngữ lập trình c# full pdf

NGƠN NGỮ
LẬP TRÌNH C#
-------------------------@&?-------------------------

MỤC LỤC
Chương 1: Microsoft .NET .............................................................................................................................2
Chương 2: Giới thiệu ngôn ngữ C# ................................................................................................................3
Chương 3: Nền tảng ngôn ngữ C#..................................................................................................................4
Kiểu dữ liệu ...................................................................................................................................................4
Biến và hằng ..................................................................................................................................................5
Câu lệnh .........................................................................................................................................................5
Namespace .....................................................................................................................................................6
Chương 4: Lập trình hướng đối tượng .......................................................................................................... 7
Mục tiêu của việc thiết kế 1 phần mềm ......................................................................................................... 7
Quá trình thiết kế phần mềm..........................................................................................................................7
Các cách tiếp cận trong thiết kế .....................................................................................................................7
Trừu tượng hóa ..............................................................................................................................................7
Đối tượng trong LTHĐT ...............................................................................................................................8
Tạo và sử dụng đối tượng ..............................................................................................................................8
Tính đóng gói – Encapsulation ....................................................................................................................10
Tính kế thừa - Inheritance, Tính đa hình - Polymorphism ........................................................................ 11
Tính trừu tượng - abstract classes ................................................................................................................13
Giao diện – Interfaces .................................................................................................................................. 16
Delegate .......................................................................................................................................................17
Event: ...........................................................................................................................................................18

Trang 1

Chương 1: Microsoft .NET
Microsoft .NET gồm 2 phần chính : Framework và Integrated Development Environment (IDE)
o Framework cung cấp những gì cần thiết và căn bản, chữ Framework có nghĩa là khung hay khung
cảnh trong đó ta dùng những hạ tầng cơ sở theo một qui ước nhất định để cơng việc được trơi chảy.
o IDE thì cung cấp một môi trường giúp chúng ta triển khai dễ dàng, và nhanh chóng các ứng dụng
dựa trên nền tảng .NET. Nếu khơng có IDE chúng ta cũng có thể dùng một trình soạn thảo ví như
Notepad hay bất cứ trình soạn thảo văn bản nào và sử dụng command line để biên dịch và thực thi,
tuy nhiên việc này mất nhiều thời gian.

Trang 2




Chương 2: Giới thiệu ngôn ngữ C#
C# là ngôn ngữ đơn giản: C# loại bỏ một vài sự phức tạp và rối rắm của những ngôn ngữ như Java và c++,
bao gồm việc loại bỏ những macro, những template, đa kế thừa, và lớp cơ sở ảo (virtual base class). Chúng
là những nguyên nhân gây ra sự nhầm lẫn hay dẫn đến những vấn đề cho các người phát triển.
C# là ngơn ngữ hiện đại: Điều gì làm cho một ngơn ngữ hiện đại? Những đặc tính như là xử lý ngoại lệ,
thu gom bộ nhớ tự động, những kiểu dữ liệu mở rộng, và bảo mật mã nguồn là những đặc tính được mong
đợi trong một ngơn ngữ hiện đại. C# chứa tất cả những đặc tính trên.
C# là ngơn ngữ hướng đối tượng: Những đặc điểm chính của ngơn ngữ hướng đối tượng (Object-oriented
language) là sự đóng gói (encapsulation), sự kế thừa (inheritance), và đa hình (polymorphism). C# hỗ trợ tất
cả các đặc tính trên.
C# là ngơn ngữ mạnh mẽ và cũng mềm dẻo: C# được sử dụng cho nhiều các dự án khác nhau như là tạo
ra ứng dụng xử lý văn bản, ứng dụng đồ họa, bản tính …
C# là ngơn ngữ ít từ khóa:

C# là ngơn ngữ hướng module: Mã nguồn C# có thể được viết trong những phần được gọi là những lớp,
những lớp này chứa các phương thức thành viên của nó. Những lớp và những phương thức có thể được sử

dụng lại trong ứng dụng hay các chương trình khác.

Trang 3




Chương 3: Nền tảng ngôn ngữ C#
Kiểu dữ liệu
C# là ngơn ngữ lập trình mạnh về kiểu dữ liệu, một ngôn ngữ mạnh về kiểu dữ liệu là phải
khai báo kiểu của mỗi đối tượng khi tạo (kiểu số nguyên, số thực, kiểu chuỗi, kiểu điều khiển...) và trình
biên dịch sẽ giúp cho người lập trình khơng bị lỗi khi chỉ cho phép một loại
kiểu dữ liệu có thể được gán cho các kiểu dữ liệu khác.
Kiểu dữ liệu của một đối tượng là một tín hiệu để trình biên dịch nhận biết kích thước và khả năng của một
đối tượng.
C# phân tập hợp kiểu dữ liệu này thành hai loại: Kiểu dữ liệu giá trị (value) và kiểu dữ
liệu tham chiếu (reference). Đối với một kiểu dữ liệu giá trị thì sẽ được lưu giữ kích
thước thật trong bộ nhớ đã cấp phát là stack. Trong khi đó thì địa chỉ của kiểu dữ liệu tham
chiếu thì được lưu trong stack nhưng đối tượng thật sự thì lưu trong bộ nhớ heap.
Ghi chú: Tất cả các kiểu dữ liệu xây dựng sẵn là kiểu dữ liệu giá trị ngoại trừ các đối
tượng và chuỗi. Và tất cả các kiểu do người dùng định nghĩa ngoại trừ kiểu cấu trúc đều là
kiểu dữ liệu tham chiếu.

Trang 4




Biến và hằng
Gán giá trị xác định cho biến: <kiểu> <tên biến> = <giá trị>;

Hằng: const <kiểu> <tên hằng> = <giá trị>;
Kiểu liệt kê:
class ViDuKieuLietKe
{
// Khai báo kiểu liệt kê
enum NhietDoNuoc
{
DoDong = 0,
DoNguoi = 20,
DoAm = 40,
DoNong = 60,
DoSoi = 100,
}
static void Main()
{
System.Console.WriteLine( “Nhiet do dong: {0}”, NhietDoNuoc.DoDong);
System.Console.WriteLine( “Nhiet do nguoi: {0}”, NhietDoNuoc.DoNguoi);
System.Console.WriteLine( “Nhiet do am: {0}”, NhietDoNuoc.DoAm);
System.Console.WriteLine( “Nhiet do nong: {0}”, NhietDoNuoc.DoNong);
System.Console.WriteLine( “Nhiet do soi: {0}”, NhietDoNuoc.DoSoi);
}
}

Câu lệnh
Phân nhánh khơng có điều kiện: gọi một trong các từ khóa sau: goto, break, continue, return,
statementthrow.
Phân nhánh có điều kiện:
if (biểu thức điều kiện)
{
<lệnh 1>

<lệnh 2>
....
}
else
{
<lệnh 1>
<lệnh 2>
...
}

Trang 5




switch (biểu thức điều kiện)
{
case <giá trị>:
<Các câu lệnh thực hiện>
<lệnh nhảy>
[default:
<Các câu lệnh thực hiện mặc định>]
}
Câu lệnh lặp:
while (Biểu thức)
<Câu lệnh thực hiện>
do
<Câu lệnh thực hiện>
while ( điều kiện )
for ([ phần khởi tạo] ; [biểu thức điều kiện]; [bước lặp])

<Câu lệnh thực hiện>
foreach ( <kiểu tập hợp> <tên truy cập thành phần > in < tên tập hợp>)
<Các câu lệnh thực hiện>

Namespace
Giả sử có một người nói Phúc là một kỹ sư, từ kỹ sư phải đi kèm với một lĩnh vực nhất định nào đó, vì nếu
khơng thì chúng ta sẽ khơng biết được là anh ta là kỹ sư cầu đường, cơ khí hay phần mềm. Khi đó một lập
trình viên C# sẽ bảo rằng Phúc là CauDuong.KySu phân biệt với CoKhi.KySu hay PhanMem.KySu.
Namespace trong trường hợp này là CauDuong, CoKhi, PhanMem sẽ hạn chế phạm vi của những từ theo
sau. Nó tạo ra một vùng khơng gian để tên sau đó có nghĩa. Tương tự như vậy ta cứ tạo các namespace để
phân thành các vùng cho các lớp trùng tên không tranh chấp với nhau.
C# đưa ra từ khóa using đề khai báo sử dụng namespace trong chương trình:
using < Tên namespace >
Để tạo một namespace dùng cú pháp sau:
namespace <Tên namespace>
{
< Định nghĩa lớp A>
< Định nghĩa lớp B >
.....
}

Trang 6




Chương 4: Lập trình hướng đối tượng
Mục tiêu của việc thiết kế 1 phần mềm:
·
·

·

Tính tái sử dụng (reusability): thiết kế các thành phần có thể được sử dụng trong nhiều phần mềm
khác nhau
Tính mở rộng (extensibility): hỗ trợ các plug-ins.
Tính mềm dẻo (flexibility):
o Có thể dễ dàng thay đổi khi thêm mới dữ liệu hay tính năng.
o Các thay đổi khơng làm ảnh hưởng nhiều đến tồn bộ hệ thống

Quá trình thiết kế phần mềm:
·
·
·
·

Quá trình thiết kế: chia phần mềm và thiết kế theo từng phần, từng component
Trừu tượng hóa: rất cần thiết trong thiết kế. Cụ thể: bỏ qua những chi tiết của component, quan tâm
các thành phần ở mức trừu tượng.
Xác định các component: top-down
Tích hợp: bottom-up. Gắn kết các components nhỏ lại với nhau.

Các cách tiếp cận trong thiết kế
·
·
·

Thiết kế theo hàm/thủ tục:
o Tìm ra các hàm/thủ tục để hoàn tất các yêu cầu
o Kết quả là hệ thống cấu trúc và mối quan hệ giữa các hàm/thủ tục
Thiết kế theo module:

o Phân tích và tìm ra các module bao gồm thành phần dữ liệu và các hàm/thủ tục liên quan
o Cách thực hiện dựa vào việc gom nhóm các thành phần tương tự nhau về ý nghĩa, phạm vi…
Thiết kế theo hướng đối tượng
o Trừu tượng hóa dữ liệu và các hàm/thủ tục liên quan
o Chia hệ thống ra thành các lớp/đối tượng
o Mỗi lớp/đối tượng có các tính năng và hành động chuyên biệt
o Các lớp có thể được sử dụng để tạo ra nhiều đối tượng cụ thể

Trừu tượng hóa

Trang 7




Đối tượng trong LTHĐT
·
·
·

Đối tượng là 1 thực thể phần mềm bao bọc các thuộc tính mơ tả trạng thái và các phương thức liên
quan.
Kiểu dữ liệu lớp đối tượng: class
Class có các tính chất sau:
o Đóng gói: chứa đựng dữ liệu và các hàm/thủ tục liên quan
o Che giấu dữ liệu: các thực thể phần mềm khác không can thiệp trực tiếp vào dữ liệu bên trong
được mà phải thông qua các phương thức cho phép

Tạo và sử dụng đối tượng:
Ví dụ: Lớp Phân Số

namespace Phan1_PhanSo
{
class PhanSo
{
private int _TuSo;
private int _MauSo;
private static int Dem = 0;//Bien dem so luong phan so da duoc tao
//Properties-----------------------------------------------------public int TuSo
{
get { return _TuSo; }
set { _TuSo = value; }
}
public int MauSo
{
get
{
return _MauSo;
}
set
{
if (value == 0)
_MauSo = 1;
else
_MauSo = value;
}
}
//Constructors----------------------------------------------------public PhanSo()
{
_TuSo = 1;
_MauSo = 1;

Dem++;
}
public PhanSo(int So)
{
_TuSo = So;
_MauSo = 1;
Dem++;
}

Trang 8




public PhanSo(int Tu, int Mau)
{
_TuSo = Tu;
//Neu mau so = 0 thi nem loi ra
if (Mau == 0)
throw new Exception("Khong khoi tao duoc phan so,
mau so phai khac 0.");
else
_MauSo = Mau;
Dem++;
}
//Methods---------------------------------------------------------//Xuat phan so
public string Xuat()
{
return _TuSo.ToString() + "/" + _MauSo.ToString();
}

//Su dung static
public static int XuatSoLuongPhanSo()
{
return Dem;
}
//Su dung operator
public static PhanSo operator +(PhanSo a, PhanSo b)
{
PhanSo KetQua = new PhanSo();
KetQua.TuSo = a.TuSo * b.MauSo + b.TuSo * a.MauSo;
KetQua.MauSo = a.MauSo * b.MauSo;
return KetQua;
}
}//End Class PhanSo
class Program
{
static void Main(string[] args)
{
try
{
//Tao cac doi tuong cua lop phan so
PhanSo PhanSo1 = new PhanSo(1, 2);
PhanSo PhanSo2 = new PhanSo(3, 2);
PhanSo PhanSo3 = new PhanSo(5);
//Xuat cac phan so
Console.WriteLine("Phan so thu nhat la: " + PhanSo1.Xuat());
Console.WriteLine("Phan so thu hai la: " + PhanSo2.Xuat());
Console.WriteLine("Phan so thu ba la: " + PhanSo3.Xuat());
//Xuat so luong cac phan so da tao
//Luu y: Khong can khoi tao doi tuong khi truy cap phuong thuc static

int SoLuongPhanSo = PhanSo.XuatSoLuongPhanSo();
Console.WriteLine("So luong phan so da tao: {0}", SoLuongPhanSo);
//Tinh tong 2 phan so, su dung operator
PhanSo Tong = PhanSo1 + PhanSo2;
Console.WriteLine(PhanSo1.Xuat() + " + "
+ PhanSo2.Xuat() + "=" + Tong.Xuat());
}

Trang 9




catch (Exception ex)
{
Console.WriteLine("Loi! " + ex.Message);
}
}
}
}//End

Tính đóng gói – Encapsulation:
The process of hiding all the internal details of an object from the outside world.
namespace Phan2_TinhDongGoi
{
class A
{
private int MyPrivate = 0;
protected int MyProtected = 0;
public int MyPublic = 0;

public void MyMethodA()
{
MyPrivate = 10;//OK! (1)
MyProtected = 10;//OK!(2)
MyPublic = 10;//OK!(3)
}
}
class B : A
{
public void MyMethodB()
{
//MyPrivate = 100;//Error! (4)
MyProtected = 100;//OK! (5)
MyPublic = 100;//OK! (6)
}
}
class Program
{
static void Main(string[] args)
{
A a = new A();
//a.MyPrivate = 10;//Error (7)
//a.MyProtected = 10;//Error (8)
a.MyPublic = 10;//OK! (9)
}
}
}

Kết luận:
o Từ (1)(4)(7) => Private chỉ trong nội bộ class A.

o Từ (2)(5)(8) => Protected chỉ trong nội bộ class A và các class kế thừa nó.
o Từ (3)(6)(9) => Public truy xuất bất kì nơi đâu đều được.
o Internal chỉ được truy xuất trong phạm vi file DLL
o Protected Internal được truy xuất trong phạm vi file DLL và lớp kế thừa.

Trang 10




Tính kế thừa - Inheritance, Tính đa hình - Polymorphism

namespace Phan3_KeThua2
{
class Shape
{
protected string _Name;
//Properties
public string Name
{
get { return _Name; }
set { _Name = value; }
}
//Methods
public virtual float Area()
{
return 0;
}
}
class Rectangle : Shape

{
protected float _Width;
protected float _Height;
//Properties
public float Width
{
get { return _Width; }
set { _Width = value; }
}
public float Height
{
get { return _Height; }
set { _Height = value; }
}
//Constructors
public Rectangle()
{
_Width = _Height = 0;
}

Trang 11




public Rectangle(string name, int width, int height)
{
_Name = name;
_Width = width;
_Height = height;

}
//Methods
public override float Area()
{
return Width * Height;
}
}
class Square : Rectangle
{
//Properties
public float Side
{
get { return _Width; }
set { _Width = _Height = value; }
}
//Constructors
public Square(string name, float side)
{
_Name = name;
Side = side;
}
}
class Circle : Shape
{
protected float _R;
//Properties
public float R
{
get { return _R; }
set { _R = value; }

}
//Constructors
public Circle(string name, float r)
{
_Name = name;
_R = r;
}
//Methods
public override float Area()
{
return (float)Math.PI * R * R;
}
}

Trang 12




class Program
{
static void Main(string[] args)
{
Shape[] MyShapes = new Shape[] {new Rectangle("Rectangle",50,20),
new Square("Square",50),
new Circle("Circle",20)};
foreach (Shape s in MyShapes)
{
Console.WriteLine("Name: " + s.Name);
Console.WriteLine("Area: " + s.Area().ToString());

}
}
}
}

Tính trừu tượng - abstract classes
Following are features of a abstract class :
o You can not create a object of abstract class
o Abstract class is designed to act as a base class (to be inherited by other classes).
o Abstract class is a design concept in program development and provides a base upon which other
classes are built.
o Abstract classes are similar to interfaces: After declaring an abstract class, it can not be instantiated
on it's own, it must be inherited.
o Abstract classes are different to interfaces: Abstract classes can have implementation or pure abstract
methods which should be implemented in the child class.
namespace Phan4_TinhTruuTuong
{
class Point
{
//Fields
private int _X;
private int _Y;
//Properties
public int X
{
get { return _X; }
set { _X = value; }
}
public int Y
{

get { return _Y; }
set { _Y = value; }
}
//Constructors
public Point(int x, int y)
{
_X = x;
_Y = y;
}
//Methods
public string Output()
{
return "(" + _X.ToString() + "," + _Y.ToString() + ")";
}
}

Trang 13




abstract class AShape
{
//Properties
public abstract Point Center
{
get;
set;
}
//MeThods

//This method must be implemented at child class
public abstract float Area();
//Abstract class: This method can be used by child class object
//But Interface class can not
//because all method at Interface must be implemented
public void WriteAString()
{
Console.WriteLine("Hello! this is a method at abstract class");
}

}
class Rectangle : AShape
{
private Point _TopLeft;
private int _Width;
private int _Height;
//Constructors
public Rectangle(Point topLeft, int width, int height)
{
_TopLeft = topLeft;
_Width = width;
_Height = height;
}
//Properties
public Point TopLeft
{
get { return _TopLeft; }
set { _TopLeft = value; }
}
public int Width

{
get { return _Width; }
set { _Width = value; }
}
public int Height
{
get { return _Height; }
set { _Height = value; }
}
//This property is override the Center property at abstract class AShape
public override Point Center
{
get { return new Point(TopLeft.X + Width / 2, TopLeft.Y + Height / 2); }
set{}
}

Trang 14




//Methods-This method is override the Area method at abstract class AShape
public override float Area()
{
return Width * Height;
}
}
class Circle : AShape
{
private Point _Center;

private float _R;
//Properties
public float R
{
get { return _R; }
set {_R = value;}
}
public override Point Center
{
get { return _Center; }
set { _Center = value; }
}
//Constructors
public Circle(Point center, float r)
{
_Center = center;
_R = r;
}
//Mehthods
public override float Area()
{
return (float) (Math.PI * R * R);
}
}
class Program
{
static void Main(string[] args)
{
Point MyPoint = new Point(0,0);
Rectangle R = new Rectangle(MyPoint,50,30);

Circle C = new Circle(MyPoint, 40);
Console.WriteLine("Center of the rectangle: " + R.Center.Output());
Console.WriteLine("Center of the circle: " + C.Center.Output());
Console.WriteLine("Area of the rectangle: " + R.Area());
Console.WriteLine("Area of the circle: " + C.Area());
R.WriteAString();
C.WriteAString();
}
}
}

Trang 15




Giao diện – Interfaces
Following are features of a abstract class :
o Single Class can implement multiple interfaces.
o If a class implements a interface then it has to provide implementation to all its methods.
namespace Phan5_GiaoDien
{
interface IMyInterface
{
void WriteName();
}
class Person : IMyInterface
{
private string Name;
public Person(string name)

{
Name = name;
}
public void WriteName()
{
Console.WriteLine(Name);
}
}
class Building : IMyInterface
{
private string Name;
public Building(string name)
{
Name = name;
}
public void WriteName()
{
Console.WriteLine(Name);
}
}
class Program
{
static void Main(string[] args)
{
IMyInterface[] School = new IMyInterface[]
{ new Person("Phuc"), new Building("I Buiding") };
foreach (IMyInterface I in School)
{
Console.Write(I.GetType().Name.ToString() + ": ");
I.WriteName();

}
}
}
}

Trang 16




Delegate:
Delegate is a class that can hold a reference to a method or a function.Delegate class has a signature and it
can only reference those methods whose signature is compliant with the class.Delegates are type-safe
functions pointers or callbacks.
namespace Phan6_Delegate
{
//Khai bao delegate
delegate int pFunction(int a, int b);
class TestDelegate
{
public int Add(int a, int b)
{
return a + b;
}
public int Mul(int a, int b)
{
return a * b;
}
}
class Program

{
static void Main(string[] args)
{
int a = 10;
int b = 20;
pFunction p;// Tao bien delegate
TestDelegate t = new TestDelegate();
//Su dung delegate
p = new pFunction(t.Add);
Console.WriteLine(p(a,b).ToString());
p = new pFunction(t.Mul);
Console.WriteLine(p(a,b).ToString());
//Kết luận:
//Khái niệm delegate tương tự như con trỏ hàm.
//Ưu điểm của Delegate đó là tính khả biến của nó.
//Có thể gọi bất cứ phương thức nào có 2 đối số int và trả về trị int.
}
}
}

Trang 17




Event:
As compares to delegates events works with source and listener methodology . So listener’s who are
interested in receiving some events they subscribe to the source.Once this subscription is done the source
raises events to all of it’s listener when needed.One source can have multiple listeners.
namespace Tuan8_Event

{
class MyClass
{
//Khai bao delegate
public delegate void MyDelegate(string Message);
//Khai bao su kien
public event MyDelegate MyEvent;
public void RaiseEvent(string Message)
{
if(MyEvent!=null)
MyEvent(Message);
}
}
class Program
{
static void Main(string[] args)
{
//Tao the hien cua class
MyClass ShowMessage = new MyClass();
//Goi su kien cho doi tuong ShowMessage
ShowMessage.MyEvent += new MyClass.MyDelegate(ShowMessage_MyEvent);
string Message = Console.ReadLine();
ShowMessage.RaiseEvent(Message);
}
//Ham duoc delegate
static void ShowMessage_MyEvent(string Message)
{
Console.WriteLine("Your message is: {0}",Message);
}
}

}

Trang 18