Improving your C# Skills

Solve modern challenges with functional programming and test-driven techniques of C#

Ovais Mehboob Ahmed Khan, John Callaway, Clayton Hunt, Rod Stephens

• Publisher: Packt Publishing
• Year: 2019
• Print ISBN:
  9781838558383
• Edition: 1
• eBook ISBN:
  9781838550318
• Topic: Computer Science
• Subtopic: Cryptography
• Index: Computer Science

Conquer complex and interesting programming challenges by building robust and concurrent applications with caches, cryptography, and parallel programming.

Key Features

• Understand how to use.NET frameworks like the Task Parallel Library (TPL)and CryptoAPI
• Develop a containerized application based on microservices architecture
• Gain insights into memory management techniques in.NET Core

Book Description

This Learning Path shows you how to create high performing applications and solve programming challenges using a wide range of C# features. You'll begin by learning how to identify the bottlenecks in writing programs, highlight common performance pitfalls, and apply strategies to detect and resolve these issues early. You'll also study the importance of micro-services architecture for building fast applications and implementing resiliency and security in.NET Core. Then, you'll study the importance of defining and testing boundaries, abstracting away third-party code, and working with different types of test double, such as spies, mocks, and fakes. In addition to describing programming trade-offs, this Learning Path will also help you build a useful toolkit of techniques, including value caching, statistical analysis, and geometric algorithms. This Learning Path includes content from the following Packt products:

• C# 7 and.NET Core 2.0 High Performance by Ovais Mehboob Ahmed Khan
• Practical Test-Driven Development using C# 7 by John Callaway, Clayton Hunt
• The Modern C# Challenge by Rod Stephens

What you will learn

• Measure application performance using BenchmarkDotNet
• Leverage the Task Parallel Library (TPL) and Parallel Language Integrated Query (PLINQ)library to perform asynchronous operations
• Modify a legacy application to make it testable
• Use LINQ and PLINQ to search directories for files matching patterns
• Find areas of polygons using geometric operations
• Randomize arrays and lists with extension methods
• Use cryptographic techniques to encrypt and decrypt strings and files

Who this book is for

If you want to improve the speed of your code and optimize the performance of your applications, or are simply looking for a practical resource on test driven development, this is the ideal Learning Path for you. Some familiarity with C# and.NET will be beneficial.

Geometry

This chapter includes geometric problems. Some ask you to calculate values such as π or the area below a curve. Others demonstrate useful techniques such as Monte Carlo algorithms. Finally, some are directly useful if you need to perform geometric operations such as drawing arrowheads or finding intersections between line segments.

Many of these problems have intuitive graphical purposes. In those cases, the solutions may include graphical components that draw the problem and its solution. The graphics code usually isn't necessary to solve the problems, however; it just makes visualizing the solution easier, so I won't describe that code in detail. Download the solutions to see all of the details.

Problems

Use the following problems to test your geometric programming skills. Give each problem a try before you turn to the solutions and download the example programs. If you have trouble with the graphical part, try to implement the non-graphical pieces. Then, you can download the example solutions and replace the key parts of the program with your code.

1. Monte Carlo π

A Monte Carlo algorithm uses randomness to approximate the solution to a problem. Often, using more random samples gives you a more accurate approximated solution or gives a greater probability that the solution is correct.

For this problem, use a Monte Carlo algorithm to approximate π. To do that, generate random points in the square (0 ≤ X, Y ≤ 1) and then see how many fall within a circle centered in that square.

2. Newton's π

Various mathematicians have developed many different ways to approximate π over the years. Sir Isaac Newton devised the following formula to calculate π:

Use Newton's method to approximate π. Let the user enter the number of terms to calculate. Display the approximation and its error.

How does this value compare to the fraction 355/113? Do you need to use checked blocks to protect the code?

3. Bisection root-finding

Root-finding algorithms find values (y) for which an equation y = F(x) equals zero. For example, the equation y = x² – 4 has roots at x = 2 and x = -2 because at those values y = 0.

To find roots using binary subdivision, the program starts with an interval, x₀ ≤ x ≤ x₁, which we suspect contains a root. For the method to work, F(x₀) and F(x₁) must have different signs. In other words, one must be greater than zero and one must be less than zero.

To look for the root, the method picks the middle X value, x_new = (x₀ + x₁) / 2, and then calculates F(x_new). If the result is greater than zero, then you know that the root lies between x_new and whichever of x₀ and x₁ gives a value less than zero.

Similarly, if the result is less than zero, you know that the root lies between x_new and whichever of x0 and x1, whichever gives a value greater than zero.

Now, you update x₀ and x₁ to bound the new interval. You then repeat the process until F(x₀) and F(x₁) are within some maximum allowed error value.

Write a program that uses binary subdivision to find roots for equations. Make the equation a delegate parameter to the main method so you can easily pass the method different equations. Use the program to find the roots for the following equations:

For extra credit, make the program draw the equations and their roots.

4. Newton's method

Binary subdivision uses intervals to quickly converge on an equation's root. Newton's method, which is also called the Newton-Raphson method, uses a different technique to converge even more quickly.

The method starts with a value (x). As long as F(x) is not close enough to zero, the method uses the derivative of the function to find the slope F'(x). It then follows the tangent line at that point to the new point x' where the line intersects the X axis. The value x' becomes the method's next guess for the root. The program continues calculating new values until F(x) is close enough to 0.

Finding the point of intersection between the tangent line and the X axis is easier than you might think. If you start with the value x_i, you simply use the following equation to find the next value, x_i+1:

Here, F is the function and F' is its derivative.

Write a program that uses Newton's method to find roots for equations. Make the equation and its derivative delegate parameters to the main method so you can easily pass different equations to the met...

Table of contents

• Title Page
• Copyright and Credits
• About Packt
• Contributors
• Preface
• What's New in .NET Core 2 and C# 7?
• Understanding .NET Core Internals and Measuring Performance
• Multithreading and Asynchronous Programming in .NET Core
• Securing and Implementing Resilience in .NET Core Applications
• Why TDD is Important
• Setting Up the .NET Test Environment
• Setting Up a JavaScript Environment
• What to Know Before Getting Started
• Tabula Rasa – Approaching an Application with TDD in Mind
• Testing JavaScript Applications
• Exploring Integrations
• Changes in Requirements
• The Legacy Problem
• Unraveling a Mess
• Geometry
• Randomization
• Files and Directories
• Advanced C# and .NET Features
• Cryptography
• Other Books You May Enjoy