This is a programming book, so let's look at some code. Pages 17-21 (accessible with "Search inside") have the first extended listing, featuring the Black-Scholes (European) option price calculation. Going line by line ...
public interface IOptionFactory - "public" is redundant and usually omitted
public Option create() - C# convention is "Create"; lower-cased (public) method names are all over the place
private double T; // expiry date - should be time to expiry
private string type; // option name (call, put) - a freeform-string parameter is a bad idea
K = Convert.ToDouble(Console.ReadLine()) - double.TryParse() with checks is better if you must create objects off command line. (All the fields are made private, and instead of a ToString() override, there is an extension method Display() - combining actual display with the price calculation).
private double CallPrice(double U) - everybody labels the underlying S, not U, and if you are wondering what calculation is being implemented, the Black-Scholes formula will be introduced 17 pages later
private double PutPrice(double U) - I would use CallPrice() and the put-call parity instead of calculating the value from scratch, but fine
public void init() - ignoring the lower-case, why have init() replace the parameterless constructor, make it public, and why have a parameterless constructor at all when there is no meaningful set of defaults? As there is a special test class, it does not make sense even as a temporary testing stub.
public Option() - calls init(), see above
public Option(string optionType) - calls init() and overwrites "type", because init() has set it arbitrarily
if (type == "c") type = "C" - but the prompt asked for "Call" or "Put"? Oddly, "p" is not recoded to "P".
public Option(string optionType, string underlying) - what is the *string*-valued underlying? Does not matter, because it is not used; the two-parameter constructor does what the singe-parameter one does, except for the c/C recoding.
if (type == "1") return CallPrice(U); else return PutPrice(U) - the monkey-coder using this code will always get a put price, thanks to the "else" instead of an explicit check; the worst-practice trifecta is rounded out by the number-as-string
static public double n(double x) - a method called "n"?! ("n" evaluates the standard-normal density, and is accompanied by "N", which calculates - actually, approximates; there is no explanation or reference for the approximation method - the cumulative density).
public struct Mediator - it's peculiar to have a structure do high-level program logic, but looking ahead, Mediator is redundant; its function could have been merged into TestOption class.
Mediator med = new Mediator() - either the authors dislike "var" keyword, or are recycling C++ code
The code is poor, and this invites the question "How much care did the authors put in this book?" Not too much.
Looking at the chapter list,
1. Global overview of the book, pp. 5-8
2. C# fundamentals, 9-24
3. Classes in C#, 25-52
4. Classes and C# advanced features, 53-96
5. Data structures and collections, 97-124
6. Creating user-defined data structures, 125-158
7. Introduction to bonds and bond pricing, 159-184
8. Data management and data lifecycle, 185-214
9. Binomial method, design patterns and Excel output, 215-240
10. * Advanced lattices and finite difference methods, 241-270
11. ? Inter-operability: namespaces, assemblies and C++/CLI, 271-310
12. * Bond pricing: design, implementation and Excel interfacing, 311-334
13. * Interpolation methods in interest-rate applications, 335-368
14. * Short-term interest-rate futures and options, 369-392
15. * Single-curve building, 393-430
16. * Multi-curve building, 431-458
17. * Swaption, cap and floor, 459-492
18. ? Software architectures and patterns for pricing applications, 493-522
19. LINQ, 523-560
20. * Introduction to C# and Excel integration, 561-580
21. * Excel automation add-ins, 581-594
22. * C# and Excel integration COM add-ins, 595-624
23. * Real-Time-Data (RTD) Server, 625-634
24. Introduction to multi-threading in C#, 635-664
25. Advanced multi-threading in C#, 665-706
26. Creating multi-threaded and parallel applications for computational finance, 707-734
* marks chapters with (non-trivial) material not found in a general-purpose C# book - I will endorse "C# in a Nutshell" by the Albaharis - and two partial credits are Ch 11, where I count only the C++ part, and Ch 18, which is just really poorly written. (By the way, "Head-first design patterns" is the best book on DP, and Mark Joshi's C++ book has an excellent, motivating discussion). Two takeaways:
The book parallels Duffy's previous book, "Financial instrument pricing using C++", by covering the finite-differences method and interpolation, and complements it by focusing on FI.
The book has useful coverage of Excel and C++ interop. With the exception of books on VSTO, Xing Zhou's "C# for front office" is the only other book which I know to cover the C#-plus-Excel topic.
Page count overstates the book's content - Console.WriteLine's alone add a dozen pages - and, really, the writing is as good as the code above. Still, if a book teaches you something new... One does not have to like a low-quality book, but one has to appreciate the authors' body of work and the usefulness of their (fairly reasonably priced) product, as is.