We Keep Coding

Passing Value on Property Change

I have 2 forms: Form A and Form B. I also have a property field class.
Form A contains the label I want changed when a property is changed. Form B contains code that will change the property field.
Property Class Code:
public class Controller
{
private static string _customerID;
public static string customerID
{
get { return _customerID; }
set
{
_customerID = value;
if (_customerID != "")
{
FormA.ChangeMe();
}
}
}
}
Form B Code:
private void something_Click(object sender, SomethingEventArgs e) {
Controller.customerID = "Cool";
}
Form A Code:
public static void ChangeMe()
{
var frmA = new FormA();
MessageBox.Show("Test: " + Controller.customerID); //This works! Shows Cool
frmA.lb2Change.Text = Controller.customerID; //This kind of works..
MessageBox.Show("Test2: " + frmA.lb2Change.Text); //This shows the correct value. Shows Cool
}
The property field value is passed (which I know from the MessageBox) however it does not update the value on the form label itself. Why is this? What am I doing wrong? I also believe there is a better alternative for achieving what ChangeMe() method is intended to achieve -- if so are there any suggestions?

You can do the following
To define a delegate
To Implement Property Change Notification
Delegate
public delegate void OnCustomerIDChanging(object sender,CancelEventArgs e);
public delegate void OnCustomerIDChanged(object sender,object value);
public class Controller
{
private static string _customerID;
public event OnCustomerIDChanging CustoerIDChanging;
public event OnCustomerIDChanged CustoerIDChanged;
public static string customerID
{
get { return _customerID; }
set
{
// make sure that the value has a `value` and different from `_customerID`
if(!string.IsNullOrEmpty(value) && _customerID!=value)
{
if(CustomerIDChanging!=null)
{
var state = new CancelEventArgs();
// raise the event before changing and your code might reject the changes maybe due to violation of validation rule or something else
CustomerIDChanging(this,state);
// check if the code was not cancelled by the event from the from A
if(!state.Cancel)
{
// change the value and raise the event Changed
_customerID = value;
if(CustomerIDChanged!=null)
CustomerIDChanged(this,value);
}
}
}
}
}
}
in your Form and when you are initiating the Controller Object
var controller = new Controller();
controller.CustomerIDChanging +=(sd,args) =>{
// here you can test if you want really to change the value or not
// in case you want to reject the changes you can apply
args.Cancel = true;
};
controller.CustomerIDChanged +=(sd,args) =>{
// here you implement the code **Changed already**
}
The above code will give you a great control over your code, also will make your controller code reusable and clean. Same
result you can get by implementing INotifyPropertyChanged interface
INotifyPropertyChanged
you might have a look on this article to get more information

In your static method ChangeMe you are creating a new Form every time, you want to Change the value. Instead of that you want to change the value of an existing form. Therefor your Controller needs an instance of this FormA. Try it like this:
public class Controller
{
//You can pass the form throught the constructor,
//create it in constructor, ...
private FormA frmA;
private string _customerID;
public string customerID
{
get { return _customerID; }
set
{
_customerID = value;
if (_customerID != "")
{
frmA.ChangeMe();
}
}
}
}
Now you don´t need to be static in your FormA:
public void ChangeMe()
{
MessageBox.Show("Test: " + Controller.customerID);
this.lb2Change.Text = Controller.customerID;
}

Passing a user defined method to the constructor

I want to create a simple input dialog. so I added a Windows From to my application and in that window I've put a label, a textbox and a button; For now it's easy to fill the required proprieties of my controls with the predefined values using constructors and return the entered value with result;
public partial class GeneralInputForm : Form
{
public string result = "";
public GeneralInputForm(string label, string defaultValue = "")
{
InitializeComponent();
label1.Text = label;
textBox1.Text = defaultValue;
}
private void button1_Click(object sender, EventArgs e)
{
result = textBox1.Text;
Close();
}
}
And now creating an instance of the from and filling the parameters with the required values;
GeneralInputForm formInput = new GeneralInputForm("Please enter your age:");
formInput.ShowDialog();
//formInput.result holds the value
My questions raises here; What if I want to check for the validity of the value that the user has entered in the textbox in the GeneralInputForm itself (and not later when instantiating the form with checking the result field)? I mean is there such a functionality in C# (delegates maybe) so that the user himself can define a method and pass a it as one of the parameters of the constructor which that method checks the textbox1.text value to be sure that for example it's successfully can be parsed into an int or float or string?
I don't want to add an ugly string parameter called variableType to my constructor and ask user to say if he requires a 'int' or 'float' or 'string' or whatever and then I myself by checking the value of variableType, wrote different statements for making sure that the entered text can be successfully parsed into int or float or string (it would be an ugly and limited solution)

Change GeneralInputForm to GeneralInputForm<T>. Is a generic class, just like List<String>.
You can use two field Func one to cast the Text to the object you want and one to check the return just like this:
public partial class GeneralInputForm<T> : Form
{
public T result = default(T);
Func<T, Boolean> check = (input) => true; // Default check
Func<String, T> cast = null; // Default cast
public GeneralInputForm(string label, string defaultValue = "", Func<String, T> cast, Func<T, Boolean> check)
{
InitializeComponent();
label1.Text = label;
textBox1.Text = defaultValue;
if(check != null)
this.check = check;
this.cast = cast;
}
private void button1_Click(object sender, EventArgs e)
{
if(cast != null)
{
T casted = cast(textBox1.Text);
if(casted != null && check(casted)){
result = textBox1.Text;
Close();
}
}
}
}
And you can use it like this:
Func<String, int> cast = (input) => int.Parse(input);
Func<int, Boolean> check = (input) => input > 0;
GeneralInputForm<int> form = new GeneralInputForm<int>("Enter a number:", "1", cast, check);
form.ShowDialog();
//etc....
More info about Generics.
This way of doing thing is named Dependecy Injection, and this approach is the constructor injection type. More info.

You don't need to pass it as a parameter. The validation function can be overridden using inheritance.
public partial class GeneralInputForm : Form
{
// Returns true if this text is valid for a textbox
protected virtual bool IsValid(string text)
{
return true; // default behaviour
}
private void button1_Click(object sender, EventArgs e)
{
if (IsValid(textBox1.Text))
{
result = textBox1.Text; // ok
Close();
}
else
{
// Show error message
}
}
}
Now you can create a form which custom-validates textboxes, by overriding (ie. replacing) the IsValid() function:
public partial class SpecificInputForm : GeneralInputForm
{
// Blank textboxes are not valid, and are restricted to 31 characters
protected override bool IsValid(string text)
{
if (string.IsNullOrWhitespace(text))
return false;
return (text.Length < 32);
}
}

While #Oscar's answer would work, making forms generic is a bit of a bad idea because the Winforms designer has aversion to them (try to inherit from that form and you'll see).
I'd probably make it so that it's not the form that is generic, but a method:
public partial class GeneralInputForm : Form
{
private GeneralInputForm() // Private constructor
{
InitializeComponent();
}
public static bool TryGetValue<T>(
string label,
string defaultValue,
Func<T, bool> check,
out T result
) where T : IConvertible
{
result = default(T);
using (var frm = new GeneralInputForm())
{
frm.label1.Text = label;
frm.textBox1.Text = defaultValue;
frm.Closing += (o, e) =>
{
var myForm = (GeneralInputForm) o;
// User closed not clicking the button?
if (myForm.DialogResult != DialogResult.OK)
return;
try
{
var checkval = (T) Convert.ChangeType(myForm.textBox1.Text, typeof (T));
if (!check(checkval))
e.Cancel = true;
}
catch
{
e.Cancel = true;
}
};
if (frm.ShowDialog() == DialogResult.OK)
{
result = (T)Convert.ChangeType(frm.textBox1.Text, typeof (T));
return true;
}
}
return false;
}
private void button1_Click(object sender, EventArgs e)
{
// Don't use `Close()` on modal forms, it's always better to
// return a dialog result. This will close the form aswell
DialogResult = DialogResult.OK;
}
}
Then use it like:
int result;
if(GeneralInputForm.TryGetValue("Enter an integer over 10",
"10",
(x) => x > 10,
out result))
MessageBox.Show(result.ToString());
else
/* User closed the form by other means */
Or:
string result;
if (GeneralInputForm.TryGetValue("Enter \"Hello\"",
"Goodbye",
(x) => x == "Hello",
out result))
This will not let you close the form by clicking button1 unless the value is correct, but will let you close it by other means (alt+f4, clicking the x, etc.). It'll return true if it was closed by the button, or false if it wasn't (you can put a Cancel button there).
You could also make the defaultValue parameter be of type T and assign defaultValue.ToString() to the textbox
A messagebox can be shown to the user in the Closing delegate if the value is not valid, or you can make your own logic
This requires that T is IConvertible, but about any type having a Parse method is

Thanks to everyone for the answers; I ended up to this simple and clear solution using delegates;
public partial class SimpleInputForm : Form
{
public string Value = "";
public delegate bool VerifyDel(string input);
private VerifyDel Methods;
public SimpleInputForm(string lable, VerifyDel method)
{
InitializeComponent();
label1.Text = lable;
Methods = new VerifyDel(method);
}
private void button1_Click(object sender, EventArgs e)
{
if (Methods(textBox1.Text))
{
Value = textBox1.Text;
Close();
}
}
}
and now I show the form with user defined functionality for the evaluation of input;
SimpleInputForm simpleInput = new SimpleInputForm("Enter your age:", (input => {
try
{
int age = int.Parse(input);
return true;
}
catch
{
MessageBox.Show("Invalid value for age!");
return false;
}
}));
//simpleInput.Value holds the input value

How can I reuse this snippet throughout a project?

I have this code on each form in my app that has textboxes to prevent the textboxes that are ReadOnly from being tabbed to:
private void FrmInventory_Load(object sender, EventArgs e)
{
foreach (var txtbx in Controls.OfType<TextBox>())
{
txtbx.TabStop = (!txtbx.ReadOnly);
}
}
It would be good to only have this code in one place, but how can I do that, as each time that "external" method was called, it would touch TextBoxes on the calling form, which smells a little fishy. Is an extension method the way to go, something like:
public static bool TextboxIsReadOnly(this TextBox txtbx)
{
return txtbx.ReadOnly;
}
...and then call it like this:
foreach (var txtbx in Controls.OfType<TextBox>())
{
txtbx.TabStop = TextboxIsReadOnly(txtbx);
}
?
That doesn't seem like it's of much value - I still would have to put most of the code in each form, just as things stand now. Creating a custom textbox that is both ReadOnly and TabStop = false seems a little overkillish...
Is there a way to have this logic execute for every TextBox-containing form, without reproducing the code all throughout the project?

Having a base class that performs that step and making it the base for all your forms would work, although you would need to be careful about calling the base version of the overloaded methods.

You can create a baseForm and Inherit that form in each of your forms.
Add a new Windows Form to your project(baseForm) and create load event
public class baseForm: Form
{
public baseForm()
{
this.Load += baseForm_Load;
}
void baseForm_Load(object sender, EventArgs e)
{
var t = GetAll<TextBoxX>(this);
foreach (var txtbx in Controls.OfType<TextBox>())
{
txtbx.TabStop = (!txtbx.ReadOnly);
}
}
public static List<T> GetAll<T>(Form f1)
{
List<T> f = new List<T>();
try {
if (f1 != null) {
CheckInner<T>(f1.Controls, ref f);
}
} catch (Exception ex) {
f.Clear();
}
return f;
}
}
And finally in each form you can do like this
public partial class FrmInventory : baseForm
{
}

Just to elaborate on the Extension Method solution you hinted at.
Extension Method
public static partial class MyExtensions
{
public static void UpdateTabStop(this TextBox txtBox)
{
txtBox.TabStop = !(txtBox.ReadOnly);
}
public static void UpdateTabStop(this Form frm)
{
foreach (var txtBox in frm.Controls.OfType<TextBox>())
{
txtBox.UpdateTabStop();
}
}
}
Then, on any Form you would do this.UpdateTabStop()... you should of course do this in an event after the controls are initialized, like Load.

Trim all user input strings in ASP.NET Web Forms

I am looking for a way to trim all user input in ASP.NET without calling Trim() on every string instance. I came across extending the DefaultModelBinder for MVC. Is there a way to do this in web forms? What options are available? As a less desirable option, is there a way to incorporate this into the set method of a class?

You could create a custom TextBox which always returns a trimmed version of the text:
public class CustomTextBox : TextBox
{
public override string Text
{
get { return base.Text.Trim(); }
set { base.Text = value; }
}
}
Then just use this instead of the normal TextBox anywhere you need this behavior.

Here is the utility method to trim all TextBoxes in a page (or a parent control) recursively.
public static void TrimTextBoxesRecursive(Control root)
{
foreach (Control control in root.Controls)
{
if (control is TextBox)
{
var textbox = control as TextBox;
textbox.Text = textbox.Text.Trim();
}
else
{
TrimTextBoxesRecursive(control);
}
}
}
Usage
protected void Button1_Click(object sender, EventArgs e)
{
TrimTextBoxesRecursive(Page);
}

You have to call this extension method from the appropriate parent, e.g. Page.TrimTextControls
public static void TrimTextControls(this Control parent, bool TrimLeading)
{
foreach (TextBox txt in parent.GetAllControls().OfType<TextBox>())
{
if (TrimLeading)
{
txt.Text = txt.Text.Trim();
}
else
{
txt.Text = txt.Text.TrimEnd();
}
}
}

How to determine if Control has Text property

When I iterate over a bunch of different controls on a Form, instead of trying to access the Text property:
String text = String.Empty;
foreach(Control control in this.Controls)
{
try
{
text = control.Text;
}
catch(Exception exception)
{
// This control probably doesn't have the Text property.
Debug.WriteLine(exception.Message);
}
}
Is there a way to just determine whether or not a given control has a Text property? Something like this:
String text = String.Empty;
foreach(Control control in this.Controls)
{
if(control has Text property)
{
text = control.Text;
}
}
I absolutely despise the Try/Catch blocks (unless there is no better alternative, of-course).

All Control objects have a Text property, so there is no point in using reflection to determine that. It will always return true.
Your problem actually is that some controls throw an exception from their Text property because they don't support it.
If you also want to be able to use custom controls that you don't know in advance, you should stick to your current solution and catch the exceptions. However, you should catch the specific exception thrown, for example NotSupportedException.
If you only ever encounter controls that you know in advance, you can select the controls that you know have a working Text property. For example:
public static bool HasWorkingTextProperty(Control control)
{
return control is Label
|| control is TextBox
|| control is ComboBox;
}
var controlsWithText = from c in this.Controls
where HasWorkingTextProperty(c)
select c;
foreach(var control in controlsWithText)
{
string text = control.Text;
// Do something with it.
}
And if you implement your own custom controls that may or may not have a Text property, then you can derive them from a base class that indicates this:
public abstract class CustomControlBase : Control
{
public virtual bool HasText
{
get { return false; }
}
}
public class MyCustomControl : CustomControlBase
{
public override bool HasText
{
get { return true; }
}
public override string Text
{
get { /* Do something. */ }
set { /* Do something. */ }
}
}
public static bool HasWorkingTextProperty(Control control)
{
return (control is CustomControlBase && ((CustomControlBase)control).HasText)
|| control is Label
|| control is TextBox
|| control is ComboBox;
}

Your question is How to determine if Control has Text property, so here is how you can do it using Reflection:
control.GetType().GetProperties().Any(x => x.Name == "Text");
Edit: If you take a look at the Control class, you will see it has a Text property.
Now, if some custom control that overrides the Control class throws an exception when accessing to the Text property, it is violating the Liskov substitution principle. In that case, I suggest you identifying those controls, although what you're doing seems to be fine.

Check this out:
private void Form1_Load(object sender, EventArgs e)
{
foreach (Control ctrl in this.Controls)
{
PropertyInfo[] properties = ctrl.GetType().GetProperties();
foreach(PropertyInfo pi in properties)
if (pi.Name == "Text")
{
//has text
}
}
}