c＃WinForms - 将主窗口的样式传递给对话框

Question

I was just wondering if there was a simpler way of passing style values from the main form to dialog boxes.

My application has user-settable style properties for all the different control types; ForeColor , BackColor , Button ForeColor , Button BackColor , Button FlatStyle etc. I want the dialog boxes to share the same, consistent style.

At the moment, I pass each of these properties to a dialog boxes like this;
(this example shows one of the more simple dialog forms, some have more control types and a lot more style properties)

using System;
using System.Drawing;
using System.Windows.Forms;

namespace MyApplication
{
    public partial class ConfirmDialog : Form
    {
        public Color ButtonBackColour { private get; set; }
        public Color ButtonForeColour { private get; set; }
        public FlatStyle ButtonFlatStyle { private get; set; }

        public string Message { private get; set; }
        public ConfirmDialog()
        {
            InitializeComponent();
        }

        private void ConfirmDialog_Load(object sender, EventArgs e)
        {
            buttonYES.ForeColor = ButtonForeColour;
            buttonCancel.ForeColor = ButtonForeColour;

            buttonYES.BackColor = ButtonBackColour;
            buttonCancel.BackColor = ButtonBackColour;

            buttonYES.FlatStyle = ButtonFlatStyle;
            buttonCancel.FlatStyle = ButtonFlatStyle;

            lblMsg.Text = Message;
        }
    }
}

Ok, now I have a static class which I use to hold the dialog Initializers;

using System.Drawing;
using System.Windows.Forms;

namespace MyApplication
{
    public static class ShowDialog
    {
        public static bool ConfirmDialog(string message, Color foreColour, Color backColour, Color buttonBackColour, Color buttonForeColour, FlatStyle buttonFlatStyle)// more style properties to come later on(flatstyle style props etc)
        {
            bool confirm = false;
            using (ConfirmDialog Dialog = new ConfirmDialog()
            {
                Message = message,
                ForeColor = foreColour,
                BackColor = backColour,
                ButtonBackColour = buttonBackColour,
                ButtonForeColour = buttonForeColour,
                ButtonFlatStyle = buttonFlatStyle
            })
            {
                DialogResult dr = Dialog.ShowDialog();
                if (dr == DialogResult.Yes)
                {
                    confirm = true;
                }
                else
                {
                    confirm = false;
                }
            }
            return confirm;
        }
    }
}

And finally, this is the mess of arguments I have to include...

private void buttonDelete_Click(object sender, EventArgs e)
{
    if (ShowDialog.ConfirmDialog("Are you sure you want to delete...?", this.ForeColour, this.BackColour, buttonDelete.BackColour, buttonDelete.ForeColour, buttonDelete.FlatStyle))// any button from main form will do
    {
        // Delete stuff...
    }
}

I am unsure if the static class is redundant, but it will make things a lot easier when the dialog boxes start to mount up.

So instead of having to pass all of these individual style properties around, I was wondering if there is a cleaner way. I know there is no Form.Style property. I suppose I could create one. But I wanted to check first with the Gurus to see if I am missing anything.

Answer 1

确保，[formname] .designer.cs中主窗体的所有属性都是公共静态，在de showdialog中你可以用它们调用它们：如果你的窗体叫做Form1：this.ForceColor = Form1.ForceColor是那个那些属性确实是公共静态的

Answer 2

Since you already have a static class defined for this purpose, you can host your style properties there, and reference them from both your forms and your dialogs. To implement this, your static class becomes more like this:

using System.Drawing;
using System.Windows.Forms;

namespace MyApplication
{
    public static class ShowDialog
    {
        public static Color ForeColour { get; set; }
        public static Color BackColour { get; set; }
        public static Color ButtonBackColour { get; set; }
        public static Color ButtonForeColour { get; set; }
        public static FlatStyle ButtonFlatStyle { get; set; }

        public static bool ConfirmDialog(string message)
        {
            bool confirm = false;
            using (ConfirmDialog Dialog = new ConfirmDialog()
            {
                Message = message,
                ForeColor = this.ForeColour,
                BackColor = this.BackColour,
                ButtonBackColour = this.ButtonBackColour,
                ButtonForeColour = this.ButtonForeColour,
                ButtonFlatStyle = this.ButtonFlatStyle
            })
            {
                DialogResult dr = Dialog.ShowDialog();
                if (dr == DialogResult.Yes)
                {
                    confirm = true;
                }
                else
                {
                    confirm = false;
                }
            }
            return confirm;
        }
    }
}

You can set these properties when your app launches, and not only will you not have to pass all these extra parameters into your ConfirmDialog method, but you can also reference them from all of your forms, instead of having to define them individually in each form. This makes it easy to manage your styles in a single place as well if you want to apply skins or need to make changes later.

Answer 3

After reading Elemental Pete's answer, I considered creating static properties I could set as the application loads, but instead of adding them to the ShowDialog static class, creating a new public class, implementing INotifyPropertyChanged to update the main form style when the style properties are changed, then creating a public static instance on the main form. This way, I can get or set the properties of [mainformname].Style from anywhere. I know little of best practices in programming, but this seems like a good approach that does everything I need.

public class DisplayStyle : INotifyPropertyChanged
    {
        private Color foreColor;
        private Color backColor;

        //Buttons
        private Color buttonForeColor;
        private Color buttonBackColor;
        private FlatStyle buttonFlatStyle;
        private FlatButtonAppearance buttonFlatAppearance;

        //ComboBoxes
        private Color comboForeColor;
        private Color comboBackColor;
        private FlatStyle comboBoxFlatStyle;

        //TextBoxes
        private Color textBoxForeColor;
        private Color textBoxBackColor;

        //CheckBoxes
        private Color checkBoxForeColor;
        private Color checkBoxBackColor;
        private FlatStyle checkBoxFlatStyle;
        private FlatButtonAppearance checkBoxFlatAppearance;

//...public properties, InotifyPropertyChanged Implementation etc...

Over on [mainformname]...

public static DisplayStyle Style = new DisplayStyle();

This is just another approach I've considered.

Answer 4

I have found yet another way to store and pass the mainform's style to other forms in the application. This time, I am utilizing the built-in User Properties .

It is pretty much the same as my other approach , only instead of saving the values to a static instance of a public class, I save the values to Properties.Settings which creates a .config file in the user's Application Data folder. It is really quite convenient, with methods for Reset() , Reload() and Save() as well as property updated events.

So I can create all the properties I need under the settings tab (or create them at run-time).
So then I can edit property values:

Properties.Settings.Default.FormForeColour = newColour;

and apply them to the form as the edits occur:

Properties.Settings.Default.PropertyChanged += new PropertyChangedEventHandler(UserSettings_PropChanged);

private void UserSettings_PropChanged(object sender, PropertyChangedEventArgs e)
{
    //update the form's display properties
    //e.g.
    this.ForeColor = Properties.Settings.Default.FormForeColour;

    labelStatus = e.PropertyName + " successfully updated";
}

So whenever I create a dialog box, I can simply set the style properties from the User Settings:

using (ConfirmDialog Dialog = new ConfirmDialog()
{
    Message = message,
    this.ForeColor = Properties.Settings.Default.FormForeColour,
    this.BackColor = Properties.Settings.Default.FormBackColour,
    this.ButtonBackColour = Properties.Settings.Default.ButtonBackColour,
    this.ButtonForeColour = Properties.Settings.Default.ButtonForeColour,
})