Превратите строку логического выражения в код .NET.

Вы можете решить это универсально так же, как калькулятор или компилятор оценивает выражение:

1. Маркируйте строку и идентифицируйте каждый маркер как оператор (OP) или операнд (A, B, C и т. д.).
2. Преобразуйте последовательность маркеров из инфикса (A OP B) в постфикс (AB OP).
3. Оцените последовательность маркеров постфикса.

Каждый из этих шагов может быть выполнен с помощью хорошо известного алгоритма на основе стека в линейном времени и пространстве. Кроме того, если вы используете этот метод, он автоматически распространяется на любые бинарные операторы, которые вы хотите добавить позже (сложение, вычитание, сопоставление нечетких строк и т. д. и т. д.).

Чтобы преобразовать инфикс в постфикс: http://scriptasylum.com/tutorials/infix_postfix/algorithms/infix-postfix/

Чтобы оценить постфикс: http://scriptasylum.com/tutorials/infix_postfix/algorithms/postfix-evaluation/

Самый простой способ сделать это — проанализировать входной текст и построить массив логических «истинных» значений, так что вы получите что-то вроде этого:

//Dictionary<string,List<string>> members;
members["Car"].Contains("BMW") // evals to True;

В качестве альтернативы, если нет функциональной разницы между любой из входных записей (т. е. переменная оценивается как истина, пока слово отображается во входном тексте), вы, вероятно, можете просто создать список строк, а не беспокоиться об использовании их классификации как словарного ключа.

Затем вы анализируете строки уравнения и смотрите, присутствуют ли значения в логическом списке, если они есть, вы заменяете их в исходной строке уравнения на 1. Если они отсутствуют, вы заменяете их на 0.

В итоге вы получите что-то вроде этого:

string str0 = "Luke" // "1"
string str1 = "(Danny || Jennifer) && (BMW)" // "(1 || 0) && (1)"
string str2 = "(Mike && BMW) || Volvo" // "(1 && 1) || 0"
string str3 = "(Mike || David) && Ford" // "(1 || 1) && 0"
string str4 = "David && !BMW" // "1 && !0"

Теперь это просто простая итеративная замена строки. Вы зацикливаете строку до тех пор, пока не останется только 1 или 0.

while (str.Length > 1)
{
  if (str.Contains("(1 || 1)"))
    str.Replace("(1 || 1)", "1");
  if (str.Contains("(1 || 0)"))
    str.Replace("(1 || 0)", "1");
  // and so on
}

В качестве альтернативы, если вы можете найти метод "eval" С#, вы можете напрямую оценить выражение (и вы также можете использовать True/False вместо 0/1).

Редактировать:

Нашел простой токенизатор, который, вероятно, подойдет для разбора тестовых уравнений:

using System;
using System.Text.RegularExpressions;

public static string[] Tokenize(string equation)
{
    Regex RE = new Regex(@"([\(\)\! ])");
    return (RE.Split(equation));
}
//from here: https://www.safaribooksonline.com/library/view/c-cookbook/0596003390/ch08s07.html

Редактировать 2: Просто написал пример проекта, который это делает.

//this parses out the string input, does not use the classifications
List<string> members = new List<string>();
string input = "Customers: David, Danny, Mike, Luke. Car: BMW";
string[] t1 = input.Split(new string[] {". "},         StringSplitOptions.RemoveEmptyEntries);
foreach (String t in t1)
{
  string[] t2 = t.Split(new string[] { ": " }, StringSplitOptions.RemoveEmptyEntries);
  string[] t3 = t2[1].Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
  foreach (String s in t3)
  {
    members.Add(s.Trim());
  }
}

Это токенизирует уравнение и заменяет его на 1 и 0.

string eq = "(Danny || Jennifer) && (!BMW)";
Regex RE = new Regex(@"([\(\)\! ])");
string[] tokens = RE.Split(eq);
string eqOutput = String.Empty;
string[] operators = new string[] { "&&", "||", "!", ")", "("};
foreach (string tok in tokens)
{
  if (tok.Trim() == String.Empty)
    continue;
  if (operators.Contains(tok))
  {
    eqOutput += tok;
  }
  else if (members.Contains(tok))
  {
    eqOutput += "1";
  }
  else 
  {
    eqOutput += "0";
  }
}

В этот момент уравнение «(Дэнни || Дженнифер) && (!BMW)» выглядит как «(1||0)&&(!1)».

Теперь сократите уравнение до 1 или 0.

while (eqOutput.Length > 1)
{
  if (eqOutput.Contains("!1"))
    eqOutput = eqOutput.Replace("!1", "0");
  else if (eqOutput.Contains("!0"))
    eqOutput = eqOutput.Replace("!0", "1");
  else if (eqOutput.Contains("1&&1"))
    eqOutput = eqOutput.Replace("1&&1", "1");
  else if (eqOutput.Contains("1&&0"))
    eqOutput = eqOutput.Replace("1&&0", "0");
  else if (eqOutput.Contains("0&&1"))
    eqOutput = eqOutput.Replace("0&&1", "0");
  else if (eqOutput.Contains("0&&0"))
    eqOutput = eqOutput.Replace("0&&0", "0");
  else if (eqOutput.Contains("1||1"))
    eqOutput = eqOutput.Replace("1||1", "1");
  else if (eqOutput.Contains("1||0"))
    eqOutput = eqOutput.Replace("1||0", "1");
  else if (eqOutput.Contains("0||1"))
    eqOutput = eqOutput.Replace("0||1", "1");
  else if (eqOutput.Contains("0||0"))
    eqOutput = eqOutput.Replace("0||0", "0");
  else if (eqOutput.Contains("(1)"))
    eqOutput = eqOutput.Replace("(1)", "1");
  else if (eqOutput.Contains("(0)"))
    eqOutput = eqOutput.Replace("(0)", "0");
}

Теперь у вас должна быть строка, содержащая только 1 или 0, обозначающую истину или ложь соответственно.

С помощью DynamicExpresso вы можете легко сделать это за 10 строк. Допустим, текст и пользовательский ввод выглядят так:

var text = "Bob and Tom are in the same class.";
var input = "(Bob || Alice) && Tom";

Вы можете считать, что "Боб", "Алиса" "Том" являются переменными, тип которых bool в C#, строка ввода пользователя становится допустимым выражением C#, оцените его с помощью DynamicExpresso и получить результат bool.

var variables = input.Split(new[] { "(", "||", "&&", ")", " " }, 
    StringSplitOptions.RemoveEmptyEntries);

var interpreter = new Interpreter();

foreach (var variable in variables)
{
    interpreter.SetVariable(variable, text.Contains(variable));
}

var result = (bool)interpreter.Parse(input).Invoke();