C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections;
using System.Collections.Generic;
using NLogic;

public class TestNLogic
{
	public static void Main()
	{		
		LogicalInteger left = new LogicalInteger(1);
		LogicalInteger right = new LogicalInteger(2);
		
		LogicalStatement trueStatement = new LogicalStatement(left, right, new LogicalLesser());
		
		Console.WriteLine("trueStatement: " + trueStatement.Evaluate());
		
		// --------------------------------------------------------------------------------
		
		LogicalString sleft = new LogicalString("hej");
		LogicalString sright = new LogicalString("tja");
		
		LogicalStatement falseStatement = new LogicalStatement(sleft, sright, new LogicalEqual());
		
		Console.WriteLine("falseStatement: " + falseStatement.Evaluate());
		
		// --------------------------------------------------------------------------------
		
		LogicalCondition trueCondition = new LogicalCondition(trueStatement);
		bool trueEval = trueCondition.Evaluate();
		
		Console.WriteLine("trueEval: " + trueEval);
		
		// --------------------------------------------------------------------------------
		
		LogicalCondition falseCondition = new LogicalCondition(falseStatement);
		bool falseEval = falseCondition.Evaluate();
		
		Console.WriteLine("falseEval: " + falseEval);
		
		// --------------------------------------------------------------------------------
				
		LogicalCondition orCondition = new LogicalCondition(LogicalOperator.OR);
		orCondition.AddCondition(trueCondition);
		orCondition.AddCondition(falseCondition);
		bool orEval = orCondition.Evaluate();
		
		Console.WriteLine("orEval: " + orEval);
		
		// --------------------------------------------------------------------------------
				
		LogicalCondition andCondition = new LogicalCondition(LogicalOperator.AND);
		andCondition.AddCondition(trueCondition);
		andCondition.AddCondition(falseCondition);
		bool andEval = andCondition.Evaluate();
		
		Console.WriteLine("andEval: " + andEval);
		
		// --------------------------------------------------------------------------------
				
		LogicalCondition andOrCondition = new LogicalCondition(LogicalOperator.OR);
		andOrCondition.AddCondition(orCondition);
		andOrCondition.AddCondition(falseCondition);
		bool andOrEval = andOrCondition.Evaluate();
		
		Console.WriteLine("andOrEval: " + andOrEval);
	}
}

namespace NLogic
{
	public class LogicalCondition
	{
		LogicalOperator operation;
		LogicalStatement statement;
		List<LogicalCondition> conditions;
		
		public LogicalCondition(LogicalStatement Statement)
		{
			operation = LogicalOperator.TRUE;
			statement = Statement;
		}
		
		public LogicalCondition(LogicalOperator Operation)
		{
			operation = Operation;
			conditions = new List<LogicalCondition>();
		}
		
		public void AddCondition(LogicalCondition condition)
		{
			conditions.Add(condition);
		}
		
		public bool Evaluate()
		{
			// Single statement.
			if (statement != null)
			{
				return EvaluateStatement();
			}

			// Condition tree.
			if (operation == LogicalOperator.AND)
			{
				return EvaluateAND();
			}
			else if (operation == LogicalOperator.OR)
			{
				return EvaluateOR();
			}
			
			return false;
		}
		
		private bool EvaluateStatement()
		{
			return statement.Evaluate();
		}
		
		private bool EvaluateAND()
		{
			foreach (LogicalCondition c in conditions)
			{
				if (!c.Evaluate())
				{
					// Return false on first false evaluation.
					return false;
				}
			}
			
			return true;
		}
		
		private bool EvaluateOR()
		{
			foreach (LogicalCondition c in conditions)
			{
				if (c.Evaluate())
				{
					// Return true on first true evaluation.
					return true;
				}
			}
			
			return false;
		}
	}
	
	public enum LogicalOperator
	{
		TRUE, 
		FALSE, 
		NOT, 
		AND, 
		OR
	}
	
	public class LogicalStatement
	{
		LogicalValue _left;
		LogicalValue _right;
		ILogicalComparator _comparator;
		
		public LogicalStatement(LogicalValue leftValue, LogicalValue rightValue, ILogicalComparator comparator)
		{
			_left = leftValue;
			_right = rightValue;
			_comparator = comparator;
		}
		
		public bool Evaluate()
		{
			return _comparator.Compare(_left, _right);
		}
	}
	
	public abstract class LogicalValue
	{	
		public abstract bool IsEqual(LogicalValue right);
		public abstract bool IsNotEqual(LogicalValue right);
		public abstract bool IsLesser(LogicalValue right);
		public abstract bool IsGreater(LogicalValue right);
		
		public static bool operator ==(LogicalValue left, LogicalValue right)
		{
			return left.IsEqual(right);
		}
		
		public static bool operator !=(LogicalValue left, LogicalValue right)
		{
			return left.IsNotEqual(right);
		}
		
		public static bool operator <(LogicalValue left, LogicalValue right)
		{
			return left.IsLesser(right);
		}
		
		public static bool operator >(LogicalValue left, LogicalValue right)
		{
			return left.IsGreater(right);
		}
	}
		
	public class LogicalInteger : LogicalValue
	{
		public int _value;
		
		public LogicalInteger(int val)
		{
			_value = val;
		}
		
		public override bool IsEqual(LogicalValue right)
		{
			return this._value == ((LogicalInteger) right)._value;
		}
		
		public override bool IsNotEqual(LogicalValue right)
		{
			return this._value != ((LogicalInteger) right)._value;
		}
		
		public override bool IsLesser(LogicalValue right)
		{
			return this._value < ((LogicalInteger) right)._value;
		}
		
		public override bool IsGreater(LogicalValue right)
		{
			return this._value > ((LogicalInteger) right)._value;
		}
	}
	
	public class LogicalString : LogicalValue
	{		
		public string _value;
		
		public LogicalString(string val)
		{
			_value = val;
		}
		
		public override bool IsEqual(LogicalValue right)
		{
			return string.Equals(this._value, ((LogicalString) right)._value, StringComparison.InvariantCultureIgnoreCase);
		}
		
		public override bool IsNotEqual(LogicalValue right)
		{
			return this._value != ((LogicalString) right)._value;
		}
		
		public override bool IsLesser(LogicalValue right)
		{
			throw new Exception("Operator < cannot be applied to operand 'string'");
		}
		
		public override bool IsGreater(LogicalValue right)
		{
			throw new Exception("Operator < cannot be applied to operand 'string'");
		}
	}
	
	public interface ILogicalComparator
	{
		bool Compare(LogicalValue left, LogicalValue right);
	}
	
	public class LogicalEqual : ILogicalComparator
	{
		public bool Compare(LogicalValue left, LogicalValue right)
		{
			return left == right;
		}
	}
	
	public class LogicalNotEqual : ILogicalComparator
	{
		public bool Compare(LogicalValue left, LogicalValue right)
		{
			return left != right;
		}
	}
	
	public class LogicalGreater : ILogicalComparator
	{
		public bool Compare(LogicalValue left, LogicalValue right)
		{
			return left > right;
		}
	}
	
	public class LogicalLesser : ILogicalComparator
	{
		public bool Compare(LogicalValue left, LogicalValue right)
		{
			return left < right;
		}
	}
}

​x
 
using System;
using System.Collections;
using System.Collections.Generic;
using NLogic;
​
public class TestNLogic
{
    public static void Main()
    {       
        LogicalInteger left = new LogicalInteger(1);
        LogicalInteger right = new LogicalInteger(2);
        
        LogicalStatement trueStatement = new LogicalStatement(left, right, new LogicalLesser());
        
        Console.WriteLine("trueStatement: " + trueStatement.Evaluate());
        
        // --------------------------------------------------------------------------------
        
        LogicalString sleft = new LogicalString("hej");
        LogicalString sright = new LogicalString("tja");
        
        LogicalStatement falseStatement = new LogicalStatement(sleft, sright, new LogicalEqual());
        
        Console.WriteLine("falseStatement: " + falseStatement.Evaluate());
        
        // --------------------------------------------------------------------------------
        
        LogicalCondition trueCondition = new LogicalCondition(trueStatement);
        bool trueEval = trueCondition.Evaluate();
        
        Console.WriteLine("trueEval: " + trueEval);
        
        // --------------------------------------------------------------------------------
        
        LogicalCondition falseCondition = new LogicalCondition(falseStatement);
        bool falseEval = falseCondition.Evaluate();
        
        Console.WriteLine("falseEval: " + falseEval);
        
        // --------------------------------------------------------------------------------
                
        LogicalCondition orCondition = new LogicalCondition(LogicalOperator.OR);
        orCondition.AddCondition(trueCondition);
        orCondition.AddCondition(falseCondition);
        bool orEval = orCondition.Evaluate();
        
        Console.WriteLine("orEval: " + orEval);
        
        // --------------------------------------------------------------------------------
                
        LogicalCondition andCondition = new LogicalCondition(LogicalOperator.AND);
        andCondition.AddCondition(trueCondition);
        andCondition.AddCondition(falseCondition);
        bool andEval = andCondition.Evaluate();
        
        Console.WriteLine("andEval: " + andEval);
        
        // --------------------------------------------------------------------------------
                
        LogicalCondition andOrCondition = new LogicalCondition(LogicalOperator.OR);
        andOrCondition.AddCondition(orCondition);
        andOrCondition.AddCondition(falseCondition);
        bool andOrEval = andOrCondition.Evaluate();
        
        Console.WriteLine("andOrEval: " + andOrEval);
    }
}
​
namespace NLogic
{
    public class LogicalCondition
    {
        LogicalOperator operation;
        LogicalStatement statement;
        List<LogicalCondition> conditions;
        
        public LogicalCondition(LogicalStatement Statement)
        {
            operation = LogicalOperator.TRUE;
            statement = Statement;
        }
        
        public LogicalCondition(LogicalOperator Operation)
        {
            operation = Operation;
            conditions = new List<LogicalCondition>();
        }
        
        public void AddCondition(LogicalCondition condition)
        {
            conditions.Add(condition);
        }
        
        public bool Evaluate()
        {
            // Single statement.
            if (statement != null)
            {
                return EvaluateStatement();
            }
​
            // Condition tree.
            if (operation == LogicalOperator.AND)
            {
                return EvaluateAND();
            }
            else if (operation == LogicalOperator.OR)
            {
                return EvaluateOR();
            }
            
            return false;
        }
        
        private bool EvaluateStatement()
        {
            return statement.Evaluate();
        }
        
        private bool EvaluateAND()
        {
            foreach (LogicalCondition c in conditions)
            {
                if (!c.Evaluate())
                {
                    // Return false on first false evaluation.
                    return false;
                }
            }
            
            return true;
        }
        
        private bool EvaluateOR()
        {
            foreach (LogicalCondition c in conditions)
            {
                if (c.Evaluate())
                {
                    // Return true on first true evaluation.
                    return true;
                }
            }
            
            return false;
        }
    }
    
    public enum LogicalOperator
    {
        TRUE, 
        FALSE, 
        NOT, 
        AND, 
        OR
    }
    
    public class LogicalStatement
    {
        LogicalValue _left;
        LogicalValue _right;
        ILogicalComparator _comparator;
        
        public LogicalStatement(LogicalValue leftValue, LogicalValue rightValue, ILogicalComparator comparator)
        {
            _left = leftValue;
            _right = rightValue;
            _comparator = comparator;
        }
        
        public bool Evaluate()
        {
            return _comparator.Compare(_left, _right);
        }
    }
    
    public abstract class LogicalValue
    {   
        public abstract bool IsEqual(LogicalValue right);
        public abstract bool IsNotEqual(LogicalValue right);
        public abstract bool IsLesser(LogicalValue right);
        public abstract bool IsGreater(LogicalValue right);
        
        public static bool operator ==(LogicalValue left, LogicalValue right)
        {
            return left.IsEqual(right);
        }
        
        public static bool operator !=(LogicalValue left, LogicalValue right)
        {
            return left.IsNotEqual(right);
        }
        
        public static bool operator <(LogicalValue left, LogicalValue right)
        {
            return left.IsLesser(right);
        }
        
        public static bool operator >(LogicalValue left, LogicalValue right)
        {
            return left.IsGreater(right);
        }
    }
        
    public class LogicalInteger : LogicalValue
    {
        public int _value;
        
        public LogicalInteger(int val)
        {
            _value = val;
        }
        
        public override bool IsEqual(LogicalValue right)
        {
            return this._value == ((LogicalInteger) right)._value;
        }
        
        public override bool IsNotEqual(LogicalValue right)
        {
            return this._value != ((LogicalInteger) right)._value;
        }
        
        public override bool IsLesser(LogicalValue right)
        {
            return this._value < ((LogicalInteger) right)._value;
        }
        
        public override bool IsGreater(LogicalValue right)
        {
            return this._value > ((LogicalInteger) right)._value;
        }
    }
    
    public class LogicalString : LogicalValue
    {       
        public string _value;
        
        public LogicalString(string val)
        {
            _value = val;
        }
        
        public override bool IsEqual(LogicalValue right)
        {
            return string.Equals(this._value, ((LogicalString) right)._value, StringComparison.InvariantCultureIgnoreCase);
        }
        
        public override bool IsNotEqual(LogicalValue right)
        {
            return this._value != ((LogicalString) right)._value;
        }
        
        public override bool IsLesser(LogicalValue right)
        {
            throw new Exception("Operator < cannot be applied to operand 'string'");
        }
        
        public override bool IsGreater(LogicalValue right)
        {
            throw new Exception("Operator < cannot be applied to operand 'string'");
        }
    }
    
    public interface ILogicalComparator
    {
        bool Compare(LogicalValue left, LogicalValue right);
    }
    
    public class LogicalEqual : ILogicalComparator
    {
        public bool Compare(LogicalValue left, LogicalValue right)
        {
            return left == right;
        }
    }
    
    public class LogicalNotEqual : ILogicalComparator
    {
        public bool Compare(LogicalValue left, LogicalValue right)
        {
            return left != right;
        }
    }
    
    public class LogicalGreater : ILogicalComparator
    {
        public bool Compare(LogicalValue left, LogicalValue right)
        {
            return left > right;
        }
    }
    
    public class LogicalLesser : ILogicalComparator
    {
        public bool Compare(LogicalValue left, LogicalValue right)
        {
            return left < right;
        }
    }
}

PadRight:詹éＯ小Ｏ end
PadLeft: 詹éＯ小Ｏend
詹éＯ小Ｏ end
PadRight:詹éʉ小壡Ｏend
PadLeft:詹éʉ小壡Ｏend
詹éʉ小壡Ｏend

Cached Result
Last Run:	12:55:19 pm
Compile:	0.052s
Execute:	0.07s
Memory:	2.22Mb
CPU:	0.122s

View IL Code