工事管理システム製品化対応

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

    <startup> 

        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

    </startup>

</configuration>

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Diagnostics;

using System.Windows.Forms;

using System.Drawing;

using System.IO;

using System.Text.RegularExpressions;

using System.Data;

using System.Security.Cryptography;

using System.Globalization;

using System.Runtime.InteropServices;

using System.Collections;

using Microsoft.VisualBasic; //for StrConv

using log4net;

using log4net.Appender;

using log4net.Repository.Hierarchy;

using ProcessManagement.DataModel;

using ProcessManagement.DB.IOAccess;

namespace ProcessManagement.Common

{

    /// <summary>

    /// 工事管理システム共通クラス

    /// </summary>

    public static class CommonMotions

    {

        #region 定義部

        /// <summary>

        /// log4netログを使用する

        /// </summary>

        private static readonly ILog logger = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

        #endregion

        #region 変数

        /// <summary>

        /// 定義ファイル読込クラス定義

        /// </summary>

        //private static DefinitionFileRead m_dfr_model = null;

        /// <summary>

        /// 管理マスタデータ保持領域

        /// </summary>

        private static SystemMaster m_systemMaster = new SystemMaster();

        /// <summary>

        /// ログインユーザー担当者データ

        /// </summary>

        private static PersonInChargeMaster m_LoginUserData = new PersonInChargeMaster();

        /// <summary>

        /// ログインユーザー参照部署データ

        /// </summary>

        private static List<PersonDepartmentMaster> m_LoginUserDepartment = new List<PersonDepartmentMaster>();

        /// <summary>

        /// ログインユーザーセキュリティ区分

        /// </summary>

        private static SecurityMaster m_LoginUserSecurity = new SecurityMaster();

        /// <summary>

        /// ログインユーザー処理起動区分

        /// </summary>

        private static List<ProcessExcute> m_LoginUserProcExe = new List<ProcessExcute>();

        /// <summary>

        /// システム初回起動チェック処理クラス

        /// </summary>

        //private static ClsSystemOnceExecute m_CheckProc = null;

        /// <summary>

        /// 製品ファイルバージョン格納エリア

        /// </summary>

        private static FileVersionInfo m_ProductVersionInfo = FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);

        #endregion

        #region コンストラクタ

        /// <summary>

        /// 何もしない

        /// </summary>

        #endregion

        #region プロパティ

        /// <summary>

        /// 本稼働フラグ

        /// </summary>

        public static bool ProductionExecution

        {

            get { return CommonDefine.m_ProductionExecution; }

        }

        /// <summary>

        /// 定義ファイル読込クラス

        /// </summary>

        //public static DefinitionFileRead DFRModel

        //{

        //    get { return m_dfr_model; }

        //}

        /// <summary>

        /// 管理マスタデータ

        /// </summary>

        public static SystemMaster SystemMasterData

        {

            get { return m_systemMaster; }

            set { m_systemMaster = value; }

        }

        /// <summary>

        /// ログインユーザー担当者データ

        /// </summary>

        public static PersonInChargeMaster LoginUserData

        {

            get { return m_LoginUserData; }

            set { m_LoginUserData = value; }

        }

        /// <summary>

        /// ログインユーザー参照部署データ

        /// </summary>

        public static List<PersonDepartmentMaster> LoginUserDepartment

        {

            get { return m_LoginUserDepartment; }

            set { m_LoginUserDepartment = value; }

        }

        /// <summary>

        /// ログインユーザーセキュリティ区分

        /// </summary>

        public static SecurityMaster LoginUserSecurity

        {

            get { return m_LoginUserSecurity; }

            set { m_LoginUserSecurity = value; }

        }

        /// <summary>

        /// ログインユーザー処理起動区分

        /// </summary>

        public static List<ProcessExcute> LoginUserProcExe

        {

            get { return m_LoginUserProcExe; }

            set { m_LoginUserProcExe = value; }

        }

        /// <summary>

        /// 製品ファイルバージョン格納エリア

        /// </summary>

        public static FileVersionInfo ProductVersionInfo

        {

            get { return m_ProductVersionInfo; }

        }

        /// <summary>

        /// システム起動チェック処理クラス

        /// </summary>

        //public static ClsSystemOnceExecute CheckProc

        //{

        //    get { return m_CheckProc; }

        //}

        #endregion

        #region 初期化

        /// <summary>

        /// 初期化

        /// </summary>

        //public static void Initialize()

        //{

        //    try

        //    {

        //        // 定義ファイル読込

        //        DefinitionFileInit();

        //        // 他共通クラス初期化

        //        DBCommon.Instance.Initialize();

        //        // 管理マスタ取得

        //        SetSystemMaster();

        //        // 起動チェッククラス初期化

        //        m_CheckProc = new ClsSystemOnceExecute();

        //    }

        //    catch (Exception ex)

        //    {

        //        logger.ErrorFormat("初期化エラー:{0}：{1}", GetMethodName(), ex.Message);

        //    }

        //}

        #endregion

        #region 定義ファイル読込

        ///// <summary>

        ///// 定義ファイル読込

        ///// </summary>

        //private static void DefinitionFileInit()

        //{

        //    try

        //    {

        //        //定義ファイル読込

        //        System.IO.FileStream fs = new System.IO.FileStream(CommonDefine.s_DefinitionFileName, System.IO.FileMode.Open);

        //        System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(DefinitionFileRead));

        //        m_dfr_model = (DefinitionFileRead)serializer.Deserialize(fs);

        //    }

        //    catch (Exception ex)

        //    {

        //        logger.ErrorFormat("定義ファイル読込エラー:{0}：{1}", GetMethodName(), ex.Message);

        //    }

        //}

        #endregion

        #region 管理マスタ取得

        /// <summary>

        /// 管理マスタ取得

        /// </summary>

        public static bool SetSystemMaster()

        {

            // 管理マスタクラス

            IOMSystem ocDB = new IOMSystem();

            try

            {

                // 管理マスタ取得

                // １レコードだけなので取り出す

                string strSQL = " Where SystemCode = 1";

                if (!ocDB.SelectAction(strSQL, ref m_systemMaster)) return false;

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return false;

            }

            finally

            {

                ocDB.close(); ocDB = null;

            }

        }

        #endregion

        #region メソッド名を取得する

        /// <summary>

        /// メソッド名を取得する

        /// </summary>

        /// <param name="StackCnt"></param>

        /// <returns></returns>

        public static string GetMethodName(int stackCnt = 1)

        {

            try

            {

                StringBuilder sb = new StringBuilder();

                // 一つ前のスタック情報

                StackFrame stackFrame = new StackFrame(stackCnt);

                // 呼び出し元メソッドの情報出力

                System.Reflection.MethodBase method = stackFrame.GetMethod();

                // Method取得失敗は戻る

                if (method == null) return string.Empty;

                // 正しく取得できているかの判定

                if (method.DeclaringType != null && !string.IsNullOrEmpty(method.DeclaringType.Name))

                {

                    // 型名

                    sb.AppendFormat("[TYPE]{0}", method.DeclaringType.Name);

                }

                if (!string.IsNullOrEmpty(method.Name))

                {

                    // 編集済みの場合は区切りを入れる

                    if (0 < sb.Length) sb.Append('/');

                    // メソッド名

                    sb.AppendFormat("[METHOD]{0}", method.Name);

                }

                return sb.ToString();

            }

            catch (Exception ex)

            {

                logger.ErrorFormat(ex.Message);

            }

            return string.Empty;

        }

        #endregion

        #region 日付より年を取得する

        /// <summary>

        /// 日付より年を取得する

        /// </summary>

        /// <returns></returns>

        public static int DateToPeriodYear(DateTime TargetDate)

        {

            try

            {

                // 今の年を取得する

                int iYear = DateTime.Now.Year;

                // 今年の期首日を取得する

                DateTime BeginninDate = DateTime.Parse(iYear.ToString() + "/" + CommonMotions.SystemMasterData.BusinessBeginningDate);

                // 日付を今年の期首日と比較して小さい場合は今の年より-1して期首年を求める

                if (TargetDate.Date < BeginninDate.Date)

                    --iYear;

                return iYear;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 期数から期の年を取得する

        /// <summary>

        /// 期数から期の年を取得する

        /// </summary>

        /// <param name="PeriodCount"></param>

        /// <returns></returns>

        public static int PeriodCountToYear(int PeriodCount)

        {

            try

            {

                // 今の年を取得する

                int iYear = DateTime.Now.Year;

                // 今年の期首日を取得する

                DateTime BeginninDate = DateTime.Parse(iYear.ToString() + "/" + CommonMotions.SystemMasterData.BusinessBeginningDate);

                // 今日を今年の期首日と比較して小さい場合は今の年より-1して期首年を求める

                if (DateTime.Now.Date < BeginninDate.Date)

                    --iYear;

                // 管理マスタの期数と比較して年を計算する

                if (PeriodCount < CommonMotions.SystemMasterData.BusinessPeriod)

                {

                    iYear -= (CommonMotions.SystemMasterData.BusinessPeriod - PeriodCount);

                }

                else if (PeriodCount > CommonMotions.SystemMasterData.BusinessPeriod)

                {

                    iYear += (PeriodCount - CommonMotions.SystemMasterData.BusinessPeriod);

                }

                return iYear;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 期の最大・最少を取得する

        /// <summary>

        /// 期の最大・最少を取得する

        /// </summary>

        /// <param name="StartDate"></param>

        /// <returns></returns>

        public static void GetPeriodYear(ref int min, ref int max)

        {

            IOConstructionBaseInfo cbiDB = new IOConstructionBaseInfo();

            try

            {

                string strSQL = "SELECT MIN(CONSTRUCTIONPERIOD), MAX(CONSTRUCTIONPERIOD) FROM CONSTRUCTIONBASEINFO";

                ArrayList arList = new ArrayList();

                if (!cbiDB.ExecuteReader(strSQL, ref arList)) return;

                object[] wrkobj = (object[])arList[0];

                min = cnvInt(wrkobj[0]);

                max = cnvInt(wrkobj[1]);

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

            }

            finally

            {

                cbiDB.close(); cbiDB = null;

            }

        }

        #endregion

        #region データ変換メソッド

        #region 西暦を和暦に変換する

        /// <summary>

        /// 西暦を和暦に変換する

        /// </summary>

        /// <returns></returns>

        public static string cnvJapaneseCalendar(DateTime Terget)

        {

            try

            {

                CultureInfo culture = new CultureInfo("ja-JP", true);

                culture.DateTimeFormat.Calendar = new JapaneseCalendar();

                return Terget.ToString("ggyy年M月d日", culture);

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return string.Empty;

            }

        }

        #endregion

        #region 今の年号を取得する

        /// <summary>

        /// 今の年号を取得する

        /// </summary>

        /// <returns></returns>

        public static string GetNameOfAnEra(DateTime TargetDate)

        {

            try

            {

                string strRet = string.Empty;

                CultureInfo culture = new CultureInfo("ja-JP", true);

                culture.DateTimeFormat.Calendar = new JapaneseCalendar();

                string result = TargetDate.ToString("ggyy年M月d日", culture);

                int strLength = 0;

                foreach (char c in result)

                {

                    if (char.IsNumber(c)) break;

                    strLength++;

                }

                strRet = result.Substring(0, strLength);

                return strRet;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return string.Empty;

            }

        }

        #endregion

        #region Int値より文字列に変化して指定位置に指定文字を入れる。(工事番号編集)

        /// <summary>

        /// Int値より文字列に変化して指定位置に指定文字を入れる。

        /// </summary>

        /// <param name="strCode"></param>

        /// <returns></returns>

        public static string cnvStringCodeFromInt(int IntCode, string strCode, int iPoint)

        {

            try

            {

                // 文字列変換

                string strWork = IntCode.ToString();

                // 指定位置が文字列長を超えている場合はエラー

                if (strWork.Length <= iPoint) return string.Empty;

                // 文字挿入

                strWork = strWork.Substring(0, iPoint) + strCode + strWork.Substring(iPoint);

                return strWork;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return string.Empty;

            }

        }

        #endregion

        #region 文字列より指定文字を除去してInt値に変換する

        /// <summary>

        /// 文字列より指定文字を除去してInt値に変換する

        /// </summary>

        /// <param name="strCode"></param>

        /// <returns></returns>

        public static int cnvIntFromStringCode(string strCode, string strRemove)

        {

            try

            {

                // 文字列除去後変換

                return cnvInt(strCode.Replace(strRemove, ""));

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 日付返還変換

        /// <summary>

        /// 日付返還変換

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static DateTime cnvDate(object sendData)

        {

            DateTime dtDateWork = DateTime.MinValue;

            try

            {

                // 空判定

                if (sendData == null) return dtDateWork;

                if (sendData.ToString().Length == 0) return dtDateWork;

                // 変換

                bool bRet = DateTime.TryParse(sendData.ToString(), out dtDateWork);

                return dtDateWork;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return dtDateWork;

            }

        }

        #endregion

        #region 文字列より数値変換（long）

        /// <summary>

        /// 文字列より数値変換（long）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static long cnvLong(object sendData)

        {

            try

            {

                long retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                long.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 文字列より数値変換（int）

        /// <summary>

        /// 文字列より数値変換（int）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static int cnvInt(object sendData)

        {

            try

            {

                int retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                int.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 文字列より数値変換（string）

        /// <summary>

        /// 文字列より数値変換（string）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static string cnvString(object sendData)

        {

            try

            {

                string retData = string.Empty;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                retData = sendData.ToString(); 

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return "";

            }

        }

        #endregion

        #region 文字列より数値変換（double）

        /// <summary>

        /// 文字列より数値変換（double）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static double cnvDouble(object sendData)

        {

            try

            {

                double retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                double.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 文字列より数値変換（float）

        /// <summary>

        /// 文字列より数値変換（float）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static float cnvFloat(object sendData)

        {

            try

            {

                float retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                float.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 文字列より数値変換（decimal）

        /// <summary>

        /// 文字列より数値変換（decimal）

        /// </summary>

        /// <param name="sendData"></param>

        /// <returns></returns>

        public static decimal cnvDecimal(object sendData)

        {

            try

            {

                decimal retData = 0;

                // 空判定

                if (sendData == null) return retData;

                if (sendData.ToString().Trim().Length == 0) return retData;

                // 変換

                decimal.TryParse(sendData.ToString().Replace(",", "").Replace("\\", "").Trim(), out retData);

                return retData;

            }

            catch (System.Exception ex)

            {

                Console.WriteLine("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region 四捨五入

        /// <summary>

        /// 四捨五入

        /// </summary>

        /// <param name="InputData"></param>

        /// <returns></returns>

        public static int cnvRound(double InputData)

        {

            int retRoundData = 0;

            try

            {

                retRoundData = (int)Math.Round(InputData, MidpointRounding.AwayFromZero);

                return retRoundData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return retRoundData;

            }

        }

        #endregion

        #region 切り上げ

        /// <summary>

        /// 切り上げ

        /// </summary>

        /// <param name="InputData"></param>

        /// <returns></returns>

        public static int cnvRoundUp(double InputData)

        {

            int retRoundData = 0;

            try

            {

                retRoundData = (int)Math.Ceiling(InputData);

                return retRoundData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return retRoundData;

            }

        }

        #endregion

        #region 切り捨て

        /// <summary>

        /// 切り捨て

        /// </summary>

        /// <param name="InputData"></param>

        /// <returns></returns>

        public static int cnvTruncate(double InputData)

        {

            int retRoundData = 0;

            try

            {

                retRoundData = (int)Math.Truncate(InputData);

                return retRoundData;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return retRoundData;

            }

        }

        #endregion

        #region 四捨五入（四捨五入位置指定）

        /// <summary>

        /// 四捨五入（四捨五入位置指定）

        /// </summary>

        /// <param name="value"></param>

        /// <param name="pos"></param>

        /// <returns></returns>

        public static int IntRound(double value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, (pos + 1));

            int upperval = (int)(value / posion);

            upperval *= posion;

            int lowerval = (int)(value % posion);

            int chkval = (int)(lowerval / Math.Pow(10, pos));

            if (chkval > 4) upperval += (1 * posion);

            return upperval;

        }

        #endregion

        #region 切り捨て（切り捨て位置指定）

        /// <summary>

        /// 切り捨て（切り捨て位置指定）

        /// </summary>

        /// <param name="value"></param>

        /// <param name="pos"></param>

        /// <returns></returns>

        public static int IntRoundDown(double value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, (pos + 1));

            int upperval = (int)(value / posion);

            upperval *= posion;

            return upperval;

        }

        #endregion

        #region 切り上げ（切り上げ位置指定）

        /// <summary>

        /// 切り上げ（切り上げ位置指定）

        /// </summary>

        /// <param name="value"></param>

        /// <param name="pos"></param>

        /// <returns></returns>

        public static int IntRoundUp(double value, int pos)

        {

            // 何乗かを求める

            int posion = (int)Math.Pow(10, (pos + 1));

            int upperval = (int)(value / posion);

            upperval *= posion;

            int lowerval = (int)(value % posion);

            int chkval = (int)(lowerval / Math.Pow(10, pos));

            if (chkval > 0) upperval += (1 * posion);

            return upperval;

        }

        #endregion

        #region 0～26までの数字をA～Zに変換する

        /// <summary>

        /// 0～26までの数字をA～Zに変換する

        /// </summary>

        /// <param name="num"></param>

        /// <returns></returns>

        public static string cnvNumberToAlphaCharacter(int num)

        {

            try

            {

                // ----- 16進数文字列 -> 数値

                int CnvCode = Convert.ToInt32("0041", 16);      // 'A'

                int LastCode = Convert.ToInt32("005A", 16);     // 'Z'

                // 'Z'を超えたら余剰を使って変換する

                int work = (CnvCode + num);

                if (work <= LastCode)

                {

                    // 変換値を加算する

                    CnvCode += num;

                }

                else

                {

                    CnvCode += (work % LastCode);

                }

                // 'Z'を超えたら採番しない

                //if (CnvCode > LastCode) return string.Empty;

                // 数値(文字コード) -> 文字

                char c = Convert.ToChar(CnvCode);

                // 英字「文字列」

                string newChar = c.ToString();

                return newChar;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return "";

            }

        }

        #endregion

        #region 日付が最小値ならば"未定"文字を返す

        /// <summary>

        /// 日付が最小値ならば"未定"文字を返す

        /// </summary>

        /// <param name="srcDate"></param>

        /// <returns></returns>

        public static string cnvDateToUndecidedString(DateTime srcDate)

        {

            try

            {

                string work = "";

                if (srcDate.Equals(DateTime.MinValue))

                    work = CommonDefine.s_UndecidedString;

                else

                    work = srcDate.ToShortDateString();

                return work;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return "";

            }

        }

        #endregion

        #region 文字列から日付を返す（文字列が"未定"文字ならば日付最小値を返す）

        /// <summary>

        /// 文字列から日付を返す

        /// 文字列が"未定"文字ならば日付最小値を返す

        /// </summary>

        /// <param name="srcDate"></param>

        /// <returns></returns>

        public static DateTime cnvUndecidedStringToDate(object srcDate)

        {

            DateTime work = DateTime.MinValue;

            try

            {

                if (!srcDate.Equals(CommonDefine.s_UndecidedString))

                    work = cnvDate(srcDate);

                return work;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return work;

            }

        }

        #endregion

        #region 文字列から数値（文字列が"未定"文字ならば0を返す）

        /// <summary>

        /// 文字列から数値

        /// 文字列が"未定"文字ならば0を返す

        /// </summary>

        /// <param name="srcDate"></param>

        /// <returns></returns>

        public static double cnvUndecidedStringToDouble(object srcDate)

        {

            double work = 0;

            try

            {

                if (!srcDate.Equals(CommonDefine.s_UndecidedString))

                    work = cnvDouble(srcDate);

                return work;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return work;

            }

        }

        #endregion

        #region 色指定文字列より色を返す

        /// <summary>

        /// 色指定文字列より色を返す

        /// </summary>

        /// <param name="strColor"></param>

        /// <returns></returns>

        public static Color cnvStringToColor(string strColor)

        {

            Color ColorRet = Color.White;

            try

            {

                // 色文字列チェック

                if (!CommonMotions.chkObjectIsNull(strColor) && strColor.Length != 0)

                {

                    ColorRet = ColorTranslator.FromHtml(strColor);

                }

                return ColorRet;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return ColorRet;

            }

        }

        #endregion

        #region 色指定文字列より色を返す・設定無しは指定場所のデフォルトを返す

        /// <summary>

        /// 色指定文字列より色を返す・設定無しは指定場所のデフォルトを返す

        /// </summary>

        /// <param name="strColor"></param>

        /// <param name="point"></param>

        /// <returns></returns>

        public static Color getBackForeColor(string strColor, CommonDefine.PalceOfColor point)

        {

            Color ColorRet = Color.White;

            try

            {

                // デフォルトセット

                if (point == CommonDefine.PalceOfColor.BackColor)

                {   // 背景

                    ColorRet = Color.White;

                }

                else if (point == CommonDefine.PalceOfColor.ForeColor)

                {   // 文字色

                    ColorRet = Color.Black;

                }

                else

                {

                    ColorRet = Color.Transparent;

                }

                if (!chkObjectIsNull(strColor) && strColor.Length != 0)

                {

                }

                else

                {

                    strColor = String.Format("0x{0:X2}{1:X2}{2:X2}", ColorRet.R, ColorRet.G, ColorRet.B);

                }

                ColorRet = cnvStringToColor(strColor);

                return ColorRet;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return ColorRet;

            }

        }

        #endregion

        #region 補色を取得する

        /// <summary>

        /// 補色を取得する

        /// </summary>

        /// <param name="color"></param>

        /// <returns></returns>

        public static Color GetComplementaryColor(Color color)

        {

            try

            {

                byte r = (byte)~color.R;

                byte g = (byte)~color.G;

                byte b = (byte)~color.B;

                return Color.FromArgb(r, g, b);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return color;

            }

        }

        #endregion

        #region 指定桁数の数値最大値を返す

        /// <summary>

        /// 指定桁数の数値最大値を返す

        /// </summary>

        /// <param name="NumLen"></param>

        /// <returns></returns>

        public static int CreateMaxNumeric(int NumLen)

        {

            try 

            {

                string strNum = string.Empty;

                for (int i = 0; i < NumLen; i++)

                {

                    strNum += "9";

                }

                return cnvInt(strNum);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return 0;

            }

        }

        #endregion

        #region オブジェクト配列の指定位置よりInt値を取得する

        /// <summary>

        /// オブジェクト配列の指定位置よりInt値を取得する

        /// </summary>

        /// <param name="objArrary"></param>

        /// <param name="DataCnt"></param>

        /// <returns></returns>

        public static int ObjectToInt(object[] objArrary, int DataCnt)

        {

            int iRet = 0;

            try

            {

                iRet = CommonMotions.cnvInt(objArrary[DataCnt]);

                return iRet;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return iRet;

            }

        }

        #endregion

        #region オブジェクト配列の指定位置よりString値を取得する

        /// <summary>

        /// オブジェクト配列の指定位置よりString値を取得する

        /// </summary>

        /// <param name="objArrary"></param>

        /// <param name="DataCnt"></param>

        /// <returns></returns>

        public static string ObjectToString(object[] objArrary, int DataCnt)

        {

            string strRet = string.Empty;

            try

            {

                strRet = CommonMotions.cnvString(objArrary[DataCnt]);

                return strRet;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return strRet;

            }

        }

        #endregion

        #region オブジェクト配列の指定位置よりDateTime値を取得する

        /// <summary>

        /// オブジェクト配列の指定位置よりDateTime値を取得する

        /// </summary>

        /// <param name="objArrary"></param>

        /// <param name="DataCnt"></param>

        /// <returns></returns>

        public static DateTime ObjectToDateTime(object[] objArrary, int DataCnt)

        {

            DateTime dtRet = DateTime.Now;

            try

            {

                dtRet = CommonMotions.cnvDate(objArrary[DataCnt]);

                return dtRet;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return dtRet;

            }

        }

        #endregion

        #region オブジェクト配列の指定位置よりdouble値を取得する

        /// <summary>

        /// オブジェクト配列の指定位置よりdouble値を取得する

        /// </summary>

        /// <param name="objArrary"></param>

        /// <param name="DataCnt"></param>

        /// <returns></returns>

        public static double ObjectToDouble(object[] objArrary, int DataCnt)

        {

            double dRet = 0;

            try

            {

                dRet = CommonMotions.cnvDouble(objArrary[DataCnt]);

                return dRet;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);

                return dRet;

            }

        }

        #endregion

        #endregion

        #region データチェックメソッド

        #region ディレクトリの存在チェック

        /// <summary>

        /// ディレクトリの存在チェック

        /// </summary>

        /// <param name="DirectryName">フォルダパス</param>

        /// <returns></returns>

        public static bool ChkDirPath(string DirectryName, bool CreateFlg = false)

        {

            try

            {

                // フォルダ (ディレクトリ) が存在しているかどうか確認する

                if (!Directory.Exists(@DirectryName))

                {

                    // 作成フラグOffならばエラー

                    if (!CreateFlg) return false;

                    // ディレクトリを作成する

                    Directory.CreateDirectory(@DirectryName);

                }

                return true;

            }

            catch (Exception ex)

            {

                logger.ErrorFormat(ex.Message);

                return false;

            }

        }

        #endregion

        #region オブジェクトのNullチェック

        /// <summary>

        /// オブジェクトのNullチェック

        /// </summary>

        /// <param name="sendData">オブジェクト</param>

        /// <returns></returns>

        public static bool chkObjectIsNull(Object sendData)

        {

            try

            {

                if (sendData == null) return true;

                return false;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック

        /// <summary>

        /// 数値チェック

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object CheckData, bool indispensable = false)

        {

            try

            {

                if (chkObjectIsNull(CheckData)) return false;

                string RecvData = cnvString(CheckData);

                double revData = 0;

                // 必須入力チェック

                if (indispensable)

                {

                    if (RecvData.Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                // Nullが入っていなくてレングスが0は数値として扱う

                if (RecvData.Replace(",", "").Replace("\\", "").Trim().Length == 0) return true;

                return double.TryParse(RecvData.Replace(",", "").Replace("\\", "").Trim(), out revData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック（long）

        /// <summary>

        /// 数値チェック（long）

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object sendData, ref long retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                return long.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック（int）

        /// <summary>

        /// 数値チェック（int）

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object sendData, ref int retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                return int.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 数値チェック（double）

        /// <summary>

        /// 数値チェック（double）

        /// </summary>

        /// <param name="data">Long文字列</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkNumeric(object sendData, ref double retData, bool indispensable = false)

        {

            try

            {

                // 必須入力チェック

                if (indispensable)

                {

                    if (cnvString(sendData).Replace(",", "").Replace("\\", "").Trim().Length == 0) return false;

                }

                return double.TryParse(cnvString(sendData).Replace(",", "").Replace("\\", "").Trim(), out retData);

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                return false;

            }

        }

        #endregion

        #region 文字列長さチェック（UTF-8）

        /// <summary>

        /// 文字列長さチェック（UTF-8）

        /// </summary>

        /// <param name="strData">対象文字列</param>

        /// <param name="lngMaxLen">最大長</param>

        /// <param name="indispensable">入力必須チェック</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkStringLength(string strData, int lngMaxLen, bool indispensable = false)

        {

            bool bRet = true;

            //int lngLen = 0;

            try

            {

                //Encoding sjis = Encoding.GetEncoding("shift-jis");

                Encoding utf8 = Encoding.GetEncoding("utf-8");

                // 必須入力チェック

                if (indispensable)

                {

                    if (strData.Length == 0) bRet = false;

                }

                // S-Jisチェック

                //lngLen = sjis.GetByteCount(strData);

                // UTF-8チェック

                //lngLen = utf8.GetByteCount(strData);

                //if (lngLen > lngMaxLen) bRet = false;

                // C#内はUTFなので文字長だけをチェックする

                if (strData.Length > lngMaxLen) bRet = false;

            }

            catch (System.Exception ex)

            {

                logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);

                bRet = false;

            }

            return bRet;

        }

        #endregion

        #region 郵便番号チェック

        /// <summary>

        /// 郵便番号チェック

        /// </summary>

        /// <param name="strData">郵便番号文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkZipcode(string strdata)

        {

            bool bRet = false;

            Regex regex = new Regex("^[0-9]{3}[-][0-9]{4}$");

            if (regex.IsMatch(strdata))

            {

                bRet = true;

            }

            return bRet;

        }

        #endregion

        #region 電話番号/ＦＡＸ番号チェック

        /// <summary>

        /// 電話番号/ＦＡＸ番号チェック

        /// </summary>

        /// <param name="data">電話番号文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkPhoneNumber(string strdata)

        {

            bool bRet = false;

            Regex regex = new Regex("^[0-9]{2,5}-[0-9]{1,4}-[0-9]{3,4}$");

            if (regex.IsMatch(strdata))

            {

                bRet = true;

            }

            return bRet;

        }

        #endregion

        #region メールアドレスチェック

        /// <summary>

        /// メールアドレスチェック

        /// </summary>

        /// <param name="data">電話番号文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkMailAddress(string strdata)

        {

            bool bRet = false;

            Regex regex = new Regex(@"\A\P{Cc}+@\P{Cc}+\z");

            if (regex.IsMatch(strdata))

            {

                bRet = true;

            }

            return bRet;

        }

        #endregion

        #region 日付チェック

        /// <summary>

        /// 日付チェック

        /// </summary>

        /// <param name="data">日付文字列</param>

        /// <returns>true:正常 false:異常</returns>

        public static bool chkDate(string strdata)

        {

            bool bRet = true;

            try

            {

                DateTime dtwork = DateTime.MinValue;

                return DateTime.TryParse(strdata, out dtwork);

            }

            catch (System.Exception ex)

            {

                logger.DebugFormat("chkDate Error message:{0}", ex.Message);

                bRet = false;

            }

            return bRet;

        }

        #endregion

        #region 対象が空かどうかをチェックする

        /// <summary>

        /// 対象が空かどうかをチェックする

        /// </summary>

        /// <param name="objCell"></param>

        /// <param name="iColumn"></param>

        /// <returns>true:空　flase:有効</returns>

        public static bool chkCellBlank(object objCell)

        {

            try

            {

                if (chkObjectIsNull(objCell)) return true;

                if (objCell.ToString().Length == 0) return true;

                return false;

            }

            catch (System.Exception ex)

            {

                logger.DebugFormat("chkDate Error message:{0}", ex.Message);

                return true;

            }

        }

        #endregion

        #region 画面フィールド入力必須チェック

        /// <summary>

        /// 画面フィールド入力必須チェック

        /// </summary>