TDD in C# From A to Z

Master test-driven development in C# from a to z by learning tdd techniques (faking, triangulation, obvious implementation), practical tests (fibonacci, fizzbuzz, roman numerals, tic-tac-toe, sticks), and continuous testing within agile.

In an agile, iterative workflow, customers and developers define user stories and acceptance tests, sketch architectural diagrams, then implement features with TDD, iterating until unit and acceptance tests pass.

Discover how shortcut-rich editors and refactoring tools speed up TDD in C#. Compare Visual Studio with ReSharper (R#), CodeRush, and VSCommands, and consider Rider for faster editing and testing.

Explore implementing the Fibonacci numbers with test-driven development, starting from simple tests and triangulation. See how NUnit tests drive the GetFibonacci logic, from base cases to recursion.

Master three main TDD techniques—faking, triangulation, and obvious implementation—using constant values, test-driven refinement, and edge-case testing (nulls, zeroes, max values) to guide C# development.

Learn how to apply test-driven development in c# by starting with exceptional, degenerate, and ancillary tests, covering nulls, empty strings, and edge cases before implementing the core canonicalization.

Practice test-driven development in C# by implementing FizzBuzz through unit tests, covering Fizz, Buzz, and FizzBuzz cases, and validating with NUnit in Visual Studio.

Apply test-driven development to implement a roman numeral parser in c#, using a dictionary map, iterating characters, handling subtractive notation, and refactoring with well-named methods.

Learn how to implement an updateable spin synchronization primitive to manage multithreading, timeouts, and event-driven responses within a TDD workflow, with live coding and tests.

Explore continuous testing in c#, using tdd to build a tic-tac-toe game, and leverage NCrunch, Live Unit Testing in Visual Studio, and dotCover for automated test feedback.

From a 3x3 tic-tac-toe, implement game rules with TDD, counting moves, tracking square state, and determining the winner, while using NCrunch for automated testing.

Embrace an assert-first approach in tdd, starting tests by writing assertions to define and verify correct outputs, revealing the simplest, targeted api for faster test creation.

Demonstrates test-driven development in a sticks game with an immutable game state, covering constructor checks, invalid moves, and machine versus human turns with machine moved and game over events.

Conclude by applying TDD in C# with faking, triangulation, and obvious implementation, building fibonacci, fizzbuzz, roman numeral parser, and tic-tac-toe, while avoiding multithreading tests and embracing continuous testing and katas.

Learn TDD in C# from a to z by practicing code katas, including the stack kata, immutable stack kata, and list kata to sharpen algorithms and practice programming.

Practice a test-driven approach to building a generic C# stack with push, pop, and peek operations. Verify IsEmpty, count, and empty-stack exceptions using a list-backed implementation.

Demonstrates building an immutable stack in C# using Lippert’s approach: define IStack<T> with Push, Pop, Peek, and IsEmpty; implement a nested EmptyStack state; and drive design with tests.

Define a generic singly linked list API with head and tail, and implement add and remove operations. Drive tests, cover edge cases, and examine remove last and remove first.

Explore code katas to practice TDD, compare a regular stack with an immutable version, and run through the list kata, then discuss TDD and preview topics for the next section.

Explore test doubles, dependency injection, and the types: fakes, dummies, stubs, spies, mocks, while learning manual doubles and using NSubstitute for mocks.

Explore unit testing with NUnit for a wage calculation that depends on a DbGateway and a Logger, highlighting challenges of external dependencies and flaky tests.

Refactor the customer design to make code testable using abstractions and dependency injection, emphasize constructor injection over property injection. Explore the concept of test doubles to inform testing strategies.

Explore test doubles for unit testing, including dummy, stub, spy, mock, and fake, and learn how each controls or verifies external dependencies during tests.

Learn to implement a dummy logger and a stub db gateway, set up test doubles in unit tests, and use spies, mocks, and fakes to verify interactions.

Explore the drawbacks of hand-rolled mocks in TDD, including boilerplate code, maintenance challenges for interfaces with many members, and the use of mocking frameworks to overcome these problems.

Discover how mocking frameworks create test doubles to isolate dependencies and streamline unit testing. Compare constrained and unconstrained approaches and review popular tools like NSubstitute, Moq, and Typemock Isolator.

Learn how to replace dependencies with the NSubstitute mocking framework, create test doubles for IDbGateway and logger, configure returns for any id, and assert GetWorkingStatistics called with the proper id.

Master NSubstitute essentials: mock methods and properties, return values with Any and Arg.Is, test exceptions with Throws, verify calls with Received, and raise events for async tests.

Compare the Detroit and London schools of testing, showing Detroit uses assertions to verify state while London verifies object interactions. Embrace a pragmatic, best-practices approach to unit testing.

Learn to use test doubles such as fakes, dummies, stubs, spies, and mocks to replace controllable dependencies, refactor for testability, and compare classic Detroit school with mockists London school.

Learn how acceptance testing complements test-driven development by translating business requirements into unit tests using SpecFlow and Gherkin. Write a simple feature with a scenario and implement a passing test.

Explore acceptance tests in TDD for C#, showing how business readable automated tests bridge the problem domain, provide executable documentation, and leverage SpecFlow in agile workflows.

Discover how SpecFlow uses Gherkin feature files and a Visual Studio extension to generate executable C# code bound to scenarios, enabling parameterized, reusable steps and clean, maintainable tests.

Explore Gherkin, a business readable domain specific language for behavior descriptions, and learn how features, scenarios, and steps map to C# functions to support documentation and acceptance tests in TDD.

Install the SpecFlow extensions for Visual Studio and the SpecFlow and testing NuGet packages to enable acceptance testing with given, when, then steps.

Explore the test pyramid from unit to integration and acceptance tests, and see how UI tests fit as end-to-end integration tests. Compare UI-based and high-level interface acceptance tests.

Compare web-UI and desktop-UI testing frameworks: Selenium, Visual Studio Coded UI Test, and TestStack.White, and learn how each records actions or uses manual code for maintainable tests.

Discover how the White framework uses the UI Automation API to locate controls, launch applications, and work with windows and standard or custom UI items using automation IDs.

Learn to write business readable automated acceptance tests with SpecFlow and Gherkin, using given-when-then steps, and compare high-level interfaces or ui manipulations for a WPF app through test-driven development.

Demonstrate tdd techniques, dependency injection, mocking, and acceptance tests through a true-false game with a statement editor saved to xml, in a wpf project using caliburn.micro and castle windsor.

Introduce an MVVM app using a serializable statement model with INotifyPropertyChanged, XML serialization, a basic persistence layer, and a Caliburn.Micro bootstrapper hosting game and main views.

Express features with SpecFlow and Gherkin, install Visual Studio tooling, and implement editing and playing the game scenarios using a shared statement list and a UI automation API.

Apply the page object design pattern to abstract UI interactions, wrap windows with a UI API, and expose high-level actions for main and game windows using TestStack.White.

Implement acceptance tests in a c# tdd workflow by using before/after scenario hooks to isolate each test with a fresh application instance, launching and interacting through spec flow steps.

Master view model implementation with TDD in C#, drive development with tests, bind via Caliburn Micro, use in-memory persistence, and employ a builder to assemble the main view model.

implements the game view model with tdd in c#, binding statement text, statement number, and score, plus a dialogue service. drives testing of next statements, correct/incorrect answers, and end-of-game logic.

See how acceptance tests and high-level requirements drive TDD in C#, from writing scenarios and user interface wrappers to test-first viewmodels, with the builder pattern for cleaner construction.

Explore test-driven development in depth, from defining TDD to its philosophy, relationships with agile, upfront design, unit tests, architecture versus design, and balancing simplicity with code suppleness.

Recognize that TDD may not suit all programmers. Weigh that writing tests is a professional requirement, yet some embrace production code first and others live without TDD.

Learn how agile and TDD relate: TDD is a technique that can stand alone, while agile is a broader methodology guiding requirements, collaboration, and short development cycles.

Tdd supports good design without replacing upfront architecture. Start with a big picture, sketch use cases and actors, and design clear API names before coding.

Unit tests alone do not guarantee project success and can become a liability without proper design; learn to craft reliable tests and balance coverage with maintainability.

Prioritize well-constructed unit tests in a TDD approach, treating tests as production code to keep maintainable, robust software while applying SOLID principles like SRP, OCP, LSP, and DIP.

Explore architecture and design, learn the difference, and how architecture is a social, high-level view built from significant components; defer early decisions and distinguish architecture patterns from design patterns.

Recognize that TDD is a matter of taste, but writing tests is essential. Acknowledge that Agile goes hand in hand with TDD, and architecture and design require balanced best practices.

Explore TDD practices in C# from a to z, covering pair-programming and ping-pong programming, test data techniques, positive-if statements, Shouldly assertions, while examining singletons, static classes, immutability and testability.

End tdd day per Kent Beck: in a team keep tests green in source control; solo, end with failing test to ease next-day work and never check in broken tests.

Explore pair-programming and ping-pong programming as TDD practices in C#, highlighting knowledge sharing, code quality, faster development, and collaborative problem solving.

Prioritize test quality by keeping cyclomatic complexity near 1 and avoiding if statements. Limit tests to about 10 lines, refactor duplication, and use the builder pattern to simplify initialization.

Avoid strange test data and excessive test cases in tdd. Use evident data, like 1, and near-value pairs such as 2 and 3 to clarify money operations.

Explore how the shouldly framework improves assertion readability and error messages, showing results such as game.points should be 100 but was 90, and covering shouldbe, shouldnotbe, shouldbetrue/false, and approval tests.

Prefer positive if-statements by naming booleans affirmatively and avoiding double negatives, improving readability in tests and production code.

Examine the debate in test-driven design over testing trivial code, including Uncle Bob and Mark Seemann, and weigh getters, setters, one-line methods, indirect testing, and future changes.

Clarify the rule of a single assertion and demonstrate testing one aspect or behavior per test, using a Money class with amount in kopeks and rubles.

Examine how singletons and static classes introduce global state and hidden dependencies that complicate unit testing. Show how constructor injection and exposing dependencies through the interfaces improves testability and design.

Explore the builder pattern for immutable objects, using fluent methods like WithName, WithAge, and WithPhones to create testable, maintainable tests with mocks.

Master tdd in c# from a to z, emphasizing test quality and maintainability; avoid long init, duplication, slow tests, and magic numbers with constants, using shouldly, pair-programming, and builder patterns.

Promote engagement with this bonus lecture by joining the mailing list, leaving reviews, and supporting the creator via discounted courses, the blog at engineerspock.com, and Patreon.