Correct use of Properties to maintain a HUD in a nested Form?

Question

Edit 1

Is it possible to do this with get/set? Something like the below? This works for me but I am worried I am missing something not to mention all the staticness.

///<summary>
/// Class to track and maintain Heads Up Display information
///</summary>
public static class HUD
{
    ///<summary>
    ///Declare variables to store HUD values
    ///</summary>
    private static string _lastName;
    private static string _firstName;
    private static string _middleName;
    private static string _suffix;
    private static string _sSN;
    private static string _personID;
    private static string _masterID;
    private static string _enrollmentID;
    private static string _planID;

    // Store a reference to THE form that holds the HUD and is visible
    private static FrmModuleHost _frmHUDHost;

    public static string PersonId
    {
     get { return _personID; }
     set
     {
      FrmHudHost.tbxHUD_PersonID.Text = value;
      _personID = value;
     }
    }

    public static string SSn
    {
     get { return _sSN; }
     set
     {
      FrmHudHost.tbxHUD_SSN.Text = value;
      _sSN = value;
     }
    }

    public static string MiddleName
    {
     get { return _middleName; }
     set
     {
      FrmHudHost.tbxHUD_MiddleName.Text = value;
      _middleName = value;
     }
    }

    public static string FirstName
    {
     get { return _firstName; }
     set
     {
      FrmHudHost.tbxHUD_FirstName.Text = value;
      _firstName = value;
     }
    }

    public static string LastName
    {
     get { return _lastName; }
     set
     {
      FrmHudHost.tbxHUD_LastName.Text = value;
      _lastName = value;
     }
    }

    public static string Suffix
    {
     get { return _suffix; }
     set
     {
      FrmHudHost.tbxHUD_SuffixName.Text = value;
      _suffix = value;
     }
    }

    public static string MasterID
    {
     get { return _masterID; }
     set
     {
      FrmHudHost.tbxHUD_MasterID.Text = value;
      _masterID = value;
     }
    }

    public static string EnrollmentID
    {
     get { return _enrollmentID; }
     set
     {
      FrmHudHost.tbxHUD_EnrollmontPeriod.Text = value;
      _enrollmentID = value;
     }
    }

    public static string PlanID
    {
     get { return _planID; }
     set
     {
      FrmHudHost.tbxHUD_PlanID.Text = value;
      _planID = value;
     }
    }

    public static FrmModuleHost FrmHudHost
    {
     get { return _frmHUDHost; }
     set { _frmHUDHost = value; }
    }
}

---

Original Post

I have a class that is responsible for updating a Heads Up Display of current selected member info. My class looks like this -->

public static class HUD
{
    ///<summary>
    ///Declare variables to store HUD values
    ///</summary>
    public static string _lastName;
    public static string _firstName;
    public static string _middleName;
    public static string _suffix;
    public static string _sSN;
    public static string _personID;
    public static string _masterID;
    public static string _enrollmentPeriod;
    public static string _planID;

    ///<summary>
    /// Method to update the display with current information
    ///</summary>
    public static void UpdateHUD (FrmModuleHost frm, params String[] args)
    {
        frm.tbxHUD_LastName.Text = args[0];
        _lastName = args[0];

        frm.tbxHUD_FirstName.Text = args[1];
        _firstName = args[1];

        frm.tbxHUD_MiddleName.Text = args[2];
        _middleName = args[2];

        frm.tbxHUD_SSN.Text = args[3];
        _sSN = args[3];

        frm.tbxHUD_PersonID.Text = args[4];
        _personID = args[4];

    }
}

What I am trying to figure out is how I can tell what args are being passed. What you see below is what is called from the Search Page as that is all that is available at that point. The other 4 values will be loaded 1 at a time on various pages. A person HAS A enrollment which HAS A plan if that helps.

        private void GetResults()
    {
        var lName = getCurrentRowVal("Last Name");
        var fName = getCurrentRowVal("First Name");
        var pID = getCurrentRowVal("Person ID");
        var sSN = getCurrentRowVal("SSN");
        var mName = getCurrentRowVal("Middle Name");

        HUD.UpdateHUD(FrmWwcModuleHost, lName, fName, mName, sSN, pID);
    }

Now when I call this from the Enrollment Page I will want everything to stay and add the EnrollmentID.

        private void GetResults()
    {
        var enrollmentID = getCurrentRowVal("EnrollmentID");

        HUD.UpdateHUD(FrmWwcModuleHost, enrollmentID);
    }

My question is, How do I do that and know which arg[] index to call and not overwrite the existing values?

Is it as simple as always providing ALL parameters as they are set? So my call from the Enrollment Page would instead look like this -->

        private void GetResults()
    {
        var enrollmentID = getCurrentRowVal("EnrollmentID");

        HUD.UpdateHUD(FrmWwcModuleHost, HUD._lastName, HUD._firstName, HUD._middleName, HUD._sSN, HUD._personID, enrollmentID);
    }

Thanks for any insights!

Answer 1

What I would do is use an ananoymous type (which can be turned into a dictionary at runtime) and then changing the values which are present.

New function definition:

public static void UpdateHUD (FrmModuleHost frm, object args);

And client code:

UpdateHUD(frm, new {
    MiddleName = "Jed",
    SSN = "..." });

Using the code from Roy Osherove's Blog, this can be turned into a dictionary. The new implementation would be similar to:

var dictionary = MakeDictionary(args);
if ( dictionary.ContainsKey("SSN") ) { _sSN = dictionary["SSN"]; }

Of course, this will all be irrelevant when C# 4.0 comes out.

Answer 2

You'll really need to ditch the params style call and establish real parameters for your methods. Just create multiple overloads for your most common call signatures.

Answer 3

C# 4.0 has optional params which are much different from the params keyword. Params keyword is literally no different at runtime than if you didn't have the params keyword at all. In other words, you just get an array of values with no way of knowing which are which. Params keyword is just a C# convenience at compile time.

Although I haven't used C# 4.0 optional parameters yet, I imagine they behave similarly to the way VB.NET optional parameters did in that you can specify a default value at the function and that default will be used if the caller doesn't specify it. But the caller still has to indicate (either with missing values or paramName:= syntax) which parameter they are specifying.

In your case I think you're better off using either normal named parameters and passing null when you don't need them, or pass a dictionary/hashtable instead.

Answer 4

Perhaps instead of

params String[] args

you should do

params KeyValuePair<String,String>[] args

where any given param's properies would be assigned something like this:

Key = "Last Name"
Value = "Hare"

Then inside your UpdateHUD method you could check to see what the Key of the parameter was so you would know which value was being passed.

Answer 5

You could pass the arguments with a Dictionary where you can assign a value to a certain name.

The cleanest version would be to make a method for each variable. e.g.

void UpdateLastName(string name)
{
   frm.tbxHUD_LastName.Text = _lastName = name;
}

Answer 6

If you can use Framework 4.0, you can use optional and named parameters. Until that time, you will need to pass all the arguments.

But, I think by your question you might misunderstand what's happening slightly. The arguments you send in params are going into the method as an argument. Their scope therefore is the method itself, so you not "overwriting" anything. The array that you used for the first call is gone (out of scope) and the array you use for the second call will have whatever you put in it. Best way to do optional parameters before 4.0 is using multiple method overloads.

Answer 7

You could also create a separate class to pass in the params array. Something like:

public class HUDParam {
   public HUDParam(paramName, paramValue) { /*[init code here...]*/ }
   public string Name { get; set; }
   public string Value { get; set; }
}

Then:

HUD.UpdateHUD(frm, new HUDParam("FirstName", "Tom"), 
    new HUDParam("LastName", "Thompson");

In your update method, you can just check the name and set the appropriate value in your HUD.

Answer 8

If you have a name association with a value but possibly unknown name values this is a candidate for a Dictionary .

Optional parameters involve no less checking than checking a dictionary if a key exists or if a member of a class is null. Since there already exists a primitive for this and it's more flexible I see no reason to use variable parameters or optional parameters.

Answer 9

I did not see a reference to a particular version of .net you are using. Here is how I handle this in .net 3.5.

First create a class for passing the update values in, but make all of the properties nullable (since all of your items are string, they are already nullable). If the values are nullable, add actual property setters, and LastNameChanged properties.

 public class UpdateData {
    public string LastName { get; set;};
    public string FirstName  { get; set;};
    public string MiddleName  { get; set;};
 ...
 }

Now your method signature looks like this:

public static void UpdateHUD (FrmModuleHost frm, UpdateData  data)
{
    if (!string.IsNullOrEmpty(data.FirstName) {
    frm.tbxHUD_LastName.Text = data.FirstName;
    _lastName = data.FirstName;
    }

    if (!string.IsNullOrEmpty(data.LastName) {
    frm.tbxHUD_FirstName.Text = data.LastName;
    _firstName = data.FirstName;
    }
    if (!string.IsNullOrEmpty(data.MiddleName) {
    frm.tbxHUD_MiddleName.Text = data.MiddleName;
    _middleName = data.FirstName;
    }

Next is the setting the UpdateData and calling the method:

UpdateHUD(FrmWwcModuleHost, new UpateData{ FirstName = "test1", LastName = "test2", ...});

Final note: you are using a lot of statics here. You might consider changing most of them. Move the static variables to an actual class with properties (but no statics), and reference the class in your code.