3 Tips & tricks for Kickass Developers in 2019 – The focused generalist

வணக்கம்,

உங்களின் .NET திறன்கள் மூலம் 2019 ஆம் ஆண்டைத் தொடங்க புதிய வழிகளைத் தேடுபவர்கள், தொடர்ந்து படிக்கவும் 🙂

1. உங்கள் C# குறியீட்டில் அதிக LINQஐப் பயன்படுத்தவும்

சமீபத்தில், செயல்பாட்டு நிரலாக்கமானது மிகவும் சூடான மற்றும் பிரபலமான தலைப்பு. C# தொழில்துறை போக்குகளுக்கு இணையாக இருக்க ஒரு செயல்பாட்டு நிரலாக்க மொழியாக மாறி வருகிறது மற்றும் .NET 3.5 (2007) முதல் டெவலப்பர்களுக்கு வழங்கும் அம்சங்களில் ஒன்றாகும். இது ஒரு தசாப்தத்திற்கும் மேலாக உள்ளது மற்றும் உண்மையிலேயே உங்கள் குறியீட்டை மேலும் படிக்கக்கூடியதாக ஆக்குகிறது.

LINQ மூலம், லூப்பிங் கட்டமைப்பைப் பயன்படுத்துவதற்குப் பதிலாக உங்கள் சேகரிப்பின் மூலம் மீண்டும் மீண்டும் செய்யும் போது உங்கள் நோக்கத்தை நேரடியாக வெளிப்படுத்தலாம். பார்க்கும் போது ஒரு எங்கே அறிக்கை, உங்கள் அறிக்கை ஒரு லூப்பில் சமமான குறியீட்டை எழுதுவதற்கு மாறாக தரவை வடிகட்டுவதாகும் என்பதை டெவலப்பர்கள் உடனடியாக புரிந்துகொள்வார்கள், என்ன நடக்கிறது என்பதைப் புரிந்துகொள்ள நீங்கள் லூப்பின் உள்ளே பார்க்க வேண்டும்.

2. நீங்கள் தட்டச்சு செய்யும் போது உங்கள் குறியீட்டை ஆவணப்படுத்தவும்

2018 இல் நான் மிகவும் சாட்சியாகக் கண்டது குறியீட்டில் ஆவணங்கள் இல்லாதது. உங்கள் சொந்தக் குறியீட்டை எழுதி 3 முதல் 6 மாதங்களுக்குப் பிறகு, நீங்கள் அதை சிறிது நேரம் பராமரிக்காமல், அது மோசமாக ஆவணப்படுத்தப்பட்டிருந்தால் அல்லது ஆவணப்படுத்தப்படாமல் இருந்தால், நீங்கள் நினைவில் வைத்திருப்பீர்கள் என்று நினைப்பதால், அது தவறு என்று நான் உங்களுக்குச் சொல்கிறேன்.

உங்கள் குறியீட்டிற்கான ஆவணங்களை எழுதுவது, உங்கள் தயாரிப்பைப் பற்றிய ஆழமான புரிதலையும், குறியீட்டைப் பராமரிப்பதற்கும், அதில் கூடுதல் அம்சங்களைச் சேர்ப்பதற்கும் பொறுப்பான அடுத்தவர்களுக்கான மரியாதையையும் காட்டுகிறது. நீங்கள் அறிவைப் பரிமாற்றம் செய்ய வேண்டியிருக்கும் போது, ​​அது ஒரு தென்றலாக இருக்கும், ஏனென்றால் நீங்கள் அடிப்படையிலிருந்து கட்டியெழுப்பிய அனைத்தையும் ஆதரிக்க ஆவணங்கள் ஏற்கனவே உள்ளன. இன்னும் சொல்லப் போனால், அந்த குறியீட்டைத் தொட்டால் மட்டுமே, சிஸ்டத்தில் ஏதேனும் பிழை ஏற்பட்டால், பயனுள்ள ஆவணப்படுத்தலுக்கு நீங்கள் நன்றியுள்ளவர்களாக இருப்பீர்கள், மேலும் அந்த வரிகளைக் கடந்து, அந்த மோசமான தருக்கப் பிழை எங்கே மறைந்திருக்கிறது என்பதைக் கண்டறிந்து, அதற்கான வழியைக் கண்டுபிடிப்பதற்கு நீங்கள் பொறுப்பாவீர்கள். அதிலிருந்து விலகிவிடு.

3. முடிந்தால் உங்கள் முறைகளை பக்கவிளைவுகள் இல்லாமல் எழுதுங்கள்

உங்கள் குறியீடு பக்க விளைவுகளை உருவாக்க வேண்டிய அவசியமில்லை. ஒரு குறிப்பிட்ட கண்ணோட்டத்தில், உங்கள் குறியீடு எப்போதும் ஒரே உள்ளீட்டில் ஒரே வெளியீட்டை உருவாக்க முயற்சிக்க வேண்டும். அதற்கு என்ன பொருள்? பயனர் இடைமுகத்தில் உள்ள பொத்தானைக் கிளிக் செய்யும் ஒவ்வொரு முறையும் கவுண்டரை அதிகரிக்க ஒரு முறையை உருவாக்குகிறீர்கள் என்று வைத்துக்கொள்வோம், உண்மையில் பயனர் உள்ளீட்டின் அடிப்படையில் ஒரு மாறக்கூடிய நிலை உள்ளது. எனவே நான் பட்டனை முதன்முதலில் கிளிக் செய்வதிலிருந்து 100 வது முறை கிளிக் செய்யும் வரை, மாநிலம் தொடர்ந்து புதுப்பிக்கப்படுவதால் எனக்கு ஒரே மாதிரியான வெளியீடு இருக்காது.

மாறக்கூடிய குறியீட்டை எழுத வேண்டாம் என்று நான் கூறவில்லை. நான் ஒரு உதவிக்குறிப்பாக பகிர்ந்து கொள்ள முயற்சிப்பது அதுவல்ல. பிறழ்வு தவிர்க்க முடியாதது, ஆனால் அதைக் கட்டுப்படுத்தலாம் மற்றும் தனிமைப்படுத்தலாம். உங்கள் குறியீட்டில் பெரும்பாலானவை நிலையற்றவை போல தூய்மையானதாக இருக்கலாம். படிக்க மட்டுமேயான புலங்கள் மற்றும் பண்புகள் இருப்பதை உறுதிசெய்யலாம். உங்களால் புதுப்பிக்க முடியாத படிப்பதற்கு மட்டுமேயான சேகரிப்புகளை வழங்கும் APIகளையும் நீங்கள் வழங்கலாம். உங்கள் வகுப்பில் உள்ள ஒரு பொருளற்ற புலத்தைப் புதுப்பிப்பதற்குப் பதிலாக, குறிப்பிட்ட வகுப்பின் ஒரு முறை மட்டுமே பயன்படுத்தப்படுகிறது, அதை ஒரு முறையின் உள்ளூர் மாறியாக மாற்றி, அதை அங்கே புதுப்பிக்கவும். வாடிக்கையாளரின் பார்வையில், உங்கள் முறையானது மாறக்கூடிய தன்மையைக் கொண்டிருந்தாலும், அதே உள்ளீடு அதே வெளியீட்டை உருவாக்கினால், நீங்கள் பொன்னானவர் 🙂

கெவின் அவுட்.

Leave a Comment