Synchronizing WPF UI Elements Using Event Bindings TextBox Placeholder WPF and Async Yield Return

Synchronizing WPF UI Elements Using Event Bindings, TextBox Placeholder WPF, and Async Yield Return

Full tutorial link > https://www.youtube.com/watch?v=_sQv3WWtsNY

Please consider supporting us on Patreon to gain access to more high-quality and frequent new videos: https://www.patreon.com/SECourses.

Our playlist page offers free access to our C# Programming, .NET Core Programming, ASP.NET Core MVC programming, Machine Learning, Software Engineering, Information Security, and technology-related courses and videos: https://www.youtube.com/@SECourses/playlists

00:00:00 Introduction to the lecture

00:00:52 Composing the .NET Core 7 #WPF application

00:01:12 Starting to design the user interface

00:01:44 Starting to code the PlaceHolder text feature for TextBoxes

00:09:05 How to do unboxing with the "as" keyword

00:09:28 Start the second part of the lecture. Adding a ListBox

00:10:20 Defining an ObservableCollection and binding to ListBox for automatic synchronization

00:13:12 Coding a random value generating method with thread-safe Random.Shared property

00:14:30 How to access UI elements from static methods in sub-threads

00:16:14 How to display hidden errors by enabling Common Language Runtime Exceptions in Microsoft Visual Studio

00:16:49 Handling "the calling thread cannot access this object because a different thread owns it error" for UI elements

00:17:51 How to do synchronization with Dispatcher.BeginInvoke

00:18:44 Starting the third part of the lecture. #Binding #UI elements to automatically notify properties

00:19:35 How to use #ObservableObject and #ObservableProperty of Microsoft Toolkit MVVM and Community Toolkit

00:23:05 How to bind UI element to ObservableProperty in XAML code

00:25:05 Setting #DataContext of UI element for proper binding

00:25:46 How to use notifyPropertyChangedEvent for automatic UI updates

00:28:00 How to get property change event triggering caller name automatically with CallerMemberName

00:32:42 #Async #Yield #Return Example

00:34:54 How to use Task.FromResult and await Task.Delay

00:36:48 How to use await keyword for an async ForEach loop

In the modern world, user interfaces (UI) are an integral part of most software applications. Responsive user interfaces are an important factor in providing a great user experience. As a result, developers must create user interfaces that are responsive and interactive. This article will explore how to create responsive user interfaces with C# and .Net Core.

The .Net Core framework provides a number of tools and frameworks for creating user interfaces. These include WPF, Windows Presentation Foundation (WPF), XAML, Windows Presentation Foundation (WPF) and Windows Forms (WinForms). Each of these frameworks have their own advantages and disadvantages, but all of them can be used to create responsive user interfaces.

The WPF framework is the preferred method for creating user interfaces with .Net Core. WPF is an open source, XAML-based, markup language that enables developers to create user interfaces with powerful and dynamic features. WPF is a great choice for creating user interfaces that are both visually appealing and functionally responsive.

WPF also offers a number of powerful features for creating user interfaces. These include the use of data binding, which allows developers to connect UI elements to data sources. This allows developers to quickly and easily create user interfaces that are responsive and interactive.

WPF also offers a number of powerful UI elements. These include the TextBox, ListBox, and Dispatcher.BeginInvoke. These UI elements can be used to create user interfaces that are interactive and responsive.

The Microsoft Community Toolkit is a great resource for creating user interfaces with WPF. This toolkit provides a number of powerful features such as ObservableCollection, ObservableObject, and ObservableProperty. These features can be used to quickly and easily create user interfaces that are responsive and interactive.

The ObservableCollection is a powerful tool that enables developers to quickly and easily bind data to UI elements. This feature allows developers to quickly and easily create user interfaces that are responsive and interactive.

The ObservableProperty is a powerful feature that enables developers to quickly and easily bind data to UI elements. This feature allows developers to quickly and easily create user interfaces that are responsive and interactive.

The NotifyPropertyChangedEvent is a powerful feature that enables developers to quickly and easily bind data to UI elements. This feature allows developers to quickly and easily create user interfaces that are responsive and interactive.

The yield return feature allows developers to quickly and easily create asynchronous code. This feature allows developers to quickly and easily create user interfaces that are responsive and interactive.

The Task.FromResult and Task.Delay features enable developers to quickly and easily create asynchronous code. These features allow developers to quickly and easily create user interfaces that are responsive and interactive.

The async await feature is a great tool for creating asynchronous code.

thumbnail: freepik

Video Transcription

• 00:00:01 Greetings everyone, I am Dr. Furkan  Gözükara. In this video, I am going  

• 00:00:05 to show you how to bind .NET Core 7 WPF user  interface elements to code behind observable  

• 00:00:11 fields and automatically get them updated in  an asynchronous and non-UI blocking fashion.  

• 00:00:16 To achieve this, I will show you how to  utilize observable property from Microsoft  

• 00:00:21 Community Toolkit and MVVM library. Moreover,  I will explain how to use NotifyPropertyChanged  

• 00:00:28 event to trigger UI updates automatically.  Furthermore, I will demonstrate how to use  

• 00:00:34 Async Yield Return and Random Shared property  to generate thread-safe random numbers in an  

• 00:00:40 asynchronous way. But another thing that I am  going to explain is how to achieve placeholder  

• 00:00:46 in WPF textboxes. I will show in details how  you can add placeholder text to WPF textboxes.  

• 00:00:53 The placeholder feature is not available by  default. Let's name this as UI Lecture. Okay.  

• 00:01:02 So, I am composing a WPF application with .NET  Core 7 which is the latest version. Okay, first  

• 00:01:11 let's add our textboxes and let's add placeholder  text to these textboxes in the best optimal way.  

• 00:01:31 Alright, so now we have two textboxes and in the  code behind I will achieve the placeholder text.  

• 00:01:39 Okay, first let's define the  placeholder text of the textboxes. Okay.  

• 00:02:00 We are going to set textboxes text to  equal to this one in the initialization.  

• 00:02:17 Okay, now we are going to utilize two events of  textboxes which are gotFocus and lostFocus. So,  

• 00:02:26 for txtEmail gotFocus we are going to define a  new event. Okay, we are doing an event binding.  

• 00:02:35 Whenever txtEmail gotFocus this method will be  called. However, I want to make this a generic  

• 00:02:44 method so that I can use same method in both  of the textboxes or if I add more textboxes  

• 00:02:51 I can also use on them. So, I will name this  as txtGotFocus like this. Okay, now we need to  

• 00:03:01 check from which object, which button this event  has come and based on that we can set the text  

• 00:03:11 or not. Alright, so if the default text is, if  the written text is equal to our default text we  

• 00:03:21 will set the text of the textbox as empty. So,  let's write. Okay, so now we are checking that  

• 00:03:31 if this textbox is equal to our txtEmail  then we need to check like this. Equal to  

• 00:03:48 then it has a default text therefore we can set  its text as equal to empty like this. However,  

• 00:03:58 as you can see this is not an optimal solution  so we can write another method such as  

• 00:04:08 returnDefaultText. This will get  the object sender. Alright. So,  

• 00:04:18 in here I will do switch and case and will  return the default text. Okay. So, based on the  

• 00:04:33 name of the sender which is a textbox for this  one. Okay, what cases do we have? We have case  

• 00:04:45 txtEmail like this and in  this case we need to return  

• 00:04:53 _emailPlaceText like this.  And if it is txtUsername  

• 00:05:05 then we need to return _userNamePlaceText and  we also need to return something for default.  

• 00:05:16 Okay, return like this. Alright, and these breaks  will never hit therefore they are like this.  

• 00:05:24 So, I now can modify this method  in a more generic way such as that.  

• 00:05:40 Okay, as you can see now I have made it much more  generalized and now we need the same for LostFocus  

• 00:05:53 Event. So, let's also set this event as.  

• 00:06:00 Alright, now let's define LostFocus. Okay. I  will also name this as txtLostFocus like this.  

• 00:06:10 And in this case what are we going to do is  we are going to reset the default text if no  

• 00:06:20 other text has entered. Alright.  So, it will be like this. If string  

• 00:06:29 is null or empty. Alright, let's  remove the parentheses. Okay, then,  

• 00:06:42 by the way we should also trim this if someone  enters empty character. Yeah. We will set the  

• 00:06:51 text as equal to default text. Alright, so what  are we doing here is we have defined a return  

• 00:07:03 default text so that we can know according to  which text box we have the placeholder text. And  

• 00:07:13 we have defined two events which are gotFocus and  lostFocus like this. And when we gotFocus we will  

• 00:07:22 check that if a different text is entered or not  and if lostFocus it will be the same principle.  

• 00:07:30 So, let's run our application and test it. We  can also put a breakpoint to see how they behave.  

• 00:07:38 Okay, so when I click it, the first text box  which is the username, now we can see the sender  

• 00:07:47 and let's see if we can see in the debug mode.  Okay, just never mind, I will enter inside the  

• 00:07:55 return default text and in here, yes, the name  is txtUsername so it will return username place  

• 00:08:02 text and if it is equal to placeholder text,  the default one, now I will set text like this  

• 00:08:09 and it is like that. Okay, now we got  lostFocus in the, which one if you ask,  

• 00:08:20 in the txtUsername and we will now return the same  and since the text was already empty, therefore we  

• 00:08:32 did set it like this, okay. Okay, now you see  they are working, let's add something different  

• 00:08:38 and yes, and something different here. Okay, so  we have, as you can see, achieved the placeholder  

• 00:08:46 feature that you can find in HTML in the WPF  text boxes. Now, we can move our next stage.  

• 00:08:59 Okay, before moving to next stage, I am going  to also show you another cool thing. This is  

• 00:09:05 the thing that you can do in the newer version  of C-Sharp programming language. You can define,  

• 00:09:11 you can do the unboxing with as keyword like  this, sender as text box. Okay, so you see it  

• 00:09:20 looks more clear if you ask me. Okay, okay,  working. Now, let's move to the next stage  

• 00:09:34 with adding a list box. In this list  box, I will display the inserted  

• 00:09:43 / added username and emails. Okay, however, for  doing that, I will use ObservableCollection. So,  

• 00:09:54 whenever I modify ObservableCollection, the  list box will get updated automatically. Okay,  

• 00:10:02 all right, let's name this button as add user.  Okay, name add user, and let's compose click  

• 00:10:15 event. Okay, for achieving that, we need  an ObservableCollection. I will make it as  

• 00:10:27 ObservableCollection. It will hold string data,  and let's name it as ListBoxContent like this.  

• 00:10:44 Okay, let's initialize it. All right, now  we need to bind this element to our list box  

• 00:10:55 as an item source. Okay, so how can I  do that? I can do that both in the code  

• 00:11:03 behind or in the XAML. So, for this one, I  will do it in the code behind. All right, so  

• 00:11:14 let's we need to also add a name to our list box  to access it. Let's call it as display users.  

• 00:11:31 Let's make it like display users. Okay, display  users.itemsSource equal to ListBoxContent.  

• 00:11:44 Since listbox content is observable collection  type, whenever an item is added or removed,  

• 00:11:52 it will notify wherever it is bind.  Okay, so in this add user click, I will  

• 00:12:04 add users to list box content like this.  Okay, let's perhaps let's use insert method,  

• 00:12:15 and I will insert into zero index. And let's  insert as txtUserNameText. Okay, and txtEmailText.  

• 00:12:36 Okay, you see I am not adding anything into list  box. What advantage this one has? If my method  

• 00:12:46 were running in a sub-thread, then it would still  work without causing any errors. I wouldn't be  

• 00:12:55 need to use dispatcher event. Okay, you see it  is working. All right. For example, we can test  

• 00:13:06 if our method is working in sub threads or not.  All right, private static void addRandomValues.  

• 00:13:26 Okay, in here, I will add  

• 00:13:34 Random.Shared next. Random.Shared is  a multi-thread safe, you see a thread  

• 00:13:42 safe property that you can use like this.  All right, we need to set it as toString.  

• 00:13:55 Lets also formatted. So, in here, I will call  Task.Factory.StartNew. I don't need to wait for  

• 00:14:07 this task to be executed or started. Whenever  they get started, it will just work. Okay,  

• 00:14:20 it's not auto completing. All  right, I will just do it myself.  

• 00:14:30 Okay, now this method call will work in a  sub-thread, not in the main thread. Therefore,  

• 00:14:39 if I wanted to access my  list box, let me show you.  

• 00:14:49 Okay, by the way, since this is a static  method, I can't just directly access it.  

• 00:14:54 To be able to access it, I need a reference  and like this and from here. Okay, items,  

• 00:15:06 display users, items, add. Right, let's add  anything because it will throw an error.  

• 00:15:17 This will say that another thread can't access  another thread's attributes. Let me show you.  

• 00:15:28 Okay, we got an invalid operation exception  happening inside here. So, you see,  

• 00:15:36 no items are added. Okay, actually, if you put  a breakpoint here, it should show us the error.  

• 00:15:47 Okay, now I can see the error here. Let  me show you. Okay, where is the error?  

• 00:16:01 All right, it is surpassing the error,  so it is not throwing the error.  

• 00:16:19 Okay, now since I clicked Common Language Runtime  Exceptions, I am able to see the exception thrown.  

• 00:16:26 It says operation is not valid while item  source is in use. Access and modify elements  

• 00:16:31 with item source control in set. Okay, even if  it weren't the case, let me show. Now when I try.  

• 00:16:49 Okay, you see the calling thread cannot access  this object because it has different threads own  

• 00:16:55 it. In a multi-threaded environment, you can't  just modify elements of a list box. Also, using  

• 00:17:13 an observable collection is a better way, if you  ask me, in many cases, so let's just remove this.  

• 00:17:20 Okay, now let's see if it is working. Okay.  

• 00:17:31 Oh, it looks like this type of object is  not also supporting observable collection.  

• 00:17:40 So we still need to use  dispatcher for synchronization.  

• 00:17:51 Okay, I will use beginInvoke. And okay.  

• 00:18:00 Okay, new action. All right, like this. And one  more thing, we need to get dispatcher from the  

• 00:18:14 main window. All right, and also I need  to write this code inside the dispatcher.  

• 00:18:21 So it turns out that I was expecting this to be  actually thread safe, but it didn't. All right,  

• 00:18:31 as you can see, now it is working without  blocking UI and fully asynchronously.  

• 00:18:37 Anyway, I will just keep this, so you  can also check it out later if you want.  

• 00:18:44 All right, and as a next thing, let's  add an event trigger, but for what?  

• 00:18:56 I am going to add a label here, and I  will say that this label will display  

• 00:19:05 number of elements. Okay, inside the list box,  

• 00:19:15 I will bind it to another field. Okay, so let's  say numberOfElementsLabel. All right. Okay,  

• 00:19:37 as a first way, I will show the easier way  with Microsoft Toolkit MVVM. Let me show you.  

• 00:19:47 Okay, let's search it in the NuGet package.  Okay, you see we have Microsoft Toolkit MVVM.  

• 00:19:56 And we also need to install Microsoft Community  Toolkit, other than the MVVM. Okay, Community  

• 00:20:05 Toolkit is named like this, Community  Toolkit Common. Okay, here, this one.  

• 00:20:26 All right, so in this case, I am going to define  an observable field. Okay, so let's say public int  

• 00:20:44 number, by the way, I will  make it like this, number of  

• 00:20:53 elements. I will tag this, attribute  this with ObservableProperty. All right,  

• 00:21:09 and this will generate automatic code if you ask  where. Okay, if I remember it, let's save it.  

• 00:21:25 Okay, by the way, this has to be inside  a public partial class, like this. Class,  

• 00:21:36 let's name it as ObserveExample. All right,  inside it, I will set it like this. And this  

• 00:21:49 has to be ObservableObject, all right. And now,  when we rebuild, let's rebuild it. Okay, and,  

• 00:22:08 okay, now it has opened the source generation,  automatic source generation. So you see,  

• 00:22:16 the Microsoft Toolkit MVVM source generator has  generated this, another public partial class  

• 00:22:25 for us. And inside it, we have now public  int number of elements, as you can see.  

• 00:22:32 And it has the onPropertyChanged event, binded  automatically, and other things which are  

• 00:22:40 necessary. Now, this is, actually this, name it  as this, number of elements, is an observable  

• 00:22:52 property that we can use. Actually,  we can make this a private as well,  

• 00:22:57 because this generated source code is public,  okay. So it handles that part for us as well. Now,  

• 00:23:05 what we need to do is, we need to bind this  into that element. Okay, let me show you.  

• 00:23:19 Okay, now, instead of  content, we will use binding,  

• 00:23:25 like this, binding. And I will bind it to, let me  show, number of elements, like this. By the way,  

• 00:23:40 I need to set the context of this, data context  equal to this, otherwise it can't know. Alright,  

• 00:23:49 and now we need to modify this property, so that  we can know it is working or not. So whenever  

• 00:24:01 I click add user click, I will increase it by  one. This is just for illustration. Okay, and  

• 00:24:14 it says it doesn't exist,  but it does exist, actually.  

• 00:24:19 Yeah, the reason is, we need to define that  object in observable, in our main window.  

• 00:24:32 Actually, we need to, okay, we need to generate  an instance of this object, so that we can use it.  

• 00:24:39 Let's say,  

• 00:24:44 observable object. Okay, and in here,  we have number of elements, okay.  

• 00:24:56 And now, I need to, okay, now we need to bind it,  and here comes the tricky part. To binding it,  

• 00:25:07 we need to bind the data context of label.  

• 00:25:12 Okay, like this, the class instance, that we  have generated, observable example. And now,  

• 00:25:20 since the data context of this particular UI  element will be instance of our observable class,  

• 00:25:32 now I can just bind its element, like this, in  the content, alright. Okay, now it is working,  

• 00:25:44 as you can see. And there is one another  methodology, which is notifyPropertyChangedEvent.  

• 00:25:55 For illustrating it, I will add another  content, and another method, alright, name,  

• 00:26:08 another, let's say, number. Okay, to be able  to achieve this, we need to first inherit  

• 00:26:20 inotifyPropertyChangedAttribute, or, okay, not  attribute, but inotifyPropertyChanged, and, okay,  

• 00:26:33 this interface requires adding a new reference,  which is using system component model. Okay,  

• 00:26:44 now it is giving us an error, because it says that  you have inherited this interface, however, you  

• 00:26:52 didn't implement its necessity, which is, when we  go to definition, we can see, I believe, which is,  

• 00:26:59 it requires an event PropertyChangedEventHandler.  Okay, so this is a necessity that we need to have,  

• 00:27:08 okay, let's define it in the bottom,  public event PropertyChangedEventHandler,  

• 00:27:16 like this, and we also need to write this  method, I wonder if it is auto-completing,  

• 00:27:26 okay, there is no auto-completion, I will write  the method myself, so the method will be private  

• 00:27:32 void notify, this name is totally from us,  propertyChanged, okay, now you can give the  

• 00:27:41 property name, or you can automatically get it as  well, probably this is available only in the newer  

• 00:27:49 version of C Sharp, okay, CallerMemberName, and  by optional, we can set property name like this,  

• 00:27:58 okay, so if we don't provide the optional  property name, then it will get its name  

• 00:28:08 automatically from the CallerMemberName,  then if, okay, this propertyChanged,  

• 00:28:17 okay, is not equal, then I will say that  propertyChanged, you see this is an event, this,  

• 00:28:29 this is the this that the CallerMemberName or the  property name, then new propertyChangedEventArgs  

• 00:28:41 and the property name, okay, so this will  also let us notify the UI thread elements,  

• 00:28:55 the binded elements. For this to work,  we need to have a property like this,  

• 00:29:01 and we need to have its get and set method,  I will say this as randomly generated string,  

• 00:29:12 okay, let's make it a string, and  we also need to have a private  

• 00:29:20 value of this when we are setting it,  yes, it's a necessity, I believe, okay,  

• 00:29:31 string. In the get method, we will just return the  randomly generated string, and in the set method,  

• 00:29:44 this is the tricky part, okay, let me show. We  will set value equal to new value, I mean the  

• 00:29:56 randomly generated string equal to value, and  we will call our notify propertyChangedEvent,  

• 00:30:05 okay, so I don't need to provide name, it will be  automatically get, and there is one final thing.  

• 00:30:13 I need to bind this label value to this property.  If you don't bind it, this event will never fire,  

• 00:30:26 okay. For example, let me show what I mean,  this is another thing that you need to solve.  

• 00:30:33 I wonder if this will automatically work  in this case, yeah, let's try it here.  

• 00:30:40 Okay, I will try it in the sub-thread,  I didn't try this previously.  

• 00:30:50 Okay, yeah, it says that we can't just  access it because this is an instance field,  

• 00:31:01 so let's try it like this, yes, and okay,  

• 00:31:10 by the way, I'm not sure if this will require  dispatcher or not, okay, the propertyChangedEvent  

• 00:31:16 is null, as you can see, why? Because we didn't  bind it to our property yet, so let's bind it,  

• 00:31:28 okay, binding, okay,  

• 00:31:39 randomly generated string like this,  and let's retry. By the way, we will  

• 00:31:45 be trying to change it in the sub-thread,  so I'm not sure if it will work or not.  

• 00:31:52 Okay, propertyChanged is not anymore null,  as you can see, because we did bind it,  

• 00:31:57 and nice. So you see, this method  works in the sub-threads as well,  

• 00:32:06 because, I think I know the reason, because this  event is already working in the main thread,  

• 00:32:14 in the UI thread, therefore, it is not throwing us  any error. So this is the second way that you can  

• 00:32:21 bind elements, bind UI elements into the code  behind variables, and whenever the code behind  

• 00:32:29 variable is updated, changed, it will notify the  UI to update its, to get its updated, alright.  

• 00:32:43 Okay, and, okay, one final thing is left in this  lecture, which is Asynchronous Yield Return, okay.  

• 00:33:05 So, okay, in this case, for Asynchronous  Yield Return, yeah, we can use the observable  

• 00:33:15 collection. This button will be async, okay,  and I'm going to write another async method.  

• 00:33:36 It will return string. Okay,  private static, returnRandNumber.  

• 00:33:42 By the way, this method will be also async,  

• 00:33:46 okay, and what does it do, what will it do?  It will return 10 numbers, okay, however, how?  

• 00:33:59 It will return 10 numbers from another  method called, which will be private static  

• 00:34:06 string, actually, this can be,  

• 00:34:11 yeah, let's just don't change it. Private  static string, return numbers, or let's say,  

• 00:34:24 returnRandomNumberStringSafely. Okay, this will  return Random.Shared.Next().ToString("N0").  

• 00:34:36 And in here, we will return yield,  return, return number, safely. However,  

• 00:34:45 we want this method to be asynchronous. Therefore,  I will do yield return Task.FromResult, okay,  

• 00:34:59 like this. And I will use await Task.Delay, so it  will return numbers with 500 milliseconds. Okay,  

• 00:35:15 and it will be like this. By the way, since  this is async, it has to return a task.  

• 00:35:23 So I will make it as IAsyncEnumerable. All right,  and task, okay, and string. Why did I make it  

• 00:35:43 async enumerable, IAsyncEnumerable,  because yield return will return whenever  

• 00:35:53 a unique iteration, an iteration has completed,  okay. So it will be like an enumeration.  

• 00:36:04 And inside this button, I am going to add  generated, okay, elements into list box content.  

• 00:36:17 By the way, currently, this will still work in  the main thread, so I think it should work fine.  

• 00:36:26 So for each return rand number method  call, okay, let's say var rand loop,  

• 00:36:42 and let's add it to our list box, like this.  Okay, so with each 500 miliseconds, by the way,  

• 00:36:52 I have to await this, so I need to await this  like this, all right, and okay. What am I missing,  

• 00:37:06 oh, I need to await for each, not inside here,  of course. Okay, since this was IAsyncEnumerable,  

• 00:37:18 I have to await ForEach, and it says now, it  is missing the index, so I will just use add.  

• 00:37:29 Okay, now, okay, what we are missing.  Oh, this will return a task string,  

• 00:37:40 therefore, and we are not using an  await here, if you use await like this,  

• 00:37:51 okay, it is not working. So we need to get result  of the task, okay, now, let's run it. Okay,  

• 00:38:00 for every 500 milliseconds, you see, we are  getting a new number inserted into our list box,  

• 00:38:07 and the user interface is fully interactive, as  you can see, I can also click this. Like this.  

• 00:38:20 all right. Are there anything  else that I want to mention?  

• 00:38:30 Okay, I think this is for all for today. If you  have any questions, please ask them in the comment  

• 00:38:39 sections, please like and subscribe our video, if  you haven't already, okay. And one final request  

• 00:38:49 that I have: we have opened a Patreon page, please  support us in here, if it is possible for you.  

• 00:38:59 The entire source code of this application  will be posted for our members, of course,  

• 00:39:06 you can type it yourself. However, if you support  us, we would appreciate very much, and it would  

• 00:39:16 enable me to generate better videos and  produce more better videos. It could allow  

• 00:39:24 me to become a full-time content producer.  Hopefully see you later in the next video.