Advanced C# for Computational Finance and Derivatives' Pricing - (code CS-CF)

The goal of this hands-on course is to apply the C# object-oriented language and the libraries in the .NET framework to the design and implementation of flexible and robust applications. The focus of the course is on using object-oriented and generic programming models in combination with useful libraries to help the quant developer produce running code for a range of pricing applications for equities and interest rate products. We also discuss how to implement the Gamma (GOF) design patterns in C# and we have seen a many-fold productivity improvement because the .NET libraries support them or can be easily adapted to support them.

Why C#? In our experience we have seen that C# and the .NET libraries are suitable for high-performance desktop applications. First, developer productivity levels are higher in C# when compared with C++, second code performance is excellent and finally the features in the language and the libraries in the .NET framework allow us to develop customizable finance applications.

Overview of Course

This intensive four-day course discusses the object-oriented and generic programming techniques in C#, using the .NET libraries and integrating them with design patterns to create finance applications. Major topics are:

• Using the .NET framework for finance applications
• Derivatives modeling for equities and fixed income products
• Classes, composition and inheritance
• Interfaces and component programming in C#
• Design patterns and customizable applications
• Interfacing with legacy systems
• Finite difference, PDE and Monte Carlo models in C#

• Advanced object-oriented, generic and functional programming
• Functionality to support application development A-Z
• Applications to computational finance
• Increased developer productivity
• Next generation design patterns in .NET
• Monte Carlo, PDE and fixed-income applications

• "Good presentation and documentation"
• "The Excel part will help us in future work"
• "All questions answered by trainer"
• "Very deep and full scope"

                                                                                 Course contents updated May 2015

Course Contents

Part I: Essential C#

Overview of the .NET framework

• Type Safety and Memory Management
• Classes and Interfaces
• Namespaces and their use in .NET
• Common Language Runtime (CLR)

Object-Oriented Programming in C#

• Classes, fields and methods
• Pass-by-value and pass-by-reference
• Constructors and object initializers
• Structs
• Properties

Advanced Classes

• Inheritance
• Polymorphism and casting
• Virtual function members
• Abstract classes and abstract methods
• Boxing and unboxing

Interfaces and Components

• Interfaces and contracts
• Implementing interfaces; the different scenarios
• Should we use an abstract class or an interface?
• Why interfaces are essential for applications

Delegates

• Motivation: function pointers and callbacks
• Delegate types and delegate instances
• Writing plug-in methods with delegates
• Multi-cast delegates
• Delegates versus interfaces

Events

• Broadcasts and notification patterns
• Event accessors and modifiers
• Events and Windows programming
• Anonymous methods

Generics in C#

• Generic types
• Generic methods and parameters
• Generic delegates

Advanced Generics

• Generic constraints
• Subclassing of generic types
• Self-referencing generic declarations
• Generic events

• One-factor Monte Carlo option pricing
• Scoping the system
• System and component interfaces
• System Decomposition

• Choosing between interfaces and delegates
• Implementing classes
• Design and system patterns (Builder, Mediator)
• Creating a single-threaded solution
• Multi-threaded solution

Fundamental Data Structures

• Strings and text handling
• Dates and Times; time zone
• Financial dates: day-count convention
• Formatting and parsing
• Regular expressions

Collections

• Defining and iterating in containers
• The Array Class
• Linked lists
• Hash tables and sorted dictionaries

Creating your own Containers

• Combining inheritance and generics
• Composition as an alternative to inheritance
• Data structures: vectors and numeric matrices
• Multi-dimensional data structures
• Applications to finance

Streams and I/O

• Stream architecture
• Stream class' members
• File, memory and pipe streams
• Stream adapters

Serialization

• Serialization engines
• Data contract serializer
• Binary serializer
• XML serializer
• Creating and applying serializers

• Background (Eiffel Programming language)
• Supplier and client: rights and responsibilities
• What is reliable and correct software?
• Correctness and Hoare triples
• Preconditions, postconditions and assertions
• Imperative and declarative statements

• Overview of Code Contract
• The binary rewriter
• The Contract class
• Implementing contract by design
• Contracts on interfaces and abstract classes
• Dealing with contract failure

• IDisposable, Dispose and Close
• Finalisers
• Automatic garbage collection
• GC internals
• Memory leaks

Part III: Design and Integration Techniques

Threads and Parallel Programming

• A quick introduction to multi-threading concepts
• Thread class
• Synchronisation
• Asynchronous delegates
• Locking
• Thread safety

Assemblies

• No more DLL hell!
• The structure of an assembly
• Private and shared assemblies
• Global Assembly Cache (GAC)
• Assemblies and their importance for component design

Reflection and Metadata

• What is reflection and why is it useful?
• Reflection applied to types
• Reflection applied to assemblies
• Reflection and member invocation
• Application configuration
• Dynamic code generation

Part IV: Creating Computational Finance Applications

• Implementing the shared data metaphor
• Passing data to a thread
• Mutex and Semaphore in C#
• Thread safety

• Blocking methods
• Sleep and EndInvoke
• Join
• Spinning

• Locking
• Mutex and Semaphore, again
• Nested locking
• Locking and atomicity

• SPMD pattern
• Master/Worker pattern
• Loop parallelism pattern
• Shared data and shared queues patterns

C# and Design Patterns

• Why design patterns and which ones to use
• Implementing patterns in C#
• Ready-made patterns in C#
• Applications in finance

Major Patterns

• Builder and Factory Method
• Adapter, Bridge
• Visitor, Strategy, Template Method
• Builder

Monte Carlo Engine in C#

• Modular decomposition
• Design of engine (Produce-consumer)
• Random number generators
• Parallel programming

Finite Difference Method (FDM)

• One-factor models
• Plain and barrier options
• Early exercise features
• The Crank Nicolson method
• Comparing FDM with trinomial method

Alternating Direction Explicit (ADE) Method

• Background and motivation
• ADE for one-factor models
• ADE for nonlinear pricing models
• Advantages of ADE

Two-Factor Model

• ADI and Splitting Methods
• Craig-Sneyd method
• Mixed derivatives and Janenko method
• ADE for two-factor problems

• Creating a structured product in C#
• Class design
• Bootstrapping and yield curves
• Linear and cubic spline interpolation
• Worksheet functions
• Add-ins

Monte Carlo Simulator

• Class Design
• Random number generators
• Stochastic equations and finite difference methods
• Using multi-threading to improve performance

Prerequisites

This is not a beginners course and we assume that the student has a working knowledge of C++ or Java, for example. Alternatively, knowledge of basic C# syntax is necessary. We also assume that you are involved in derivative pricing application development or plan to move into this area.

If you have any queries, please do not hesitate to contact

Who should attend?

Course Form

Duration, price, date, locations and registration