C# 7 and .NET Core Solutions

Once you understand the fundamental definition of an abstract class, when and why to use one becomes obvious. Let’s see what it is.

• Create abstract class for cat
• Use the abstract class to inherit from and create objects
• Add enumerators and constructors and run the application 

For many developers, interfaces are equally confusing and their purpose is not clearly understood. Interfaces are actually quite easy to get to grips with once you understand the concept that defines an interface. Let’s do that here!

• Create abstract class cat and inherit Cheetah class from it
• Create an interface IPurrable and add a method to it
• Implement the interface and run the console application 

Generics is a very interesting way of writing code. Instead of specifying the data type of the elements in the code at design time, you can actually delay the specification of those elements until they are used in code. Let’s get started with it then.

• Write a generic class and add a constructor
• Specify different data type arguments of each instantiation
• Run your console application 

Let's assume that we want to find the properties of certain classes in our code, but we can't be sure how many classes we will need to inspect. A generic interface could come in very handy here.

• Create a generic interface and implement it
• Add a constructor and implementation
• Create a simple class in the console application and run the console application 

In OOP, inheritance is associated with the beginning of something new and better. Let’s learn how. In this video.

• Create a few classes
• Inherit them from other classes to form new, feature-rich objects 

In abstraction, we abstract the common functionality and put it in a single class that will be used to provide this shared functionality to all classes that inherit from it. Let’s see how that works.

• Create SpaceCadet and inherit SpacePrivate and LabResearcher
• Check for potential fixes
• Add another class, PlanetExplorer and inherit SpaceCadet class 

A user does not need to know what the inner workings of a class are. Encapsulation takes care of that.

• Create a new class. Add variables and constructors
• Create methods and define them as private or public depending on the need
• Create variables and hide the inner wokings of the class
• Call different constructors and run console application 

Polymorphism means something has many forms. You can create multiple implementations of an interface.

• Create a class and inherit other classes from it
• Fix issues identified and add methods and override them
• Look at examples of dynamic and static polymorphism 

Single responsibility principle means that a class has a specific task it needs to fulfill and nothing else. In this video, we will learn more about it

• Create a new class
• Add a method that sets the maximum troop capacity
• Add trycatch clause that will attempt to set maximum troop capacity but will fail 

When creating classes, we need to ensure that the class prohibits any breaking modifications by needing to change internal code. This is a closed class. If we extend the class and allow it its open class

• Create a class. Add an enumerator
• Create classes and derive other classes from them
• Extend classes to create other classes 

As a developer, you should know what to tell the users and what information to log. That is called exception handling.

• Create a class and add code to call ReadXMLFile
• Modify the file to include an exception filter 

In this video, we will be using regex, to match a valid date.

• Create a regex to validate a date pattern
• Create a new method called ValidDate() that takes a string as the parameter
• Change the regular expression 

Sometimes, we need to sanitize input. In this video, we will look at replacing the bad words in a string with asterisks. now!

• Create a new method and let it accept a string parameter
• Look for the blacklisted words
• Add a method that takes the input and looks for the occurrence of the words defined in the pattern 

In this video, we are going to process fresh documents as version one documents.

• Add the usual extension method code
• Add the regex
• Add some output text to show the current date and the valid filename types 

Being able to ZIP several files and upload a single ZIP file makes more sense than having to upload several smaller files. So, in this video, we will create and extract ZIP files.

• Create a console application
• create a few files of varying sizes
• Create a method called ZipIt() and add the code to it to ZIP 

Sometimes, you need to perform some in-memory compression of a large amount of text. We will be doing it in this video.

• Create a class that will contain two extension methods
• create a new MemoryStream to return to the calling code
• Created a method illustrate the use of in-memory compression and decompression 

With acync and await, developers can keep their applications fully responsive while performing intensive tasks such as file processing. This makes a perfect candidate for using asynchronous code.

• Create two folders and add large files
• Create a new WinForms application and add a forms times control, a button, and a label c
• Set the source and destination directory 

Making a custom type serializable means that you can apply serialization to custom types.

• Adding an abstract class
• Create a class
• Create a method to serialize the class 

If you want more control over what is serialized, you should implement ISerializable on your object. This gives a developer complete control over what is serialized.

• Create a class called Vehicle
• Add the fields and the constructor
• Add the deserialization constructor that will deserialize the fields 

From the name you probably guessed that theXmlSerializer serializes data into XML. It gives you more control over the XML structure of the serialized data. Typical real-world examples for using this serializer would be to maintain compatibility with XML web services. It is also an easy medium to use when transmitting data using some type of message queuing (such as MSMQ or RabbitMQ).

• Create a Student class
• Create a class for a subject
• Serialize the subject object 

Unlike BinaryFormatter, JSON serialization serializes data in a human-readable format. Using XmlSerializer also produces XML that is human-readable, but JSON serialization produces a smaller data size than XmlSerializer. JSON is primarily used to exchange data and can be used with many different programming languages (as can XML).

• Create 2 classes
• Set up the Student object
• Add a JsonSerializer object to your code and set the formatting to indented 

In asynchronous programming, the async methods can have three possible return types. We will take a look at each return type in this video.

• Create a new Windows forms project and drag the Button control
• Change the button1_Click event and add the async keyword to the click event
• Add a method that will call the previous asynchronous methods and display the result 

Task-based Asynchronous Pattern (TAP) is now the recommended method to create asynchronous code. And we will learn to handle them in this video.

• Create a large text file and place it in a folder
• Create a method called ReadBigFile() that returns a Task<TResult> type
• Read the result from the method into an integer variable 

Exception handling in asynchronous programming has always been a challenge. This was especially true in the catch blocks. We will look at it now

Well, background threads are identical to foreground threads with the exception that if all foreground threads are terminated, the background threads are stopped too. In this video we will create a simple application that defines the thread created as a background thread.

• Create a new console application
• Create a new instance of your Demo class and add it to a new thread
• Modify our thread and set its priority down to low 

Popular thinking dictates that the thread pool should be used for brief jobs. This is because the thread pool is limited in size. There are many other processes in the system that will use the thread pool. You, therefore, do not want your application to hog all the threads in the thread pool.

• Read the number of processors on the current computer
• Get the Minimum and maximum allowable thread pool size
• Generate a random number between the minimum and maximum thread pool size 

Sometimes, we need to create multiple threads. Before we can continue, however, we need to wait for these threads to complete doing whatever they need to do. For this, the use of tasks is best suited.

• Create a new method
• Create three tasks that then create three threads
• Add the current thread ID and then make the thread sleep for the amount of milliseconds supplied 

There are instances where we want to give sole access to a process to a specific thread. We can do this using the lock keyword. This will, therefore, execute this process in a threadsafe manner

• Add an object with the private modifier
• Add two methods that take an integer of seconds to sleep as a parameter
• Create a lock using and then make the thread sleep 

Parallel.Invoke allows us to execute tasks in (you guessed it) parallel. Sometimes, you need to perform operations simultaneously and, in so doing, speed up the processing.

• Create two methods
• Make the thread sleep
• Instantiate a new instance of the demo class 

In this video, we will learn how to use a parallel foreach loop and then cancel it.

• Look at where parallel foreach loop performs better
• Solve the example using standard way by iterating over a list
• Create a file for each item using foreach 

Sometimes, Parallel foreach loop throws an error. Developers need to take care of that.

• Create List<String> object of IP addresses
• Check IP addresses of other end to see which is alive
• Throw an exception if not present 

Before we can begin exploring Rx, we need to install it and then see how an event works in C#.

• Create a console application
• Add a new class called DotNet
• See the working of events using Rx 

Rx allows developers to use the IObservable interface, which represents synchronous datastreams, to write queries using LINQ. In this video, we will be looking at the LINQ functionality of Rx in more detail.

• Add a new Windows forms project
• Set winformRx as your startup project
• Run your application 

Imagine having to synchronize events across servers in different geographical areas and time zones. Schedulers come in very handy in these situations. So we will use them in this video.

• Create the onload event handler
• Add some code to read the text entered into the textbox
• Modify code in the onload event handler 

Debugging lambda expressions allows us to check the results of a lambda expression on the fly and modify the expression to test different scenarios. We will create a very basic lambda expression and change it in the Watch window to produce a different value.

• Create a console application and add a class called LambdaExample to the console application
• Create an expression to return only the things starting with the string
• Place a breakpoint on the expression and run your application 

In this video, we will take a look at how to create an application on Windows using Visual Studio 2017

• Create a .NET Core console application in Visual Studio 2017
• Modify the code 

Let's take a look at building your first ASP.NET Core app. In this video, we will just create a very basic ASP.NET Core application and briefly discuss the Startup class.

• Create a new project in Visual Studio 2017
• Edit the Startup.cs file 

Publishing an ASP.NET Core application is quite straightforward. We will take a look at publishing the application via Command Prompt (run as administrator) and then publishing the ASP.NET Core application to IIS on a Windows server.

• Open up Command Prompt by running it as administrator
• Run the application by typing in dotnet AspNetCore.dll.
• Publish your application by clicking publish 

This recipe will show you how to set up middleware in your ASP.NET Core application. Middleware in ASP.NET defines how our application responds to any HTTP requests it receives.

• Modify the code contained inside the Configure() method of our Startup class
• Display the welcome page middleware
• Add a NuGet package to application so that we can serve static files 

Inside the MVC framework, the Controllers, Models, and Views need to work together to form the HTTP request and response cycle. The fundamental starting point, however, is calling the correct Controller based on the HTTP request it receives. Without that, our application built on the MVC framework can't work.

• Inside the Controllers folder, add a new class called StudentController
• In the Configure() method, change the app.UseMvc()
• Add the route mapping to the FindController() method 

So far we have been using plain C# classes as Controllers, but it is far more common have your Controllers inherit from the Controller base class which the MVC framework provides. This allows developers to return complex objects from their Controllers, students in our case.

• Modify the StudentController class
• Add a new folder to your project called Views
• Delete the code that is currently in there and replace it