title: Overloading a method with delegates in c#
body: <p>Is there some way I can "overload" a function using delegates? I'd like to have a system in place wherein I can pass an anonymous function in a constructor and save it in a member variable. Data type isn't really an issue, but the passed functions can have one or two parameters. I've tried using (params double[] vals) in the delegate definition, but that complicates the passed anonymous functions and allows more parameters than should be allowed.</p>
  
  <p>So I've created two empty methods to hold the two types. As an example:</p>
  
  <pre><code>public class OpWrapper
  {
      public int operands;      //the number of operands this operator needs.
      public int precedence;    //the precedence this operator gets when calculating.
      public bool rightAssoc;   //whether or not this operator is right associative (true) or left associative (false).
  
      public delegate double evalDelegate(double a, double b);
      public delegate double calcDelegate(double a);
      public evalDelegate eval; //method used for two value inputs. Assigned in constructor.
      public calcDelegate calc; //method used for single value input. Assigned in constructor.
  
      //constructor initializes all variables.
      public OpWrapper(int o, int p, evalDelegate f, bool a = false)
      {
          operands = o;
          precedence = p;
          rightAssoc = a;
          eval = new evalDelegate(f);
      }
      //overloaded constructor assigns the proper method.
      public OpWrapper(int o, int p, calcDelegate f, bool a = false)
      {
          operands = o;
          precedence = p;
          rightAssoc = a;
          calc = new calcDelegate(f);
      }
  
      public double evaluate(params double[] values)
      {
          //do stuff
          if (operands == 1)
          {
              return calc(values[0]);
          }
          else
          {
              return eval(values[0], values[1]);
          }
          //more stuff
      }
  
  }
  </code></pre>
  
  <p>Ultimately, what I'd like to do is more like this:</p>
  
  <pre><code>public class OpWrapper
  {
      public int operands;      //the number of operands this operator needs.
      public int precedence;    //the precedence this operator gets when calculating.
      public bool rightAssoc;   //whether or not this operator is right associative (true) or left associative (false).
  
      public delegate double evalDelegate(double a, double b);
      public delegate double calcDelegate(double a);
      public ???????? calc; //method that does the passed function.
  
      //constructor initializes all variables.
      public OpWrapper(int o, int p, evalDelegate f, bool a = false)
      {
          operands = o;
          precedence = p;
          rightAssoc = a;
          eval = new evalDelegate(f);
      }
      //overloaded constructor assigns the proper method.
      public OpWrapper(int o, int p, calcDelegate f, bool a = false)
      {
          operands = o;
          precedence = p;
          rightAssoc = a;
          calc = new calcDelegate(f);
      }
  
      public double evaluate(params double[] values)
      {
          //do stuff
          if (operands == 1)
          {
              return calc(values[0]);
          }
          else
          {
              return calc(values[0], values[1]);
          }
          //more stuff
      }
  
  }
  </code></pre>
  
  <p>I'm not tremendously familiar with C#, yet, but surely there is a way to do something like this without having to define an instance of one delegate or the other that will just go unused.</p>