using DataEntity;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace XImagingXhandler.XDAL
{
    /// <summary>
    /// ÒºÌå²ÎÊýʵÌåÀà
    /// </summary>
    [SugarTable("liquid")]
    public class Liquid:IEntity
    {
        private string _liquid_type_id = "";
        /// <summary>
        /// ÒºÌåÀàÐÍid Ö÷¼ü
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ÒºÌåÀàÐÍid")]
        public string liquid_type_id
        {
            get { return _liquid_type_id; }
            set
            {
                if (liquid_type_id == value) return; // ±ÜÃâÖظ´ÉèÖÃÏàͬµÄÖµ
                _liquid_type_id = value;
                OnPropertyChanged(nameof(liquid_type_id));
            }
        }

        private string _liquid_type_name = "";
        /// <summary>
        /// ÒºÌåÀàÐÍÃû³Æ
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ÒºÌåÀàÐÍÃû³Æ")]
        public string liquid_type_name
        {
            get { return _liquid_type_name; }
            set
            {
                if (liquid_type_name == value) return;
                _liquid_type_name = value;
                OnPropertyChanged(nameof(liquid_type_name));
            }
        }
        private string _liquid_type_name_en = "";
        /// <summary>
        /// ÒºÌåÀàÐÍÃû³ÆÓ¢ÎÄ
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ÒºÌåÀàÐÍÃû³ÆÓ¢ÎÄ")]
        public string liquid_type_name_en
        {
            get { return _liquid_type_name_en; }
            set
            {
                if (liquid_type_name_en == value) return;
                _liquid_type_name_en = value;
                OnPropertyChanged(nameof(liquid_type_name_en));
            }
        }
        private string _liquid_range_id = "";
        /// <summary>
        /// ÒºÌ巶Χid Ö÷¼ü
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ÒºÌ巶Χid")]
        public string liquid_range_id
        {
            get { return _liquid_range_id; }
            set
            {
                if (liquid_range_id == value) return;
                _liquid_range_id = value;
                OnPropertyChanged(nameof(liquid_range_id));
            }
        }
        private string _liquid_range_name = "";
        /// <summary>
        /// ÒºÌ巶ΧÃû³Æ
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ÒºÌ巶ΧÃû³Æ")]
        public string liquid_range_name
        {
            get { return _liquid_range_name; }
            set
            {
                if (liquid_range_name == value) return;
                _liquid_range_name = value;
                OnPropertyChanged(nameof(liquid_range_name));
            }
        }
        private string _liquid_range_name_en = "";
        /// <summary>
        /// ÒºÌ巶ΧÃû³ÆÓ¢ÎÄ
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ÒºÌ巶ΧÃû³ÆÓ¢ÎÄ")]
        public string liquid_range_name_en
        {
            get { return _liquid_range_name_en; }
            set
            {
                if (liquid_range_name_en == value) return;
                _liquid_range_name_en = value;
                OnPropertyChanged(nameof(liquid_range_name_en));
            }
        }
        private string _device_arm_id = "";
        /// <summary>
        /// ±Ûid Ö÷¼ü
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("±Ûid")]
        public string device_arm_id
        {
            get { return _device_arm_id; }
            set
            {
                if (device_arm_id == value) return;
                _device_arm_id = value;
                OnPropertyChanged(nameof(device_arm_id));
            }
        }
        private string _liquid_id = "";
        /// <summary>
        /// ÒºÌåid Ö÷¼ü
        /// </summary>
        [SugarColumn(ColumnName = "liquid_id", IsPrimaryKey = true)]
        [Description("ÒºÌåid")]
        public string liquid_id
        {
            get { return _liquid_id; }
            set
            {
                if (liquid_id == value) return;
                _liquid_id = value;
                OnPropertyChanged(nameof(liquid_id));
            }
        }
        private string _liquid_name = "";
        /// <summary>
        /// ÒºÌåÃû³Æ
        /// </summary>
        [SugarColumn(ColumnName = "liquid_name")]
        [Description("ÒºÌåÃû³Æ")]
        public string liquid_name
        {
            get { return _liquid_name; }
            set
            {
                if (liquid_name == value) return;
                _liquid_name = value;
                OnPropertyChanged(nameof(liquid_name));
            }
        }
        private string _liquid_category = "";
        /// <summary>
        /// ÒºÌåÀàÐÍ
        /// </summary>
        [SugarColumn(ColumnName = "liquid_category")]
        [Description("ÒºÌåÀàÐÍ")]
        public string liquid_category
        {
            get { return _liquid_category; }
            set
            {
                if (liquid_category == value) return;
                _liquid_category = value;
                OnPropertyChanged(nameof(liquid_category));
            }
        }
        private string _content = "";
        /// <summary>
        /// ÒºÌåÃèÊöÐÅÏ¢
        /// </summary>
        [SugarColumn(ColumnName = "content")]
        [Description("ÒºÌåÃèÊöÐÅÏ¢")]
        public string content
        {
            get { return _content; }
            set
            {
                if (content == value) return;
                _content = value;
                OnPropertyChanged(nameof(content));
            }
        }
        private string _liquid_volume_type = "";
        /// <summary>
        /// ÒºÌåÌå»ýÀàÐÍId£¨Íâ¼ü£©
        /// </summary>
        [SugarColumn(ColumnName = "liquid_volume_type")]
        [Description("ÒºÌåÌå»ýÀàÐÍId")]
        public string liquid_volume_type
        {
            get { return _liquid_volume_type; }
            set
            {
                if (liquid_volume_type == value) return;
                _liquid_volume_type = value;
                OnPropertyChanged(nameof(liquid_volume_type));
            }
        }
        private double _aspirate_speed = 100;
        /// <summary>
        /// ÎüÈ¡ÒºÌåµÄËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_speed")]
        [Description("ÎüÈ¡ÒºÌåµÄËÙ¶È")]
        public double aspirate_speed
        {
            get { return _aspirate_speed; }
            set
            {
                if (aspirate_speed == value) return;
                _aspirate_speed = value;
                OnPropertyChanged(nameof(aspirate_speed));
            }
        }
        private double _aspirate_acceleration = 100;
        /// <summary>
        /// ÎüÈ¡ÒºÌåµÄ¼ÓËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_acceleration")]
        [Description("ÎüÈ¡ÒºÌåµÄ¼ÓËÙ¶È")]
        public double aspirate_acceleration
        {
            get { return _aspirate_acceleration; }
            set
            {
                if (aspirate_acceleration == value) return;
                _aspirate_acceleration = value;
                OnPropertyChanged(nameof(aspirate_acceleration));
            }
        }
        private double _aspirate_deceleration = 100;
        /// <summary>
        /// ÎüÈ¡ÒºÌåµÄ¼õËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_deceleration")]
        [Description("ÎüÈ¡ÒºÌåµÄ¼õËÙ¶È")]
        public double aspirate_deceleration
        {
            get { return _aspirate_deceleration; }
            set
            {
                if (aspirate_deceleration == value) return;
                _aspirate_deceleration = value;
                OnPropertyChanged(nameof(aspirate_deceleration));
            }
        }
        private int _aspirate_delay = 0;
        /// <summary>
        /// ÎüÈ¡ÒºÌåµÄÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_delay")]
        [Description("ÎüÈ¡ÒºÌåµÄÑÓ³Ùʱ¼ä")]
        public int aspirate_delay
        {
            get { return _aspirate_delay; }
            set
            {
                if (aspirate_delay == value) return;
                _aspirate_delay = value;
                OnPropertyChanged(nameof(aspirate_delay));
            }
        }
        private double _before_aspirate_volume = 0;
        /// <summary>
        /// Ç°Îü¿ÕÆøµÄÌå»ý
        /// </summary>
        [SugarColumn(ColumnName = "before_aspirate_volume")]
        [Description("Ç°Îü¿ÕÆøµÄÌå»ý")]
        public double before_aspirate_volume
        {
            get { return _before_aspirate_volume; }
            set
            {
                if (before_aspirate_volume == value) return;
                _before_aspirate_volume = value;
                OnPropertyChanged(nameof(before_aspirate_volume));
            }
        }
        private int _before_aspirate_delay = 0;
        /// <summary>
        /// Ç°Îü¿ÕÆøÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "before_aspirate_delay")]
        [Description("Ç°Îü¿ÕÆøÑÓ³Ùʱ¼ä")]
        public int before_aspirate_delay
        {
            get { return _before_aspirate_delay; }
            set
            {
                if (before_aspirate_delay == value) return;
                _before_aspirate_delay = value;
                OnPropertyChanged(nameof(before_aspirate_delay));
            }
        }
        private double _after_aspirate_volume = 0;
        /// <summary>
        /// ºóÎü¿ÕÆøµÄÌå»ý
        /// </summary>
        [SugarColumn(ColumnName = "after_aspirate_volume")]
        [Description("ºóÎü¿ÕÆøµÄÌå»ý")]
        public double after_aspirate_volume
        {
            get { return _after_aspirate_volume; }
            set
            {
                if (after_aspirate_volume == value) return;
                _after_aspirate_volume = value;
                OnPropertyChanged(nameof(after_aspirate_volume));
            }
        }
        private int _after_aspirate_delay = 0;
        /// <summary>
        /// ºóÎü¿ÕÆøÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "after_aspirate_delay")]
        [Description("ºóÎü¿ÕÆøÑÓ³Ùʱ¼ä")]
        public int after_aspirate_delay
        {
            get { return _after_aspirate_delay; }
            set
            {
                if (after_aspirate_delay == value) return;
                _after_aspirate_delay = value;
                OnPropertyChanged(nameof(after_aspirate_delay));
            }
        }
        private double _aspirate_enter_speed = 0;
        /// <summary>
        /// ÎüҺʱ½øÈë¿×ÄÚµÄʱËÙ
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_enter_speed")]
        [Description("ÎüҺʱ½øÈë¿×ÄÚµÄʱËÙ")]
        public double aspirate_enter_speed
        {
            get { return _aspirate_enter_speed; }
            set
            {
                if (aspirate_enter_speed == value) return;
                _aspirate_enter_speed = value;
                OnPropertyChanged(nameof(aspirate_enter_speed));
            }
        }
        private double _aspirate_out_speed = 0;
        /// <summary>
        /// ÎüҺʱ³ö¿×µÄʱËÙ
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_out_speed")]
        [Description("ÎüҺʱ³ö¿×µÄʱËÙ")]
        public double aspirate_out_speed
        {
            get { return _aspirate_out_speed; }
            set
            {
                if (aspirate_out_speed == value) return;
                _aspirate_out_speed = value;
                OnPropertyChanged(nameof(aspirate_out_speed));
            }
        }

        private double _before_a_liquid_volume = 0;
        /// <summary>
        /// ÎüҺǰ¶àÎüÒºÌåµÄÌå»ý
        /// </summary>
        [SugarColumn(ColumnName = "before_a_liquid_volume")]
        [Description("ÎüҺǰ¶àÎüÒºÌåµÄÌå»ý")]
        public double before_a_liquid_volume
        {
            get { return _before_a_liquid_volume; }
            set
            {
                if (before_a_liquid_volume == value) return;
                _before_a_liquid_volume = value;
                OnPropertyChanged(nameof(before_a_liquid_volume));
            }
        }
        private double _after_a_liquid_volume = 0;
        /// <summary>
        /// ÎüÒººó¶àÎüÒºÌåµÄÌå»ý
        /// </summary>
        [SugarColumn(ColumnName = "after_a_liquid_volume")]
        [Description("ÎüÒººó¶àÎüÒºÌåµÄÌå»ý")]
        public double after_a_liquid_volume
        {
            get { return _after_a_liquid_volume; }
            set
            {
                if (after_a_liquid_volume == value) return;
                _after_a_liquid_volume = value;
                OnPropertyChanged(nameof(after_a_liquid_volume));
            }
        }
        private string _aspirate_well_bottom_length = "0";
        /// <summary>
        /// Àë¿×µ×µÄ¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_well_bottom_length")]
        [Description("Àë¿×µ×µÄ¾àÀë")]
        public string aspirate_well_bottom_length
        {
            get { return _aspirate_well_bottom_length; }
            set
            {
                if (aspirate_well_bottom_length == value) return;
                _aspirate_well_bottom_length = value;
                OnPropertyChanged(nameof(aspirate_well_bottom_length));
            }
        }
        private int _aspirate_position_type = 0;
        /// <summary>
        /// ÎüҺλÖÃÀàÐÍ£º0£ºLiquid;1:¿×¿ÚÒÔÏ£»2£º¿×µ×²¿
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_position_type")]
        [Description("ÎüҺλÖÃÀàÐÍ")]
        public int aspirate_position_type
        {
            get { return _aspirate_position_type; }
            set
            {
                if (aspirate_position_type == value) return;
                _aspirate_position_type = value;
                OnPropertyChanged(nameof(aspirate_position_type));
            }
        }
        private string _aspirate_well_x = "0";
        /// <summary>
        /// ÎüҺƫÀë¿×ÖÐÐÄx¾àÀë,¶à×éÓÃ","·Ö¸î
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_well_x")]
        [Description("ÎüҺƫÀë¿×ÖÐÐÄx¾àÀë")]
        public string aspirate_well_x
        {
            get { return _aspirate_well_x; }
            set
            {
                if (aspirate_well_x == value) return;
                _aspirate_well_x = value;
                OnPropertyChanged(nameof(aspirate_well_x));
            }
        }
        private string _aspirate_well_y = "0";
        /// <summary>
        /// ÎüҺƫÀë¿×ÖÐÐÄy¾àÀ룬¶à×éÓÃ","·Ö¸î
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_well_y")]
        [Description("ÎüҺƫÀë¿×ÖÐÐÄy¾àÀë")]
        public string aspirate_well_y
        {
            get { return _aspirate_well_y; }
            set
            {
                if (aspirate_well_y == value) return;
                _aspirate_well_y = value;
                OnPropertyChanged(nameof(aspirate_well_y));
            }
        }
        private int _is_probe = 0;
        /// <summary>
        /// ¸ÃÒºÌåÊÇ·ñ¿ÉÒÔ±»ÒºÃæ̽²âµ½£¬1£º¿ÉÒÔ£»0£º²»¿ÉÒÔ
        /// </summary>
        [SugarColumn(ColumnName = "is_probe")]
        [Description("¸ÃÒºÌåÊÇ·ñ¿ÉÒÔ±»ÒºÃæ̽²âµ½")]
        public int is_probe
        {
            get { return _is_probe; }
            set
            {
                if (is_probe == value) return;
                _is_probe = value;
                OnPropertyChanged(nameof(is_probe));
            }
        }
        private string _sensibility = "0";
        /// <summary>
        /// ÎüÒºÒºÃæ̽²âÁéÃô¶È
        /// </summary>
        [SugarColumn(ColumnName = "sensibility")]
        [Description("ÎüÒºÒºÃæ̽²âÁéÃô¶È")]
        public string sensibility
        {
            get { return _sensibility; }
            set
            {
                if (sensibility == value) return;
                _sensibility = value;
                OnPropertyChanged(nameof(sensibility));
            }
        }
        private string _blocking_sensibility = "0";
        /// <summary>
        /// ÎüÒºÒºÃæ¶ÂÈû̽²âÁéÃô¶È
        /// </summary>
        [SugarColumn(ColumnName = "blocking_sensibility")]
        [Description("ÎüÒºÒºÃæ¶ÂÈû̽²âÁéÃô¶È")]
        public string blocking_sensibility
        {
            get { return _blocking_sensibility; }
            set
            {
                if (blocking_sensibility == value) return;
                _blocking_sensibility = value;
                OnPropertyChanged(nameof(blocking_sensibility));
            }
        }
        private double _well_top_length = 0;
        /// <summary>
        /// ¿ªÆôѹÁ¦¸ÐӦǰ¾àÀë¿×¿ÚϵĴ¹Ö±¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "well_top_length")]
        [Description("¿ªÆôѹÁ¦¸ÐӦǰ¾àÀë¿×¿ÚϵĴ¹Ö±¾àÀë")]
        public double well_top_length
        {
            get { return _well_top_length; }
            set
            {
                if (well_top_length == value) return;
                _well_top_length = value;
                OnPropertyChanged(nameof(well_top_length));
            }
        }
        private double _liquid_down_length = 0;
        /// <summary>
        /// ǹͷÔÚÒºÃæϵĿªÊ¼ÎüÒºµÄÉî¶È
        /// </summary>
        [SugarColumn(ColumnName = "liquid_down_length")]
        [Description("ǹͷÔÚÒºÃæϵĿªÊ¼ÎüÒºµÄÉî¶È")]
        public double liquid_down_length
        {
            get { return _liquid_down_length; }
            set
            {
                if (liquid_down_length == value) return;
                _liquid_down_length = value;
                OnPropertyChanged(nameof(liquid_down_length));
            }
        }
        private string _probeinfo = "";
        /// <summary>
        /// ̽²âÌáʾÄÚÈÝ
        /// </summary>
        [SugarColumn(ColumnName = "probeinfo")]
        [Description("̽²âÌáʾÄÚÈÝ")]
        public string probeinfo
        {
            get { return _probeinfo; }
            set
            {
                if (probeinfo == value) return;
                _probeinfo = value;
                OnPropertyChanged(nameof(probeinfo));
            }
        }
        private int _aspirate_is_knock_wall = 0;
        /// <summary>
        /// ÎüÒººó£¬ÊÇ·ñÅö±Ú,
        /// </summary>
        [SugarColumn(ColumnName = "aspirate_is_knock_wall")]
        [Description("ÎüÒººó£¬ÊÇ·ñÅö±Ú")]
        public int aspirate_is_knock_wall
        {
            get { return _aspirate_is_knock_wall; }
            set
            {
                if (aspirate_is_knock_wall == value) return; 
                _aspirate_is_knock_wall = value;
                OnPropertyChanged(nameof(aspirate_is_knock_wall));
            }
        }
        private int _knock_direction = 0;
        /// <summary>
        /// Åö±ÚµÄ·½Ïò
        /// </summary>
        [SugarColumn(ColumnName = "knock_direction")]
        [Description("Åö±ÚµÄ·½Ïò")]
        public int knock_direction
        {
            get { return _knock_direction; }
            set
            {
                if (knock_direction == value) return;
                _knock_direction = value;
                OnPropertyChanged(nameof(knock_direction));
            }
        }
        private double _knock_speed = 0;
        /// <summary>
        /// Åö±ÚµÄËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "knock_speed")]
        [Description("Åö±ÚµÄËÙ¶È")]
        public double knock_speed
        {
            get { return _knock_speed; }
            set
            {
                if (knock_speed == value) return;
                _knock_speed = value;
                OnPropertyChanged(nameof(knock_speed));
            }
        }
        private int _knock_wall_delay = 0;
        /// <summary>
        /// Åö±ÚÖ®ºóµÄÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "knock_wall_delay")]
        [Description("Åö±ÚÖ®ºóµÄÑÓ³Ùʱ¼ä")]
        public int knock_wall_delay
        {
            get { return _knock_wall_delay; }
            set
            {
                if (knock_wall_delay == value) return;
                _knock_wall_delay = value;
                OnPropertyChanged(nameof(knock_wall_delay));
            }
        }
        private double _knock_well_height = 0;
        /// <summary>
        /// Åö±Ú¿ªÊ¼Ê±¿ÌÓë¿×¿ÚÖ®¼äµÄ¸ß¶È²î
        /// </summary>
        [SugarColumn(ColumnName = "knock_well_height")]
        [Description("Åö±Ú¿ªÊ¼Ê±¿ÌÓë¿×¿ÚÖ®¼äµÄ¸ß¶È²î")]
        public double knock_well_height
        {
            get { return _knock_well_height; }
            set
            {
                if (knock_well_height == value) return;
                _knock_well_height = value;
                OnPropertyChanged(nameof(knock_well_height));
            }
        }

        private double _knock_wall_length = 0;
        /// <summary>
        /// Åö±Ú¿ªÊ¼Ê±¿ÌÓë·½Ïò±ÛµÄ¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "knock_wall_length")]
        [Description("Åö±Ú¿ªÊ¼Ê±¿ÌÓë·½Ïò±ÛµÄ¾àÀë")]
        public double knock_wall_length
        {
            get { return _knock_wall_length; }
            set
            {
                if (knock_wall_length == value) return;
                _knock_wall_length = value;
                OnPropertyChanged(nameof(knock_wall_length));
            }
        }

        private double _knock_wall_x = 0d;
        /// <summary>
        /// ÎüÒºÅö±ÚʱxÆ«ÒÆÁ¿%
        /// </summary>
        [SugarColumn(ColumnName = "knock_wall_x")]
        [Description("ÎüÒºÅö±ÚʱxÆ«ÒÆÁ¿%")]
        public double knock_wall_x
        {
            get { return _knock_wall_x; }
            set
            {
                if (knock_wall_x == value) return; 
                _knock_wall_x = value;
                OnPropertyChanged(nameof(knock_wall_x));
            }
        }

        private double _knock_wall_y = 0d;
        /// <summary>
        /// ÎüÒºÅö±ÚʱyÆ«ÒÆÁ¿%
        /// </summary>
        [SugarColumn(ColumnName = "knock_wall_y")]
        [Description("ÎüÒºÅö±ÚʱyÆ«ÒÆÁ¿%")]
        public double knock_wall_y
        {
            get { return _knock_wall_y; }
            set
            {
                if (knock_wall_y == value) return;
                _knock_wall_y = value;
                OnPropertyChanged(nameof(knock_wall_y));
            }
        }

        private int _knock_wall_position_type = 0;
        /// <summary>
        /// Åö±ÚλÖÃÀàÐÍ£º0£ºLiquid;1:¿×¿ÚÒÔÏ£»2£º¿×µ×²¿
        /// </summary>
        [SugarColumn(ColumnName = "knock_wall_position_type")]
        [Description("Åö±ÚλÖÃÀàÐÍ")]
        public int knock_wall_position_type
        {
            get { return _knock_wall_position_type; }
            set
            {
                if (knock_wall_position_type == value) return;
                _knock_wall_position_type = value;
                OnPropertyChanged(nameof(knock_wall_position_type));
            }
        }
        private double _dispense_speed = 100;
        /// <summary>
        /// ÅÅÒºµÄËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "dispense_speed")]
        [Description("ÅÅÒºµÄËÙ¶È")]
        public double dispense_speed
        {
            get { return _dispense_speed; }
            set
            {
                if (dispense_speed == value) return;
                _dispense_speed = value;
                OnPropertyChanged(nameof(dispense_speed));
            }
        }
        private double _dispense_acceleration = 100;
        /// <summary>
        /// ÅųöÒºÌåµÄ¼ÓËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "dispense_acceleration")]
        [Description("ÅųöÒºÌåµÄ¼ÓËÙ¶È")]
        public double dispense_acceleration
        {
            get { return _dispense_acceleration; }
            set
            {
                if (dispense_acceleration == value) return;
                _dispense_acceleration = value;
                OnPropertyChanged(nameof(dispense_acceleration));
            }
        }
        private double _dispense_deceleration = 100;
        /// <summary>
        /// ÅųöÒºÌåµÄ¼õËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "dispense_deceleration")]
        [Description("ÅųöÒºÌåµÄ¼õËÙ¶È")]
        public double dispense_deceleration
        {
            get { return _dispense_deceleration; }
            set
            {
                if (dispense_deceleration == value) return;
                _dispense_deceleration = value;
                OnPropertyChanged(nameof(dispense_deceleration));
            }
        }
        private int _dispense_delay = 0;
        /// <summary>
        /// ÅųöÒºÌåµÄÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "dispense_delay")]
        [Description("ÅųöÒºÌåµÄÑÓ³Ùʱ¼ä")]
        public int dispense_delay
        {
            get { return _dispense_delay; }
            set
            {
                if (dispense_delay == value) return;
                _dispense_delay = value;
                OnPropertyChanged(nameof(dispense_delay));
            }
        }
        private double _before_dispense_volume = 0;
        /// <summary>
        /// Ç°Îü¿ÕÆøµÄÌå»ý
        /// </summary>
        [SugarColumn(ColumnName = "before_dispense_volume")]
        [Description("Ç°Îü¿ÕÆøµÄÌå»ý")]
        public double before_dispense_volume
        {
            get { return _before_dispense_volume; }
            set
            {
                if (before_dispense_volume == value) return;
                _before_dispense_volume = value;
                OnPropertyChanged(nameof(before_dispense_volume));
            }
        }
        private int _before_dispense_delay = 0;
        /// <summary>
        /// Ç°Îü¿ÕÆøÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "before_dispense_delay")]
        [Description("Ç°Îü¿ÕÆøÑÓ³Ùʱ¼ä")]
        public int before_dispense_delay
        {
            get { return _before_dispense_delay; }
            set
            {
                if (before_dispense_delay == value) return;
                _before_dispense_delay = value;
                OnPropertyChanged(nameof(before_dispense_delay));
            }
        }
        private double _after_dispense_volume = 0;
        /// <summary>
        /// ºóÎü¿ÕÆøµÄÌå»ý
        /// </summary>
        [SugarColumn(ColumnName = "after_dispense_volume")]
        [Description("ºóÎü¿ÕÆøµÄÌå»ý")]
        public double after_dispense_volume
        {
            get { return _after_dispense_volume; }
            set
            {
                if (after_dispense_volume == value) return;
                _after_dispense_volume = value;
                OnPropertyChanged(nameof(after_dispense_volume));
            }
        }
        private int _after_dispense_delay = 0;
        /// <summary>
        /// ºóÎü¿ÕÆøÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "after_dispense_delay")]
        [Description("ºóÎü¿ÕÆøÑÓ³Ùʱ¼ä")]
        public int after_dispense_delay
        {
            get { return _after_dispense_delay; }
            set
            {
                if (after_dispense_delay == value) return;
                _after_dispense_delay = value;
                OnPropertyChanged(nameof(after_dispense_delay));
            }
        }
        private double _dispense_enter_speed = 100;
        /// <summary>
        /// ÅÅҺʱ½øÈë¿×ÄÚµÄʱËÙ
        /// </summary>
        [SugarColumn(ColumnName = "dispense_enter_speed")]
        [Description("ÅÅҺʱ½øÈë¿×ÄÚµÄʱËÙ")]
        public double dispense_enter_speed
        {
            get { return _dispense_enter_speed; }
            set
            {
                if (dispense_enter_speed == value) return;
                _dispense_enter_speed = value;
                OnPropertyChanged(nameof(dispense_enter_speed));
            }
        }
        private double _dispense_out_speed = 100;
        /// <summary>
        /// ÅÅҺʱ³ö¿×µÄʱËÙ
        /// </summary>
        [SugarColumn(ColumnName = "dispense_out_speed")]
        [Description("ÅÅҺʱ³ö¿×µÄʱËÙ")]
        public double dispense_out_speed
        {
            get { return _dispense_out_speed; }
            set
            {
                if (dispense_out_speed == value) return;
                _dispense_out_speed = value;
                OnPropertyChanged(nameof(dispense_out_speed));
            }
        }
        private double _dispense_well_bottom_length = 0;
        /// <summary>
        /// ÅÅÒºÀë¿×µ×µÄ¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "dispense_well_bottom_length")]
        [Description("ÅÅÒºÀë¿×µ×µÄ¾àÀë")]
        public double dispense_well_bottom_length
        {
            get { return _dispense_well_bottom_length; }
            set
            {
                if (dispense_well_bottom_length == value) return;
                _dispense_well_bottom_length = value;
                OnPropertyChanged(nameof(dispense_well_bottom_length));
            }
        }
        private int _dispense_position_type = 0;
        /// <summary>
        /// ÅÅҺλÖÃÀàÐÍ£º0£ºLiquid;1:¿×¿ÚÒÔÏ£»2£º¿×µ×²¿
        /// </summary>
        [SugarColumn(ColumnName = "dispense_position_type")]
        [Description("ÅÅҺλÖÃÀàÐÍ")]
        public int dispense_position_type
        {
            get { return _dispense_position_type; }
            set
            {
                if (dispense_position_type == value) return;
                _dispense_position_type = value;
                OnPropertyChanged(nameof(dispense_position_type));
            }
        }
        private double _dispense_well_x = 0;
        /// <summary>
        /// ÅÅҺƫÀë¿×ÖÐÐÄx¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "dispense_well_x")]
        [Description("ÅÅҺƫÀë¿×ÖÐÐÄx¾àÀë")]
        public double dispense_well_x
        {
            get { return _dispense_well_x; }
            set
            {
                if (dispense_well_x == value) return;
                _dispense_well_x = value;
                OnPropertyChanged(nameof(dispense_well_x));
            }
        }
        private double _dispense_well_y = 0;
        /// <summary>
        /// ÅÅҺƫÀë¿×ÖÐÐÄy¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "dispense_well_y")]
        [Description("ÅÅҺƫÀë¿×ÖÐÐÄy¾àÀë")]
        public double dispense_well_y
        {
            get { return _dispense_well_y; }
            set
            {
                if (dispense_well_y == value) return;
                _dispense_well_y = value;
                OnPropertyChanged(nameof(dispense_well_y));
            }
        }
        private string _dispense_sensibility = "";
        /// <summary>
        /// ÅÅÒºÒºÃæ̽²âÁéÃô¶È£º0£º¸ß£»1£ºÖУ»2£ºµÍ
        /// </summary>
        [SugarColumn(ColumnName = "dispense_sensibility")]
        [Description("ÅÅÒºÒºÃæ̽²âÁéÃô¶È")]
        public string dispense_sensibility
        {
            get { return _dispense_sensibility; }
            set
            {
                if (dispense_sensibility == value) return;
                _dispense_sensibility = value;
                OnPropertyChanged(nameof(dispense_sensibility));
            }
        }
        private string _dispense_blocking_sensibility = "";
        /// <summary>
        /// ÅÅÒºÒºÃæ¶ÂÈûÁéÃô¶È£º0£º¸ß£»1£ºÖУ»2£ºµÍ
        /// </summary>
        [SugarColumn(ColumnName = "dispense_blocking_sensibility")]
        [Description("ÅÅÒºÒºÃæ¶ÂÈûÁéÃô¶È")]
        public string dispense_blocking_sensibility
        {
            get { return _dispense_blocking_sensibility; }
            set
            {
                if (dispense_blocking_sensibility == value) return; 
                _dispense_blocking_sensibility = value;
                OnPropertyChanged(nameof(dispense_blocking_sensibility));
            }
        }
        private int _dispense_is_knock_wall = 0;
        /// <summary>
        /// ÅÅÒººó£¬ÊÇ·ñÅö±Ú
        /// </summary>
        [SugarColumn(ColumnName = "dispense_is_knock_wall")]
        [Description("ÅÅÒººó£¬ÊÇ·ñÅö±Ú")]
        public int dispense_is_knock_wall
        {
            get { return _dispense_is_knock_wall; }
            set
            {
                if (dispense_is_knock_wall == value) return;
                _dispense_is_knock_wall = value;
                OnPropertyChanged(nameof(dispense_is_knock_wall));
            }
        }
        private int _dispense_knock_direction = 0;
        /// <summary>
        /// ÅÅÒºÅö±ÚµÄ·½Ïò£¬1:¶«·½£»2£ºÎ÷·½£»3£ºÄÏ·½£»4£º±±·½
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_direction")]
        [Description("ÅÅÒºÅö±ÚµÄ·½Ïò")]
        public int dispense_knock_direction
        {
            get { return _dispense_knock_direction; }
            set
            {
                if (dispense_knock_direction == value) return;
                _dispense_knock_direction = value;
                OnPropertyChanged(nameof(dispense_knock_direction));
            }
        }
        private double _dispense_knock_speed = 0;
        /// <summary>
        /// ÅÅÒºÅö±ÚµÄËÙ¶È
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_speed")]
        [Description("ÅÅÒºÅö±ÚµÄËÙ¶È")]
        public double dispense_knock_speed
        {
            get { return _dispense_knock_speed; }
            set
            {
                if (dispense_knock_speed == value) return;
                _dispense_knock_speed = value;
                OnPropertyChanged(nameof(dispense_knock_speed));
            }
        }
        private int _dispense_knock_wall_delay = 0;
        /// <summary>
        /// ÅÅÒºÅö±ÚÖ®ºóµÄÑÓ³Ùʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_wall_delay")]
        [Description("ÅÅÒºÅö±ÚÖ®ºóµÄÑÓ³Ùʱ¼ä")]
        public int dispense_knock_wall_delay
        {
            get { return _dispense_knock_wall_delay; }
            set
            {
                if (dispense_knock_wall_delay == value) return;
                _dispense_knock_wall_delay = value;
                OnPropertyChanged(nameof(dispense_knock_wall_delay));
            }
        }
        private double _dispense_knock_well_height = 0;
        /// <summary>
        /// ÅÅÒºÅö±Ú¿ªÊ¼Ê±¿ÌÓë¿×¿ÚÖ®¼äµÄ¸ß¶È²î
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_well_height")]
        [Description("ÅÅÒºÅö±Ú¿ªÊ¼Ê±¿ÌÓë¿×¿ÚÖ®¼äµÄ¸ß¶È²î")]
        public double dispense_knock_well_height
        {
            get { return _dispense_knock_well_height; }
            set
            {
                if (dispense_knock_well_height == value) return;
                _dispense_knock_well_height = value;
                OnPropertyChanged(nameof(dispense_knock_well_height));
            }
        }
        private double _dispense_knock_wall_length = 0;
        /// <summary>
        /// ÅÅÒºÅö±Ú¿ªÊ¼Ê±¿ÌÓë·½Ïò±ÛµÄ¾àÀë
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_wall_length")]
        [Description("ÅÅÒºÅö±Ú¿ªÊ¼Ê±¿ÌÓë·½Ïò±ÛµÄ¾àÀë")]
        public double dispense_knock_wall_length
        {
            get { return _dispense_knock_wall_length; }
            set
            {
                if (dispense_knock_wall_length == value) return;
                _dispense_knock_wall_length = value;
                OnPropertyChanged(nameof(dispense_knock_wall_length));
            }
        }

        private double _dispense_knock_wall_x = 0d;
        /// <summary>
        /// ÅÅÒºÅö±ÚʱxÆ«ÒÆÁ¿%
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_wall_x")]
        [Description("ÎüÒºÅö±ÚʱxÆ«ÒÆÁ¿%")]
        public double dispense_knock_wall_x
        {
            get { return _dispense_knock_wall_x; }
            set
            {
                if (dispense_knock_wall_x == value) return;
                _dispense_knock_wall_x = value;
                OnPropertyChanged(nameof(dispense_knock_wall_x));
            }
        }

        private double _dispense_knock_wall_y = 0d;
        /// <summary>
        /// ÅÅÒºÅö±ÚʱyÆ«ÒÆÁ¿%
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_wall_y")]
        [Description("ÎüÒºÅö±ÚʱyÆ«ÒÆÁ¿%")]
        public double dispense_knock_wall_y
        {
            get { return _dispense_knock_wall_y; }
            set
            {
                if (dispense_knock_wall_y == value) return;
                _dispense_knock_wall_y = value;
                OnPropertyChanged(nameof(dispense_knock_wall_y));
            }
        }

        private int _dispense_knock_position_type = 0;
        /// <summary>
        /// ÅÅÒºÅö±ÚλÖÃÀàÐÍ£º0£ºLiquid£»1:¿×µ×²¿£»2£º¿×¿ÚÏÂ
        /// </summary>
        [SugarColumn(ColumnName = "dispense_knock_position_type")]
        [Description("ÅÅÒºÅö±ÚλÖÃÀàÐÍ")]
        public int dispense_knock_position_type
        {
            get { return _dispense_knock_position_type; }
            set
            {
                if (dispense_knock_position_type == value) return;
                _dispense_knock_position_type = value;
                OnPropertyChanged(nameof(dispense_knock_position_type));
            }
        }
        private int _liquid_status = 0;
        /// <summary>
        /// ÒºÌå¼Ç¼ÊÇ·ñ¿ÉÓÃ
        /// </summary>
        [SugarColumn(ColumnName = "liquid_status")]
        [Description("ÒºÌå¼Ç¼ÊÇ·ñ¿ÉÓÃ")]
        public int liquid_status
        {
            get { return _liquid_status; }
            set
            {
                if (liquid_status == value) return;
                _liquid_status = value;
                OnPropertyChanged(nameof(liquid_status));
            }
        }

        private DateTime _timestamp = DateTime.Now;
        /// <summary>
        /// Êý¾ÝÐиüÐÂʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "timestamp")]
        [Description("Êý¾ÝÐиüÐÂʱ¼ä")]
        public DateTime timestamp
        {
            get { return _timestamp; }
            set
            {
                if (timestamp == value) return; 
                _timestamp = value;
                OnPropertyChanged(nameof(timestamp));
            }
        }
        private int _is_default_type = 0;
        /// <summary>
        /// ÊÇ·ñÊÇĬÈÏÀàÐÍ£º1£º ĬÈÏ£»0£º×Ô¶¨Òå
        /// </summary>
        [SugarColumn(ColumnName = "is_default_type")]
        [Description("ÊÇ·ñÊÇĬÈÏÀàÐÍ")]
        public int is_default_type
        {
            get { return _is_default_type; }
            set
            {
                if (is_default_type == value) return;
                _is_default_type = value;
                OnPropertyChanged(nameof(is_default_type));
            }
        }

        private double _cutgumspeed = 0d;
        /// <summary>
        /// Çнº¹ý³ÌµÄʱËÙ£¬°Ù·Ö±È
        /// </summary>
        [SugarColumn(ColumnName = "cutgumspeed", IsIgnore =true)]
        [Description("Çнº¹ý³ÌµÄʱËÙ£¬°Ù·Ö±È")]
        public double cutgumspeed
        {
            get { return _cutgumspeed; }
            set
            {
                if (cutgumspeed == value) return;
                _cutgumspeed = value;
                OnPropertyChanged(nameof(cutgumspeed));
            }
        }

        private int _divorcedgum_enable = 0;
        /// <summary>
        /// ÊÇ·ñ×öÇнº·ÖÀ붯×÷
        /// </summary>
        [SugarColumn(ColumnName = "divorcedgum_enable", IsIgnore = true)]
        [Description("ÊÇ·ñ×öÇнº·ÖÀ붯×÷")]
        public int divorcedgum_enable
        {
            get { return _divorcedgum_enable; }
            set
            {
                if (divorcedgum_enable == value) return;
                _divorcedgum_enable = value;
                OnPropertyChanged(nameof(divorcedgum_enable));
            }
        }

        private double _divorcedgum_xaxis = 0d;
        /// <summary>
        /// ·ÖÀ뽺ÌåxÖá°Ú¶¯¾àÀ룬mm
        /// </summary>
        [SugarColumn(ColumnName = "divorcedgum_xaxis", IsIgnore = true)]
        [Description("·ÖÀ뽺ÌåxÖá°Ú¶¯¾àÀ룬mm")]
        public double divorcedgum_xaxis
        {
            get { return _divorcedgum_xaxis; }
            set
            {
                if (divorcedgum_xaxis == value) return;
                _divorcedgum_xaxis = value;
                OnPropertyChanged(nameof(divorcedgum_xaxis));
            }
        }

        private double _divorcedgum_yaxis = 0d;
        /// <summary>
        /// ·ÖÀ뽺ÌåyÖá°Ú¶¯¾àÀ룬mm
        /// </summary>
        [SugarColumn(ColumnName = "divorcedgum_yaxis", IsIgnore = true)]
        [Description("·ÖÀ뽺ÌåyÖá°Ú¶¯¾àÀ룬mm")]
        public double divorcedgum_yaxis
        {
            get { return _divorcedgum_yaxis; }
            set
            {
                if (divorcedgum_xaxis == value) return;
                _divorcedgum_yaxis = value;
                OnPropertyChanged(nameof(divorcedgum_yaxis));
            }
        }

        public void Copy(Liquid liquid)
        {
            
        }
    }
}