Develop Reference

How can I start multiple vscode from c# and keep track of when they terminate?

I want to start vscode as an external editor in a program that Im writing in c#. I use the Process class. I can do that but I also like to be notified when a particular instance is closed. Now I run into problems. If I only start one instance of vscode, the process terminates when that window is closed which is what I want. However, if I start a second vscode that process will terminate immediately. This becomes an issue when the user already has an instance open and use my program.
Anyone with an idea on how this can be solved?

Two parts are necessary to answer your question.
The first is the pure C# one: How to start a process and wait for it to end
Everything you need for this is in the Process class.
To start a process: Process.Start
Once started, to wait for exit, you have a few options:
Process.WaitForExit
Process.WaitForExitAsync
Process.Exited (this is an event handler that you can subscribe to)
Then there is another part needed to answer the question: How VS Code behaves when started from the command line and its options
By default, VS Code will return immediately after starting (so as not to block a shell if it was started from CLI). So, you'll need to pass a few parameters.
Based on the previous link, those would be:
-w or --wait => Wait for the file to be closed before returning.
-n or --new-window => Opens a new session of VS Code instead of restoring the previous session. (this is default behaviour, but you might want to specify it anyways in case this ever changes [or the user changes this])

Closing multiple projects in Visual Studio

I have two projects running in Visual Studio but whenever I exit one the other keeps running. How can I close both?
Ps: I'm using Application.Exit() to close the first one

If you want to use Application.Exit() to close the first process, and you want to close the second process at the same time, try adding the following lines immediately before you call Application.Exit():
Process[] processes = Process.GetProcessesByName("SecondProcess");
processes[0].Kill();
where SecondProcess is the process name of your second process. (You will also need to add a using reference to System.Diagnostics.)
This code assumes exactly one such process will be running; if that's not necessarily the case, you might need to do more.
Use with caution: killing a running process like this might not be advisable! Other methods are possible and probably better but without more information about your exact setup it's hard to know which approach to suggest.

Until a process has started, do something

So I have a background program that starts with Windows, minimized to system tray icon. Once it loads I need it to constantly start checking if a process has started (for example VLC). Once the process has started, It must wait for it to close in order to start doing stuff and then get back to check if it has started. I've been trying to do this for a while now, but I just can't figure out how.
How would I constantly check if a program has started?

One way would be to have the Background Deamon look for aprogramm of a specific name. Unfortunately this not overly reliable (due to name overlaps), would require a lot of polling and runs the risk of race conditions (the process starting when your deamon is still working).
What would be reliable, is if it is the Deamon that actually starts the foreground process. That way it could do work before Process.Start() and after Process.WaitForExit(), with full information when both states happen: https://learn.microsoft.com/en-us/dotnet/api/system.diagnostics.process?view=netcore-3.1
Steam is a good example. It is a single-instance process, so any further requests can be relayed to the running instance. The desktop links to programms/games are actually weblinks - not programm links. Those links use the :steam protocoll, wich is associated with the steam processes. So it goes like this:
user klicks on a WebLink with :steam procotoll
Windows resolves to hand this into a commandline call to the steam programm
A instance is started with the proper order in via commandline. Single instancing will not allow a 2nd instanc to start, but hand the request over a already running one
the already or now suddenly running instance calls the programm, having full data on when it starts and ends - being the actuall logical caller

Running Projects Programmatically

I was wondering if it is possible to open a second project (in the same solution as the first one) by code in the first project.
For example i have one form application project and another console application project.
The form application starts and when the user clicks a button i want the console application to run and the form application to stop.
Or could someone tell me how to delete my application .exe file?

The projects don't need to be in the same solution to do that. Just use Process.Start to start the executable for another application, and then close the main form to end the current application.
If you don't want to run the code as an entirely different process then it may also make sense to have a 3rd project that is a "class library" that the other two projects could add a reference to. This would allow you to define common code used in either application, using classes that are generalized to be helpful in either project.

I'm not sure what you're trying to do; but Process class has Start and Kill methods that will let you launch / exit processes.
http://msdn.microsoft.com/en-us/library/system.diagnostics.process.aspx

Access Running Instance Of Application

I found there are lots of posts showing how to detect if the application instance already running. But I cant find any one that shows how to access or use the same running application.
I have created shell menu items and linked them an application. For ex. If you right click on any folder it shows "OS Monitor". If i clicked on that an application is started. If I again right clicked on the folder and selected "OS Monitor" another instance of same application is started. I have to prevent this. Further more when user closes the "OS Monitor" form I just made it hidden. So that if the user again selects the same menu option then the same running form need to show.
I have created the application using C#2005. Does anybody have the idea how I could access the same running instance of the application.
Thanks in advance.

As address spaces of applications are separated, you have to use some global mechanism/object. An example is named mutexes: you create a named mutex, if it already exists, then the application was already running. Using Mutexes for ensuring that only one instance is running is presented on this blog
The second step is to communicate with the running instance. Therefore you have to use some IPC mechanism. Easiest is to use Windows messages if you are running Windows (like in the example from Blog). Note that this would not be portable to MONO as you have to make native calls. If that matters you could use a network connection among other possibilities. See answers to this question: IPC Mechanisms in C# - Usage and Best Practices.
After having transmitted the parameters to the running instance, you have to exit of course, otherwise you'll end up with two applications running. For a short time (the time of parameter transfer) you have indeed two instances running but only one effectively is doing the job.
This response was made under the assumption that you can/wish to make modifications to "OS Monitor".