public Task(TaskType type, Connection client = null, object args = null)
 {
     Type = type;
     _client = client;
     _args = args;
     Query = null;
 }

        public Task(string name, bool isimportant, bool ishard, int estimatetomato, 
            TaskType  tasktype, TaskPriority taskpri,
            TaskStatus taskstatus = TaskStatus.INQUEUE, DateTime? reminder = null)
        {
            this.name = name;
            this.isImportant = isimportant ? "important" : "not important";
            this.isHard = ishard ? "hard" : "easy";
            this.estimateToamto = estimatetomato;

            this.completeTomato = 0;
            this.incompleteTomato = 0;
            this.innerBreak = 0;
            this.outterBreak = 0;
            this.completeness = 0;
            this.difficulties = 0;
            this.satisfaction = 0;
            this.efficiency = 0;
            this.improvement = 0;
            this.achivement = 0;
            this.focusness = 0;

            this.taskStatus = taskstatus;
            this.taskType = tasktype;
            this.taskPriority = taskpri;
        }

 public WorkerTask(BackgroundWorker worker, TaskType task)
 {
     this.MyWorker = worker;
     this.Task = task;
     this.FileOrDirPaths = new List<string>();
     this.MediaOptions = new MediaWizardOptions();
 }

        public static AbstractTask CreateTaskByType(TaskType type)
        {
            if (type == TaskType.DefaultTask)
                return new DefaultTask();

            return null;
        }

 public Task(TaskType type, HTTPAgent.FileType fileType, long fileId, string fileTitle)
 {
     mType = type;
     mFileType = fileType;
     mFileId = fileId;
     mFileTitle = fileTitle;
 }

		public static int GetCount(TaskType type)
		{
			if (!taskCount.ContainsKey(type)) {
				return 0;
			}
			return taskCount[type];
		}

 /// <summary>
 /// 
 /// </summary>
 /// <param name="opcode"></param>
 /// <param name="type">消息的处理方法</param>
 /// <param name="taskType">任务分类</param>
 /// <param name="isVerifyLogin">是否进行登录验证，默认是进行的，只有登录等极少数的消息是不需要验证的</param>
 public NetMethodAttribute(ushort opcode, NetMethodType type, TaskType taskType, bool isVerifyLogin = true)
 {
     OpCode = opcode;
     MethodType = type;
     IsVerifyLogin = isVerifyLogin;
     TaskType = taskType;
 }

 public void AddTask(TaskType Type, object[] Args)
 {
     Task t = new Task(qu.Count, Type, Args);
     qu.Add(t);
     try { Changed(t); }
     catch { }
 }

 /// <summary>
 /// Létrehoz egy feladatot a megadott típussal és célponttal
 /// </summary>
 /// <param name="Type">A feladat típusa</param>
 /// <param name="Item">A feladat célpontja</param>
 public Task(TaskType Type, Items.ItemBase Item)
 {
     if (Type == TaskType.Any) { throw new ArgumentException("TaskType.Any cannot be used here"); }
     this.Type = Type;
     this.Item = Item;
     this.AssignedSince = Statistics.CurrentLoop;
 }

        void OnGUI()
        {
            type = (TaskType)EditorGUILayout.EnumPopup("Task Type", type);
            taskName = EditorGUILayout.TextField("Task Name", taskName);
            ns = EditorGUILayout.TextField("Namespace", ns);
            category = EditorGUILayout.TextField("Category(?)", category);
            description = EditorGUILayout.TextField("Description(?)", description);
            agentType = EditorGUILayout.TextField("Agent Type(?)", agentType);

            if (GUILayout.Button("CREATE")){

                if (string.IsNullOrEmpty(taskName)){
                    EditorUtility.DisplayDialog("Empty Task Name", "Please give the new task a name","OK");
                    return;
                }

                if (type == TaskType.Action)
                    CreateFile(GetActionTemplate());

                if (type == TaskType.Condition)
                    CreateFile(GetCoditionTemplate());

                taskName = "";
                GUIUtility.hotControl = 0;
                GUIUtility.keyboardControl = 0;
            }

            if (type == TaskType.Action)
                GUILayout.Label(GetActionTemplate());

            if (type == TaskType.Condition)
                GUILayout.Label(GetCoditionTemplate());
        }

 public Task(string name, string description, int priority, TaskType type)
 {
     _name = name;
     _description = description;
     _priority = priority;
     _type = type;
 }

        public bool addHeldPoints(TaskType type, int amount)
        {
            switch (type)
            {
                case TaskType.Attendance:
                    freezeInfo.attendanceScore += amount;
                    break;
                case TaskType.Cooperation:
                    freezeInfo.cooperationScore += amount;
                    break;
                case TaskType.CrossCurricular:
                    freezeInfo.crossCurricularScore += amount;
                    break;
                case TaskType.Puzzle:
                    freezeInfo.puzzleScore += amount;
                    break;
                case TaskType.Story:
                    freezeInfo.storyScore += amount;
                    break;
                default:
                    return false;
            }

            return true;
        }

 public TaskFromAsyncTest(TestParameters parameters)
 {
     _api = parameters.Api;
     _sourceType = parameters.SourceTaskType;
     _fromAsyncType = parameters.FromAsyncTaskType;
     _errorCase = parameters.ErrorCase;
     _overloadChoice = parameters.OverloadChoice;
 }

 public Task(TextBox textBox, string command, Label label, TaskType taskType, ref bool running)
 {
     TextBox = textBox;
     Command = command;
     Label = label;
     TaskType = taskType;
     Running = running;
 }

 public UpdateTaskCommand(int taskId, string name, TaskType type, TaskCategory category, int orderId)
 {
     this.taskId = taskId;
     this.name = name;
     this.type = type;
     this.category = category;
     this.orderId = orderId;
 }

 public static TaskType FromDTO(this DTO.TaskType source)
 {
     var h = new TaskType();
     h.TypeName = source.TypeName;
     if (source.AnyAttr != null)
         h.AnyAttr = source.AnyAttr.ToList();
     return h;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="iPacketID"></param>
 /// <param name="priority"></param>
 /// <param name="taskType"></param>
 /// <param name="onPacketReceive"></param>
 internal PacketHandler(ushort iPacketID, PacketPriority priority, TaskType taskType,
     PacketReceiveCallback onPacketReceive)
 {
     m_PacketID = iPacketID;
     m_PacketPriority = priority;
     m_OnReceive = onPacketReceive;
     m_TaskType = taskType;
 }

    private void FillControl()
    {
        postID = Request.QueryString["TaskID"];
        if (string.IsNullOrEmpty(postID))
        {
            Response.Redirect("default.aspx", true);
        }
        try
        {
            DataTable dt = taskDal.GetTaskByID(Convert.ToInt32(postID));
            if (dt.Rows.Count > 0)
            {
                DataRow row = dt.Rows[0];
                this.lblTitle.Text = row["Title"].ToString();
                this.lblContent.Text = row["Content"].ToString();
                this.lblCreateTime.Text = row["CreateTime"] == DBNull.Value ? "" : row["CreateTime"].ToString();
                this.lblComTime.Text = row["CompleteTime"] == DBNull.Value ? "" : row["CompleteTime"].ToString();
                hidTaskUser.Value = row["userid"] == DBNull.Value ? "" : row["userid"].ToString();
                string status = row["status"].ToString();
                string typeID = hidTypeID.Value = row["TypeID"] == DBNull.Value ? "0" : row["TypeID"].ToString();
                string processID = row["ProcessID"].ToString();
                lblStatus.Text = status;
                hidID.Value = postID;
                // ddlProcessType.ProcessingID = status;
                lblAuthor.Text = hidTaskUser.Value;
                if (this.lblComTime.Text.Length == 0)
                {
                    //this.lblComTime.Text = "not completed";
                }
                string attachment = row["FileName"] == DBNull.Value ? "" : row["FileName"].ToString();
                if (attachment.Length > 0)
                {
                    this.linkAttachment.Text = attachment;
                }
                TaskType t = new TaskType(typeID);
                if (t.TaskStatus != TaskType.Task.Task)
                {
                    this.lblStatusMessage.Visible = false;
                    this.lblStatus.Visible = false;
                    this.lblComTime.Visible = false;
                    lblCompleteTime.Visible = false;
                }

                foreach (ListItem il in this.ddlProcessType.Items)
                {
                    if (il.Value == processID)
                    {
                        il.Selected = true;
                        break;
                    }
                }
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(this, ex.Message);
        }
    }

 public void EditUserTaskProgress(Guid userId, TaskType type, int value)
 {
     Tasks task = _task.FirstOrDefault(X => X.UserId == userId && X.Type == type);
     if (task != null)
     {
         task.Progress = value;
         _uow.SaveChanges();
     }
 }

 public string CheckValidity(string message, TaskType taskType)
 {
     if (taskType == TaskType.Ping) {
         return CheckValidPing(message);
     } else if (taskType == TaskType.Dns) {
         return CheckValidDns(message);
     }
     return _statusBad;
 }