Assigning a variable to an expression C#

Question

Is it possible to assign a variable to an expression in C# so that I don't have to write a method for it? For example, a variable named canBuild be equal to an expression "numResources > 50". And whenever that variable is called, it recalculates it's value. I've tried looking into lambdas but I don't really understand the documentation.

Thank you

EDIT:

Here's an attempt I tried with using lamdas:

public void setStateFloat(float variable, float comparison, int compareType)
{
    Func<bool> stateEval;
    switch(compareType)
    {
        case 0:
            stateEval = () => variable < comparison;
            break;
        case 1:
            stateEval = () => variable > comparison;
            break;
        case 2:
            stateEval = () => variable == comparison;
            break;
    }
}

Will this work if variable and comparison are not local to the object using this function (as in an object referring to another objects variable). I doubt it since it will only be a copy of the variable and not a pointer/reference to the where the original variable is stored.

Also, if I wanted to store a reference to the function, how would I do that?

The reason behind this is that I am developing a highly structured and modular system for designers and one of the requirements is creating a function from their input that are calculated initially and then used during runtime. Alternative approaches are welcome.

Kind thanks.

Answer 1

You won't be able to completely avoid the notion of a method, but C# lambda expressions offers a nice clean syntax for creating anonymous functions that can be used the way you're suggesting. In your example, the expression has no input parameters, and would therefore look like this:

() => numResources > 50

Here, numResources refers to a variable that is declared elsewhere in your code, but visible in the scope where the anonymous function is created. This results in a closure over numResources, which in C# means that the anonymous function can access that variable at any time, even if the function is invoked from a location where numResources isn't normally available.

Now, in order to assign the anonymous function to a variable so that it can be evaluated multiple times or passed around between methods, a delegate type must be used. These days, delegates are usually declared using one of the Func<TResult,...> or Action<...> types.

Since your example expression has no parameters and returns a bool, you would declare the variable as being of type Func<bool>. Combining declaration and initialization in a single statement, this becomes:

Func<bool> canBuild = () => numResources > 50;

Note that the type needs to be explicitly declared, var won't work here. Now you have a variable canBuild, which you can use just as if it was the name of a method:

bool result = canBuild();

Example

// Declare and initialize numResources
int numResources = 42;

// Declare and initialize a delegate and the anonymous function
Func<bool> canBuild = () => numResources > 50;

// Invoke the function    
bool result = canBuild();  // False this time, since 42 < 50

// Update numResources
numResources = 75;

// Invoke the function again 
bool result = canBuild();  // True this time

Example with closure over local variable

The following example demonstrates how C# closures make variables become shared, so that the anonymous function is actually referencing the original variable, and not just a copy:

    class Program
    {
        public static void CreateAnonFuncs(out Func<int> getNumber, 
                                           out Action<int> setNumber)
        {
            // Declare a local variable
            int localNum = 42;

            // Create anonymous functions that reference the local variable
            getNumber = () => localNum;
            setNumber = (n) => { localNum = n; };

            // Let's update the local variable afterwards
            localNum = 21;
        }

        public static void Main()
        {
            // Call the method that creates the functions
            CreateAnonFuncs(out var getter, out var setter);

            // Now invoke the functions to prove that the variable is shared
            Console.WriteLine($"Value from getter: {getter()}"); // 21 (not 42)
            setter(99);
            Console.WriteLine($"New value from getter: {getter()}"); // 99 (not 21)
        }
    }

Answer 2

I'm not sure what are you trying to achieve, but you could take a look at properties with getter implementation, like so:

public class Test 
{
   private int _numResources;
   public bool CanBuild 
   { 
      get
      {
        return _numResources == 50;
      }
   }
}