C# Dictionary Application: Applying Values through the selection of keys

Question

I have a dictionary that I am using to define the ratings of copper cable. I want to use these values to calculate how many cables it will take to meet a certain connections rating. The size of the connection, the cable type, and system type are selected by two ComboBoxs named cb_amperage, cb_cable_size and, cb_system_type. The answer found once the equation runs is to be displayed in a text box named tb6_cable_qty. I welcome any and all comments and suggestions. Thank you in advance for the assistance.

The math is easy:

decimal x, y, z;
x = decimal.Parse(cb_amperage.);
y = decimal.Parse();//<---- this value must come from the dictionary below
a = decimal.Parse();//<---- this value must also come from a dictionary below
z = (x / y) * a
tb6_cable_qty.Text = Math.Round(z,2).ToString();


void Cb_amperageSelectedIndexChanged(object sender, EventArgs e)    
 { 
        if (!String.!IsNullOrEmpty(cb_amperage) & !String.IsNullOrEmpty(cb_cable_size))
        //not sure if the above is right but I think it coveys the idea
       {
        //function based on the values in the dictionary below
       }

  //Cable Dictionary 1 used for cable quantity calculation
  Dictionary<string, int> cable_dictionary_1 = new Dictionary<string, int>();

  cable_dictionary_1.Add ("#1", 130);
  cable_dictionary_1.Add ("1/0", 150);
  cable_dictionary_1.Add ("2/0", 175);
  cable_dictionary_1.Add ("3/0", 200);
  cable_dictionary_1.Add ("4/0", 230);
  cable_dictionary_1.Add ("250", 255);
  cable_dictionary_1.Add ("300", 285);
  cable_dictionary_1.Add ("400", 355);
  cable_dictionary_1.Add ("500", 380);
  cable_dictionary_1.Add ("600", 720);
  cable_dictionary_1.Add ("750", 475);


        //System Type Dictionary used for cable quantity calculation
  Dictionary<string, int> system_type_dictionary = new Dictionary<string, int>();

  system_type_dictionary.Add ("3P 3W", 3);
  system_type_dictionary.Add ("3P 4W", 4);

EDIT 1: mmr; please take a look at the code below. I have a feeling I missed something that I would know if I was a little more expierenced. The following is my implementation of the first part of the solution you suggested. I get an error. I think it is because these two items, the string and the dictionary dont know they are supposed to be linked. Here is the error; *Invalid token ',' in class, struct, or interface member declaration (CS1519). See what you can see. Thanks again.

//The following strings are used in the cable quantity calculation
  private const string cblsize1 = "#1";
  private const string cblsize2 = "1/0";
  private const string cblsize3 = "2/0";
  private const string cblsize4 = "3/0";

//Cable Dictionary 1 used for cable quantity calculation
        Dictionary<string, int> cable_dictionary_1 = new Dictionary<string, int>();

  cable_dictionary.Add(cblsize1, 130);//#1 Cable
  cable_dictionary.Add(cblsize2, 150);//1/0 Cable
  cable_dictionary.Add(cblsize3, 175);//2/0 Cable
  cable_dictionary.Add(cblsize4, 200);//3/0 Cable

Answer 1

I'm not sure what your question is? It sounds like you got it all covered.

Answer 2

Edit: Wait, now I've gotten your question!

Here's what I'd do:

First, for each key, make them into a list of strings, so:

private const string mFirst = "#1";

Then, add into the dictionary:

mDictionary.Add(mFirst, 130); //etc...

Then, for each combo box, add in your strings

comboBox1.Add(mFirst);
comboBox1.Add(mSecond); //etc...

Then, add an event to the combo box selected index changed:

comboBox1_SelectedIndexChanged(SomeEventStuff I Forget)

When the value changes there, update your value for y. Do the same for comboBox2, and update the value for z. Once either value is updated, just update the result at the same time.

Edit 2:

To do the math, I'd have a function that looks like:

float CopperCalc(float inX, float inY, float inA){
     if (inY != 0){//avoid the division by zero
         return (inX / inY) * inA;
     } else {
         return 0; //just assume it's zero here.
     }//I'm not Jon Skeet, I can't divide by zero
}

Then, call that function inside your selectedindexchanged handlers, and use it to update your textbox:

 //put your mX, mY, and mA as member values of your class, and then
 //they get updated.  For instance:
 void comboBox1_SelectedIndexChanged(Events){
     mX = mDictionary[comboBox1.SelectedItem];
     textBox1.Text = CopperCalc(mX, mY, mA).ToString("f1");
 }

And put the same function for each combo box, so as the combo box updates, then the textbox updates as well. This stuff only makes sense if you want to try to automatically determine what the combination of wires should be automatically:

This sounds like a variant of the Knapsack Problem-- is that correct? You need to figure out some minimal combination of copper wiring in order to meet a connections requirement? Is there some minimum or maximum or other constraint? Why not just throw a huge amount of copper in order make the minumum requirement?

THat's a very long winded way of saying that I think I'll need more information in order to understand the problem; but, if the knapsack problem is a reasonable analog, then there are solutions, but they are NP-complete to implement. That is, they won't run 'quickly', but if you only have twelve wire gauges (or whatever), you should probably be fine for speed.

Answer 3

Solved!!!! Below is the code. Thanks to Rudedog2 of the MSDN C# Forum!

partial class MainForm
{
 double x, y, z;  

 List<string> cable_size1;
 List<string> system_type_list;
 List<string> amperage;

 Dictionary<string, double> cable_dictionary_1;
 Dictionary<string, double> system_type;
 Dictionary<string, double> amperage_dictionary;

private void MainFormLoad(object sender, EventArgs e)
 {
   //Each of the following lists populate the ComboBoxes
   //to be selected on the main form.
   amperage = new List<string>();
   cable_size1 = new List<string>();
   system_type_list = new List<string>();   

   cable_dictionary_1 = new Dictionary<string, double>();
   system_type = new Dictionary<string, double>();
   amperage_dictionary = new Dictionary<string, double>();

   //
   InitializeCurrentLoadCB();
   InitializeCableSizeCB();
   InitializeSystemTypeCB();

   //---------------Dictionaries---------------------------------------------------------
   InitializeSystemTypeLookup();
   InitializeCableLookup();
   InitializeAmperageLookup();
 }
 private void InitializeCurrentLoadCB()
 {
   //Amperage List, No Exclusions-----------------------------------------------------------
   amperage = new List<string>();
   amperage.Add("Please Select Amperage");
   amperage.Add("400");
   amperage.Add("800");
   amperage.Add("1000");
   amperage.Add("1200");
   amperage.Add("1600");
   amperage.Add("2000");
   amperage.Add("2500");
   amperage.Add("3000");
   amperage.Add("3200");
   amperage.Add("4000");
   amperage.Add("5000");
   amperage.Add("6000");

   cb_test_1.DataSource = amperage;
   cb_test_1.SelectedIndex = 0;
   cb_test_1.DropDownStyle = ComboBoxStyle.DropDownList;
 }
 private void InitializeCableSizeCB()
 {
   //Cable List, No Exclusions --------------------------------------------------------------
   cable_size1 = new List<string>();
   cable_size1.Add("Please Select Cable Size");
   cable_size1.Add ("#1");
   cable_size1.Add ("1/0");
   cable_size1.Add ("2/0");
   cable_size1.Add ("3/0");
   cable_size1.Add ("4/0");
   cable_size1.Add ("250");
   cable_size1.Add ("300");
   cable_size1.Add ("400");
   cable_size1.Add ("500");
   cable_size1.Add ("600");
   cable_size1.Add ("700");
   cable_size1.Add ("750");

   cb_test_2.DataSource = cable_size1;
   cb_test_2.SelectedIndex = 0;
   cb_test_2.DropDownStyle = ComboBoxStyle.DropDownList;
   //Initial DataBind for cable size ComboBox
 }
 private void InitializeSystemTypeCB()
 {
   //System Type List 
   system_type_list = new List<string>();
   system_type_list.Add("Select System Type");
   system_type_list.Add("3 Phase 3 Wire");
   system_type_list.Add("3 Phase 4 Wire");

   cb_test_3.DataSource = system_type_list;
   cb_test_3.SelectedIndex = 0;
   cb_test_3.DropDownStyle = ComboBoxStyle.DropDownList;
   //Initial DataBind for cb_system type ComboBox    
 }


 private void Button1Click(object sender, System.EventArgs e)
 { 

  if (!String.IsNullOrEmpty(cb_test_1.Text) &&
     (!String.IsNullOrEmpty(cb_test_2.Text) && 
     (!String.IsNullOrEmpty(cb_test_3.Text))))
   { 
    double a;
    if (cb_test_1.SelectedIndex != 0)
     {
      x = amperage_dictionary[amperage[cb_test_1.SelectedIndex]];     
     }              

    if (cb_test_2.SelectedIndex != 0)
     {
      y = cable_dictionary_1[cable_size1[cb_test_2.SelectedIndex]];     
     } 

    if (cb_test_3.SelectedIndex != 0)
     {
      z = system_type[system_type_list[cb_test_3.SelectedIndex]];
     }   

    a = ((x / y)*z);
    this.tb_1.Text = Math.Round(a,2).ToString();

   }

 }
 private void InitializeSystemTypeLookup()
 {
  //System Type Dictionary
  this.system_type = new Dictionary<string, double>();
  this.system_type.Add(this.system_type_list[0], 0);
  this.system_type.Add(this.system_type_list[1], 3);
  this.system_type.Add(this.system_type_list[2], 4);
 }
 private void InitializeCableLookup()
 {
  //Cable Dictionary 1 used for cable quantity calculation
  this.cable_dictionary_1 = new Dictionary<string, double>();
  this.cable_dictionary_1.Add (this.cable_size1[0], 0);
  this.cable_dictionary_1.Add (this.cable_size1[1], 130);
  this.cable_dictionary_1.Add (this.cable_size1[2], 150);
  this.cable_dictionary_1.Add (this.cable_size1[3], 175);
  this.cable_dictionary_1.Add (this.cable_size1[4], 200);
  this.cable_dictionary_1.Add (this.cable_size1[5], 230);
  this.cable_dictionary_1.Add (this.cable_size1[6], 255);
  this.cable_dictionary_1.Add (this.cable_size1[7], 285);
  this.cable_dictionary_1.Add (this.cable_size1[8], 355);
  this.cable_dictionary_1.Add (this.cable_size1[9], 380);
  this.cable_dictionary_1.Add (this.cable_size1[10], 720);
  this.cable_dictionary_1.Add (this.cable_size1[11], 475);
 }
 private void InitializeAmperageLookup()
 {
  //Amperage Dictionary 
  this.amperage_dictionary = new Dictionary<string, double>();
  this.amperage_dictionary.Add(this.amperage[0], 0);
  this.amperage_dictionary.Add(this.amperage[1], 400);
  this.amperage_dictionary.Add(this.amperage[2], 800);
  this.amperage_dictionary.Add(this.amperage[3], 1000);
  this.amperage_dictionary.Add(this.amperage[4], 1200);
  this.amperage_dictionary.Add(this.amperage[5], 1600);
  this.amperage_dictionary.Add(this.amperage[6], 2000);
  this.amperage_dictionary.Add(this.amperage[7], 2500);
  this.amperage_dictionary.Add(this.amperage[8], 3000);
  this.amperage_dictionary.Add(this.amperage[9], 3200);
  this.amperage_dictionary.Add(this.amperage[10], 4000);
  this.amperage_dictionary.Add(this.amperage[11], 5000);
  this.amperage_dictionary.Add(this.amperage[12], 6000);  
 }


}