综合

img ccat

三值逻辑的一种实现

发表于2004/10/17 4:50:00  1709人阅读

分类: .net技术 真理与美

        以前的文章中,我们讨论了三值逻辑可能的运算体系和可能的代码实现。这里,我们给出一种完全的实现方式。以下代码利用枚举,在每一个三值逻辑对象中标识出其认可的算法,如果两个对象认可的与/或算法不一致,则抛出异常。出于程序结构上的完整性限制,逻辑对象具有默认算法——Arithmetics.Mathemetic。但是,我们可以在运行期修改它这个标识,也可以通过工厂方法方便的得到指定算法的对象。
        以下为算法标识枚举Arithmetics的定义:
 public enum Arithmetics {Mathematic, Database, Verify};
        以下为三值逻辑结构的代码,从不同的与/或运算静态方法的名字上,我们可以看出它们支持的算法。当然,如您所见,这种设计结构是封闭的,我们不能为它添加新的算法——从实用角度上看,这三种算法已经可以应付几乎所有场合了。
  public struct VarBool
 {
  // The three possible Boolw3 values.
  public static readonly VarBool Null = new VarBool(0);
  public static readonly VarBool False = new VarBool(-1);
  public static readonly VarBool True = new VarBool(1);
  // private field that stores –1, 0, 1 for False, Null, True.
  private sbyte value;
  private Arithmetics _Arithmetic;
  public Arithmetics Arithmetic
  {
   get
   {
    return _Arithmetic;
   }
   set
   {
    _Arithmetic = value;
   }
  }

  // private instance constructor. The value parameter must be –1, 0, or 1.
  private VarBool(int value)
  {
   this.value = (sbyte)value;
   this._Arithmetic = Arithmetics.Mathematic;
  }

  /// <summary>
  /// 从数据库组件的逻辑字段值中构造实例
  /// </summary>
  /// <param name="value">只能为System.Boolean或DBNull类型。</param>
  public static VarBool Read(object value)
  {
   if(null == value)
    throw new ArgumentException("The value is null!");
   if(value is bool || value is DBNull)
    return (VarBool)value;
   else
    throw new ArgumentException("The value must in true, false or DBNull!");
  }

  /// <summary>
  /// 从字符串解析值。
  /// </summary>
  /// <param name="value">可选值为"True"、"False"、"Null"</param>
  public static VarBool Parse(string value)
  {
   switch(value)
   {
    case "True" :
    {
     return True;
    }
    case "False":
    {
     return False;
    }
    case "Null":
    {
     return Null;
    }
    default:
     throw new ArgumentException("The value must in /"True/", /"False/" or /"Null/"!");
   }
  }

  // Properties to examine the value of a Boolw3. Return true if this
  // Boolw3 has the given value, false otherwise.
  public bool IsNull { get { return value == 0; } }
  public bool IsFalse { get { return value < 0; } }
  public bool IsTrue { get { return value > 0; } }
  // Implicit conversion from bool to Boolw3. Maps true to Boolw3.True and
  // false to Boolw3.False.
  public static implicit operator VarBool(bool x)
  {
   return x? True: False;
  }

  public static implicit operator VarBool(DBNull x)
  {
   return Null;
  }

  // Explicit conversion from Boolw3 to bool.Throws an exception if the
  // given Boolw3 is Null, otherwise returns true or false.
  public static explicit operator bool(VarBool x)
  {
   if (x.value == 0) throw new InvalidOperationException();
   return x.value > 0;
  }

  public static explicit operator DBNull(VarBool x)
  {
   if (x.value != 0) throw new InvalidOperationException();
   return DBNull.Value;
  }

  // Equality operator. Returns Null if either operand is Null, otherwise
  // returns True or False.
  public static VarBool operator ==(VarBool x, VarBool y)
  {
   if (x.value == 0 || y.value == 0) return Null;
   return x.value == y.value? True: False;
  }
  // Inequality operator. Returns Null if either operand is Null, otherwise
  // returns True or False.
  public static VarBool operator !=(VarBool x, VarBool y)
  {
   if (x.value == 0 || y.value == 0) return Null;
   return x.value != y.value? True: False;
  }
  // Logical negation operator. Returns True if the operand is False, Null
  // if the operand is Null, or False if the operand is True.
  public static VarBool operator !(VarBool x)
  {
   return new VarBool(-x.value);
  }

  public override bool Equals(object obj)
  {
   return base.Equals (obj);
  }
  
  public override int GetHashCode()
  {
   return this.value;
  }
  
  public override string ToString()
  {
   if (value > 0) return "True";
   if (value < 0) return "False";
   return "Null";
  }

  public static VarBool MathAnd(VarBool x, VarBool y)
  {
   return new VarBool(x.value < y.value? x.value: y.value);
  }

  public static VarBool MathOr(VarBool x, VarBool y)
  {
   return new VarBool(x.value > y.value? x.value: y.value);
  }

  public static VarBool DBAnd(VarBool x, VarBool y)
  {
   if (x.value == 0 || y.value ==0) return Null;
   return new VarBool(x.value < y.value ? x.value : y.value);
  }
  
  public static VarBool DBOr(VarBool x, VarBool y)
  {
   if (x.value == 0 || y.value ==0) return Null;
   return new VarBool(x.value > y.value ? x.value : y.value);
  }

  public static VarBool VerifyAnd(VarBool x, VarBool y)
  {
   if (x.value == -1 || y.value == -1) return False;
   if (x.value == 1 || y.value == 1) return True;
   return Null;
  }
  
  public static VarBool VerifyOr(VarBool x, VarBool y)
  {
   if (x.value == 1 || y.value == 1) return True;
   if (x.value == -1 & y.value == -1) return False;
   return True;
  }

  public static VarBool operator &(VarBool x, VarBool y)
  {
   if(x.Arithmetic != y.Arithmetic)
    throw new ArgumentException(string.Format("左参数选择了{0}算法,而右参数选择了{1}算法。", x.Arithmetic, y.Arithmetic));
   switch(x.Arithmetic)
   {
    case Arithmetics.Database:
     return DBAnd(x, y);
    case Arithmetics.Mathematic:
     return MathAnd(x, y);
    case Arithmetics.Verify:
     return VerifyAnd(x, y);
    default:
     return Null;
   }
  }

  public static VarBool operator |(VarBool x, VarBool y)
  {
   if(x.Arithmetic != y.Arithmetic)
    throw new ArgumentException(string.Format("左参数选择了{0:D}算法,而右参数选择了{1:D}算法。", x.Arithmetic, y.Arithmetic));
   switch(x.Arithmetic)
   {
    case Arithmetics.Database:
     return DBOr(x, y);
    case Arithmetics.Mathematic:
     return MathOr(x, y);
    case Arithmetics.Verify:
     return VerifyOr(x, y);
    default:
     return Null;
   }
  }

 }

        以下为三值逻辑类的工厂方法类。通过工厂类的构造函数参数,我们可以指定即将生成的三值逻辑对象支持何种算法,这使得我们可以通过更简单和直观的方式生成对象。
 /// <summary>
 /// VarBool 的工厂方法集合,封装算法选择。
 /// 如果不通过该工厂生成VarBool,其默认算
 /// 法为Mathematic,也可以在运行期修改
 /// Arithmetic属性来指定算法。
 /// </summary>
 public class VarBoolBuilder
 {
  private Arithmetics _Arithmetic;
  public VarBoolBuilder(Arithmetics Arithmetic)
  {
   _Arithmetic = Arithmetic;
  }
  public VarBool Null
  {
   get
   {
    VarBool re = VarBool.Null;
    re.Arithmetic = _Arithmetic;
    return re;
   }
  }
  public VarBool True
  {
   get
   {
    VarBool re = VarBool.True;
    re.Arithmetic = _Arithmetic;
    return re;
   }
  }
  public VarBool False
  {
   get
   {
    VarBool re = VarBool.False;
    re.Arithmetic = _Arithmetic;
    return re;
   }
  }
  public VarBool Read(object value)
  {
   VarBool re = VarBool.Read(value);
   re.Arithmetic =  _Arithmetic;
   return re;
  }
  public VarBool Parse(string value)
  {
   VarBool re = VarBool.Parse(value);
   re.Arithmetic =  _Arithmetic;
   return re;
  }
 }

 

阅读全文
0 0

相关文章推荐

img
取 消
img