Windows Presentation Foundation Masterclass

In this lecture you will learn about the basic way in which a WPF app is structured, and how one has to code it, as well as learn about the requirements to start developing apps for this platform.

In this lecture you will prepare the IDE on your Windows computer for it to support Windows Presentation Foundation development, by installing Visual Studio Community 2019 and Blend for Visual Studio

In this lecture you will create your first WPF project, and learn about its structure, the way you will use the files, and how the XAML and C# MainWindow files are the ones to start using from the beginning

Create a Hello World app with WPF and test it directly on your Windows PC from Visual Studio 2017.

Create a Hello World app with WPF and test it directly on your Windows PC from Visual Studio 2019, this time using a .NET Core WPF template

In this lecture we will compare the .NET Framework vs the .NET Core, and will talk a bit about the future of .NET and what a unified .NET 5 means for developers.

In this lecture you will learn about some of the features of C#, ranging from how it is simple, modern and object oriented, to why it is considered type-safe.

In this lecture you will start to use XAML a bit more, defining new types of elements into the UI, implementing StackPanels and testing the base functionality of Buttons and TextBoxes when running the app

Starting to define the values for the properties of XAML elements is crucial for the application to look better, and work better. In this lecture you will learn about a couple of value types that can be easily assigned through XAML code.

The Grid is one of the most powerful XAML elements, and in this lecture you will learn how to use it to sepparate the available space in columns and rows, as well as the three ways there are to define size, such as Auto and stars (*)

In this lecture you will learn how the connection between XAML and C# can be established, so you can access XAML elements from C# to access, modify and set their values.

In this lecture you will take a look at the processes that are going on "backstage" that allow the XAML elements to be accessed from C#, understanding some of the autogenerated C# files and how partial classes work. How XAML works with g.i.cs files to get this done.

In this lecture you will create your first event handler directly from XAML, and will understand how event handlers are executed when an event is fired.

In this lecture you will use the C# files a bit more, by creating event handlers with the help of Intellisense, Visual Studio's autocompletion tool, and coding the functionality for some of the buttons of the calculator.

In this lecture you will continue to work with methods as event handlers for click events, but will now take a closer look at how they are defined. You will also assign one single event handler for multiple button's events, and learn how to identify which one triggered the event.

In this lecture we will learn how to use a C# object as another type, more specifically, we will use the sender from the click event handlers as a Button so we can get one of the values from the Button itself, and refactor our code in the process.

In this lecture you will learn how to create your own custom types by using the enum and class keywords to create new classes and enumerators. You will also implement switch statements to complete the functionality of the calculator app.

In this lecture you will perform some testing on your application, and identify a single scenario where the reult that is being displayed may not be the ideal.

In this lecture you will start to use a Message Box to display pop up alerts from your WPF application, varying from error alerts to warning alerts with sound and image included.

Our percentage button is working alright, however there are some scenarios when the result may not be the expected. So in this lecture I challenge you to try to resolve the described issue, before you take a look at the solution that I offer.

In this lecture you will start to style the buttons of the calculator, so it has some extra personality, by changing the background and forground colors,but we will also identify how inefficient doing it element by element is.

In this lecture you will start to implement static resources on your XAML Window, so you can reuse the definition of SolidColorBrush to apply throughout many elements and start defining more efficient XAML code.

Now that you have used Static Resurces inside the Window, in this lecture you will learn to make those resources available throughout the entire application as global resources that are defined inside the App.xaml file.

Your XAML code is now more efficient, but there are still a lot of repetitions on your code when styling your controls, by implementing styles you will be able to implicitly establish styles to all those elements that are of TargetType without needing to add additional code.

Implicit styles apply automatically, but when you need more than one style for the same TargetType, it is time to define new styles with a Key attribute set up so they become explicit styles and can be assigne through StaticResources to the style property of a XAML element

In this lecture you will create a new type of project from Visual Studio: a Console Project, that will allow you to focus on the C# language without having to deal with XAML. You will start to understand how these projects work by accessing the Console class and its WriteLine and ReadLine methods

Once you have your Console Proyect ready, you will start to practice defining variables, understand how the var keyword works, and how the scope of the variables is very important.

In this lecture you will get familiar with the use and definition of classes, as well as what namespaces are, how are they important, and why are they related to using directives. Also, you will start to create new using directives, which will be important to access code in other namespaces.

Time to define properties, another type of members for a class. Unlike methods, properties are not functionalities, but values, and serve as a way of protecting variables that should be private, without blocking the access to their values.

Objects, or instances of a class, are variables that are of a complex type. In this lecture you will define your own objects, that are of the types of the classes that you have created, and learn about static members, and accessing non static members.

In this lecture you will learn about inheritance, or how you can reuse the functionalities of one class on another related class, by making the second class a child class that can still behave like the parent class, and acces its members.

In this lecture you will learn how to define many different methods that are named the exact same way, but that have different signatures, and how to access different signatures from the same method. This is called method overloading.

In this lecture you will learn how to redefine the functionality of a method that was inherited from another class, by marking the original method as virtual, and using the override keyword, in conjuction with the base keyword, to override the initial functionality of a method in child classes.

In this lecture you will learn how to define interfaces that can help you extend the functionality of classes,even those which have already inherited from another class by defining new members that have to be later implemented.

Once you have defined an interface and the members that it will contain, it is time to implement the interface by implementing the functionality of its members. You will also learn how you can use an object as an interface, having access to the members defined inside that interface, no matter what type that object is.

In this lecture you will create a second Window that will be a part of your WPF app, and will learn how, different to a Page, you can have multiple windows at once.

In this lecture, now that you have multiple windows, you will learn how to open them, how you can wait until they are closed before being able to return to a previous page (difference between Show and ShowDialog methods) and how to programatically close them.

In this lecture you will prepare the WPF project to start working with SQLite by adding the sqlite-net NuGet package as a reference inside it. This package will add functionalities for CRUD operations and connections to the SQLite database

In this lecture you will create the model for the table that will be used inside the SQLite database by creating a class.This class will define the table, and its properties will define the columns.You will also define some SQLite attributes such as primarykey and autoincrement.

In this lecture you will learn about other SQLite attributes that will come in handy, such as the promatykey attribute, or the AutoIncrement, the MacLenght and the Ignore, all of these very usefull when constructing the tables and wanting to have a bit more control over how they get created.

In this lecture you will begin to isert new entries into a new SQLite database, by of course first creating a Table based entirely on the Model class, so it gets created with the necessary columns and the established attributes. You will learn how to establich connections to a database, and to create the database file.

The using directive is useful, but it is not the only reason the using keyword exists, in this lecture you will learn about the using statement, its relationship with the IDisposable interface, and how it allows for a much more elegant way to solve the fact that we have to always close a SQLite connection.

"}" data-sheets-userformat="{"2":769,"3":[null,0],"11":4,"12":0}">Now that you are inserting entries into a table, in this lecture you will learn to read them, by establishing more efficiently the connection with SQLite, and transforming a query into a List<T>

In this lecture you will create a ListView in XAML and start adding elements to it in two ways, by directly accessing the ListView's Items property and adding ListViewItems to it, and by setting the ItemsSource property to an IEnumerable.

In this lecture you will understand why an object, when displayed as a string, displays its namespace and type, and you will override the ToString method to implement custom functionality to it and make the ListView display useful information.

In this lecture you will learn about DataBinding and how it works, as well as hot it will let you bind two objects and their properties together in different ways, including OneWay, TwoWay, OneWayToSource and OneTime.

Using an ItemTemplate in this lecture will let you establish how each element on a ListView will look like, and will also teach you how to use DataBinding from an object in C# to many different properties on XAML by establishing a Data Context and a DataTemplate.

This lecture will guide you as you implement the functionality to a search box inside the ListView to filter the contacts that are being displayed by those whose name match the one written in the box.

The Language Integrated Query or Linq is a super powerful feature that you can use in C# to perform queries on lists, such as orderby, where, orderbydescending, distinct, and many others, this lecture teaches you the Where and OrderBy methods, as well as the full query language that you can use in C#

In this lecture we will quickly update our code so that the database is read again after navigating to the details window. This way, if the user updated or deleted something, the changes will be reflected back in the ListView.

In this lecture you will learn how to create a UserControl, or a control that will be customized to look and behave the way you need to, You will define its layout, and begin to create the functionality, before replacing the ItemTemplate with one of these.

Once you have created a custom user control, in ths lecture you will learn how you can start using this inside any Page or Window by defining a namespace with the xmlns keyword, and replacing an ItemTemplate, however, you will also notice that Binding requires a dependency property of a dependency object.

Binding to a Custom User Control, or implementing styling and animations for that matter, requires dependency properties. So in this lecture you will learn about dependency properties, how they are different from regular properties, how to use them and implement default functionality, for Binding to work.

In this lecture we will start to improve the UI for our application, starting by extending, horizontally, how the ListViewItem is defined, that way, the user control can use the entire available space.

In this video we will talk about improving the User Interface for our new contacts window, so that it looks a bit more modern and allows the user to see a sort of placeholder when entering the values inside the XAML text boxes.

In order to learn to perform REST requests, we will use Microsoft's CustomVision API inside our WPF application, during this lecture you will learn how this easy service will allow you to integrate Artificial Intelligence in your application, even without the need to know a thing about AI.

In this lecture you will take a look at how a CustomVision project from Microsoft is built, the way you classify the images, how the accuracy of the model is displayed, and how to test the AI. You will also create your own CustomVision API project

In this lecture you will upload the images and classify them, inside the CustomVision project, so the AI learns to identify one group from each other. After training the AI you will be able to test, directly from the website, how an image is classified, and receive results and probabilities for each tab.

In this lecture you will learn how to select a file from the local computer using WPF and the OpenFileDialog. You will learn how to help the user filter the type of elements that they should select, and to get an image file and display it inside an Image XAML element by assigning the file as a BitmapImage to the Source (ImageSource) of the Image element.

Once you have the image file path, in this lecture you will be able to create the entire HTTP request that needs to be sent to the service, following the CustomVision API's request, you will add the necessary headers, set the body to a byte array, configure the URL, and post a request to the REST service using HttpClient on a WPF app.

The service is going to respond once it has received the POST request, and the response is going to contain a JSON formatted string, which you will have to deserialize into C# objects. This lecture will teach you how a JSON is conformed, and how to easily create the C# classes that will help with deserializing a JSON.

In this lecture you will learn to use the Newtonsoft.Json package to transform a JSON formatted string into C# objects, by creating the correctly formatted classes for the JSON that has been received from the CustomVision API.

In this lecture you will define a ListView to display the response from the API service, already deserialized from JSON into C# objects, by using a GridView, so you can have multiple columns inside of the ListView. You will also learn how to use the Path and StringFormat properties when binding on XAML.

In this lecture you will start to understand why is an architectural pattern useful, and how the MVVM pattern is going to work and be devided. Also, you will understand the benefits of implementing a pattern, since it makes the code easier to maintain, easier to test, easier to reuse and overall more efficient.

In this lecture we will explore the Accu Weather API services that are available for free for us to use, so we understand eventually what type of requests we have to make from our application

In this lecture we continue to explore the AccuWeather API to familiarize ourselves with how the requests are made, for us to later implement them on our Xamarin applications in the form of HTTP REST requests

In this lecture you will take a look at the previous projecst ahta you have built to try and identify what would be conforming the Model part of the MVVM pattern in them, before jumping into creating a new WPF application.

In this lecture you will use the example JSON response by the AccuWeather API endpoint to create the C# classes that will be necessary to eventually deserialize that JSON into C# objects, with the help of the Json Utils online tool

In this lecture you will take a look at the other projects that you have built and identify what the View Model would look like if you had implemented the use of the MVVM architectural pattern inside it. You will also begin to understando how the MVVM pattern could help you reuse this sort of code between many different projects.

Now that you understand how to layout the View Model inside your projects, in this lecture you will create the code that makes GET requests to both of the endoints of the API by building the list in the format that is required and getting a key from the service.

In this lecture you will explore the way that the View should be layed out inside the projects that you build, and how the communication between it and the View Model will occur.

In this lecture you will define what information from the Model you need to display inside the View, and create a New Window. You will learn how to change the default launch Window from the App class by modifying the StartupUri value, how binding will substitude naming the elements, and how commands will substitude event handlers.

In this lecture you will learn about the INotifyPropertyChanged interface, which will let objects update each other through binding and repsond to value changes to always keep the information updated.

In this lecture you will implement the INotifyPropertyChanged interface on a new ViewModel classes, as well as create the OnPropertyChanged method that will be called from the setter of every property to handle changes to the values.

In this lecture you will learn to implement binding through XAML with the help of a new ViewModel class, and to set some binding in design time thanks to the Design Properties available in WPF applications

In this lecture we will check if our bindings are working correctly, and learn about design time only bindings, which will only be set while the application is being designed, and not when it runs.

It is time to learn about the ICommand interface and how it will help replace event handlers from the code behind over to elegant commands in the ViewModel. You will learn how the command works and uses its CanExecute and Execute members to implement a greatly related functionality with buttons and other elements.

In this lecture you will implement the ICommand interface inside of a new class defined inside the ViewModel, and call some of the ViewModel's functionality directly by adding a ViewModel property from the Execute method and ignoring the parameter received in the CanExecute to simply always return true

Now that the ICommand is implemented, the ViewModel will require a property of that type to be able to bind it to the view through the setting of Source and Path, pointing to that public proeprty. The command will also need a special initialization and the binding of the CommandParameter to create a robust connection with the View

In this lecture we will bind a command parametter to the ICommand from the button, so that that parameter can be used to re-evaluate the CanExecute for the command, and make sure that the button is disabled when no query has been set yet.

, how it uses the INotifyCollectionChanged interface to maintain the view updated of any changes to the collection, either when adding new elements, deleting them or modigying them."}" data-sheets-userformat="{"2":769,"3":[null,0],"11":4,"12":0}">In this lecture you will learn about the ObservableCollection<T>, how it uses the INotifyCollectionChanged interface to maintain the view updated of any changes to the collection, either when adding new elements, deleting them or modigying them.

In this lecture you will create a new property that is of type ObservableCollection<T>, so that we have a list of cities that will update the view with the cities that are retrieved from the autocomplete endpoint for the Accu Weather API.

Now that you react to changes in the text of a TextBox with the help of Binding, you will bind an ObservableCollection to a ListView, and also get the SelectedItem through TwoWay binding so we can get the weather, which will also be bound by changing the Source, Path, UpdateSourceTrigger and Mode binding setters

In this lecture you will learn about the IValueConverter interface as yet another interface that will help in the implementation of great functionality from the ViewModel to the View, as communication between the Model and the View. You will learn about its Convert and ConvertBack members, and some examples of how to use this.

In this lecture you will create a new class inside the ViewModel and have it implement the IValueConverter interface so you can use it to transform a bool over to a string, and eventually into information that the user will find helpful to be displayed inside the View.

In this lecture we will review what the application that we will build will look like, and understand what classes will be needed for it to work. These clases will define the model of a notes application, and will eventually define the tables that exist inside a local database.