කේත සුවඳ යනු දෝෂ ගණන වැඩි කිරීමට ඉඩ ඇති සැලසුමේ ගැටලුවක් ඇති බව පෙන්නුම් කරන රෝග ලක්ෂණයකි: මෙය කලාප සඳහා නොවේ, නමුත් කලාප වලට කේත ක්රම සුවඳ විලවුන් සඳහා දිගු ක්රම මෙන් දායක විය හැකිය.
සිට:
ප්‍රති-රටාව (හෝ ප්‍රති-රටාව) යනු සමාජීය හෝ ව්‍යාපාර මෙහෙයුම් හෝ මෘදුකාංග ඉංජිනේරු විද්‍යාවේ බහුලව භාවිතා වන නමුත් අකාර්යක්ෂම හා / හෝ ප්‍රායෝගිකව ප්‍රති ro ලදායක වන රටාවකි.
ප්රදේශ වේ විරෝධී රටා. කේතයේ ගුණාත්මකභාවය හෝ කියවීමේ හැකියාව වැඩි නොකරන, දෝෂ ගණන අඩු නොකරන, සහ කේතය ප්‍රතික්‍රියාකාරකයට වඩාත් සංකීර්ණ කිරීමට පමණක් හේතු වන වැඩි වැඩක් ඔවුන්ට අවශ්‍ය වේ.
ක්රම ඇතුළත කලාප භාවිතා නොකරන්න; ඒ වෙනුවට ප්‍රතික්‍රියාකාරකය
ක්රම කෙටි විය යුතුය . ක්‍රමයක පේළි දහයක් පමණක් තිබේ නම්, අනෙක් පස් මත වැඩ කිරීමේදී ඒවායින් පහක් සැඟවීමට ඔබ කලාප භාවිතා නොකරනු ඇත.
එසේම, සෑම ක්රමයක්ම එක හා එකම දේ කළ යුතුය. කලාප, අනෙක් අතට, විවිධ දේ වෙන් කිරීමට අදහස් කරයි . ඔබේ ක්‍රමය A, B නම්, කලාප දෙකක් නිර්මාණය කිරීම තර්කානුකූල ය, නමුත් මෙය වැරදි ප්‍රවේශයකි; ඒ වෙනුවට, ඔබ ක්‍රමවේදය වෙනම ක්රම දෙකකට ප්‍රතිනිර්මාණය කළ යුතුය.
මෙම අවස්ථාවේ දී කලාප භාවිතා කිරීම ද ප්‍රතිචක්‍රීකරණය කිරීම වඩාත් අපහසු කරයි. ඔබට ඇති බව සිතන්න:
private void DoSomething()
{
var data = LoadData();
#region Work with database
var verification = VerifySomething();
if (!verification)
{
throw new DataCorruptedException();
}
Do(data);
DoSomethingElse(data);
#endregion
#region Audit
var auditEngine = InitializeAuditEngine();
auditEngine.Submit(data);
#endregion
}
දෙවන කලාපය කෙරෙහි අවධානය යොමු කිරීම සඳහා පළමු කලාපය බිඳ දැමීම අවදානම් පමණක් නොවේ: ගලායාම නැවැත්වීම හැර අපට පහසුවෙන් අමතක කළ හැකිය ( returnඒ වෙනුවට ආරක්ෂක වගන්තියක් තිබිය හැකිය , එය හඳුනා ගැනීම ඊටත් වඩා දුෂ්කර ය), නමුත් ගැටලුවක් ද ඇත කේතය මේ ආකාරයෙන් ප්‍රතිනිර්මාණය කළ යුතු නම්:
private void DoSomething()
{
var data = LoadData();
#region Work with database
var verification = VerifySomething();
var info = DoSomethingElse(data);
if (verification)
{
Do(data);
}
#endregion
#region Audit
var auditEngine = InitializeAuditEngine(info);
auditEngine.Submit(
verification ? new AcceptedDataAudit(data) : new CorruptedDataAudit(data));
#endregion
}
දැන්, කලාපවල තේරුමක් නැති අතර, පළමු කලාපයේ කේතය දෙස නොබලා ඔබට දෙවන කලාපයේ කේතය කියවා තේරුම් ගත නොහැක.
මම සමහර විට දකින තවත් අවස්ථාවක් මෙයයි:
public void DoSomething(string a, int b)
{
#region Validation of arguments
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b <= 0)
{
throw new ArgumentOutOfScopeException("b", ...);
}
#endregion
#region Do real work
...
#endregion
}
තර්ක වලංගු කිරීම LOC දස දහස් ගණනක් දක්වා විහිදෙන විට කලාප භාවිතා කිරීමට පෙළඹේ, නමුත් මෙම ගැටළුව විසඳීමට වඩා හොඳ ක්රමයක් තිබේ: .NET Framework ප්‍රභව කේතය භාවිතා කරන ක්‍රමය:
public void DoSomething(string a, int b)
{
if (a == null)
{
throw new ArgumentNullException("a");
}
if (b <= 0)
{
throw new ArgumentOutOfScopeException("b", ...);
}
InternalDoSomething(a, b);
}
private void InternalDoSomething(string a, int b)
{
...
}
කණ්ඩායම් කිරීමට ක්රම වලින් පිටත කලාප භාවිතා නොකරන්න
ක්ෂේත්ර, දේපල ආදිය කාණ්ඩගත කිරීම සඳහා සමහර අය ඒවා භාවිතා කරයි . මෙම ප්‍රවේශය වැරදියි: ඔබේ කේතය ස්ටයිල්කොප් අනුකූල නම්, ක්ෂේත්ර, දේපල, පුද්ගලික ක්රම, ඉදිකිරීම්කරුවන් යනාදිය දැනටමත් කාණ්ඩගත කර ඇති අතර පහසුවෙන් සොයාගත හැකිය. එය එසේ නොවේ නම්, ඔබේ කේත පදනම හරහා ඒකාකාරිත්වය සහතික කරන නීති රීති යෙදීම ගැන සිතීම ආරම්භ කිරීමට කාලය පැමිණ තිබේ.
වෙනත් පුද්ගලයින් සමාන ආයතන රාශියක් සැඟවීමට කලාප භාවිතා කරයි . නිදසුනක් ලෙස, ඔබට ක්ෂේත්ර සියයක් සහිත පංතියක් ඇති විට (ඔබ අදහස් සහ සුදු අවකාශය ගණන් කළහොත් අවම වශයෙන් පේළි 500 ක් වත් කරයි), එම ක්ෂේත්‍රයන් කලාපයක් තුළ තැබීමට, බිඳවැටීමට හා ඒවා අමතක කිරීමට ඔබ පෙළඹෙනු ඇත. නැවතත්, ඔබ එය වැරදියි: පන්තියක බොහෝ ක්ෂේත්ර තිබියදී, ඔබ උරුමය භාවිතා කිරීම ගැන වඩා හොඳින් සිතිය යුතුය, නැතහොත් වස්තුව වස්තු කිහිපයකට කපන්න.
අවසාන වශයෙන්, සමහර පුද්ගලයින් ආශ්‍රිත දේවල් කාණ්ඩගත කිරීම සඳහා කලාප භාවිතා කිරීමට පෙළඹේ : එහි නියෝජිතයා සමඟ සිදුවීමක්, හෝ IO හා සම්බන්ධ වෙනත් ක්රම සමඟ IO සම්බන්ධ ක්රමයක් යනාදිය. පළමු අවස්ථාවේ දී, එය නඩත්තු කිරීමට අපහසු වන අවුලක් බවට පත්වේ , කියවා තේරුම් ගන්න. දෙවන අවස්ථාවේ දී, වඩා හොඳ සැලසුම වනුයේ පන්ති කිහිපයක් නිර්මාණය කිරීමයි.
කලාප සඳහා හොඳ භාවිතයක් තිබේද?
අංක ජනනය කේතය: උරුමය භාවිතය ඇති විය. තවමත්, කේත උත්පාදනය කිරීමේ මෙවලම් වෙනුවට අර්ධ පන්ති භාවිතා කළ යුතුය. C # ට කලාපීය සහය තිබේ නම්, එය බොහෝ දුරට මෙම උරුම භාවිතය නිසා වන අතර, දැන් බොහෝ අය ඔවුන්ගේ කේතයේ කලාප භාවිතා කර ඇති නිසා, පවතින කේත පදනම් කඩ නොකර ඒවා ඉවත් කිරීමට නොහැකි වනු ඇත.
ඒ ගැන සිතන්න goto. භාෂාව හෝ IDE විශේෂාංගයකට සහය දක්වයි යන්නෙන් අදහස් වන්නේ එය දිනපතා භාවිතා කළ යුතු බවයි. StyleCop SA1124 රීතිය පැහැදිලිය: ඔබ කලාප භාවිතා නොකළ යුතුය. කවදාවත්.
උදාහරණ
මම දැනට මගේ සහායකයාගේ කේතය පිළිබඳ කේත සමාලෝචනයක් කරමින් සිටිමි. කෝඩ්බේස්හි කලාප රාශියක් අඩංගු වන අතර ඇත්ත වශයෙන්ම කලාප භාවිතා නොකරන්නේ කෙසේද සහ කලාප නරක කේත වලට තුඩු දෙන්නේ ඇයි යන දෙකටම කදිම නිදසුනකි. මෙන්න උදාහරණ කිහිපයක්:
4 000 LOC රාක්ෂයා:
මම මෑතකදී Programmers හි කොතැනක හෝ කියවා ඇත්තෙමි. ගොනුවක වැඩිපුර usings අඩංගු වන විට ("භාවිතයට නොගත් භාවිතයන් ඉවත් කරන්න" විධානය ක්‍රියාත්මක කිරීමෙන් පසු), මෙම ගොනුවේ පන්තිය ඕනෑවට වඩා වැඩ කරන බවට හොඳ ලකුණකි. ගොනුවේ ප්‍රමාණයට ද එය අදාළ වේ.
කේතය සමාලෝචනය කරන අතරතුර, මට 4 000 LOC ගොනුවක් හමු විය. මෙම කේතයේ කතුවරයා එකම පේළි 15 ක ක්‍රමය සිය ගණනක් පිටපත් කර අලවන ලද අතර විචල්‍යයන්ගේ නම් සහ කැඳවුම් ක්‍රමය තරමක් වෙනස් කළේය. සාමාන්‍ය රීජෙක්ස් එකක් මඟින් ගොනුව 4 000 LOC සිට 500 LOC දක්වා අඩු කිරීමට ඉඩ දී ඇත. මට හොඳටම විශ්වාසයි වඩාත් දක්ෂ ලෙස ප්‍රතිනිර්මාණය කිරීමෙන් මෙම පන්තිය පේළි දුසිම් කිහිපයකට අඩු කළ හැකිය.
කලාප භාවිතා කිරීමෙන්, කේතය නඩත්තු කිරීමට නොහැකි සහ දුර්වල ලෙස ලිවීමට නොහැකි බව නොසලකා හැරීමටත්, කේතය නැවත ප්‍රතිනිර්මාණය කිරීම වෙනුවට දැඩි ලෙස අනුපිටපත් කිරීමටත් කතුවරයා උනන්දු කළේය.
කලාපය “කරන්න”, කලාපය “කරන්න බී”:
තවත් විශිෂ්ට උදාහරණයක් වන්නේ රාක්ෂයා ආරම්භක ක්රමයක් වන අතර එය හුදෙක් කාර්ය 1, පසුව කාර්ය 2, පසුව කාර්ය 3 යනාදිය සිදු කරන ලදී. කාර්යයන් පහක් හෝ හයක් මුළුමනින්ම ස්වාධීන වූ අතර, සෑම එකක්ම බහාලුම් පන්තියක යමක් ආරම්භ කරයි. එම සියලු කාර්යයන් එක් ක්‍රමයකට කාණ්ඩ කර කලාපවලට කාණ්ඩ කරන ලදී.
මෙය එක් වාසියක් විය:
- කලාපයේ නම් බැලීමෙන් මෙම ක්‍රමය තේරුම් ගැනීමට ඉතා පැහැදිලිය. මෙය පැවසුවහොත්, නැවත ප්‍රතිනිර්මාණය කළ ක්‍රමයම මුල් පිටපත තරම්ම පැහැදිලි වනු ඇත.
අනෙක් අතට, ගැටළු බහු විය:
කලාප අතර පරායත්තතා තිබේද යන්න පැහැදිලි නැත. බලාපොරොත්තු වන පරිදි, විචල්යයන් නැවත භාවිතා කිරීමක් සිදු නොවීය. එසේ නොවුවහොත් නඩත්තු කිරීම ඊටත් වඩා බියකරු සිහිනයක් විය හැකිය.
මෙම ක්‍රමය පරීක්ෂා කිරීමට නොහැකි තරම් විය. වරකට දේවල් විස්සක් කරන ක්‍රමය නිවැරදිව කරන්නේ දැයි ඔබ පහසුවෙන් දැන ගන්නේ කෙසේද?
ක්ෂේත්ර කලාපය, දේපල කලාපය, ඉදිකිරීම් කලාපය:
සමාලෝචනය කරන ලද කේතයේ සියලුම ක්ෂේත්ර, සියලු ගුණාංග එකට කාණ්ඩගත කළ ප්රදේශ රාශියක් අඩංගු විය. මෙය පැහැදිලි ගැටළුවක් විය: මූලාශ්ර කේත වර්ධනය.
ඔබ ගොනුවක් විවෘත කර විශාල ක්ෂේත්ර ලැයිස්තුවක් දුටු විට, ඔබ පළමුව පන්තිය ප්‍රතිනිර්මාණය කිරීමට වැඩි නැඹුරුවක් දක්වයි, පසුව කේතය සමඟ වැඩ කරන්න. කලාප සමඟ, ඔබ දේවල් කඩා වැටීම හා ඒ ගැන අමතක කිරීම පුරුද්දක් කර ගනී.
තවත් ගැටළුවක් නම්, ඔබ එය සෑම තැනකම කරන්නේ නම්, ඔබ එක්-බ්ලොක් කලාප නිර්මාණය කරන බවක් පෙනේ, එයින් කිසිදු තේරුමක් නැත. මා සමාලෝචනය කළ කේතයේ ඇත්ත වශයෙන්ම මෙය සිදුවිය, එහිදී #region Constructorඑක් ඉදිකිරීම්කරුවෙකු අඩංගු විය.
අවසාන වශයෙන්, ක්ෂේත්ර, දේපල, ඉදිකිරීම්කරුවන් යනාදිය දැනටමත් පිළිවෙලට තිබිය යුතුය . ඒවා නම් සහ ඒවා සම්මුතීන්ට ගැලපෙන්නේ නම් (විශාල අකුරකින් ආරම්භ වන නියතයන් යනාදිය), මූලද්‍රව්‍ය වර්ගය නතර වන්නේ කොතැනින්ද යන්න සහ වෙනත් ආරම්භ වන්නේ කොතැනින්ද යන්න දැනටමත් පැහැදිලි ය, එබැවින් ඒ සඳහා කලාප පැහැදිලිව නිර්මාණය කිරීමට ඔබට අවශ්‍ය නැත.