public MobileQueryPacket(StatusType type, Serial serial)
     : base(0x34, "Get Player Status", 10)
 {
     Stream.Write(0xEDEDEDED); // always 0xEDEDEDED in legacy client
     Stream.Write((byte)type);
     Stream.Write(serial);
 }

 public StatusChangedEventArgs(string oldText, StatusType oldType, string text, StatusType type)
 {
     this.OldText = oldText;
     this.OldType = oldType;
     this.Text = text;
     this.Type = type;
 }

        public OldTighteningResultUpload(Message message)
            : base(message)
        {
            string str = Data.Substring(2, 10);
            Int64 id = Int64.Parse(str.Trim());
            try {
                TighteningID = (UInt32)id;
            } catch {
                TighteningID = 0;
            }

            VIN = Data.Substring(14, 25);
            PSetNo = Convert.ToInt32(Data.Substring(41, 3));
            BatchCount = Convert.ToInt32(Data.Substring(46, 4));

            TorqueStatus = (StatusType)(int.Parse(Data.Substring(55, 1)));
            AngleStatus = (StatusType)(int.Parse(Data.Substring(58, 1)));
            Success = (TorqueStatus == StatusType.OK && AngleStatus == StatusType.OK);

            Torque = int.Parse(Data.Substring(61, 6)) / 100.0F;
            Angle = int.Parse(Data.Substring(69, 5));

            str = Data.Substring(76, 10);
            str += " ";
            str += Data.Substring(87, 8);
            Timestamp = Convert.ToDateTime(str);

            BatchStatus = (BatchStatusType)(Data[97] - 48);
        }

 void OnTriggerStay2D(Collider2D other)
 {
     if (other.gameObject.tag == "Player") {
         target = other.gameObject;
         currentStatus = StatusType.Trace;
     }
 }

 public override void RenderRow (IRenderContext context, int rowIndex, StatusType statusType, int width, int height)
 {
     if (statusType == StatusType.Normal && rowIndex % 2 != 0) {
         context.Theme.RenderRule (context.Context, width, height);
     }
     base.RenderRow (context, rowIndex, statusType);
 }

 /// <summary>
 /// New status for Event type
 /// </summary>
 /// <param name="tevent">Event type</param>
 /// <param name="tstatus">Execution status</param>
 public void add(SolutionEventType tevent, StatusType tstatus)
 {
     if(!states.ContainsKey(tevent)) {
         states[tevent] = new SynchronizedCollection<StatusType>();
     }
     states[tevent].Add(tstatus);
 }

        public void ThreadMain()
        {
            while (running)
            {
                try
                {
                    LastException = null;
                    type = StatusType.Running;
                    int toSleep = Run();
                    type = StatusType.Stopped;
                    Thread.Sleep(toSleep);
                }
                catch (Exception e)
                {
                    type = StatusType.Crashed;
                    LastException = e;
                    ExceptionTime = DateTime.Now;
                    if (!running)
                    {
                        break;
                    }
                    else
                    {
                        LogHelper.WriteLog(GetType().Name, e.ToString());
                        try
                        {

                            //Sleep a while to prevent fill the disk
                            Thread.Sleep(10000);
                        }
                        catch { }
                    }
                }
            }
        }

 /// <summary>
 /// Instantiates SigningCertificate with the parameterized properties
 /// </summary>
 /// <param name="userName">The name of the user the signing certificate is associated with.</param>
 /// <param name="certificateId">The ID for the signing certificate.</param>
 /// <param name="certificateBody">The contents of the signing certificate.</param>
 /// <param name="status">The status of the signing certificate. <code>Active</code> means the key is valid for API calls, while <code>Inactive</code> means it is not.</param>
 public SigningCertificate(string userName, string certificateId, string certificateBody, StatusType status)
 {
     _userName = userName;
     _certificateId = certificateId;
     _certificateBody = certificateBody;
     _status = status;
 }

        private static void UpdateCourseTopicAssignment(long? courseTopicAssignmentId, long? employeeCourseAssignmentId, int? courseTopicId, bool completed,
            StatusType section, int sequence)
        {

            DBHelper.ExecuteNonQuery(
                new SqlCommand()
                    .WithConnection(DBHelper.ConnectionString)
                    .ForProcedure("UpdateCourseTopicAssignment",
                        x => x.WithParam("@CourseTopicAssignmentID", courseTopicAssignmentId, id => id > 0)
                              .WithParam("@EmployeeCourseAssignmentID", employeeCourseAssignmentId, id => id > 0)
                              .WithParam("@CourseTopicID", courseTopicId, id => id > 0)
                              .WithParam("@Completed", completed)
                              .WithParam("@Started", (bool?)null)
                              .WithParam("@Notified", (bool?)null)
                              .WithParam("@Section", Translator.ToDBValue(section))
                              .WithParam("@SectionSequence", (byte)sequence)
                    ),
                true);
            //new SqlCommand(@"UpdateCourseTopicAssignment") { CommandType = CommandType.StoredProcedure },
            //new SqlParameter { ParameterName = "@CourseTopicAssignmentID", DbType = DbType.Int64, Value = ToParamValue(courseTopicAssignmentId, id => id > 0) },
            //new SqlParameter { ParameterName = "@EmployeeCourseAssignmentID", DbType = DbType.Int64, Value = ToParamValue(employeeCourseAssignmentId,id=>id>0) },
            //new SqlParameter { ParameterName = "@CourseTopicID", DbType = DbType.Int32, Value = OrDefault(courseTopicId,DBNull.Value,id=>id>0) },
            //new SqlParameter { ParameterName = "@Completed", DbType = DbType.Boolean, Value = completed },
            //new SqlParameter { ParameterName = "@Started", DbType = DbType.Boolean, Value = DBNull.Value },
            //new SqlParameter { ParameterName = "@Notified", DbType = DbType.Boolean, Value = DBNull.Value },
            //new SqlParameter { ParameterName = "@Section", DbType = DbType.String, Value = Translator.ToDBValue(section) },
            //new SqlParameter { ParameterName = "@SectionSequence", DbType = DbType.Byte, Value = sequence });
        }

 /// <summary>
 /// Instantiates AccessKey with the parameterized properties
 /// </summary>
 /// <param name="userName">Name of the user the key is associated with.</param>
 /// <param name="accessKeyId">The ID for this access key.</param>
 /// <param name="status">The status of the access key. <code>Active</code> means the key is valid for API calls, while <code>Inactive</code> means it is not.</param>
 /// <param name="secretAccessKey">The secret key used to sign requests.</param>
 public AccessKey(string userName, string accessKeyId, StatusType status, string secretAccessKey)
 {
     _userName = userName;
     _accessKeyId = accessKeyId;
     _status = status;
     _secretAccessKey = secretAccessKey;
 }

 void OnTriggerExit2D(Collider2D other)
 {
     if (other.gameObject.tag == "Player") {
         Patrol ();
         currentStatus = StatusType.Patrol;
     }
 }

 /// <summary>
 /// 类型：方法
 /// 名称：UserInfo
 /// 作者：taixihuase
 /// 作用：通过参数值构造 UserInfo 对象
 /// 编写日期：2015/7/12
 /// </summary>
 /// <param name="guid"></param>
 /// <param name="uniqueId"></param>
 /// <param name="account"></param>
 /// <param name="nickname"></param>
 /// <param name="status"></param>
 public UserInfo(Guid guid, string account, int uniqueId = -1, string nickname = "", StatusType status = StatusType.Default)
 {
     Guid = guid;
     UniqueId = uniqueId;
     Account = account;
     Nickname = nickname;
     Status = status;
 }

 public AgreementException(StatusType status, FaultType fault, CommonOutputType commonOutput, RecordCommonOutputType recordCommonOutput)
     : base(status.Code == "200" || status.Code == "400" ? fault.Message.Value : status.Message.Single().Value)
 {
     this.status = status;
     this.fault = fault;
     this.commonOutput = commonOutput;
     this.recordCommonOutput = recordCommonOutput;
 }

        public StatusText(GameObject obj, StatusType type, string text)
        {
            font = GameManager.TheGameManager.Font;

            this.type = type;
            this.text = text;
            this.owner = obj;
            this.Position = owner.Center;
        }

        public StatusText(Unit owner, StatusType type, string text)
        {
            font = GameManager.TheGameManager.defaultFont;

            this.type = type;
            this.text = text;
            this.owner = owner;
            this.Position = owner.Center;
        }

        public IList<StatusType> Select(StatusType data)
        {
            IList<StatusType> datos = new List<StatusType>();
            datos = GetHsql(data).List<StatusType>();
            if (!Factory.IsTransactional)
                Factory.Commit();
            return datos;

        }

        private string StatusToMessage(StatusType type)
        {
            var statusString = Helper.Translate("StatusType" + type.ToString());

            if (!string.IsNullOrEmpty(statusString))
                return statusString;

            return type.ToString();

        }

 /// <summary>
 /// Initializes a new instance of the <see cref="User"/> class.
 /// </summary>
 /// <param name="age">The age.</param>
 /// <param name="sexType">Type of the sex.</param>
 /// <param name="statusType">Type of the status.</param>
 /// <param name="applicationId">The application id.</param>
 /// <param name="version">The version.</param>
 public User(int age, SexType sexType,
     StatusType statusType, Guid applicationId, Guid sessionId, String version)
 {
     this.ApplicationId = applicationId;
     this.Version = version;
     this.Age = age;
     this.Sex = sexType;
     this.Status = statusType;
     this.DateCreated = DateTime.Now;
     this.SessionId = sessionId;
 }

        public void Read(string[] fields)
        {
            if (fields.Length != 13)
            {
                throw new InvalidDataException(string.Format("$GPRMC sentence needs to have 13 fields, but {0} were found.", fields.Length));
            }

            int n = 0;

            if (fields[n] != "$GPRMC")
                throw new InvalidDataException(string.Format("Expected \"$GPRMC\", found \"{0}\"", fields[n]));
            n++;

            TimeSpan time = ParseTime(fields[n]);
            n++;

            if (fields[n] == "A")
                Status = StatusType.Active;
            else if (fields[n] == "V")
                Status = StatusType.Void;
            else
                throw new InvalidDataException(string.Format("Unknown status \"{0}\"", fields[n]));
            n++;

            Latitude = ParseLatitude(fields[n], fields[n + 1]);
            n += 2;

            Longitude = ParseLongitude(fields[n], fields[n + 1]);
            n += 2;

            double speed;
            if (double.TryParse(fields[n], out speed))
                GroundSpeedKnots = speed;
            n++;

            double angle;
            if (double.TryParse(fields[n], out angle))
                TrackAngle = angle;
            n++;

            int day = int.Parse(fields[n].Substring(0, 2));
            int month = int.Parse(fields[n].Substring(2, 2));
            int year = int.Parse(fields[n].Substring(4, 2));

            if (year > 90)
                year += 1900;
            else
                year += 2000;

            DateTime = new DateTime(year, month, day, time.Hours, time.Minutes, time.Seconds, time.Milliseconds, DateTimeKind.Utc);

            //Magnetic variation not implemented
            //Fix kind not implemented
        }

 public static char ToDBValue(StatusType section)
 {
     switch (section)
     {
         case StatusType.Presenting:
             return 'P';
         case StatusType.Testing:
             return 'T';
     }
     return 'P';  //This is for the compiler because this will never execute, but the compiler thinks that not all code paths return a value even though they do.
 }