The C# language does not directly contain an Eval function for evaluating a string as a math expression, though there are still a number of ways to go about it.

You could, for example, use the CodeDOM to dynamically compile an object that contains the expression string.

Or, while not necessarily a good coding practice, but certainly a short and simple route, you could use System.Xml.XPath.XPathNavigator.Evaluate(string xpath) as shown here:

public class XPathEval : I24MathParser {
	public float Evaluate(string expression) {
		System.Xml.XPath.XPathNavigator navigator =
			new System.Xml.XPath.XPathDocument(new System.IO.StringReader("<r/>")).CreateNavigator();

		//expath evaluator needs
		//	'/' expressed as "div"
		//	'%' expressed as "mod"
		string xpathExpression = expression.Replace("/", " div ").Replace("%", " mod ");
		float answer = Convert.ToSingle(navigator.Evaluate(String.Format("number({0})", xpathExpression)));

		return answer;
	}
}

The XPathEval class is implementing this interface to facilitate swapping out Evaluate providers:

interface I24MathParser {
	float Evaluate(string expression);
}

Here is a more verbose, native solution - a lightweight math expression parser for evaluating 24 Game user input:

/// <summary>
/// Lightweight math parser - C# does not have an Evaluate function
/// </summary>
public class MathParser : I24MathParser {
	//used to translate brackets to implied multiplication - i.e. "3(4)5(6)" will be interpreted as "3*(4)*5*(6)"
	private const string bracketsPattern = @"(?<=[0-9)])(?<rightSide>\()|(?<=\))(?<rightSide>[0-9])";

	//finds multiplication or division sub expression - i.e. "4*8-4*2)" yields {"4*8", "4*2"}
	private const string multiplyDividePattern = @"[0-9]+[/*][0-9]+";

	//finds bracketed expressions - i.e. "(4+30)(10-1)" yields {"4+30", "10-1"}
	private const string subExpressionPattern = @"\(([0-9/*\-+]*)\)";

	//splits expression into it elements - i.e. "4+-30-4.123" yields {"4", "+", "-30" ,"-", "4.123"}
	private const string tokenPattern = @"(?:(?<=[/*\-+]|^)[+-]?)?(?:[0-9]+(?:\.[0-9]*)?)|[/*\-+]";

	Regex brackets;
	Regex multiplyDivide;
	Regex subExpression;
	Regex token;


	public MathParser() {
		//initialize reusable regular expressions
		brackets = new Regex(bracketsPattern, RegexOptions.Compiled);
		subExpression = new Regex(subExpressionPattern, RegexOptions.Compiled);
		token = new Regex(tokenPattern, RegexOptions.Compiled);
		multiplyDivide = new Regex(multiplyDividePattern, RegexOptions.Compiled);
	}


	public float Evaluate(string input) {
		//brackets with no operator implies multiplication
		string equation = brackets.Replace(input, "*${rightSide}");
		float answer = Solve(equation);

		return answer;
	}


	float Solve(string equation) {
		//carry out order of operations
		//	bracketed subexpressions - for any operator
		equation = SolveSubExpressions(subExpression, equation);

		//	multiplication and division
		equation = SolveSubExpressions(multiplyDivide, equation);

		//	addition and subtraction
		float answer = ParseEquation(equation);

		return answer;
	}


	string SolveSubExpressions(Regex subExpression, string equation) {
		float subResult;
		Match match = subExpression.Match(equation);

		while (match.Success) {
			if (match.Groups[1].Length > 0) {
				//recursively solve for subexpressions -- match group 1 excludes outer brackets
				subResult = Solve(match.Groups[1].Value);
			}
			else {
				//no more nested expressions - get final result for this subExpression
				subResult = ParseEquation(match.Value);
			}


			//replace subexpression with resolved answer
			equation = equation.Replace(match.Value, subResult.ToString());

			//retest updated equation string
			match = subExpression.Match(equation);
		}

		return equation;
	}


	float ParseEquation(string equation) {
		Match match = token.Match(equation);
		float leftSide = leftSide = float.Parse(match.Value);
		string symbol;
		float rightSide;
		match = match.NextMatch();

		while (match.Success) {
			symbol = match.Value;
			match = match.NextMatch();

			if (match.Success)
			{
				rightSide = float.Parse(match.Value);
				leftSide = Calculate(leftSide, symbol, rightSide);
				match = match.NextMatch();
			}
		}

		return leftSide;
	}


	float Calculate(float leftSide, string symbol, float rightSide) {
		float answer;

		switch (symbol) {
			case "/":
				answer = leftSide / rightSide;
				break;

			case "*":
				answer = leftSide * rightSide;
				break;

			case "-":
				answer = leftSide - rightSide;
				break;

			case "+":
				answer = leftSide + rightSide;
				break;

			default:
				throw new ArgumentException();
		}

		return answer;
	}
}

This is the main class that handles puzzle generation and user interaction

/// <summary>
/// The Game.  Handles user interaction and puzzle generation.
/// </summary>
class TwentyFourGame {
	//puzzle parameters
	private const int listSize = 4;
	private const int minValue = 1;
	private const int maxValue = 9;

	//signals end of game
	private const string quitToken = "Q";

	//the only valid puzzle solution
	private const float targetValue = 24;

	//Regular Expressions for evaluating math input
	private const string dictionaryBlacklistPattern = @"[^1-9/*\-+()]";
	private const string inputDigitsPattern = @"(?:(?<=[+-]|^)[+-]?)?(?:[0-9]+(?:\.[0-9]*)?)";
	Regex dictionaryBlackList;
	Regex inputDigits;
	I24MathParser mathParser;

	public TwentyFourGame() {
		//initialize reusable regular expressions
		dictionaryBlackList = new Regex(dictionaryBlacklistPattern, RegexOptions.Compiled);
		inputDigits = new Regex(inputDigitsPattern, RegexOptions.Compiled);

		//define instance of math evaluator provider
		//custom parser
		//mathParser = new MathParser();

		//xpath parser
		mathParser = new XPathEval();
	}


	static void Main(string[] args)	{
		TwentyFourGame game = new TwentyFourGame();
		game.PrintInstructions();
		game.PlayGame();
	}


	void PlayGame()	{
		string input;
		bool endGame = false;


		//repeat play cycle until user signals the end
		do {
			string puzzle = GetPuzzle();
			bool isValid = false;

			//continue prompting user until valid input is received
			do {
				float answer;
				string message = String.Empty;

				try {
					//show user puzzle and get read their solution
					input = GetInput(puzzle);

					if (input.Length == 0) {
						//skip current puzzle - perhaps there is no solution
						isValid = true;
						message = "Skipping this puzzle";
					}
					else if (String.Compare(input, quitToken, true) == 0) {
						//user wishes to quit
						isValid = true;
						message = "End Game";
					}
					else if (ValidateInput(input, puzzle)) {
						//interpret user input and calculate answer
						answer = mathParser.Evaluate(input);

						if (answer == targetValue) {
							isValid = true;
							message = String.Format("Good work.  {0} = {1}.", input, answer);
						}
						else {
							isValid = false;
							message = String.Format("Incorrect.  {0} = {1}.  Try again.", input, answer);
						}
					}
					else {
						isValid = false;
						message = "Invalid input.  Try again.";
					}
				}
				catch {
					message = "An error occurred.  Check your input and try again.";
					isValid = false;
				}
				finally {
					PrintMessage(message);
					PrintMessage(String.Empty);
					PrintMessage(String.Empty);
				}
			} while (!isValid);
		} while (!endGame);

		//pause
		GetInput(String.Empty);
	}


	bool ValidateInput(string input, string puzzle) {
		bool isValid;

		if (dictionaryBlackList.IsMatch(input)) {
			//illegal characters used
			isValid = false;
		}
		else {
			//get inputted digits and compare to those in puzzle
			string inputNumbers = String.Join(" ", from Match m in inputDigits.Matches(input) orderby float.Parse(m.Value) select m.Value);

			isValid = inputNumbers.CompareTo(puzzle) == 0;
		}

		return isValid;
	}


	string GetPuzzle() {
		int[] digits = new int[listSize];

		//randomly choose 4 digits (from 1 to 9)
		Random rand = new Random();

		for (int i = 0; i < digits.Length; i++) {
			digits[i] = rand.Next(minValue, maxValue);
		}

		//format for display
		Array.Sort(digits);
		string puzzle = String.Join(" ", digits);
		return puzzle;
	}


	string GetInput(string prompt) {
		Console.Write(String.Concat(prompt, ":  "));
		return Console.ReadLine();
	}


	void PrintMessage(string message) {
		Console.WriteLine(message);
	}


	void PrintInstructions() {
		PrintMessage("--------------------------------- 24 Game ---------------------------------");
		PrintMessage(String.Empty);
		PrintMessage("------------------------------- Instructions ------------------------------");
		PrintMessage("Four digits will be displayed.");
		PrintMessage("Enter an equation using all of those four digits that evaluates to 24");
		PrintMessage("Only * / + - operators and () are allowed");
		PrintMessage("Digits can only be used once, but in any order you need.");
		PrintMessage("Digits cannot be combined - i.e.: 12 + 12 when given 1,2,2,1 is not allowed");
		PrintMessage("Submit a blank line to skip the current puzzle.");
		PrintMessage("Type 'Q' to quit");
		PrintMessage(String.Empty);
		PrintMessage("Example: given 2 3 8 2, answer should resemble 8*3-(2-2)");
		PrintMessage("---------------------------------------------------------------------------");
		PrintMessage(String.Empty);
		PrintMessage(String.Empty);
	}
}

Example output:

--------------------------------- 24 Game ---------------------------------

------------------------------- Instructions ------------------------------
Four digits will be displayed.
Enter an equation using all of those four digits that evaluates to 24
Only * / + - operators and () are allowed
Digits can only be used once, but in any order you need.
Digits cannot be combined - i.e.: 12 + 12 when given 1,2,2,1 is not allowed
Submit a blank line to skip the current puzzle.
Type 'Q' to quit

Example: given 2 3 8 2, answer should resemble 8*3-(2-2)
---------------------------------------------------------------------------


1 3 3 4:  4*(3-1)*3
Good work.  4*(3-1)*3 = 24.


1 3 5 6: