自动验证(二)

字段

 internal interface IField 
 {
        int index { get; }
        string Name { get; }
        bool IsNullable { get; }
        DBTable Table { get; }
        bool IsKey { get; }
        int maxLength { get; }
        int minLength { get; }
        string flag { get; }
 }

 

这么多描述,自然是给验证做准备

1. 先创建一个委托

 public delegate Message FVaild<T>(T Value);

 

 

然后 一个泛型类

internal class Vaild<T> : IVaild<T>
{
        private FVaild<T> vs;
        public void AddVaild(FVaild<T> vaild)
        {
            vs += vaild;
        }

        public void RemoveVaild(FVaild<T> vaild)
        {
            vs -= vaild;
        }

        public Message Check(T value)
        {
            return vs(value);
        }
}

 

然后 在Fileld上继承

 internal abstract class DBField<T> : Vaild<T>, IField
    {
        public DBField(DBFieldDao dao, DBTable table)
        {
            this._table = table;
            this._index = dao.index;
            this._name = dao.name;
            this._isNullable = dao.isNullable;
            this._maxLength = dao.maxLength;
            this._minLength = dao.minLength;
            this._isKey = dao.IsKey;
            this._flag = dao.flag;
        }

        private int _index;
        private string _name;
        private bool _isNullable;
        private int _maxLength;
        private int _minLength = 0;
        private bool _isKey; //是否是主键
        private DBTable _table;
        private string _flag;

        public int index
        {
            get { return _index; }
        }

        public string Name
        {
            get { return _name; }
        }

        public bool IsNullable
        {
            get { return _isNullable; }
        }

        public DBTable Table
        {
            get { return _table; }
        }

        public bool IsKey
        {
            get { return _isKey; }
        }

        public int maxLength
        {
            get { return _maxLength; }
        }

        public int minLength
        {
            get { return _minLength; }
        }

        public string flag
        {
            get { return _flag; }
        }

        public abstract void Parse();
        public abstract T GetValue();
    }

 

 

    internal class DBField_String : DBField<string>  //nvarchar ntext nchar varchar text char
    {
        public DBField_String(DBFieldDao dao, DBTable table) : base(dao, table) { 
            //加入默认验证
        }
        public override string GetValue()
        {
            throw new NotImplementedException();
        }

        public override void Parse()
        {
            throw new NotImplementedException();
        }
    }

 

 

  internal class DBTable
  {
        public Dictionary<string, dynamic> dict;
        public DBTable(int length)
        {
            if (length == 0) dict = new Dictionary<string, dynamic>();
            else
            {
                dict = new Dictionary<string, dynamic>(length);
            }
        }

        public void Parse()
        {  
            
        }

        public void AddFields(dynamic field)
        {
            dict.Add(field.Name, field);
        }

        public bool Check()
        {
            return false;
        }


        /// <summary>
        ///  GetValue()
        ///  CHeck(T value)
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public dynamic this[string key]
        {
            get { return dict[key]; }
        }
  }

 

 

现在问题就来了

1. 动态类型。

    之前曾经想尝试不使用动态类型,发现就算不是用他 还是需要强转一次. 既然始终要用 不如就用动态类型.

　 但是动态类型 简单看了一下。 觉得就是一个语法糖.. 理论上说 c# 1.0 也可以实现动态类型。 一切通过object 转不就完了

　 

2. 

public bool Check() { return false; }

 

单个Field 时能通过Field 实现,

但是如何实现整个验证 传的参数就是一个问题. 如何传入一个完全不一样值的 也用动态类型？

 

next..