Windows forms 2.0 programming in c#

Asked 4 years, 2 months ago. Active 5 months ago. Viewed 13k times. Improve this question. Drew Noakes k gold badges silver badges bronze badges. That is, possibly never, and certainly not any time soon. NET Framework isn't going to go away. Applications that are still highly Windows-bound should keep using it. If you're porting for the sake of porting, don't. If you're porting because you really want it to run elsewhere, take a look at Mono.

Winforms is not available in. Incidentally, refactoring code that doesn't have any dependencies on Forms to a. NET Standard library is worthwhile. This maximizes the reusability of such code. Standard application code that isn't going to be used elsewhere doesn't benefit unless, again, you have an actual need to run it on other platforms. Evk: Never say never again.

Heinzi main. Net core point is cross platform support, and WinForms on. Show 1 more comment. Active Oldest Votes. Judging by your project file, you're actually targeting. NET Core 2. Improve this answer. InteXX 5, 5 5 gold badges 34 34 silver badges 61 61 bronze badges. Thanks for your comments - I suspected that this was the case. So, in order to move to. Net standard 2. Is Xamarin.

Forms the best choice? I think the whole idea is to use. That way you can write different UIs for each platform, but reuse the logic across all of them. Although it's not obvious from the enumeration value's name, this code actually prevents ThreadException from being fired. Instead, it dumps the user straight out of the application before displaying the. NET unhandled-exception dialog from Figure In general, the behavior exhibited by UnhandledExceptionMode. ThrowException isn't the most user friendly, or informative, when something catastrophic happens.

Instead, it's much better to involve users in deciding how an application shuts down. Going the other way, you can also use command line arguments to let users make decisions about how they want their application to start up. Command line arguments allow users to determine an application's initial state and operational behavior when launched. To do this, you change your application's entry point method, Main , to accept a string array to contain all the passed arguments:.

NET constructs the string array by parsing the command line string, which means extracting substrings, delimited by spaces, and placing each substring into an element of the array. Command line syntax, which dictates which command line arguments your application can process and the format they should be entered in, is left up to you.

Here is one simple approach:. If your static Main method isn't where you want to handle the command line arguments for your application session, GetCommandLineArgs can come in handy for retrieving the command line arguments for the current application session: 4. You can see that GetCommandLineArgs always returns a string array with at least one item: the executable path.

Processing command line arguments is relatively straightforward, although special types of applications, known as single-instance applications, need to process command line arguments in special ways. By default, each EXE is an application that has an independent lifetime, even if multiple instances of the same application are running at the same time. All these kinds of applications require that another instance detect the initial instance and then cut its own lifetime short.

You could build a custom single-instance application using custom code that incorporates threading and. NET remoting. However, the VB. NET runtime library, Microsoft. ApplicationServices namespace. Forms , but WindowsFormsApplicationBase is designed to replace the use of the Application class to run and manage an application's lifetime, as you'll see shortly. If you are using C , you add a reference to this assembly by right-clicking the project and selecting Add Reference from the context menu.

From the. When this DLL is referenced, you derive from WindowsFormsApplicationBase before extending your custom class with support for single-instance applications and passing command line arguments:.

Next, you configure SingleInstanceApplication to support single-instance applications. IsSingleInstance is false by default, and the constructor is a great place to change this situation. To incorporate this into your application, replace the standard application start-up logic from your application's entry point. Then, use the following code to create an instance of your custom WindowsFormsApplicationBase type:.

Run method analog—which you invoke to open the main application form. Additionally, WindowsFormsApplicationBase. Run expects a string array containing command line arguments; passing null causes an exception to be thrown. To specify which form is the main application form, you override WindowsFormsApplicationBase.

MainForm appropriately:. As a final flourish, you can expose your custom WindowsFormsApplicationBase type via a static instantiation-helper method and thereby cut down on client code:. The effect of SingleInstanceApplication is to restrict an application to only one instance, no matter how many times it is executed. This single-instance scheme works fine as is, but it works better when the first instance of the application has a need to get command line arguments from any subsequent instances.

A multiple-SDI application has multiple windows for content, although each window is a top-level window. When a document is created or opened, it is loaded into a new window each time, whether the file was requested via the menu system or the command line.

The first time the application is called, the first new instance of the top-level form is created and set as the main application form instance; if a file was requested, it is also opened by the form. Subsequent requests to the application are routed to the custom WindowsFormsApplicationBase object located in the already-running application instance.

Each request is handled to create a new form and build up the appropriate menu structures to support navigation between top-level instances, as well as opening and closing existing top-level instances. Figure We also need to ensure that the application stops running only after all top-level forms have been closed. We make the appropriate configurations from the constructor of the custom WindowsFormsApplicationBase class:.

However, with a multiple-instance SDI application, no form is the main form; therefore, no matter which form was created first, we want the application to close only after the last remaining top-level form is closed, and hence the need to explicitly set ShutdownStyle to AfterAllFormsClose.

In this code, if a file argument was passed, a request is made to the main form to open it. Because all forms in a multiple-instance SDI application are top-level, however, no form is actually the main form. However, we must specify one if we override OnCreateMainForm , which helps later when the application needs to know which of the top-level forms is the active form. CreateTopLevelWindow is static because no specific form instance is responsible for creating another form.

To cope with subsequent requests to launch the application, we again override OnStartupNextInstance :. Here, the helper CreateTopLevelWindow is again passed command line arguments and called upon to create a new top-level window, opening a file if necessary.

Multiple-instance SDI applications also allow files to be opened from existing top-level forms via the File Open menu, something we implement using the same static CreateTopLevelWindow method to open files from the command line:. CreateTopLevelWindow contains the code to check whether the desired file is already opened and, if it is, to bring the top-level window that contains it to the foreground; otherwise, the file is opened into a new top-level window.

Multiple-instance SDI applications also typically allow the creation of new files from the command line or from the File New Window menu of a currently open top-level form. We tweak the OpenFile method to not open a file if null or if an empty string was passed as the file name:. Because a new file doesn't have a name, the top-level form gives it one; the standard naming convention for a new file is the concatenation of some default text with a version number.

In this example, we use a combination of "Untitled" and an incremental count of the number of opened top-level forms, for uniqueness. As mentioned before, a multiple-SDI application should implement a menu that allows users to navigate between open top-level forms as this is easier when files have unique names.

MultiSDIApplication is an appropriate location for this logic because it manages the application:. You can also see that the list box has been populated with the city values.

A Radiobutton is used to showcase a list of items out of which the user can choose one. Step 2 Once the Radiobutton has been added, go to the properties window by clicking on the Radiobutton control. A checkbox is used to provide a list of options in which the user can choose multiple choices. We will add 2 checkboxes to our Windows forms. These checkboxes will provide an option to the user on whether they want to learn C or ASP.

Step 1 The first step is to drag the checkbox control onto the Windows Form from the toolbox as shown below. Step 2 Once the checkbox has been added, go to the properties window by clicking on the Checkbox control. A button is used to allow the user to click on a button which would then start the processing of the form. Step 1 The first step is to drag the button control onto the Windows Form from the toolbox as shown below. Step 2 Once the Button has been added, go to the properties window by clicking on the Button control.

Congrats, you now have your first basic Windows Form in place. When working with windows form, you can add events to controls. An event is something that happens when an action is performed.

Probably the most common action is the clicking of a button on a form. In C Windows Forms, you can add code which can be used to perform certain actions when a button is pressed on the form. The below example will showcase an event for the Listbox control. So whenever an item is selected in the listbox control, a message box should pop up which shows the item selected.

Step 1 Double click on the Listbox in the form designer. By doing this, Visual Studio will automatically open up the code file for the form. And it will automatically add an event method to the code. This event method will be triggered, whenever any item in the listbox is selected. Above is the snippet of code which is automatically added by Visual Studio, when you double-click the List box control on the form.

One you make the above changes, and run the program in Visual Studio you will see the following output. From the output, you can see that when any item from the list box is selected, a message box will pops up.

This will show the selected item from the listbox. Again this follows the same philosophy. Just double click the button in the Forms Designer and it will automatically add the method for the button event handler. Then you just need to add the below code. Once you click the Submit button, a message box will pop, and it will correctly show you what you entered in the user details section. Probably the best example is when we see the Windows Explorer itself. The folder structure in Windows Explorer is like a tree-like structure.

Step 1 The first step is to drag the Tree control onto the Windows Form from the toolbox as shown below. Step 2 The next step is to start adding nodes to the tree collection so that it can come up in the tree accordingly.

Step 3 The next step is to start adding the child nodes to the tree collection.