I am working in C#. I find myself creating dialogs for editing my application settings all the time. For every Control on the dialog I am reading the configuration file and set it accordingly. After pressing OK, I am reading all the controls and store the values in the configuration files or something similar again.
This seems to be very time consuming, simple and repetitive. Does anybody have an idea how to simplify this process? Code generation? Helper classes?
You can bind WinForms controls directly to application settings, which should make your life a lot easier for creating dialogs to manage them.
Just select a control and look for the (Application Settings) option under the Data group in the properties pane. I put up a screenshot here to illustrate.
Do these application settings dialogs need to be pretty or are they simply there for personal configuration? If it's the latter, read all the settings into a class and assign that class to a property editor.
Not recommended for a good-looking, final UI though.
Best bet would be to use the "Settings" that are included in the default template for a winforms rather than "configuration" it is easier and the settings can be bound to just about any property for a control or read independently. Once discovered they are well documented, easy to customise and easy to use.
If you need to use configuration then I'd look at using a custom configuration section and bind that to a property grid or control set for editing. The configuration makes it easy to read and write changes to the configuration.
Related
I want to create a program that will enable user to open a file. That would create a new tab and assign a class to that tab that contains over 200 fields of various types (which I have already designed, along with read and write code of the program).
Then I would create an interface that would enable user to change any of that 200 fields.
Does that mean I have to create a property for each and every single of 200 fields that I have in order to bind them with fields?
Is there another way? Is this kind of program more viable for WindowsForms?
It seems a lot easier to do this programmatically instead of using XAML.
Is there a 3rd solution?
Maybe you are looking for the PropertyGrid. It may be not as beautiful as you'd expect, but it would cover major of your needs. There're some customizations examples, but it still looks ugly (IMO).
Otherwise you could create a control by yourself. Define deferent templates for various types of your properties. It shouldn't be difficult: some reflection, create bindings via C#, some templates.
I am still getting used to working with c# and wpf. I have made a number of smalls apps to do single tasks. To give the same feel to the apps my company uses I use the same logo, colours and layout.I am also developing a project settings class to save the project variables to file using a json file ( I hope ) and a slide out panel to give the user access to the project variables.
It would make sense to save this as a sort of template / base project so that every time I start a new project I can use this base project to shortcut the workload but every time I to do this I get errors. I have read about class library but am not certain if the is correct way forward or should be some sort of template.
Can someone explain if want I want to do is possible in wpf and what is the correct way forward please. Any questions on here (this site) assumed a bit too much knowledge for me and I can't get my head around the msdn references. So any good links would be helpful
Thanks
In Visual Studio, once you have the basic solution template that you want.
File->Export Tenplate.
Create a new Project Template.
Or if you just want to create a reusable theme. Create a class library and put some ResourceDictionaries inside with your styles and templates, etc. Then reference it from each new project and import the resource dictionaries. This solution would probably be easier to maintain over time as you could easily replace the referenced DLL with a new version when you make changes to the common UI theming.
I want to save state of lot of CheckBoxes (checked/unchecked) and some TextBoxes on a WPF screen in .settings file (As I do not want to use database/filing).
Whether I have to save all these checkboxes and textboxes in setings file or there is a better way to do it?
If this is to remember the state of controls in an application, I would definitely use user settings to store this. Creating a separate setting for each control can be time consuming initially, but it makes life a little easier later. However, if you don't want to do this, you can simply create a custom settings class with a public property for each control and then simply use an instance of that class as your one savable setting.
So I've seen many questions that talk about the best method to store settings but haven't really seen any that deal with my situation.
Basically my app today has one settings tab with about 75 options/settings. A user is able to basically have different "copies" of these settings (think: dropdown that when you select it, all 75 options are set to whatever was in that associated .xml file).
Right now I just store settings using XML. The problem is that when my application needs to ACCESS a setting, it is literally accessing the UI directly (checkboxes, etc...)
My question: Should I basically created a "has changed" event for every control, and then update the appropriate setting structure (and only save when the user hits save)?
I'm worried that I shouldn't be accessing the UI directly, and it's doing that today ALL over the app. I want to be sure that my new solution is appropriate/how C# was designed.
Thanks in advance!
~ Josh
It sounds like you want to have a class that represents a configuration. Serializing to/from XML allows you to store it in a file or database.
A static singleton can provide the application with the currently active configuration's values. The application should not be checking the UI elements on a non-visible form to get the settings each time one is needed.
Designing the settings form so that it handles a instance of a configuration allows it to be used to display/update the active configuration or a saved configuration. It ought to simplify letting a user load a configuration, modify it, and save it as a new configuration.
And 75 is, as a rule, a lot of settings for a single tab to manage.
WPF makes it very easy to create conditional formatting rules at design time based the underlying bound data values.
Are there any existing solutions that allow end users to create conditional formatting rules at run time?
Edit: I understand how to apply conditional formatting. I am curious if there are existing solutions that provide mechanisms for end users to create custom styles at run time
Edit: Excel's Conditional Formatting capability could be viewed as an example of the type of capability I am looking for
Karl Shifflett did a demo LOB application in WPF a few years ago. He demonstrated a way to dynamically load XAML "skins" in your application. Using this type of logic, a customer could create XAML and load it dynamically to skin the application, or you could provide an interface for a customer to dynamically change style properties and have the application appearance change based on those property settings.
His example is on his blog as well as on the Code Project.
Everything done in WPF via XAML can be done in C#, so you can create styles and triggers with C# only.
Here's an example.
For runtime formatting solutions, I would suggest using value converters.
You can get inputs from end users on what kind of formatting they need. And apply them in converters.
The following link How to customize tool item and tool container may help you. The LinsUIWPF suite is a free software. It allows end client to customize all tool items and tool container style.