Introducere în clase
Această pornire rapidă așteaptă să aveți o mașină pe care o puteți folosi pentru dezvoltare. Subiectul .NET Get Started in 10 minutes are instrucțiuni pentru instalarea mediului dvs. de dezvoltare local pe Mac, PC sau Linux. O vedere rapidă de ansamblu a comenzilor pe care le veți folosi este în introducerea în pornirile rapide locale cu link-uri la mai multe detalii.
Creați-vă aplicația
Folosind o fereastră terminal, creați un director numit classes. Vă veți construi aplicația acolo. Schimbați la acel director și tastați dotnet new console în fereastra consolă. Această comandă creează aplicația dvs. Deschideți Program.cs. El ar trebui să arate astfel:using System;
namespace classes
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
În această pornire rapidă, urmează să creați noi tipuri care reprezintă un cont bancar. În mod normal dezvoltatorii definesc fiecare clasă într-un fișier text diferit. Aceasta face mai ușor să organizezi pe măsură ce un program crește în mărime. Creați un nou fișier numit BankAccount.cs în directorul classes.
Acest fișier va conține definiția unui cont bancar. Programarea Orientată pe Obiecte organizează codul creând tipuri în formă de clase. Aceste clase conțin codul care reprezintă o entitate specifică. Clasa BankAccount reprezintă un cont bancar. Codul implementează operații specifice prin metode și proprietăți. În această pornire rapidă, contul bancar suportă acest comportament:
- Are un număr de 10 cifre care identifică în mod unic contul bancar.
- Are un șir de caractere care reține numele proprietarilor.
- Soldul poate fi obținut.
- Acceptă depuneri.
- Acceptă extrageri.
- Soldul inițial trebuie să fie pozitiv.
- Extragerile nu pot rezulta în sold negativ.
Definiți tipul cont bancar
Puteți începe creând bazele unei clase care definește acel comportament. Ar arăta astfel:
using System;
namespace classes
{
public class BankAccount
{
public string Number { get; }
public string Owner { get; set; }
public decimal Balance { get; }
{
public class BankAccount
{
public string Number { get; }
public string Owner { get; set; }
public decimal Balance { get; }
public void MakeDeposit(decimal amount, DateTime date, string note)
{
}
{
}
public void MakeWithdrawal(decimal amount, DateTime date, string note)
{
}
}
}
{
}
}
}
Înainte de a începe, haideți să aruncăm o privire la ce ați construit. Declararea namespace oferă o cale de a organiza logic codul dvs. Această pornire rapidă este relativ mică, deci veți pune tot codul într-un singur namespace.
public class BankAccount definește clasa, sau tipul, pe care îl creați. Tot ce este între { și } care urmează declararea clasei definește comportamentul clasei. Există cinci membri ai clasei BankAccount. Primii trei sunt proprietăți. Proprietățile sunt elemente de date și pot avea cod care forțează validare sau alte reguli. Ultimii doi sunt metode. Metodele sunt blocuri de cod care realizează o singură funcție. Citind numele fiecăruia dintre membrii ar trebui să ofere destulă informație pentru dvs. sau alt dezvoltator să înțelegeți ce face clasa.
Deschideți un nou cont
Prima facilitate de implementat este deschiderea unui cont bancar. Când un client deschide un cont, ei trebuie să furnizeze un sold inițial, și informații despre deținătorul sau deținătorii acelui cont.Crearea unui nou obiect de tipul BankAccount înseamnă definirea unui constructor care atribuie aceste valori. Un constructor este un membru care are același nume ca al clasei. El este folosit pentru a inițializa obiecte ale acelui tip clasă. Adăugați următorul constructor la tipul BankAccount:
public BankAccount(string name, decimal initialBalance)
{
this.Owner = name;
this.Balance = initialBalance;
}
Constructorii sunt apelați când dvs. apelați un obiect folosind new. Înlocuiți linia Console.WriteLine("Hello World!"); în program.cs cu următoarele linii (înlocuiți <name> cu numele dvs.):
var account = new BankAccount("<name>", 1000);
Console.WriteLine($"Account {account.Number} was created for {account.Owner} with {account.Balance} initial balance.");
Tastați dotnet run pentru a vedea ce are loc.
Ați remarcat că numărul contului este gol? Este timpul să corectăm acest lucru. Numărul contului ar trebui să fie atribuit când obiectul este construit. Dar nu ar trebui să fie responsabilitatea apelantului să îl creeze. Codul clasei BankAccount ar trebui să știe cum să atribuie noi numere de cont. Un simplu mod de a face aceasta este să începeți cu un număr de 10 cifre. Incrementați-l când fiecare nou cont este creat. In final, memorați numărul contului curent când un obiect este construit.
Adăugați următoarea declarație de membru la clasa BankAccount:
private static int accountNumberSeed = 1234567890;
Acesta este un membru de date. Este private, ceea ce înseamnă că poate fi accesat doar de codul dinăuntrul clasei BankAccount. Este o cale de a separa responsabilitățile publice (cum este a avea un număr de cont) de implementarea privată (cum numărul de cont este generat.) El este de asemenea static, ceea ce înseamnă că este împărțit de toate obiectele BankAccount. Valoarea unei variabile non-statice este unică la fiecare instanță a obiectului BankAccount. Adăugați următoarele două linii la constructor pentru a atribui numărul de cont:
this.Number = accountNumberSeed.ToString();
accountNumberSeed++;
Tastați dotnet run pentru a vedea rezultatele.
Creați depuneri și extrageri
Clasa dvs. de cont bancar trebuie să accepte depuneri și extrageri pentru a lucra corect. Haideți să implementăm depuneri și extrageri creând un jurnal cu fiecare tranzacție pentru cont. Aceasta are câteva avantaje peste simpla actualizare a soldului la fiecare tranzacție. Istoricul poate fi folosid pentru a controla toate tranzacțiile și a lucra cu solduri zilnice. Calculând soldul din istoricul tuturor tranzacțiilor când este nevoie. orice erori într-o singură tranzacție care sunt corectate vor fi corect reflectate în soldul următoarei calculări.Haideți să începem creând un nou tip să reprezinte o tranzacție. Acesta este un simplu ti care nu are nici o responsabilitate. Ii trebuie câteva proprietăți. Creați un fișier nou numit Transaction.cs. Adăugați următorul cod în el:
using System;
namespace classes
{
public class Transaction
{
public decimal Amount { get; }
public DateTime Date { get; }
public string Notes { get; }
public Transaction(decimal amount, DateTime date, string note)
{
this.Amount = amount;
this.Date = date;
this.Notes = note;
}
}
}
Acum, haideți să adăugăm o List<T> de obiecte Transaction la clasa BankAccount. Adăugați următoarea declarație:
private List<Transaction> allTransactions = new List<Transaction>();
Clasa List<T> vă cere să importați un namespace diferit. Adăugați următorul rând la începutul lui BankAccount.cs:
using System.Collections.Generic;
Acum, haideți să schimbăm cum Balance (soldul) este raportat. El poate fi găsit prin însumarea valorilor tuturor tranzacțiilor. Modificați declarația lui Balance în clasa BankAccount în următoarea:
public decimal Balance
{
get
{
decimal balance = 0;
foreach (var item in allTransactions)
{
balance += item.Amount;
}
return balance;
}
}
Acest exemplu vă arată un aspect important al proprietăților. Dvs. calculați acum soldul când un alt programator cere valoarea. Calculul dvs. enumeră toate tranzacțiile, și oferă suma ca soldul curent.
In continuare, implementați metodele MakeDeposit și MakeWithdrawal. Aceste metode vor impune finalele două reguli: că soldul inițial trebuie să fie pozitiv, și că orice extragere trebuie să nu creeze un sold negativ.
Aceasta introduce conceptul de excepții. Calea standard de a indica faptul că o metodă nu poate să își finalizeze lucrul său cu succes este să arunce o excepție. Tipul excepției și mesajul asociat cu ea descrie eroarea. Aici, metoda MakeDeposit aruncă o excepție dacă sumă depunerii este negativă. Metoda MakeWithdrawal aruncă o excepție dacă suma extragerii este negativă, sau dacă aplicarea extragerii rezultă într-un sold negativ:
public void MakeDeposit(decimal amount, DateTime date, string note)
{
if (amount <= 0)
{
throw new ArgumentOutOfRangeException(nameof(amount), "Amount of deposit must be positive");
}
var deposit = new Transaction(amount, date, note);
allTransactions.Add(deposit);
}
public void MakeWithdrawal(decimal amount, DateTime date, string note)
{
if (amount <= 0)
{
throw new ArgumentOutOfRangeException(nameof(amount), "Amount of withdrawal must be positive");
}
if (Balance - amount < 0)
{
throw new InvalidOperationException("Not sufficient funds for this withdrawal");
}
var withdrawal = new Transaction(-amount, date, note);
allTransactions.Add(withdrawal);
}
Instrucțiunea throw aruncă o excepție. Execuția metodei curente sfârșește, și va reporni când un bloc potrivit catch este găsit. Veți adăuga un bloc catch pentru a testa acest cod puțin mai încolo.
Constructorul ar trebui să primească o schimbare astfel încât el să adauge o tranzacție inițială, în loc de a actualiza soldul direct. Fiindcă ați scris deja metoda MakeDeposit, apelați-o din constructorul dvs. Constructorul finalizat ar trebui să arate astfel:
public BankAccount(string name, decimal initialBalance)
{
this.Number = accountNumberSeed.ToString();
accountNumberSeed++;
this.Owner = name;
MakeDeposit(initialBalance, DateTime.Now, "Initial balance");
}
DateTime.Now este o proprietate care întoarce data și ora curente. Testați aceasta adăugând câteva depuneri și extrageri în metoda dvs. Main:
account.MakeWithdrawal(500, DateTime.Now, "Rent payment");
Console.WriteLine(account.Balance);
account.MakeDeposit(100, DateTime.Now, "friend paid me back");
Console.WriteLine(account.Balance);
Apoi, testați că dvs. prindeți condiții de eroare încercând să creați un cont cu un sold negativ:
// Test that the initial balances must be positive:
try
{
var invalidAccount = new BankAccount("invalid", -55);
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine("Exception caught creating account with negative balance");
Console.WriteLine(e.ToString());
}
Dvs. folosiți instrucțiunile try și catch pentru a marca un bloc de cod care poate arunca excepții, și pentru a prinde acele erori pe care le așteptați. Puteți folosi aceeași tehnică pentru a testa codul care aruncă pentru un sold negativ:
// Test for a negative balance
try
{
account.MakeWithdrawal(750, DateTime.Now, "Attempt to overdraw");
}
catch (InvalidOperationException e)
{
Console.WriteLine("Exception caught trying to overdraw");
Console.WriteLine(e.ToString());
}
Salvați fișierul și tastați dotnet run pentru a-l încerca.
Provocare - înregistrați toate tranzacțiile
Pentru a finaliza această pornire rapidă, puteți scrie metoda GetAccountHistory care creează un string pentru istoricul tranzacțiilor. Adăugați această metodă la tipul BankAccount:public string GetAccountHistory()
{
var report = new System.Text.StringBuilder();
report.AppendLine("Date\t\tAmount\tNote");
foreach (var item in allTransactions)
{
report.AppendLine($"{item.Date.ToShortDateString()}\t{item.Amount}\t{item.Notes}");
}
return report.ToString();
}
Aceasta folosește clasa StringBuilder pentru a formata un șir care conține o linie pentru fiecare tranzacție. Ați văzut codul de formatare a șirurilor mai devreme în aceste porniri rapide. Un nou caracter este '\t'. Acesta introduce un tab pentru a formata ieșirea.
Adăugați această linie pentru a o testa în Program.cs:
Console.WriteLine(account.GetAccountHistory());
Tastați dotnet run pentru a vedea rezultatele.
Următorii pași
Dacă v-ați blocat, puteți vedea sursa pentru această pornire rapidă în depozitul nostru GitHub.Felicitări, ați finalizat toate pornirile noastre rapide (Quickstarts). Dacă sunteți doritori să învățați mai mult, încercați tutorialele noastre.
Tradus din această pagină oficială de documentație Microsoft.
Niciun comentariu:
Trimiteți un comentariu