1: struct keisan

   2: {

   3:     public int i;

   4:  

   5:     List<range> condition;

   6:  

   7:     //tostring

   8:     public override string ToString()

   9:     {

  10:         return "" + i;

  11:     }

  12:  

  13:     //コンストラクタ

  14:     public keisan(int i) {

  15:         this.i = i;

  16:         condition = new List<range>();

  17:     }

  18:  

  19:     //新しく追加するとき

  20:     public keisan(keisan ks) {

  21:         this.i = ks.i;

  22:         condition = new List<range>();

  23:  

  24:         foreach(range r in ks.condition){

  25:             condition.Add(r);

  26:         }

  27:     }

  28:  

  29:     //bool へのキャスト

  30:     public static implicit operator bool(keisan ks){

  31:         foreach(range r in ks.condition){

  32:             if(r.min > ks.i || r.max < ks.i){

  33:                 return false;

  34:             }

  35:         }

  36:         return true;

  37:     }

  38:  

  39:     //int へのキャスト

  40:     public static implicit operator int(keisan ks) {

  41:         return ks.i;

  42:     }

  43:  

  44:     //int からのキャスト

  45:     public static implicit operator keisan(int i)

  46:     {

  47:         return new keisan(i);

  48:     }

  49:  

  50:     //オペレーター

  51:  

  52:  

  53:     //<

  54:     public static keisan low(int i, keisan ks) {

  55:         keisan result = new keisan(ks);

  56:         result.condition.Add(new range(i, int.MaxValue));

  57:  

  58:         return result;

  59:     }

  60:     public static keisan high(int i, keisan ks)

  61:     {

  62:         keisan result = new keisan(ks);

  63:         result.condition.Add(new range(int.MinValue, i));

  64:  

  65:         return result;

  66:     }

  67:  

  68:     public static keisan operator <(keisan ks, int i) {

  69:         return high(i, ks);

  70:     }

  71:     public static keisan operator <(int i, keisan ks){

  72:         return low(i, ks);

  73:     }

  74:  

  75:     //>

  76:     public static keisan operator >(int i, keisan ks){

  77:         return high(i, ks);

  78:     }

  79:     public static keisan operator >(keisan ks, int i){

  80:         return low(i, ks);

  81:     }

  82:  

  83:     //<=

  84:     //>=

  85: }

  86:  

  87: struct range{

  88:     public range(int min, int max) {

  89:         this.min = min;

  90:         this.max = max;

  91:     }

  92:  

  93:     public int min;

  94:     public int max;

  95: }

   1: keisan k = 100;

   2:  

   3: if (200 > k > 0) {

   4:     MessageBox.Show(""+k);

   5: }