अपनी शाखा के साथ मेल - जोल रखना, और उचित कार्य के रूप में खेलना, कम तनाव के साथ बेहतर सॉफ्टवेयर बनाता है.

गर्म ले लो: अधिकांश विकासकर्ता विकास के हर चरण में सिद्ध होने की कोशिश कर रहे हैं, और यह उनकी जैविकता और उनकी समृद्धि दोनों को मार रहा है. यहाँ एक बेहतर तरीका है.

परिचय

मैं के लिए सॉफ्टवेयर व्यावसायिक रूप से निर्माण किया गया है... ठीक है, चलो बस मुझे याद है जब "Agyles" एक नया विचार था और नहीं एक कंपनी मैनेजर द्वारा अधिक खड़े को उचित ठहराने के लिए।

वर्षों के दौरान, मैं कुछ देखा है: सबसे अच्छा कोड मैंने कभी नहीं लिखा है परियोजनाओं से जहां मैंने महसूस किया था खेलने के लिए अनुमति. सबसे खराब कोड परियोजना से आया जहाँ हर कुंजी के बारे में सोचा जा रहा था की तरह, जहां मैं एक मिनट से "पुष्ट - तैयार" कोड लिखने की कोशिश कर रहा था.

यह दुर्घटनात्मक नहीं है. वातावरण और दबाव अच्छी तरह से मिश्रण नहीं है.

तो मैं एक तरीका विकसित किया है कि गंदगी, निर्माण, निर्माण - तैयार करने के लिए तैयार. मैं इसे कहते हैं "यह काम करते हैं, सुंदर करते हैं, यह नीचे ताला"लेकिन वास्तव में, यह आप पर पूर्णता लटका के भार के बिना खुद को प्रयोग करने की अनुमति है.

तीन चरण

मुझे स्पष्ट होना चाहिए: यह लापरवाह होने या अनुशासन से दूर रहने के बारे में नहीं है. यह के बारे में है के बारे में है. सही अनुशासन को सही समय पर लागू करना.

graph LR
    subgraph "Phase 1: Make It Work"
        A[New Requirement] --> B[Explore & Experiment]
        B --> C{Does It Work?}
        C -->|No| D[Try Different Approach]
        D --> B
        C -->|Yes| E[Basic Solution]
    end

    subgraph "Phase 2: Make It Pretty"
        E --> F[Refactor & Clean]
        F --> G[Apply SOLID Pragmatically]
        G --> H[Get Stakeholder Feedback]
        H --> I[Polished Solution]
    end

    subgraph "Phase 3: Lock It Down"
        I --> J[Add Tests]
        J --> K[Security Review]
        K --> L[Add Monitoring]
        L --> M[Production Ready]
    end

    style A stroke:#f59e0b,stroke-width:3px
    style E stroke:#0ea5e9,stroke-width:3px
    style I stroke:#8b5cf6,stroke-width:3px
    style M stroke:#10b981,stroke-width:4px

फेस 1: काम कीजिए ।

इकाईः पहले खेलें. अपने अनुमानों की पुष्टि करें. कुछ पाने के लिए जाओ.

यह वह चरण है जहाँ आपकी शाखा एक सेंडी है. मेक्सी कोड ठीक है. मृत अंत में तीन बार शुरू होता है. बढ़ियाआप यहाँ एक गिरजे का निर्माण नहीं कर रहे हैं; आप एक चाकू पर रंग रहे हैं.

आप क्या पता लगाने की कोशिश कर रहे हैं:

• क्या यह एपीआई वास्तव में ऐसा व्यवहार करता है कि इसका दावा कैसे होता है? (स्कारर: यह शायद ही होता है)
• क्या मैं भी मेरे पास औज़ारों के साथ इस समस्या को हल कर सकता हूँ?
• टिकट में लिखे गए व्यक्‍तियों की वास्तविक माँगें क्या हैं?
• क्या यह दो घंटे की समस्या है या दो सप्ताह की समस्या है?

गंभीर अन्तर्दृष्टि: जब तक आप एक पंडेंट, अपने शाखा है तुम्हारा. यह अपने प्रयोगात्मक संस्थान को देखने की जरूरत नहीं है। कोई भी अपने झूठ शुरू करने के लिए की जरूरत नहीं है, आपकी टिप्पणीात्मक कोड, आपकी टिप्पणी में टिप्पणी की गई है: यह भयानक है, ठीक बाद में टिप्पणी. लेकिन, हर बार जब आपके पास कुछ है कि काम करता है, और धक्का दिया है. अपने CIsecripts, एक अच्छी तरह से आप अधिक परिवर्तन दे जाएगा. एक अच्छी तरह से, एक और अधिक परीक्षण आप के रूप में परिवर्तन, यह अधिक गंभीर रूप से नहीं है. यह एक साथ शुरू करने के लिए एक और अधिक गंभीर रूप में, मैं अभी भी नहीं किया गया है. यह तीन बार फिर भी एक साथ शुरू किया जा रहा है. "

बाज़ू फ़ायदे: आमतौर पर यह एक दिल दहलानेवाली टीम है। रिमोट/साइट टीमों में, लगातार प्रगति का एक निरंतर निशान, "लेकिन प्रगति" हर किसी को आश्वस्त करता है कि काम आगे बढ़ रहा है - बिना आप SLONONONON में काम करने के लिए किया जा रहा है।

यह मनोवैज्ञानिक स्वतंत्रता अनिवार्य है. जब आप जानते हैं कि आप सब कुछ दूर फेंक सकते हैं और ताजा शुरू कर सकते हैं, आप साहसपूर्वक निर्णय करते हैं. आप कोशिश करते हैं कि शायद काम नहीं करेंगे. कभी कभी कभी आप एक लेख को पढ़ने की जरूरत होती है, एक वीडियो देखते हैं, एक लंबे समय के लिए. याद रखें कि आपका काम अच्छा सॉफ्टवेयर बनाने के लिए है और अच्छा निर्णय करने के लिए अच्छी तरह से नहीं है. कोई उदारता नहीं.

// Phase 1 code looks like this - and THAT'S OKAY
public async Task<Result> ProcessThing(Request req)
{
    // TODO: what if this is null?
    var data = await _api.GetSomething(req.Id);

    // This probably isn't right but let's see what happens
    var transformed = data.Items
        .Where(x => x.Status != "deleted") // Is this the right filter?
        .Select(x => new Thing { Name = x.Name }); // Missing loads of fields

    // HACK: hardcoded for now
    return new Result { Items = transformed.ToList(), Total = 42 };
}

यह उत्पादन कोड है? भगवान नहीं. क्या यह उपयोगी है? बिल्कुल. यह आपको बताता है कि क्या आपका तरीका भी काम नहीं करने से पहले भी व्यवहार कर रहा है जो काम नहीं करेगा.

फ़ीडबैक पर एक नोट: आप पर फ़ीडबैक प्राप्त कर सकते हैं कोई भी 1 चरण में बिंदु - कुंजी चुना जा रहा है कौन ऐसा करने का लक्ष्य होना चाहिए, सबसे बढ़िया गुण पैदा करना न कि कड़ी मेहनत करना ।

"क्या यह आकार समझ में आता है?" किसी प्रकार के काम के दिन बचा जा सकता है. कुछ उपयोगकर्ता-फ्पर बनाने? शायद यह कम नहीं है, जब तक कि व्यापार कवर नहीं है, कुछ लोग ऊपर गिर जाता है कैसे कुछ पर गिर जाता है. " रूप यह नहीं है कि नहीं कार्य.. यह ठीक है, वे PROCOT 2 में फ़ीडबैक दे.

अपने फैसले का इस्तेमाल कीजिए । स्पष्ट, स्वीकार करने के लिए नहीं, नहीं है कि पहले से ही किया गया था. "सेट कहते हैं कि 'हैswonsssysys' - क्या इसका मतलब है तीन बार कोशिश करें, या तेजी से असफल और सूचना? यह एक घातक बातचीत है. "

अगर एक सूलीर के इनपुट गंभीर है लेकिन वे किसी भी कोड के साथ संघर्ष करते हैं, एक मामूली सा डेमो बनाने. एक हार्ड scutd खुश है कि दिखाता है कि धारणा को साबित कर सकते हैं बाहर के मामलों की ध्यानपूर्वक प्रतिक्रियाओं के बिना मूल्यवान प्रतिक्रिया खोल सकते हैं.

लक्ष्य सबसे अच्छा गुण है, शुद्धता नहीं ।

फेस 2: इसे सुंदर बनाएँ

इकाईः अब आप जानते हैं कि आप क्या निर्माण कर रहे हैं, यह बनाने के लिए अच्छा.

Scration चरण अपना काम पूरा किया है. आप संदर्भ कार्यों की पुष्टि की है, आप समस्या का आकार समझते हैं, और आप शायद एक दर्जन किनारा मामलों मूल टिकट का उल्लेख नहीं किया है.

अब आप इसे साफ:

// Phase 2: Same logic, but actually maintainable
public async Task<ProcessingResult> ProcessItemsAsync(
    ProcessingRequest request,
    CancellationToken cancellationToken = default)
{
    ArgumentNullException.ThrowIfNull(request);

    var items = await _itemRepository.GetActiveItemsAsync(
        request.AccountId,
        cancellationToken);

    var processedItems = items
        .Where(item => item.Status != ItemStatus.Deleted)
        .Select(item => _mapper.ToProcessedItem(item))
        .ToList();

    return new ProcessingResult
    {
        Items = processedItems,
        TotalCount = processedItems.Count,
        ProcessedAt = _timeProvider.UtcNow
    };
}

यह है जहाँ आप:

• एसओआईडी सिद्धांत लागू करें प्लोटोनी (बल्कि) वह माबूद खुद उनकी इबादत से इन्कार नहीं करते
• चीज़ें उचित नाम दें
• टाइप संकेत और XML दस्तावेज जोड़ें
• कॉलर्स के दृष्टिकोण से एपीआई सतह के बारे में सोचो
• किनारा मामलों को हैंडल करें जो आपने चरण 1 में खोज लिए हैं

गंभीर रूप से, यह गैर-टाइट सूलीदार फ़ीडबैक के लिए सबसे अच्छा समय है. सुविधा अब दृश्‍य है और प्रयोग किया है, लेकिन आप अभी तक इसके लिए जाँच का भुगतान नहीं किया है. यदि वे कहते हैं कि "चिक, हम इसे एक्स करने के लिए चाहते थे," आप एक व्यापक जाँच सूट को मिटाने के बिना दिल तोड़ सकते हैं.

फेस 3: ताला नीचे

इकाईः कठिन यह, इसे परीक्षण, यह कठिन बनाने के लिए.

अब केवल और अब आप अपनी जाँच लिखते हैं। सुरक्षा जांच जोड़ें। उत्पादन सीमाओं के मामलों के लिए उचित त्रुटि लागू करें। ध्यान दें और गार्ड शामिल करें।

क्यों अब तक इंतज़ार करें? आप अंत में पता है कि आप क्या जांच कर रहे हैं.

सामने 1 में लिखा गया परीक्षण गलत होता है - आप समस्या को अभी तक नहीं समझते थे. जाँच 2 में लिखा गया था - आप अब भी कर रहे थे Gret. जाँच 3 में लिखा गया जाँच कर रहे हैं. सहीक्योंकि कार्यान्वयन स्थिर है।

[Theory]
[InlineData(0)]
[InlineData(1)]
[InlineData(100)]
public async Task ProcessItemsAsync_WithValidRequest_ReturnsCorrectCount(
    int itemCount)
{
    // Arrange
    var items = _fixture.CreateMany<Item>(itemCount).ToList();
    _mockRepository
        .Setup(r => r.GetActiveItemsAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
        .ReturnsAsync(items);

    // Act
    var result = await _sut.ProcessItemsAsync(
        new ProcessingRequest { AccountId = Guid.NewGuid() });

    // Assert
    result.TotalCount.Should().Be(itemCount);
    result.Items.Should().HaveCount(itemCount);
}

[Fact]
public async Task ProcessItemsAsync_WithNullRequest_ThrowsArgumentNullException()
{
    // Act & Assert
    await _sut.Invoking(s => s.ProcessItemsAsync(null!))
        .Should().ThrowAsync<ArgumentNullException>();
}

[Fact]
public async Task ProcessItemsAsync_ExcludesDeletedItems()
{
    // Arrange
    var items = new[]
    {
        new Item { Status = ItemStatus.Active },
        new Item { Status = ItemStatus.Deleted },
        new Item { Status = ItemStatus.Active }
    };
    _mockRepository
        .Setup(r => r.GetActiveItemsAsync(It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
        .ReturnsAsync(items);

    // Act
    var result = await _sut.ProcessItemsAsync(
        new ProcessingRequest { AccountId = Guid.NewGuid() });

    // Assert
    result.Items.Should().HaveCount(2);
}

इस चरण में यह भी शामिल है:

• सुरक्षा समीक्षा (अनुप्रयोग, प्राधिकार, इनपुट वैध)
• ( बोझ तले क्या होता है?)
• असफल मोड विश्लेषण (यदि डाटाबेस धीमा हो तो क्या? यदि एपीआई बार बाहर हों)
• निगरानी करते हुए (हम कैसे पता चलेगा कि यह उत्पादन में टूट गया है?)

फ़ीडबैक कोलॉज़ी

अलग अलग अलग चरणों में लोगों को शामिल होना चाहिए. इस गलत जाओ और आप संघर्ष में डूब जाएगा.

graph TB
    subgraph "Phase 1: Technical Voices"
        P1[Make It Work] --> T1[Senior Dev Review]
        T1 --> T2["Does the approach<br/>make sense?"]
        T2 --> T3["Any obvious<br/>architectural issues?"]
    end

    subgraph "Phase 2: Non-Technical Voices"
        P2[Make It Pretty] --> N1[Product Owner Demo]
        N1 --> N2["Does it meet<br/>the requirement?"]
        N2 --> N3["Is the UX<br/>intuitive?"]
    end

    subgraph "Phase 3: Ops/Security Voices"
        P3[Lock It Down] --> O1[Security Review]
        O1 --> O2[Operations Review]
        O2 --> O3["Will it hold up<br/>in production?"]
    end

    T3 --> P2
    N3 --> P3

    style T1 stroke:#3b82f6,stroke-width:2px
    style N1 stroke:#8b5cf6,stroke-width:2px
    style O1 stroke:#ef4444,stroke-width:2px

फेस 1: तकनीकी आवाज केवल - scorors, आर्केंटs. वे समाधान के आकार के लिए अतीत देख सकते हैं. गैर-स्टिटिक्स सूलीरों को कठोर कोड में आतंक होगा और जब आप अभी भी डेटा मॉडल बाहर कर रहे हैं के बारे में पूछ रहे हैं.

फेस 2: गैरटिकल आवाजों का स्वागत है. सुविधा प्रयोग किया जाता है, बटन कार्य करता है. उत्पाद मालिक और डिज़ाइनर अब भी शामिल हैं, परिवर्तन अभी तक नहीं लिखा है.

फेस 3: "क्या होगा अगर यह 10x ट्रैफिक हो जाता है?" "क्या होता है अगर कोई कठोर इनपुट चला जाता है?" ये चिंता केवल एक बार के लिए काम करता है.

बतौर सेंडबाक्स्स

यहाँ मेरी विकास जीवन बदल गया है कि बात है: जब तक आप एक सहवास, अपने शाखा पूरी तरह से निजी है.

यह स्पष्ट लग सकता है, लेकिन मुझे लगता है कि विकासकर्ता हर तरह से उनके स्थायी रिकॉर्ड पर जा रहा है। वे प्रयोग करने के लिए डर रहे हैं। बदसूरत कोड लिखने के लिए डर। चीजों को तोड़ने के लिए डर।

मैं चाहता हूँ कि आप अपनी विशेषता शाखा के बारे में एक सेंड के रूप में सोचना चाहते हैं. एक Wargogogs जहां विस्फोट उम्मीद कर रहे हैं और कोई नुकसान नहीं हो जाता है.

graph TD
    A[Feature Branch Created] --> B[Experiment Freely]
    B --> C{Did it work?}
    C -->|No| D[Try Something Else]
    D --> B
    C -->|Yes| E[Clean Up the Mess]
    E --> F[Interactive Rebase]
    F --> G[Squash to Clean Commits]
    G --> H[Raise PR]
    H --> I[Public Code Review]

    style B stroke:#f59e0b,stroke-width:3px
    style D stroke:#f59e0b,stroke-width:2px
    style H stroke:#10b981,stroke-width:3px

    subgraph "Private - Go Mental"
        B
        C
        D
        E
    end

    subgraph "Public - Be Professional"
        H
        I
    end

अभ्यास में, इसका अर्थ है:

• कमिट अकसर, यहां तक कि कोड कंपाइल नहीं करता है
• लिखें FIXME और TODO हर जगह टिप्पणी
• डिबगिंग कोड को जगह में छोड़ें जब आप देख रहे हों
• बहुत से "इस दृष्टिकोण का उल्लेख करें" निर्णय करता है
• संदेश कमिट करने के बारे में चिंता मत करो (आप बाद में 'गाछ' करेंगे)

फिर, पहले आप एक पंडी उठाने से पहले:

1. कोड साफ करें (पिक 2)
2. जांच जोड़ें (पीएसला 3)
3. इपॉसिटरी इतिहास में इस वस्तु को पुनःसित करने के लिए अंतर्क्रियात्मक रीफ्रेशित करें
4. एक सही कमिट संदेश लिखें

Pald समीक्षा करनेवाले एक स्पष्ट कहानी के साथ साफ, पेशेवर कोड देखते हैं. वे छह गलत शुरू नहीं होते हैं, 3m "क्यों यह खूनी काम क्यों नहीं करता" या "अभुकार" इतिहास.

इन्हें बनाने का काम सार्वजनिक तरीके से चलता है ।

यह तनाव कम क्यों करता है

पारंपरिक "सभी समय में पेशेवर" विकास को कुचल दिया जाता है. हर पंक्ति को स्थायी महसूस होता है. यह तरीका उस दबाव को हटा देता है जिसमें एडस्‌ शामिल है: खेल वैध कार्य है PRG 1, फ़ीडबैक तब आता है जब पिकिंग 2 में निर्धन है, और जाँच को सही ढंग से लिखा जाता है 3 क्योंकि अंत में आप क्या परीक्षण कर रहे हैं पता है.

"ठीक काम है."

TDD अच्छी तरह से काम करता है जब डोमेन अच्छी तरह से समझा जाता है या आप एक ज्ञात बग को काट रहे हैं. लेकिन जब समस्या अभी भी है, लिखने का मतलब है गलत चीज़ को तीन बार एक कतार में परीक्षण. यह तरीका है कि: पहली बार परीक्षण, जांच जब स्थिर है.

वस्त्रदार सोम (और डिकी का खाली रहस्य)

तो यह तीन Saphrth अपने डिजाइन सिद्धांतों के लिए क्या करता है? संक्षिप्त में: यह बौद्ध धर्म को मारता है. यहाँ है कि यह कैसे मेरी सोच में परिवर्तन करता है C# में DLD, DY और H# में है.

मैं 2 में "गाली" सिद्धांतों को लागू करने का उल्लेख किया. मुझे क्या मतलब है के बारे में विशिष्ट होना चाहिए.

PLOD सिद्धांतों का एक अच्छा सेट है. मैं उन्हें सिखाते हैं. लेकिन मैं टीमों का उपयोग करते हैं. लेकिन मैंने देखा है कि टीमों एकल ज़िम्मेदारी के नाम में एक खरगोश छेद गायब हो जाते हैं या खोलने/ बंद करने के लिए, सिस्टम बनाने के लिए ताकि वे समझ में आ रहे हैं.

यहाँ मेरी पसंद है:

जब SELD लागू करें:

• तुम्हारे पास सबूत है कि आप पेशी की आवश्यकता होगी
• SIGARS कोड को स्पष्ट बनाता है
• आप कुछ और का उपयोग करेंगे निर्माण कर रहे हैं

जब आप सोएली लागू नहीं करें:

• आप भविष्य की माँगों के बारे में अटकलें लगा रहे हैं
• जीव - विज्ञानी स्पष्ट रूप से बिना जटिलता को बढ़ाता है
• आप केवल आप बनाए रखना है कि आंतरिक कोड निर्माण कर रहे हैं

कोड की तीन वही रेखा एक समय से पहले के रूप में बेहतर हैं। आप हमेशा से निकाल सकते हैं जब आप पैटर्न स्पष्ट रूप से देखते हैं। आप आसानी से एक बदमाश को उपयोग नहीं कर सकते कि आपकी बनावट में बनाया गया है।

// Over-engineered SOLID worship
public interface IThingProcessor { }
public interface IThingProcessorFactory { }
public class ThingProcessorFactory : IThingProcessorFactory { }
public class ThingProcessor : IThingProcessor { }
public class ThingProcessorDecorator : IThingProcessor { }
public class ThingProcessorValidationDecorator : IThingProcessor { }

// What you probably actually need
public class ThingProcessor
{
    public async Task<Result> ProcessAsync(Thing thing)
    {
        // Just do the thing
    }
}

यदि आपको बाद में इन्जेक्शन की जरुरत पड़ेगी, तो रीफ्रेक्टिंग बहुत महँगा होगा. और अधिक-से-परिंग के लिए महँगा होगा क्योंकि आप एक छोटी परतों को रख रहे हैं जो उनके बनाए रखने की नहीं हैं.

यीशु ने अपने चेलों को सिखाया था कि वे उसके चेले बन सकते हैं ।

और जबकि हम पवित्र गायों को मार रहे हैं, चलो के बारे में बात करते हैं रेट (अपने आप को दोहराने मत करो) यह शायद सबसे संदेहात्मक रूप से हमारे उद्योग में सिद्धांत लागू किया है, और जब बिना विचार के लागू किया, यह अच्छा से अधिक नुकसान उत्पन्न करता है.

समस्या यह है: हर तरह की बुराई एक जैसी नहीं है.

जब कोड के दो टुकड़े समान लगते हैं लेकिन अलग उद्देश्यों से सेवा करते हैं, उन्हें एक साझा जोड़े की चीज़ों में निकालते हैं जो स्वतंत्र रूप से स्वतंत्र होनी चाहिए. अब जब एक मामले का उपयोग करते हैं, तो आप या तो कर रहे हैं:

1. दोनों मामलों से निपटने के लिए पैरामीटरों और शर्त जोड़े (संत्र को बदतर बनाता है)
2. अन्य उपयोग केस तोड़ रहे हैं
3. साझा कोड पीछे नक़ल करें और इसे संपादित करें (अनुष्टन गलत था)

// "DRY" solution - looks clever, causes pain
public async Task<Result> ProcessEntity<T>(
    T entity,
    bool validateFirst = true,
    bool sendNotification = false,
    Func<T, bool>? customFilter = null,
    Action<T>? preProcess = null,
    Action<T>? postProcess = null) where T : IEntity
{
    // 50 lines of conditional spaghetti trying to handle
    // "processing" for Users, Orders, and Products
    // because they all had 3 similar lines once
}

// What you probably actually need
public async Task<Result> ProcessUser(User user) { /* 15 clear lines */ }
public async Task<Result> ProcessOrder(Order order) { /* 15 clear lines */ }
public async Task<Result> ProcessProduct(Product product) { /* 15 clear lines */ }

हाँ, दूसरी ओर में कुछ "मिट" है. लेकिन प्रत्येक विधि है:

• अकेलेपन में समझने के लिए आसान
• साइड प्रभाव के बगैर परिवर्धित करने के लिए आसान
• जब यह एंटिटी क़िस्म हटाया जाता है तो मिटाने के लिए आसान
• साफ इनपुट तथा आउटपुट के साथ जाँचने में आसान है

DY संस्करण एक सपना है क्योंकि यह सब कुछ होने की कोशिश कर रहा है सभी कॉल्स करने के लिए. हर परिवर्तन सभी उपयोग मामलों को समझने की जरूरत है. हर बग का जोखिम कुछ और.

मेरा नियम: आप जब तक देखा है गति को मजबूत करने के लिए कदम एक ही बात 3 बार और आप यकीन है कि यह प्रतिनिधित्व कर रहे हैं एक ही विचार यह है कि एक साथ उभरेगा. तब तक, कॉपी के एक बिट ठीक है. यह एक नैतिक असफलता नहीं है; यह उचित चेतावनी है.

Daconm काफी हद तक गलत है। आप हमेशा लगातार गुणा कर सकते हैं बाद में जब पैटर्न स्पष्ट है। आप आसानी से एक बुरा एक बुरा वापस नहीं कर सकते कि अपने कोड बेस के माध्यम से तैयार है।

C# में इंटरफेस समस्या

यहाँ एक और पवित्र गाय है कि हत्या की जरूरत है: "हर वर्ग एक इंटरफेस की जरूरत है" पैटर्न.

वापस के प्रारंभिक दिनों में, किसी ने निर्णय किया कि कोड जाँच योग्य बनाने के लिए, आप हर जगह अधिकारियों को बदनाम करने के लिए की जरूरत है। तर्क था: आप एक ठोस वर्ग का मज़ाक नहीं कर सकते, तो हर सेवा की जरूरत है IService और ServiceImpl.. अचानक हर C# कोड बेस... / मैं ... केवल जांच के लिए मौजूद था कि सिर्फ.

// The interface tax - early 2010s style
public interface IUserService { }
public interface IOrderService { }
public interface IEmailService { }
public interface INotificationService { }
public interface IPaymentProcessor { }
public interface IInventoryManager { }

// Each with exactly ONE implementation
public class UserService : IUserService { }
public class OrderService : IOrderService { }
// ... you get the idea

यह माल पंथ प्रोग्रामिंग था. हम के लिए एक जटिल कर भुगतान कर रहे थे आणविक प्रदर्शक जांच यूटिलिटीज़ तथा टेस्टमेंट्स आणविक प्रदर्शक भविष्य में जो फेरबदल किए जाते हैं, वे बहुत कम हैं ।

यहाँ बात है: तुम अब इस की जरूरत नहीं है.

आधुनिक उपहास फ्रेमवर्क जैसे नेबुलेट और मोजेसी अंधविश्‍वासों के वर्गों का उपहास कर सकते हैं. अधिक महत्वपूर्ण तरीके से, अ. नैट कोर के अंश में पूरी तरह से ठोस प्रकार के साथ काम करता है:

// Modern approach - just register the concrete type
services.AddScoped<UserService>();
services.AddScoped<OrderService>();
services.AddScoped<EmailService>();

// In your controller or service
public class OrderController(OrderService orderService, UserService userService)
{
    // Primary constructor injection - clean and simple
}

कोई इंटरफेस नहीं. IOrderService. सिर्फ आप सेवा की जरूरत है, सीधे.

"लेकिन परीक्षण के बारे में क्या?" मैंने सुना है तुम रो रहे हो.

इकाई जाँच के लिए, आपके पास विकल्प है:

1. कुंजी विधियाँ बनाएँ virtual और हँसते हो और परिहास करते है,
2. परीक्षा डाटाबेस के साथ वास्तविक सेवा इस्तेमाल करें (अनुप्रयोग जाँच अक्सर अधिक मूल्यवान हैं)
3. इंटरफेस जोड़ें जब आप वास्तव में जांच के लिए इसकी जरूरत है

यह तीसरा मुद्दा है: रीफ्रेक्टिंग औज़ार अंतरफलक को निकालने पर अच्छे तरीके से जांच कर रहे हैं.

सवार या दृश्य छात्रो में, यह शाब्दिक है Ctrl+. ✔ " निकालें इंटरफेस" और आप कर रहे हैं. हर विधि निकाली जाती है, वर्ग इसे लागू करने के लिए अद्यतन किया जाता है, और आप सभी उपयोगों को पा सकते हैं अगर जरूरी हो. यह सेकंड लेता है.

// Phase 1 & 2: Just write the class
public class OrderService
{
    public async Task<Order> CreateOrderAsync(CreateOrderRequest request) { ... }
    public async Task<Order?> GetOrderAsync(int orderId) { ... }
    public async Task CancelOrderAsync(int orderId) { ... }
}

// Phase 3: Need to mock it for testing? Extract interface in 2 seconds
public interface IOrderService
{
    Task<Order> CreateOrderAsync(CreateOrderRequest request);
    Task<Order?> GetOrderAsync(int orderId);
    Task CancelOrderAsync(int orderId);
}

public class OrderService : IOrderService { ... }

अब मेरा काम फूल: इंटरफेस 1 पर आते हैं.

"यह काम करना" के दौरान और "बहुत सुंदर" के दौरान, मैं सिर्फ क्लासों को लिखते हैं. कोई समय से पहले से ही नहीं. कोड सरल है, और बाहर कूदना आसान है (कोई भी बीच में कूद नहीं) IFoo और Foo, और तेजी से लिखने के लिए.

जब मैं "इसे नीचे मारो" और जांच करने की जरूरत है, तब मैं तय करता हूँ कि कौन सी सेवाओं वास्तव में मजाक की जरूरत है। आमतौर पर यह आप की तुलना में कम होता है - आम तौर पर केवल बाहरी संयोजन HTTP ग्राहक, डेटाबेस, और संदेश कतार की तरह है।

आंतरिक व्यापार तर्क सेवाओं के लिए? आधा समय मैं सीधे ही उन्हें सही निर्भरता के साथ परीक्षण. जाँच किसी भी तरह से अधिक मूल्यवान हैं क्योंकि वे वास्तविक व्यवहार की जाँच करते हैं, नहीं कि मैं क्या का उपहास करते हैं. सोच व्यवहार होना चाहिए.

// Services I typically DO extract interfaces for (external boundaries)
public interface IPaymentGateway { }      // Third-party API
public interface IEmailSender { }         // External service
public interface IBlobStorage { }         // Cloud storage

// Services I typically DON'T need interfaces for (internal logic)
public class OrderValidator { }           // Pure logic, test directly
public class PriceCalculator { }          // Pure logic, test directly
public class OrderService { }             // Test with real repo + in-memory DB

बिंदु है: "सिर्फ मामले में" लिख बंद करना बंद करो. कंडोम क्लासों को लिखें. यदि आपको जाँच के लिए इंटरफेस की आवश्यकता हो या असली पॉलीफ़ाइफ़ॉसिस के लिए बाद में, एक को हाल ही में आधुनिक उपकरण के साथ वास्तविक सेकण्ड लेता है.

आपका कोड बेसर आसान होगा, अधिक scrac, और आपके पास कार्यान्वयन के साथ सिंक में रखने का भार नहीं होगा.

कनेक्शन

अजीब बात तो यह है कि यह तरीका और भी मेल खाता है असली "Aggargo" प्रक्रियाओं से अधिक स्पष्ट है मैं सामना किया है. काम सॉफ्टवेयर तेजी से (Peee - 1). परिवर्तन (Psse - 2) करने के लिए प्रतिक्रिया जब सुविधा sididddidedddids) है, कोई वेग ट्रैक, कोई खूनी चार्ट नहीं जला रहा है.

आधुनिक "आंग्रेजी" प्रक्रियाों द्वारा हटा दिया गया है जिन्होंने इतने सारे रस्मों को जोड़ने के लिए नहीं छोड़ा है. यह तरीका वापस खेलता है - नहीं, लेकिन सृजनात्मक कार्य का एक वैध चरण के रूप में।

जब इस सवाल का इस्तेमाल नहीं किया जाए

मैं ईमानदार होना चाहिए: यह हमेशा सही तरीका नहीं है.

बग फिक्सेस: जब आप किसी ज्ञात बग को ठीक कर रहे हैं, टीडी शैली ज्यादा अर्थ रखती है. एक जाँच लिखें जो बग को उत्पन्न करता है, ठीक किया.

अच्छी तरह से दिखाई गई समस्याएँ: आप एक मानक एल्गोरिथ्म या एक पैटर्न लागू कर रहे हैं आप एक सौ बार इस्तेमाल किया है, तो आप एक प्रभावी चरण की जरूरत नहीं है.

ज्ञात आवश्यकताओं के साथ क्लिलाइन्स: आप वास्तव में जानते हैं कि आप क्या निर्माण कर रहे हैं और जब यह जहाज की जरूरत है, तो आप शायद 1 खुदाई बंद हो सकता है.

उच्च- व्यवस्थित वातावरण: यदि प्रत्येक गलती पर हस्ताक्षर करने की जरूरत है, तो सेंडिंग मुश्किल है. हालांकि आप अभी भी स्थानीय रूप से जाँच कर सकते हैं धक्का देने से पहले.

लेकिन के लिए अधिक विशेषता विकास है - जहां आवश्यकताएँ एक बिट home, तकनीकी दृष्टिकोण स्पष्ट नहीं है, और आपको सोचने के लिए अंतरिक्ष की जरूरत है - यह तरीका शानदार तरीके से काम करता है।

जूनई डेवलपर के लिए एक नोट

यदि आप अपने पेशे में जल्दी कर रहे हैं, तो आप दिखाने के लिए दबाव महसूस कर सकते हैं "पूर्ण समय" कोड कोड सभी समय. आप के लिए नहीं है. इस तीन Sphrope के बारे में इस्तेमाल करें - बस के बारे में स्पष्ट हो कि आप में क्या कर रहे हैं, और हमेशा काम पूरा करने के लिए पूरी तरह से खत्म हो जाएगा 3 के लिए. कोई भी काम पूरी तरह से किया जा सकता है अगर यह विकसित करने के लिए, उत्पादन, अंत में परीक्षण कोड.

निचला पंक्ति

यह काम करते हैं, सुंदर करते हैं, यह नीचे ताला.

पहले से योजना बनाइए, मगर जल्द - से - जल्द अटकलें मत लगाइए ।

"डाज गलत एक पागल की तुलना में दूर रहता है।"

PREGER चरण एक दोषी गुप्त नहीं है - यह प्रक्रिया का एक विशिष्ट हिस्सा है। आपकी शाखा आपकी सेंडी है जब तक आप एक Photoming. तकनीकी फ़ीडबैक जल्दी आता है, गैर-योजक फ़ीडबैक के मध्य में आता है, और सुरक्षा फ़ीडबैक देर से आता है।

यह प्रकृति को जीवित रखता है, तनाव को कम करता है, और उन व्यवस्थाओं को उत्पन्‍न करता है जो सुंदर रूप से विकसित करती हैं, क्योंकि आप इस समस्या को हल करने से पहले समझ चुके हैं ।

एक मिनट से सिद्ध होने की कोशिश करना बंद करो. खेल खेलने के लिए अपने आप को अनुमति दें.

---

संबंधित पढ़ना

यदि यह रीग्रेसन होता है, तो आप इन सम्बन्धित पोस्टों का भी आनन्द ले सकते हैं:

• कैसे मैं सॉफ्टवेयर बिल्ड करें - इस दृष्टिकोण के पीछे के परीक्षण तत्त्वज्ञान में गहरा जाता है, और तीन चरणों के विस्तृत कोड उदाहरणों के साथ।
• हर दिन के खड़े बकवास कर रहे हैं (जब तक वे उनका भुगतान नहीं करते) - मेरा मानना है कि क्यों समारोह कर रहा है, और कैसे पता लगाने के लिए कि क्या अपने रस्मों उनके रखने का उत्पादन कर रहे हैं.
• एक सरल विचार: जो वास्तव में काम करता है लिखने के लिए - क्योंकि अन्यथा हम उपकरण हैं, नहीं, और उन्हें जीवित दस्तावेज़ों के रूप में इलाज करने के लिए सही बात बनाने का एकमात्र तरीका है।
• रेफ़रेंस कोड बेस पर काम करना - दशकों के संसाधन जीवन से व्यावहारिक सबक, जिनमें इन सिद्धांतों को लागू करने के लिए भी शामिल है जब आप एक प्रणाली सीख रहे हैं आप नहीं बना रहे हैं।