/trunk/src/ProcessManagement/ProcessManagement/Common/CommonMotions.cs - 工事管理システム製品化対応 - Redmine

h-you / trunk / src / ProcessManagement / ProcessManagement / Common / CommonMotions.cs @ 485

       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.DB.Core;
       using ProcessManagement.DataModel;
       using ProcessManagement.DB.IOAccess;
       using ProcessManagement.Forms.CustomControls;
       using ProcessManagement.Forms.DataEntry;
       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 List<ConsumptionTax> m_ConsumptionTax = new List<ConsumptionTax>();
               /// <summary>
               /// ログインユーザー担当者データ
               /// </summary>
               private static PersonInChargeMaster m_LoginUserData = new PersonInChargeMaster();
               /// <summary>
               /// ログインユーザー参照部署データ
               /// </summary>
               private static List<PersonDepartmentMaster> m_LoginUserRefDepartment = 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 FileVersionInfo m_ProductVersionInfo = FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);
               /// <summary>
               /// RGBカラーテーブル
               /// </summary>
               private static Color[] m_RGBColor = new Color[256];
               #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 List<ConsumptionTax> ConsumptionTax
+              {
                   get { return m_ConsumptionTax; }
                   set { m_ConsumptionTax = value; }
+              }
               /// <summary>
               /// ログインユーザー担当者データ
               /// </summary>
               public static PersonInChargeMaster LoginUserData
+              {
                   get { return m_LoginUserData; }
                   set { m_LoginUserData = value; }
+              }
               /// <summary>
               /// ログインユーザー参照部署データ
               /// </summary>
               public static List<PersonDepartmentMaster> LoginUserRefDepartment
+              {
                   get { return m_LoginUserRefDepartment; }
                   set { m_LoginUserRefDepartment = 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>
               /// RGBカラーテーブル
               /// </summary>
               public static Color[] RGBColor
+              {
                   get { return m_RGBColor; }
                   set { m_RGBColor = value; }
+              }
               /// <summary>
               /// 製品ファイルバージョン格納エリア
               /// </summary>
               public static FileVersionInfo ProductVersionInfo
+              {
                   get { return m_ProductVersionInfo; }
+              }
               #endregion
               #region 初期化
               /// <summary>
               /// 初期化
               /// </summary>
               public static bool Initialize()
+              {
                   try
+                  {
                       // 定義ファイル読込
                       DefinitionFileInit();
                       // ----- 他共通クラス初期化
                       // DB接続情報取得
                       DBCommon.Instance.Initialize();
                       // 管理マスタ取得
                       if (!SetSystemMaster()) return false;
                       // 消費税データ取得
                       if (!SetconsumptionTax()) return false;
                       // 共通費計算係数取得
                       if(!ClsCostCulculation.DBToArrayData()) return false;
                       // ＲＧＢカラーパレット作成処理
                       CreatePalette();
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("初期化エラー:{0}：{1}", GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #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
+                  {
                       CultureInfo culture = new CultureInfo("ja-JP", true);
                       culture.DateTimeFormat.Calendar = new JapaneseCalendar();
                       return TargetDate.ToString("gg", culture);
+                  }
                   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 オブジェクトよりBool値変換（bool）
               /// <summary>
               /// オブジェクトよりBool値変換（bool）
               /// </summary>
               /// <param name="sendData"></param>
               /// <returns></returns>
               public static bool cnvBool(object sendData)
+              {
                   try
+                  {
                       bool retData = false;
                       // 空判定
                       if (sendData == null) return retData;
                       if (sendData.ToString().Trim().Length == 0) return retData;
                       // 変換
                       bool.TryParse(sendData.ToString(), out retData);
                       return retData;
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #endregion
               #region オブジェクトより数値変換（TimeSpan）
               /// <summary>
               /// オブジェクトより数値変換（TimeSpan）
               /// </summary>
               /// <param name="sendData"></param>
               /// <returns></returns>
               public static TimeSpan cnvTimeSpan(object sendData)
+              {
                   try
+                  {
                       TimeSpan retData = TimeSpan.Zero;
                       // 空判定
                       if (sendData == null) return retData;
                       if (sendData.ToString().Trim().Length == 0) return retData;
                       // 変換
                       TimeSpan.TryParse(sendData.ToString().Trim(), out retData);
                       return retData;
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);
                       return TimeSpan.MinValue;
+                  }
+              }
               #endregion
               #region decimal値をTimeSpan値へ変換する
               /// <summary>
               /// decimal値をTimeSpan値へ変換する
               /// </summary>
               public static TimeSpan cnvDecimal2TimeSpan(decimal sendData)
+              {
                   try
+                  {
                       TimeSpan retData = TimeSpan.Zero;
                       // 空判定
                       if (sendData.ToString().Trim().Length == 0) return retData;
                       // 変換
                       retData = new TimeSpan((int)sendData, (int)((sendData % 1) * 100.00m), 0);
                       return retData;
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);
                       return TimeSpan.MinValue;
+                  }
+              }
               #endregion
               #region TimeSpan値をdecimal値へ変換する
               /// <summary>
               /// TimeSpan値をdecimal値へ変換する
               /// </summary>
               public static decimal cnvTimeSpan2Decimal(TimeSpan sendData)
+              {
                   try
+                  {
                       decimal retData = 0;
                       // 空判定
                       if (sendData.ToString().Trim().Length == 0) return retData;
                       // 変換
                       retData = sendData.Hours + (sendData.Minutes / 100.00m);
                       return retData;
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);
                       return 0.0m;
+                  }
+              }
               #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;
+              }
               public static decimal DecimalRoundUp(decimal value, int pos)
+              {
                   // 何乗かを求める
                   int posion = (int)Math.Pow(10, pos);
                   return (Math.Ceiling(value * posion) / posion);
+              }
               #endregion
               #region 0～26までの数字をA～Zに変換する
               /// <summary>
               /// 0～26までの数字をA～Zに変換する
               /// </summary>
               /// <param name="num"></param>
               /// <returns></returns>
               public static string cnvNumberToAlphaChar(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 Excelのカラム名的なアルファベットを数値へ変換します。
               /// <summary>
               /// Excelのカラム名的なアルファベットを数値へ変換します。
               /// </summary>
               /// <returns></returns>
               public static int cnvAlphaToNumber(this string self)
+              {
                   int result = 0;
                   if (string.IsNullOrEmpty(self)) return result;
                   char[] chars = self.ToCharArray();
                   int len = self.Length - 1;
                   foreach (var c in chars)
+                  {
                       int asc = (int)c - 64;
                       if (asc < 1 || asc > 26) return 0;
                       result += asc * (int)Math.Pow((double)26, (double)len--);
+                  }
                   return (result - 1);
+              }
               #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, TermMaster.PalceOfColorDef point)
+              {
                   Color ColorRet = Color.White;
                   try
+                  {
                       // デフォルトセット
                       if (point == TermMaster.PalceOfColorDef.BackColor)
                       {   // 背景
                           ColorRet = Color.White;
+                      }
                       else if (point == TermMaster.PalceOfColorDef.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 ^ 0xFF);
                       byte g = (byte)(color.G ^ 0xFF);
                       byte b = (byte)(color.B ^ 0xFF);
                       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 ＲＧＢカラーパレット作成処理
               /// <summary>
               /// ＲＧＢカラーパレット作成処理
               /// </summary>
               /// <returns></returns>
               private static void CreatePalette()
+              {
                   try
+                  {
                       // 青→緑
                       for (int i = 0; i < 64; i++)
+                      {
                           int _green = i * 4;
                           m_RGBColor[i] = Color.FromArgb(255, 0, _green, 255 - _green);
+                      }
                       // 緑→黄
                       for (int i = 0; i < 64; i++)
+                      {
                           int _red = i * 4;
                           m_RGBColor[i + 64] = Color.FromArgb(255, _red, 255, 0);
+                      }
                       // 黄→赤
                       for (int i = 0; i < 128; i++)
+                      {
                           int _green = 255 - i * 2;
                           m_RGBColor[i + 128] = Color.FromArgb(255, 255, _green, 0);
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 半角数字を全角数字に変換する。
               /// <summary>
               /// 半角数字を全角数字に変換する。
               /// </summary>
               public static string HanToZenNum(string s)
+              {
                   return Regex.Replace(s, "[0-9]", p => ((char)(p.Value[0] - '0' + '０')).ToString());
+              }
               #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 時間チェック（TimeSpan）
               /// <summary>
               /// 時間チェック（TimeSpan）
               /// </summary>
               /// <returns>true:正常 false:異常</returns>
               public static bool chkTimeSpan(object sendData, ref TimeSpan retData, bool indispensable = false)
+              {
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           if (cnvString(sendData).Trim().Length == 0) return false;
+                      }
                       return TimeSpan.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>
               /// <param name="str"></param>
               /// <returns></returns>
               public static bool chkIsHiragana(string str)
+              {
                   return Regex.IsMatch(str, @"^\p{IsHiragana}*$");
+              }
               #endregion
               #region 指定文字が全てカタカナのチェック
               /// <summary>
               /// 指定文字が全てカタカナのチェック
               /// </summary>
               /// <param name="str"></param>
               /// <returns></returns>
               public static bool chkIsKatakana(string str)
+              {
                   return Regex.IsMatch(str, @"^\p{IsKatakana}*$");
+              }
               #endregion
               #region 指定文字が全て数字のチェック
               /// <summary>
               /// 指定文字が全て数字のチェック
               /// </summary>
               /// <param name="str"></param>
               /// <returns></returns>
               public static bool chkIsNumeric(string str)
+              {
                   return Regex.IsMatch(str, @"[^a-zA-z0-9-_]");
+              }
               #endregion
               #region 画面フィールド入力必須チェック
               /// <summary>
               /// 画面フィールド入力必須チェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldIndispensable(Control dispControl)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (chkObjectIsNull(dispControl))
+                      {
                           bAns = false;
+                      }
                       else
+                      {
                           if (dispControl.Text.ToString().Length == 0)
+                          {
                               bAns = false;
+                          }
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力文字数チェック
               /// <summary>
               /// 画面フィールド入力文字数チェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="sLength">文字列長</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldLengthCheck(Control dispControl, int sLength, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // レングスチェック
                           bAns = chkStringLength(dispControl.Text.ToString(), sLength);
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力日付チェック
               /// <summary>
               /// 画面フィールド入力日付チェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldDateCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // 未定はエラーにしない
                           if (!indispensable && dispControl.Text.Equals(CommonDefine.s_UndecidedString)) { }
                           else
                               // 日付チェック
                               bAns = chkDate(dispControl.Text.ToString());
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールドコンボボックスチェック
               /// <summary>
               /// 画面フィールド入力コンボボックスチェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldCombCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       ComboBox comboBox = (ComboBox)dispControl;
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
                           // 必須時未定はエラー
                           if (dispControl.Text.Equals(CommonDefine.s_UndecidedString)) bAns = false;
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // 未定はエラーにしない
                           if (!indispensable && dispControl.Text.Equals(CommonDefine.s_UndecidedString)) { }
                           else
+                          {
                               // 入力チェック
                               if (dispControl.Text.ToString().Length == 0) bAns = false;
+                          }
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力郵便番号チェック
               /// <summary>
               /// 画面フィールド入力郵便番号チェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldZipCodeCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // 郵便番号チェック
                           bAns = chkZipcode(dispControl.Text.ToString());
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力Intチェック
               /// <summary>
               /// 画面フィールド入力Intチェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldIntCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           int work = 0;
                           // 数値チェック
                           //bAns = chkNumeric(dispControl.Text.ToString(), ref work);
                           bAns = int.TryParse(dispControl.Text.ToString(), out work);
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力Doubleチェック
               /// <summary>
               /// 画面フィールド入力Doubleチェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldDoubleCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           double work = 0;
                           // 数値チェック
                           bAns = chkNumeric(dispControl.Text.ToString(), ref work);
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力電話番号チェック
               /// <summary>
               /// 画面フィールド入力電話番号チェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldPhoneNumberCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // 電話番号チェック
                           bAns = chkPhoneNumber(dispControl.Text.ToString());
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力メールアドレスチェック
               /// <summary>
               /// 画面フィールド入力メールアドレスチェック
               /// </summary>
               /// <param name="dispControl">コントロールオブジェクト</param>
               /// <param name="indispensable">true:必須入力チェック</param>
               /// <returns>false:エラー true:エラーなし</returns>
               public static bool DispFieldMailAddressCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // メールアドレスチェック
                           bAns = chkMailAddress(dispControl.Text.ToString());
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力カタカナチェック
               /// <summary>
               /// 画面フィールド入力カタカナチェック
               /// </summary>
               public static bool DispFieldKatakanaCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // カタカナチェック
                           bAns = chkIsKatakana(dispControl.Text.ToString());
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 画面フィールド入力ひらながチェック
               /// <summary>
               /// 画面フィールド入力ひらがなチェック
               /// </summary>
               public static bool DispFieldHiraganaCheck(Control dispControl, bool indispensable = false)
+              {
                   bool bAns = true;
                   try
+                  {
                       // 必須入力チェック
                       if (indispensable)
+                      {
                           bAns = DispFieldIndispensable(dispControl);
+                      }
                       if (dispControl.Text.ToString().Length != 0)
+                      {
                           // ひらながチェック
                           bAns = chkIsHiragana(dispControl.Text.ToString());
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       bAns = false;
+                  }
                   finally
+                  {
                       // 背景色変更
                       chgBackColor(dispControl, bAns);
+                  }
                   return bAns;
+              }
               #endregion
               #region 指定した日が第何週かを求める
               /// <summary>
               /// 指定した日が第何週かを求める
               /// </summary>
               /// <param name="date"></param>
               /// <returns></returns>
               public static int NthWeek(DateTime date)
+              {
                   int w = (int)(new DateTime(date.Year, date.Month, 1).DayOfWeek);
                   return (date.Day + w - 1) / 7 + 1;
+              }
               #endregion
               #endregion
               #region ---------- 工事管理システム専用
               #region システム起動確認データ取得
               /// <summary>
               /// システム起動確認データ取得
               /// </summary>
               public static void GetSystemExecute(ref SystemExecute recordRec)
+              {
                   IOSystemExecute SysExecDB = new IOSystemExecute();
                   try
+                  {
                       // システムのバージョンをチェックする
                       // キーを取得する
                       int PCode = CommonDefine.ExePrimaryCode.First(x => x.Value.Equals("システムバージョン")).Key;
                       // バージョン読込
                       string strSQL = SysExecDB.CreatePrimarykeyString(PCode);
                       if (!SysExecDB.SelectAction(strSQL, ref recordRec))
                       {   // レコード無時はエラー
                           logger.ErrorFormat("バージョンチェックデータ読込みエラー：{0}", CommonMotions.GetMethodName());
                           return;
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
                   finally
+                  {
                       SysExecDB.close(); SysExecDB = null;
+                  }
+              }
               #endregion
               #region 製品版・確認運用時Trueを返す
               /// <summary>
               /// 製品版・確認運用時Trueを返す
               /// </summary>
               /// <returns></returns>
               public static bool OperationConfirmation()
+              {
                   try
+                  {
                       bool bRet = false;
                       switch (ProductDefine.ProductType)
+                      {
                           case (int)ProductDefine.ProductTypeDef.Originals:
                           case (int)ProductDefine.ProductTypeDef.ProductsModelType2_1:
                           case (int)ProductDefine.ProductTypeDef.ProductsModelType2_2:
                               break;
                           case (int)ProductDefine.ProductTypeDef.ProductsModelType1:
                               // 一人親方バージョンはtrue
                               bRet = true;
                               break;
                           default:
                               break;
+                      }
                       return bRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #endregion
               #region 実行ファイル名称よりタイトル取得
               /// <summary>
               /// 実行ファイル名称よりタイトル取得
               /// </summary>
               /// <returns></returns>
               public static string GetExecFileName()
+              {
                   try
+                  {
                       FileVersionInfo CurVersionInfo = CommonMotions.ProductVersionInfo;
                       StringBuilder strTitle = new StringBuilder();
                       for (int i = 0; i < CurVersionInfo.ProductName.Length; i++)
+                      {
                           if (i < 1) strTitle.Append(CurVersionInfo.ProductName.Substring(i, 1));
                           else strTitle.AppendFormat("　{0}", CurVersionInfo.ProductName.Substring(i, 1));
+                      }
                       return strTitle.ToString();
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #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
+                  {
                       // 管理マスタ取得
                       // １レコードだけなので取り出す
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.Append(" Where SystemCode = 1");
                       if (!ocDB.SelectAction(strSQL.ToString(), 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>
               public static bool SetconsumptionTax()
+              {
                   // 消費税データクラス
                   IOMConsumptionTax TaxDB = new IOMConsumptionTax();
                   try
+                  {
                       // 消費税データ取得
                       StringBuilder strSQL = new StringBuilder();
                       m_ConsumptionTax.Clear();
                       strSQL.Append(" Order By StartDate");
                       if (!TaxDB.SelectAction(strSQL.ToString(), ref m_ConsumptionTax)) return false;
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
                   finally
+                  {
                       TaxDB.close(); TaxDB = 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>
               /// <param name="PeriodCount"></param>
               /// <returns></returns>
               public static int PeriodCountToYear(int PeriodCount)
+              {
                   IOMBizPeriodHistory BizHisDB = new IOMBizPeriodHistory();
                   try
+                  {
                       // 今の年を取得する
                       int iYear = DateTime.Now.Year;
                       StringBuilder strSQL = new StringBuilder();
                       BizPeriodHistory BizHisRec = new BizPeriodHistory();
                       // 営業期
                       strSQL.Append(BizHisDB.CreatePrimarykeyString(PeriodCount, (int)BizPeriodHistory.PeriodFlagDef.BizPeriod));
                       // 運営期履歴情報読込
                       if (!BizHisDB.SelectAction(strSQL.ToString(), ref BizHisRec)) return iYear;
                       iYear = BizHisRec.BeginDate.Year;
                       return iYear;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return 0;
+                  }
                   finally
+                  {
                       BizHisDB.close(); BizHisDB = null;
+                  }
+              }
               #endregion
               #region システム設定が営業期数の時にtrueを返す
               /// <summary>
               /// システム設定が営業期数の時にtrueを返す
               /// </summary>
               /// <returns></returns>
               public static bool BasePeriodYear()
+              {
                   bool bret = false;
                   try
+                  {
                       switch (CommonMotions.SystemMasterData.ConstructionNoBase)
+                      {
                           case (int)SystemMaster.ConstrNoBaseDef.BusinessPeriod:
                               bret = true;
                               break;
                           default:
                               bret = false;
                               break;
+                      }
                       return bret;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return bret;
+                  }
+              }
               #endregion
               #region 年度選択ラベル初期セット
               /// <summary>
               /// 年度選択ラベル初期セット
               /// </summary>
               /// <param name="control"></param>
               public static void SetSerchTitle(Label lbl1, Label lbl2, NumericUpDown updown, Label lbl3)
+              {
                   try
+                  {
                       int nlabelX = lbl1.Location.X;
                       int nCtrlDef = updown.Location.X - lbl2.Location.X;
                       // タイトル文字セット
                       lbl1.Text = GetYearTitle();
                       lbl3.Text = GetYearTitle(false);
                       // タイトル表示制御
                       if (BasePeriodYear())
+                      {
                           lbl2.Visible = true;
+                      }
                       else
+                      {
                           lbl2.Visible = false;
                           Point po = updown.Location;
                           po.X -= nCtrlDef;
                           updown.Location = po;
                           Point po2 = lbl3.Location;
                           po2.X -= nCtrlDef;
                           lbl3.Location = po2;
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 管理マスタの指定により年度名称を返す
               /// <summary>
               /// 管理マスタの指定により年度名称を返す
               /// </summary>
               /// <returns></returns>
               public static string GetYearTitle(bool bTitle = true)
+              {
                   string strTitle = string.Empty;
                   try
+                  {
                       if (bTitle)
+                      {
                           if (BasePeriodYear())
+                          {
                               strTitle = "営業期数";
+                          }
                           else
+                          {
                               strTitle = "工事年度";
+                          }
+                      }
                       else
+                      {
                           if (BasePeriodYear())
+                          {
                               strTitle = "期";
+                          }
                           else
+                          {
                               strTitle = "年度";
+                          }
+                      }
                       return strTitle;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return strTitle;
+                  }
+              }
               #endregion
               #region 工事情報より期の最大・最少を取得する
               /// <summary>
               /// 工事情報より期の最大・最少を取得する
               /// </summary>
               /// <param name="StartDate"></param>
               /// <returns></returns>
               public static void GetPeriodYearMinMax(ref int min, ref int max)
+              {
                   IOConstructionBaseInfo cbiDB = new IOConstructionBaseInfo();
                   try
+                  {
                       StringBuilder strSQL = new StringBuilder();
                       bool bPeriod = CommonMotions.BasePeriodYear();
                       if (bPeriod)
                       {   // ----- 営業期ベースの時
                           strSQL.Append("SELECT MIN(CONSTRUCTIONPERIOD), MAX(CONSTRUCTIONPERIOD) FROM CONSTRUCTIONBASEINFO");
+                      }
                       else
                       {   // ----- 工事年度ベースの時
                           strSQL.Append("SELECT MIN(ConstructionYear), MAX(ConstructionYear) FROM CONSTRUCTIONBASEINFO");
+                      }
                       ArrayList arList = new ArrayList();
                       if (!cbiDB.ExecuteReader(strSQL.ToString(), ref arList)) return;
                       object[] wrkobj = (object[])arList[0];
                       min = cnvInt(wrkobj[0]);
                       max = cnvInt(wrkobj[1]);
                       if (bPeriod)
                       {   // ----- 営業期ベースの時
                           if (min < 1)
+                          {
                               min = 1;
                               max = 1;
+                          }
+                      }
                       else
                       {   // ----- 工事年度ベースの時
                           if (min < 1)
+                          {
                               min = CommonMotions.SystemMasterData.ConstrBeginDate.Year;
                               max = CommonMotions.SystemMasterData.ConstrCompDate.Year;
+                          }
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
                   finally
+                  {
                       cbiDB.close(); cbiDB = null;
+                  }
+              }
               #endregion
               #region 管理マスタの現在年を取得する
               /// <summary>
               /// 管理マスタの現在年を取得する
               /// </summary>
               /// <returns></returns>
               public static int GetPeriodYear()
+              {
                   try
+                  {
                       int nYearVal = DateTime.Now.Year;
                       if (CommonMotions.BasePeriodYear())
+                      {
                           // ----- 営業期ベースの時
                           nYearVal = CommonMotions.SystemMasterData.BusinessPeriod;
+                      }
                       else
+                      {
                           // ----- 工事年度ベースの時
                           nYearVal = CommonMotions.SystemMasterData.ConstrYear;
+                      }
                       return nYearVal;
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return 0;
+                  }
+              }
               #endregion
               #region 対象日より営業期・工事年度を取得する
               /// <summary>
               /// 対象日より営業期・工事年度を取得する
               /// </summary>
               /// <param name="NowDay"></param>
               /// <returns></returns>
               public static int ConvDate2YearOrPeriod(DateTime NowDay)
+              {
                   IOMBizPeriodHistory BizHisDB = new IOMBizPeriodHistory();
                   try
+                  {
                       int nRetVal = 0;
                       // 範囲に入るデータを取得する
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.AppendFormat(" WHERE (DATE(BeginDate) <= DATE('{0}'))", NowDay.ToShortDateString());
                       strSQL.AppendFormat(" AND (DATE('{0}') <= DATE(CompleteDate))", NowDay.ToShortDateString());
                       strSQL.AppendFormat(" And PeriodFlag = {0}", CommonMotions.SystemMasterData.ConstructionNoBase);
                       strSQL.Append(" Order By PeriodFlag Asc, PeriodYear Asc");
                       List<BizPeriodHistory> BizList = new List<BizPeriodHistory>();
                       if (!BizHisDB.SelectAction(strSQL.ToString(), ref BizList)) return 0;
                       nRetVal = BizList[0].PeriodYear;
                       return nRetVal;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return 0;
+                  }
                   finally
+                  {
                       BizHisDB.close(); BizHisDB = null;
+                  }
+              }
               #endregion
               #region ポイントに規定値を加算して戻す
               /// <summary>
               /// ポイントに規定値を加算して戻す
               /// </summary>
               /// <param name="PosPoint"></param>
               public static Point SetFormPosion(Point PosPoint)
+              {
                   Point po = PosPoint;
                   try
+                  {
                       po.X += CommonDefine.s_DefalutShiftValue;
                       po.Y += CommonDefine.s_DefalutShiftValue;
                       return po;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
                       return po;
+                  }
+              }
               #endregion
               #region フィールドバックカラー変更処理
               /// <summary>
               /// フィールドバックカラー変更処理（あまりカッコ良くない^^;）
               /// </summary>
               /// <param name="objCtrl"></param>
               /// <param name="chgColor"></param>
               public static void chgBackColor(object objCtrl, bool bPara, bool bWarning = false)
+              {
                   try
+                  {
                       // エラー色・ワーニング色
                       Color ErrorColor = CommonDefine.s_clrError;
                       if (bWarning) ErrorColor = CommonDefine.s_clrWarning;
                       if (objCtrl.GetType().Equals(typeof(TextBox))
                           || objCtrl.GetType().Equals(typeof(TextBoxEX)))
+                      {
                           TextBox wrk = (TextBox)objCtrl;
                           if (bPara)
+                          {
                               wrk.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.BackColor = ErrorColor;
                               wrk.Focus();
+                          }
+                      }
                       else if (objCtrl.GetType().Equals(typeof(DataGridViewTextBoxCell)))
+                      {
                           DataGridViewTextBoxCell wrk = (DataGridViewTextBoxCell)objCtrl;
                           if (bPara)
+                          {
                               wrk.Style.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.Style.BackColor = ErrorColor;
                               wrk.Selected = true;
+                          }
+                      }
                       else if (objCtrl.GetType().Equals(typeof(ComboBoxEX))
                               || objCtrl.GetType().Equals(typeof(ComboBox)))
+                      {
                           ComboBox wrk = (ComboBox)objCtrl;
                           if (bPara)
+                          {
                               wrk.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.BackColor = ErrorColor;
                               wrk.Focus();
+                          }
+                      }
                       else if (objCtrl.GetType().Equals(typeof(ListBox)))
+                      {
                           ListBox wrk = (ListBox)objCtrl;
                           if (bPara)
+                          {
                               wrk.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.BackColor = ErrorColor;
                               wrk.Focus();
+                          }
+                      }
                       else if (objCtrl.GetType().Equals(typeof(Label)))
+                      {
                           Label wrk = (Label)objCtrl;
                           if (bPara)
+                          {
                               wrk.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.BackColor = ErrorColor;
+                          }
+                      }
                       else if (objCtrl.GetType().Equals(typeof(NumericUpDown)))
+                      {
                           NumericUpDown wrk = (NumericUpDown)objCtrl;
                           if (bPara)
+                          {
                               wrk.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.BackColor = ErrorColor;
+                          }
+                      }
                       else if (objCtrl.GetType().Equals(typeof(DateTimePicker)))
+                      {
                           DateTimePicker wrk = (DateTimePicker)objCtrl;
                           if (bPara)
+                          {
                               wrk.BackColor = CommonDefine.s_clrNormal;
+                          }
                           else
+                          {
                               wrk.BackColor = ErrorColor;
+                          }
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
+                  }
+              }
               #endregion
               #region 営業期数より工事年を取得する
               /// <summary>
               /// 営業期数より工事年を取得する
               /// </summary>
               /// <param name="Period"></param>
               /// <returns></returns>
               public static int BusinessPeriodToConstructionYears(int Period)
+              {
                   try
+                  {
                       int Beginning = 0;
                       int diffwork = 0;
                       int RetYears = 0;
                       string strwork = string.Empty;
                       // 現在期との差分を求める
                       diffwork = Period - CommonMotions.SystemMasterData.BusinessPeriod;
                       // 期首月を取得する
                       Beginning = CommonMotions.SystemMasterData.BusinessBeginDate.Month;
                       // 年数を求める
                       DateTime dateWork = DateTime.Now;
                       int nowMounth = DateTime.Now.Month;
                       // 期首月を境に年度を計算する
                       int iYear = 0;
                       if (nowMounth < Beginning)
                           iYear = dateWork.AddYears(-1).Year;
                       else
                           iYear = dateWork.Year;
                       // ベース年を求める
                       RetYears = iYear + diffwork;
                       return RetYears;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return 0;
+                  }
+              }
               #endregion
               #region 発注者名を法人格を含んだ形で連結する
               /// <summary>
               /// 発注者名を法人格を含んだ形で連結する
               /// </summary>
               /// <param name="master"></param>
               /// <returns></returns>
               public static string OrderersNameUnion(OrderersMaster master)
+              {
                   try
+                  {
                       string strRet = string.Empty;
                       if (master.CorporateStatusPoint == (int)BusinessTypeMaster.StatusNamePointDef.Forword)
                           strRet = master.CorporateStatusName + "　" + master.OrderersName1 + "　" + master.OrderersName2;
                       else if (master.CorporateStatusPoint == (int)BusinessTypeMaster.StatusNamePointDef.Back)
                           strRet = master.OrderersName1 + "　" + master.CorporateStatusName + "　" + master.OrderersName2;
                       else
                           strRet = master.OrderersName1 + "　" + master.OrderersName2;
                       return strRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #endregion
               #region メッセージ送信メソッド(テキストボックス背景文字表示用)
               /// <summary>
               /// メッセージ送信メソッド
               /// </summary>
               /// <param name="hWnd"></param>
               /// <param name="Msg"></param>
               /// <param name="wParam"></param>
               /// <param name="lParam"></param>
               /// <returns></returns>
               [DllImport("user32.dll", CharSet = CharSet.Unicode)]
               public static extern IntPtr SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, string lParam);
               #endregion
               #region ファイルの時間を取得する
               /// <summary>
               /// ファイルの時間を取得する
               /// </summary>
               /// <param name="FilePath">ファイルパス</param>
               /// <param name="flg">取得日付フラグ</param>
               /// <returns></returns>
               public static DateTime GetFileTimeStamp(string FilePath, char flg)
+              {
                   try
+                  {
                       DateTime dtDateTime = DateTime.MinValue;
                       if (flg == 'C')
+                      {
                           // 作成日時を取得する
                           dtDateTime = File.GetCreationTime(@FilePath);
+                      }
                       else if (flg == 'U')
+                      {
                           // 更新日時を取得する
                           dtDateTime = File.GetLastWriteTime(@FilePath);
+                      }
                       else if (flg == 'A')
+                      {
                           // アクセス日時を取得する
                           dtDateTime = File.GetLastAccessTime(@FilePath);
+                      }
                       return dtDateTime;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return DateTime.Now;
+                  }
+              }
               #endregion
               #region ファイルパスよりmd5のハッシュ値を返す
               /// <summary>
               /// ファイルパスよりmd5のハッシュ値を返す
               /// </summary>
               /// <param name="FilePath"></param>
               /// <returns></returns>
               public static string GetFileHashData(string FilePath)
+              {
                   try
+                  {
                       //ファイルを開く
                       FileStream fs = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
                       //MD5CryptoServiceProviderオブジェクトを作成
                       MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
                       //ハッシュ値を計算する
                       byte[] bs = md5.ComputeHash(fs);
                       //リソースを解放する
                       md5.Clear();
                       //ファイルを閉じる
                       fs.Close();
                       return BitConverter.ToString(bs).ToLower().Replace("-", "");
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #endregion
               #region 郵便番号より住所を検索する
               /// <summary>
               /// 郵便番号より住所を検索する
               /// </summary>
               /// <param name="ZipCode">郵便番号</param>
               public static void SearchZipCode2Address(string ZipCode, ref string Address1, ref string Address2)
+              {
                   Address1 = "";                //住所
                   Address2 = "";                //住所
                   //処理時間を計測
                   Stopwatch sw = new Stopwatch();
                   //処理時間計測開始
                   sw.Start();
                   // 郵便番号セット
                   string sKey = ZipCode;
                   //文字列の前後のスペースをとる
                   sKey = sKey.Trim(' ');
                   //Microsoft.VisualBasic名前空間のStrConv関数を使って、全角文字を半角文字に変換
                   sKey = Strings.StrConv(sKey, VbStrConv.Narrow, 0);
                   // 文字列の長さを取得する
                   int iLength = sKey.Length;
                   // '-'がある場合は先頭文字目の後から '-' を検索し、見つかった位置を取得する
                   int iFind = 0;
                   if ((iFind = sKey.IndexOf('-', 0)) != 0)
+                  {
                       //左から3文字+"-"文字以降をtmpZip変数に代入
                       sKey = sKey.Substring(0, 3) + sKey.Substring(iFind + 1);
+                  }
                   try
+                  {
                       //StreamReaderオブジェクトの作成
                       StreamReader sr = new StreamReader(@CommonDefine.s_AddressFilePath, Encoding.Default);
                       //1行ずつ読み込み
                       string dat = "";
                       while ((dat = sr.ReadLine()) != null)
+                      {
                           string tmpZip = "";
                           //カンマで区切られた文字列を取得
                           string[] sbuf = dat.Split(',');
                           //配列の3番目が郵便番号
                           tmpZip = sbuf[2].Trim('"');
                           //入力された郵便番号と比較
                           if (sKey == tmpZip)
+                          {
                               //住所を作成
                               //都道府県名+市区町村名+町域名
                               Address1 = sbuf[6].Trim('"') + sbuf[7].Trim('"');
                               Address2 = sbuf[8].Trim('"');
                               sw.Stop();  //処理時間計測終了
                               // 処理時間をTimeSpan構造体で書式付き表示
                               TimeSpan ts = sw.Elapsed;
                               // 出力例：00:00:00.9984668
                               logger.DebugFormat("処理時間:{0}", ts.ToString());
                               break;          //ループを抜ける
+                          }
                           Application.DoEvents();
+                      }
                       //ファイルを閉じる
                       sr.Close();
+                  }
                   catch (Exception ex)
+                  {
                       //ファイルエラーが発生した場合
                       MessageBox.Show(ex.Message, "ファイルエラー", MessageBoxButtons.OK, MessageBoxIcon.Error);
                       //処理を抜ける
                       return;
+                  }
+              }
               #endregion
               #region 文字列より指定文字から後ろを省いて戻す
               /// <summary>
               /// 文字列より指定文字から後ろを省いて戻す
               /// </summary>
               /// <param name="Mijiretu"></param>
               /// <param name="Delimiter"></param>
               /// <returns></returns>
               public static string ComentSucstring(string Mijiretu, string Delimiter)
+              {
                   string strRet = Mijiretu;
                   try
+                  {
                       if (Mijiretu.IndexOf(Delimiter) < 0) return strRet;
                       int TargetCnt = Mijiretu.IndexOf(Delimiter) - 1;
                       if (TargetCnt > 0)
                           strRet = Mijiretu.Substring(0, TargetCnt);
                       return strRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #endregion
               #region 今の時間をセパレータを除いた文字列で戻す
               /// <summary>
               /// 今の時間をセパレータを除いた文字列で戻す
               /// </summary>
               /// <returns></returns>
               public static string stringNowJikan()
+              {
                   string[] wrk = DateTime.Now.ToShortDateString().Split('/');
                   string[] wrk2 = DateTime.Now.ToShortTimeString().Split(':');
                   return string.Format("{0}{1}{2}{3}{4}{5}"
                                                   , wrk[0], wrk[1], wrk[2]
                                                   , wrk2[0], wrk2[1], wrk2[2]);
+              }
               #endregion
               #region 経過日数を工数で返す
               /// <summary>
               /// 経過日数を工数で返す
               /// </summary>
               /// <param name="StartDate"></param>
               /// <param name="CompDate"></param>
               /// <returns></returns>
               public static double DiffMounthTimes(DateTime StartDate, DateTime CompDate)
+              {
                   // 差分計算
                   TimeSpan DiffDate = CompDate - StartDate;
                   // 当日までなので+1日する
                   TimeSpan wrkts = new TimeSpan(1, 0, 0, 0);
                   DiffDate = DiffDate + wrkts;
                   // 工数の最小単位で割って１０分の１にする
                   //return (((double)DiffDate.Days) / CommonDefine.s_ManHourUnitDays) / 10;
                   // 日数から月数へ変換する
                   return ClsCalendar.cnvMonthFromDays(DiffDate.Days);
+              }
               #endregion
               #region 文字列を指定文字で指定レングス分埋める
               /// <summary>
               /// 文字列を指定文字で指定レングス分埋める
               /// </summary>
               /// <param name="OrgString"></param>
               /// <param name="SetLength"></param>
               /// <param name="Before"></param>
               /// <returns></returns>
               public static string SetBlankString(string OrgString, string SetString, int SetLength, bool Before)
+              {
                   try
+                  {
                       string strRet = string.Empty;
                       int stringLength = OrgString.Length;
                       // 文字列を埋める
                       for (int i = 0; i < (SetLength - stringLength); i++) strRet += SetString;
                       // 前か後か
                       if (Before)
+                      {
                           strRet = strRet + OrgString;
+                      }
                       else
+                      {
                           strRet = OrgString + strRet;
+                      }
                       return strRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #endregion
               #region 現在年を西暦で求める
               /// <summary>
               /// 現在年を西暦で求める
               /// </summary>
               public static int GetBaseCounstructionYear(int years)
+              {
                   try
+                  {
                       int Beginning = 0;
                       int diffwork = 0;
                       string strwork = string.Empty;
                       if (CommonMotions.BasePeriodYear())
                       {   // ----- 営業期ベースの時
                           // 現在期との差分を求める
                           diffwork = years - SystemMasterData.BusinessPeriod;
                           // 期首月を取得する
                           Beginning = SystemMasterData.BusinessBeginDate.Month;
+                      }
                       else
                       {   // ----- 営業年度ベースの時
                           // 現在期との差分を求める
                           diffwork = years - SystemMasterData.ConstrYear;
                           // 期首月を取得する
                           Beginning = SystemMasterData.ConstrBeginDate.Month;
+                      }
                       // 年数を求める
                       DateTime dateWork = DateTime.Now;
                       int nowMounth = DateTime.Now.Month;
                       // 期首月を境に年度を計算する
                       int iYear = 0;
                       if (nowMounth < Beginning)
                           iYear = dateWork.AddYears(-1).Year;
                       else
                           iYear = dateWork.Year;
                       // ベース年を求める
                       return (iYear + diffwork);
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", GetMethodName(), ex.Message);
                       return 0;
+                  }
+              }
               #endregion
               #region 指定期・指定年度の期首日・期末日を取得する
               /// <summary>
               /// 指定期・指定年度の期首日・期末日を取得する
               /// </summary>
               /// <param name="nYear"></param>
               /// <param name="bBeginDay"></param>
               /// <param name="bPeriod"></param>
               /// <returns></returns>
               public static DateTime GetOpeningEndDate(int nYear, bool bBeginDay = true)
+              {
                   IOMBizPeriodHistory BizHisDB = new IOMBizPeriodHistory();
                   try
+                  {
                       DateTime dtRet = DateTime.Now.Date;
                       StringBuilder strSQL = new StringBuilder();
                       BizPeriodHistory BizHisRec = new BizPeriodHistory();
                       int nFlg = (int)BizPeriodHistory.PeriodFlagDef.BizPeriod;
                       if (BasePeriodYear())
                       {   // 営業期
                           nFlg = (int)BizPeriodHistory.PeriodFlagDef.BizPeriod;
+                      }
                       else
                       {   // 工事年度
                           nFlg = (int)BizPeriodHistory.PeriodFlagDef.ConstrYear;
+                      }
                       strSQL.Append(BizHisDB.CreatePrimarykeyString(nYear, nFlg));
                       // 運営期履歴情報読込
                       if (!BizHisDB.SelectAction(strSQL.ToString(), ref BizHisRec)) return dtRet;
                       if (bBeginDay)
+                      {
                           // 期首取得時
                           dtRet = BizHisRec.BeginDate;
+                      }
                       else
+                      {
                           // 期末取得時
                           dtRet = BizHisRec.CompleteDate;
+                      }
                       return dtRet;
+                  }
                   catch (System.Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return DateTime.Today;
+                  }
                   finally
+                  {
                       BizHisDB.close(); BizHisDB = null;
+                  }
+              }
               #endregion
               #region TimeSpanから年数を取得する
               /// <summary>
               /// TimeSpanから年数を取得する（切り上げ）
               /// </summary>
               /// <param name="timespan"></param>
               /// <returns></returns>
               public static int GetTimeSpanYears(this TimeSpan timespan)
+              {
                   return CommonMotions.cnvRoundUp((double)timespan.Days / 365.2425);
+              }
               #endregion
               #region TimeSpanから月数を取得する
               /// <summary>
               /// TimeSpanから月数を取得する
               /// </summary>
               /// <param name="timespan"></param>
               /// <returns></returns>
               public static int GetTimeSpanMonths(this TimeSpan timespan)
+              {
                   return (int)((double)timespan.Days / 30.436875);
+              }
               #endregion
               #region 工事種別より工事詳細台帳が作成ＯＫかどうかをチェックする
               /// <summary>
               /// 工事種別より工事詳細台帳が作成ＯＫかどうかをチェックする
               /// </summary>
               /// <param name="ConstructionType"></param>
               /// <returns></returns>
               public static bool CheckCreateLedgerData(int ConstructionStatusFlg, int ConstructionType)
+              {
                   try
+                  {
                       bool ExcuteFlg = false;
                       int[] Status = new int[] { CommonDefine.ProjectsStatus.First(x => x.Value.Equals("一般補修工事")).Key,
                                                   CommonDefine.ProjectsStatus.First(x => x.Value.Equals("空家補修工事")).Key,
                                                   CommonDefine.ProjectsStatus.First(x => x.Value.Equals("Hit'sV工事")).Key,
                                                   };
                       for (int i = 0; i < Status.Length; i++)
+                      {
                           //if (ConstructionStatusFlg == Status[i] && ConstructionType == CommonDefine.s_CreateLedgerData[i])
                           if (ConstructionStatusFlg == Status[i])
+                          {
                               ExcuteFlg = true;
                               break;
+                          }
+                      }
                       return ExcuteFlg;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #endregion
               #region 予算書・台帳給与金額計算処理
               /// <summary>
               /// 予算書・台帳給与金額計算処理
               /// </summary>
               public static void CalcPayValueData(double MonthryCost, double OrdersPrice, int workingCount,
                                                   ref double ExecutionAmount, ref double AmountConfigRate,
                                                   bool bSalaryCorrection = true)
+              {
                   try
+                  {
                       // 受注金額が0の場合は1として計算する
                       if (OrdersPrice == 0) OrdersPrice = 1;
                       // 日当計算
                       double DairySalary = 0;
                       if (bSalaryCorrection)
                           DairySalary = (MonthryCost * CommonDefine.s_SalaryCorrection) / CommonDefine.s_ManHourUnitMonth;
                       else
+                      {
                           DairySalary = MonthryCost / CommonDefine.s_ManHourUnitMonth;
+                      }
                       // 給与支払総額
                       int iInput = CommonMotions.cnvRound(DairySalary * workingCount);
                       // 実行金額に給与支払総額をセットする
                       ExecutionAmount = iInput;
                       // 金額構成率計算
                       AmountConfigRate = (iInput / OrdersPrice) * 100.0;
                       // 構成率が範囲外の場合は0にする
                       if (AmountConfigRate < -999.00 || 999.00 < AmountConfigRate) AmountConfigRate = 0;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 給与取得ＳＱＬ作成処理
               /// <summary>
               /// 給与取得ＳＱＬ作成処理
               /// </summary>
               private static string GetSalaryValue(int PersonCode, DateTime GetData)
+              {
                   try
+                  {
                       // SQL作成
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.Append("SELECT");
                       strSQL.Append(" A.MONTHLYSALARY");
                       strSQL.Append(", A.YEARSALARY");
                       strSQL.Append(", A.PERSONCODE");
                       strSQL.Append(", A.STARTDATE");
                       strSQL.Append(" FROM PERSONSALARYMASTER As A");
                       strSQL.Append("    , (SELECT");
                       strSQL.Append("             BB.PERSONCODE");
                       strSQL.Append("           , MAX(BB.STARTDATE) sDate");
                       strSQL.Append("       FROM PERSONSALARYMASTER As BB");
                       strSQL.AppendFormat(" WHERE BB.PERSONCODE = {0}", PersonCode);
                       strSQL.AppendFormat(" AND DATE(BB.StartDate) <= DATE('{0}')", GetData.ToShortDateString());
                       strSQL.Append(" GROUP BY BB.PERSONCODE) As B");
                       strSQL.Append(" WHERE A.PERSONCODE = B.PERSONCODE");
                       strSQL.Append(" AND A.STARTDATE = B.sDate");
                       return strSQL.ToString();
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #endregion
               #region 担当者給与金額取得処理(単独処理)
               /// <summary>
               /// 担当者給与金額取得処理（単独処理）
               /// </summary>
               public static bool GetSalaryValue(int PersonCode, ref double MonthryCost, ref double YearsCost, DateTime GetData)
+              {
                   IOMPersonInCharge PersonDB = new IOMPersonInCharge();
                   try
+                  {
                       // 初期値セット
                       MonthryCost = 0;
                       YearsCost = 0;
                       // データ取得
                       string strSQL = GetSalaryValue(PersonCode, GetData);
                       ArrayList arList = new ArrayList();
                       if (!PersonDB.ExecuteReader(strSQL, ref arList)) return false;
                       if (arList.Count < 1) return false;
                       object[] objGetData = (object[])arList[0];
                       // 取得値セット
                       MonthryCost = CommonMotions.cnvDouble(objGetData[0]);
                       YearsCost = CommonMotions.cnvDouble(objGetData[1]);
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
                   finally
+                  {
                       PersonDB.close(); PersonDB = null;
+                  }
+              }
               #endregion
               #region 担当者給与金額取得処理（セッションコネクト別）
               /// <summary>
               /// 担当者給与金額取得処理（セッションコネクト別）
               /// </summary>
               public static bool GetSalaryValue(IOMPersonInCharge PersonDB, int PersonCode,
                                                   ref double MonthryCost, ref double YearsCost, DateTime GetData)
+              {
                   try
+                  {
                       // 初期値セット
                       MonthryCost = 0;
                       YearsCost = 0;
                       // データ取得
                       string strSQL = GetSalaryValue(PersonCode, GetData);
                       ArrayList arList = new ArrayList();
                       if (!PersonDB.ExecuteReader(strSQL, ref arList, false)) return false;
                       object[] objGetData = (object[])arList[0];
                       // 取得値セット
                       MonthryCost = CommonMotions.cnvDouble(objGetData[0]);
                       YearsCost = CommonMotions.cnvDouble(objGetData[1]);
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #endregion
               #region 与えられたキー値より機密管理区分データを取得する
               /// <summary>
               /// 与えられたキー値より機密管理区分データを取得する
               /// </summary>
               /// <param name="KeyValue"></param>
               /// <returns></returns>
               public static KeyValuePair<int, string> SearchSecurityRankList(int KeyValue)
+              {
                   KeyValuePair<int, string> RetPairvalue = new KeyValuePair<int, string>(0, string.Empty);
                   try
+                  {
                       for (int i = 0; i < CommonDefine.SecurityRankList.Count; i++)
+                      {
                           if (CommonDefine.SecurityRankList[i].Key == KeyValue)
+                          {
                               RetPairvalue = CommonDefine.SecurityRankList[i];
+                          }
+                      }
                       return RetPairvalue;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return RetPairvalue;
+                  }
+              }
               #endregion
               #region 与えられたキー値より機密区分範囲データを取得する
               /// <summary>
               /// 与えられたキー値より機密区分範囲データを取得する
               /// </summary>
               /// <param name="KeyValue"></param>
               /// <returns></returns>
               public static KeyValuePair<int, string> SearchSecurityRangeList(int KeyValue)
+              {
                   KeyValuePair<int, string> RetPairvalue = new KeyValuePair<int, string>(0, string.Empty);
                   try
+                  {
                       for (int i = 0; i < CommonDefine.SecurityRangeList.Count; i++)
+                      {
                           if (CommonDefine.SecurityRangeList[i].Key == KeyValue)
+                          {
                               RetPairvalue = CommonDefine.SecurityRangeList[i];
+                          }
+                      }
                       return RetPairvalue;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return RetPairvalue;
+                  }
+              }
               #endregion
               #region 登録完了メッセージ表示
               /// <summary>
               /// 登録完了メッセージ表示
               /// </summary>
               /// <param name="strTitle"></param>
               public static void EntryEndMessage(string strTitle)
+              {
                   try
+                  {
                       string strMes = string.Format("{0} 登録完了しました。", strTitle);
                       MessageBox.Show(strMes, "登録完了メッセージ", MessageBoxButtons.OK, MessageBoxIcon.Information);
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               public static void EntryEndMessage(string strTitle, string strTitle2)
+              {
                   try
+                  {
                       string strMes = string.Format("{0} {1}完了しました。", strTitle, strTitle2);
                       string strGuidance = string.Format("{0}完了メッセージ", strTitle2);
                       MessageBox.Show(strMes, strGuidance, MessageBoxButtons.OK, MessageBoxIcon.Information);
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 削除完了メッセージ表示
               /// <summary>
               /// 削除完了メッセージ表示
               /// </summary>
               /// <param name="strTitle"></param>
               public static void RemoveEndMessage(string strTitle)
+              {
                   try
+                  {
                       string strMes = string.Format("{0} 削除完了しました。", strTitle);
                       MessageBox.Show(strMes, "削除完了メッセージ", MessageBoxButtons.OK, MessageBoxIcon.Information);
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 経過給与を計算する
               /// <summary>
               /// 経過給与を計算する
               /// </summary>
               /// <param name="dtStart"></param>
               /// <param name="PersonCode"></param>
               /// <returns></returns>
               public static int CalcElapsedSalary(IOMPersonInCharge SalDB, DateTime dtStart, DateTime dtLast, int PersonCode, bool bConnect = true)
+              {
                   try
+                  {
                       int RetSalary = 0;
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.Append("SELECT SUM(SAL.SALARY) FROM");
                       strSQL.Append(" (SELECT AX.hiduke,");
                       //strSQL.AppendFormat(" ROUND((AX.salary * {0}) / DATE_FORMAT(LAST_DAY(AX.hiduke), '%d')) AS SALARY,", CommonDefine.s_SalaryCorrection);
                       strSQL.AppendFormat(" ROUND((AX.salary * {0}) / 30) AS SALARY,", CommonDefine.s_SalaryCorrection);
                       strSQL.Append(" MAX(AX.StartD) FROM");
                       strSQL.Append(" (SELECT A.d hiduke, B.MonthlySalary salary, B.STARTDATE StartD FROM");
                       strSQL.Append(" (SELECT A1.years, A2.month, A3.days, DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days)) AS d");
                       strSQL.Append(" FROM yearmaster AS A1, monthmaster AS A2, daymaster AS A3");
                       strSQL.Append(" WHERE");
                       if (dtStart.Year == dtLast.Year)
+                      {
                           strSQL.AppendFormat(" (A1.years = {0} AND A2.month IN(", dtStart.Year.ToString("0000"));
                           for (int i = dtStart.Month; i <= dtLast.Month; i++)
+                          {
                               if (i != dtStart.Month) strSQL.Append(", ");
                               strSQL.AppendFormat("{0} ", i);
+                          }
                           strSQL.Append("))");
+                      }
                       else
+                      {
                           strSQL.Append(" (");
                           for (int iYear = dtStart.Year; iYear <= dtLast.Year; iYear++)
+                          {
                               // 先頭以外はORを追加する
                               if (iYear != dtStart.Year) strSQL.AppendFormat(" OR");
                               strSQL.AppendFormat(" (A1.years = {0}", iYear.ToString("0000"));
                               strSQL.Append(" AND A2.month IN (");
                               if (iYear == dtStart.Year)
                               {   // 先頭年
                                   for (int i = dtStart.Month; i <= 12; i++)
+                                  {
                                       if (i != dtStart.Month) strSQL.Append(", ");
                                       strSQL.AppendFormat("{0} ", i);
+                                  }
+                              }
                               else if (iYear == dtLast.Year)
                               {   // 最終年
                                   for (int i = 1; i <= dtLast.Month; i++)
+                                  {
                                       if (i != 1) strSQL.Append(", ");
                                       strSQL.AppendFormat("{0} ", i);
+                                  }
+                              }
                               else
                               {   // 以外の年
                                   for (int i = 1; i <= 12; i++)
+                                  {
                                       if (i != 1) strSQL.Append(", ");
                                       strSQL.AppendFormat("{0} ", i);
+                                  }
+                              }
                               strSQL.Append("))");
+                          }
                           strSQL.Append(")");
+                      }
                       strSQL.Append(" AND DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days)) IS NOT NULL");
                       strSQL.AppendFormat(" AND (DATE('{0}') <= DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days))", dtStart.ToShortDateString());
                       strSQL.AppendFormat(" AND DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days)) <= DATE('{0}'))", dtLast.ToShortDateString());
                       strSQL.Append(" ORDER BY d) A");
                       strSQL.Append(", PERSONSALARYMASTER AS B");
                       strSQL.AppendFormat(" WHERE B.PERSONCODE = {0}", PersonCode);
                       strSQL.Append("       AND B.STARTDATE <= A.d");
                       strSQL.Append(" ORDER BY A.d, B.STARTDATE DESC) AS AX");
                       strSQL.Append(" GROUP BY AX.hiduke");
                       strSQL.Append(" ORDER BY AX.hiduke");
                       strSQL.Append(" ) AS SAL");
                       ArrayList ArData = new ArrayList();
                       if (!SalDB.ExecuteReader(strSQL.ToString(), ref ArData, bConnect)) return 0;
                       foreach (object[] objRec in ArData)
+                      {
                           RetSalary += CommonMotions.cnvInt(objRec[0]);
+                      }
                       return RetSalary;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return 0;
+                  }
+              }
               #endregion
               #region 期間より零れた経過給与を取得する
               /// <summary>
               /// 期間より零れた経過給与を取得する
               /// </summary>
               /// <returns></returns>
               public static void CalcSpilledSalary(IOMPersonInCharge SalDB
                                                   , int TargetYear, DateTime dtStart, DateTime dtLast
                                                   , int PersonCode
                                                   , ref int NextDiffDay
                                                   , ref int PrevDiffDay)
+              {
                   try
+                  {
                       DateTime dtDefaultStart = CommonMotions.GetOpeningEndDate(TargetYear, true);
                       DateTime dtDefaultEnd = CommonMotions.GetOpeningEndDate(TargetYear, false);
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.Append("Select");
                       strSQL.Append(" Base.ConstructionCode");
                       strSQL.Append(", Ledger.ConstructionStart");
                       strSQL.Append(", Ledger.ConstructionEnd");
                       strSQL.Append(", LDetail.GroupCount");
                       strSQL.Append(", LDetail.SalaryFlg");
                       strSQL.Append(", LDetail.SalaryDays");
                       strSQL.Append(" From");
                       strSQL.Append(" constructionbaseinfo As Base");
                       strSQL.Append(" Inner Join constructionledger As Ledger");
                       strSQL.Append("       On Ledger.ConstructionCode = Base.ConstructionCode");
                       strSQL.AppendFormat("  And DATE('{0}') <= DATE(Ledger.ConstructionEnd)", dtDefaultStart.ToShortDateString());
                       strSQL.Append(" Inner Join constructionledgerdetail As LDetail");
                       strSQL.Append("       On LDetail.ConstructionCode = Base.ConstructionCode");
                       strSQL.AppendFormat(" And LDetail.GroupCount = {0}", (int)ConstructionLedgerDetail.GroupCountDef.Payroll);
                       strSQL.AppendFormat(" And LDetail.CompanyCode = {0}", PersonCode);
                       strSQL.AppendFormat(" And LDetail.SalaryFlg = {0}", (int)CommonDefine.SalaryDevision.DaysInput);
                       strSQL.Append(" Where");
                       if (CommonMotions.BasePeriodYear())
                           strSQL.AppendFormat(" Base.ConstructionPeriod = {0}", TargetYear);
                       else
                           strSQL.AppendFormat(" Base.ConstructionYear = {0}", TargetYear);
                       strSQL.AppendFormat(" And Base.ConstructionPersonCode = {0}", PersonCode);
                       strSQL.Append(" And (");
                       strSQL.AppendFormat("DATE('{0}') <= DATE(Ledger.ConstructionStart)", dtLast.ToShortDateString());
                       strSQL.AppendFormat(" And DATE(Ledger.ConstructionEnd) <= DATE('{0}')", dtDefaultEnd.ToShortDateString());
                       strSQL.Append(")");
                       ArrayList ArData = new ArrayList();
                       if (!SalDB.ExecuteReader(strSQL.ToString(), ref ArData)) return;
                       // 半端分の日数を取得する
                       NextDiffDay = ArData.Cast<object[]>().Sum(x => CommonMotions.cnvInt(x[5]));
                       // 先期の半端分の日数を取得する
                       PrevDiffDay = CalcSpilledPreviusDay(SalDB, TargetYear, dtStart, PersonCode);
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 先期の終了後零れた日数を取得する
               /// <summary>
               /// 先期の終了後零れた日数を取得する
               /// </summary>
               /// <returns></returns>
               private static int CalcSpilledPreviusDay(IOMPersonInCharge SalDB
                                                   , int TargetYear, DateTime dtStart, int PersonCode)
+              {
                   try
+                  {
                       int RetDay = 0;
                       // 先期の期末を取得する
                       int PrevTargetYear = (TargetYear - 1);
                       if (PrevTargetYear < 1) return 0;
                       DateTime dtPrevEnd = CommonMotions.GetOpeningEndDate((TargetYear - 1), false);
                       // 今期の最初が先期の最後より大きい場合は処理しない
                       if (dtPrevEnd < dtStart) return 0;
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.Append("Select");
                       strSQL.Append(" Base.ConstructionCode");
                       strSQL.Append(", Ledger.ConstructionStart");
                       strSQL.Append(", Ledger.ConstructionEnd");
                       strSQL.Append(", LDetail.GroupCount");
                       strSQL.Append(", LDetail.SalaryFlg");
                       strSQL.Append(", LDetail.SalaryDays");
                       strSQL.Append(" From");
                       strSQL.Append(" constructionbaseinfo As Base");
                       strSQL.Append(" Inner Join constructionledger As Ledger");
                       strSQL.Append("       On Ledger.ConstructionCode = Base.ConstructionCode");
                       strSQL.Append(" Inner Join constructionledgerdetail As LDetail");
                       strSQL.Append("       On LDetail.ConstructionCode = Base.ConstructionCode");
                       strSQL.AppendFormat(" And LDetail.GroupCount = {0}", (int)ConstructionLedgerDetail.GroupCountDef.Payroll);
                       strSQL.AppendFormat(" And LDetail.CompanyCode = {0}", PersonCode);
                       strSQL.AppendFormat(" And LDetail.SalaryFlg = {0}", (int)CommonDefine.SalaryDevision.DaysInput);
                       strSQL.Append(" Where");
                       if (CommonMotions.BasePeriodYear())
                           strSQL.AppendFormat(" Base.ConstructionPeriod = {0}", PrevTargetYear);
                       else
                           strSQL.AppendFormat(" Base.ConstructionYear = {0}", PrevTargetYear);
                       strSQL.AppendFormat(" And Base.ConstructionPersonCode = {0}", PersonCode);
                       strSQL.Append(" And(");
                       strSQL.AppendFormat("DATE('{0}') <= DATE(Ledger.ConstructionStart)", (dtStart.AddDays(-1)).ToShortDateString());
                       strSQL.AppendFormat(" And DATE(Ledger.ConstructionEnd) <= DATE('{0}')", dtPrevEnd.ToShortDateString());
                       strSQL.Append(")");
                       ArrayList ArData = new ArrayList();
                       if (!SalDB.ExecuteReader(strSQL.ToString(), ref ArData)) return 0;
                       // 半端分の日数を取得する
                       RetDay = ArData.Cast<object[]>().Sum(x => CommonMotions.cnvInt(x[5]));
                       return RetDay;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return 0;
+                  }
+              }
               #endregion
               #region 経過給与を一括計算する
               /// <summary>
               /// 経過給与を一括計算する
               /// </summary>
               /// <param name="dtStart"></param>
               /// <param name="PersonCode"></param>
               /// <returns></returns>
               public static void CalcElapsedSalaryAll(IOMPersonInCharge SalDB, int TargetYear, ArrayList TargetList, ref List<KeyValuePair<int, long>> SalDataList)
+              {
                   try
+                  {
                       if (TargetList.Count < 1) return;
                       StringBuilder strSQL = new StringBuilder();
                       // 非受注コード
                       int nNotOrderCode = CommonDefine.ProjectsStatus.First(x => x.Value.Equals("非 受 注")).Key;
                       bool bFirst = true;
                       foreach (object[] ObjRec in TargetList)
+                      {
                           int DepartmentCode = CommonMotions.cnvInt(ObjRec[(int)CommonLedgerData.GetPersonTerm.DepartmentCode]);
                           int PersonCode = CommonMotions.cnvInt(ObjRec[(int)CommonLedgerData.GetPersonTerm.PersonCode]);
                           int nKeyCode = (DepartmentCode * 100000000) + PersonCode;
                           DateTime dtStart = CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.StartDate]);
                           DateTime dtLast = CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.CompDate]);
                           if (!bFirst) strSQL.Append(" UNION ");
                           strSQL.AppendFormat("SELECT {0} As LinkKey, SUM(SAL{0}.SALARY) FROM", nKeyCode);
                           strSQL.Append(" (SELECT AX.hiduke");
                           strSQL.AppendFormat("   , ROUND((AX.salary * {0}) / 30) AS SALARY", CommonDefine.s_SalaryCorrection);
                           strSQL.Append("         , MAX(AX.StartD)");
                           strSQL.Append("  From (SELECT A.d hiduke, B.MonthlySalary salary, B.STARTDATE StartD FROM");
                           strSQL.Append("              (SELECT A1.years");
                           strSQL.Append("                    , A2.month");
                           strSQL.Append("                    , A3.days");
                           strSQL.Append("                    , DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days)) AS d");
                           strSQL.Append("               FROM yearmaster AS A1, monthmaster AS A2, daymaster AS A3");
                           strSQL.Append("               WHERE");
                           if (dtStart.Year == dtLast.Year)
+                          {
                               strSQL.AppendFormat(" (A1.years = {0} AND A2.month IN (", dtStart.Year.ToString("0000"));
                               for (int i = dtStart.Month; i <= dtLast.Month; i++)
+                              {
                                   if (i != dtStart.Month) strSQL.Append(", ");
                                   strSQL.AppendFormat("{0} ", i);
+                              }
                               strSQL.Append("))");
+                          }
                           else
+                          {
                               strSQL.Append(" (");
                               for (int iYear = dtStart.Year; iYear <= dtLast.Year; iYear++)
+                              {
                                   // 先頭以外はORを追加する
                                   if (iYear != dtStart.Year) strSQL.AppendFormat(" OR");
                                   strSQL.AppendFormat(" (A1.years = {0}", iYear.ToString("0000"));
                                   strSQL.Append(" AND A2.month IN (");
                                   if (iYear == dtStart.Year)
                                   {   // 先頭年
                                       for (int i = dtStart.Month; i <= 12; i++)
+                                      {
                                           if (i != dtStart.Month) strSQL.Append(", ");
                                           strSQL.AppendFormat("{0} ", i);
+                                      }
+                                  }
                                   else if (iYear == dtLast.Year)
                                   {   // 最終年
                                       for (int i = 1; i <= dtLast.Month; i++)
+                                      {
                                           if (i != 1) strSQL.Append(", ");
                                           strSQL.AppendFormat("{0} ", i);
+                                      }
+                                  }
                                   else
                                   {   // 以外の年
                                       for (int i = 1; i <= 12; i++)
+                                      {
                                           if (i != 1) strSQL.Append(", ");
                                           strSQL.AppendFormat("{0} ", i);
+                                      }
+                                  }
                                   strSQL.Append("))");
+                              }
                               strSQL.Append(")");
+                          }
                           strSQL.Append("              AND DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days)) IS NOT NULL");
                           strSQL.AppendFormat("        AND (DATE('{0}') <= DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days))", dtStart.ToShortDateString());
                           strSQL.AppendFormat("        AND DATE(CONCAT(A1.years, '/', A2.month, '/', A3.days)) <= DATE('{0}'))", dtLast.ToShortDateString());
                           strSQL.Append("              ORDER BY d) A");
                           strSQL.Append(" , PERSONSALARYMASTER AS B");
                           strSQL.Append("   Inner Join personinchargemaster As C");
                           strSQL.Append("          On C.PersonCode = B.PersonCode");
                           strSQL.AppendFormat("    And C.LedgerFlg = {0}", (int)PersonInChargeMaster.LedgerDivNoDef.CalcTarget);
                           strSQL.AppendFormat(" WHERE B.PERSONCODE = {0}", PersonCode);
                           //strSQL.Append("       AND B.STARTDATE <= A.d");
                           strSQL.Append("       AND B.STARTDATE = ");
                           strSQL.Append("                          (Select BB.STARTDATE From PERSONSALARYMASTER AS BB");
                           strSQL.AppendFormat("                                        Where BB.PERSONCODE = {0}", PersonCode);
                           strSQL.Append("                                              AND BB.STARTDATE <= A.d");
                           strSQL.Append("                                              Order By BB.STARTDATE DESC");
                           strSQL.Append("                                              Limit 1)");
                           strSQL.Append(" ORDER BY A.d, B.STARTDATE DESC) AS AX");
                           strSQL.Append(" GROUP BY AX.hiduke");
                           strSQL.Append(" ORDER BY AX.hiduke");
                           strSQL.AppendFormat(" ) AS SAL{0}", nKeyCode);
                           bFirst = false;
+                      }
                       ArrayList ArData = new ArrayList();
                       if (!SalDB.ExecuteReader(strSQL.ToString(), ref ArData)) return;
                       foreach (object[] objRec in ArData)
+                      {
                           SalDataList.Add(new KeyValuePair<int, long>(CommonMotions.cnvInt(objRec[0]), CommonMotions.cnvLong(objRec[1])));
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 期間より零れた経過給与を取得しデータテーブルの開始終了日を変更する
               /// <summary>
               /// 期間より零れた経過給与を取得しデータテーブルの開始終了日を変更する
               /// </summary>
               /// <returns></returns>
               public static void CalcSpilledSalaryAll(IOMPersonInCharge SalDB
                                                   , int TargetYear
                                                   , ref ArrayList TargetList)
+              {
                   try
+                  {
                       if (TargetList.Count < 1) return;
                       // デフォルト開始・終了を取得する
                       DateTime dtDefaultStart = CommonMotions.GetOpeningEndDate(TargetYear, true);
                       DateTime dtDefaultEnd = CommonMotions.GetOpeningEndDate(TargetYear, false);
                       DateTime dtPrevEnd = CommonMotions.GetOpeningEndDate((TargetYear - 1), false);
                       // 先期の期末を取得する
                       int PrevTargetYear = (TargetYear - 1);
                       if (PrevTargetYear < 1) return;
                       List<KeyValuePair<int, int>> wrkManCode = new List<KeyValuePair<int, int>>();
                       List<KeyValuePair<DateTime, DateTime>> wrkStEdDate = new List<KeyValuePair<DateTime, DateTime>>();
                       bool bFirst = true;
                       StringBuilder strSQL = new StringBuilder();
                       foreach (object[] ObjRec in TargetList)
+                      {
                           // 開始・終了日が無い場合はデフォルトの期首・期末を使用する
                           DateTime stDate = CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.StartDate]);
                           DateTime edDate = CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.CompDate]);
                           CalcStartCompDate(TargetYear,
                                               dtDefaultStart, dtDefaultEnd,
                                               CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.HireStartDays]),
                                               CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.HireCompDays]),
                                               CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.NextStartDate]),
                                               CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.NextCompDate]),
                                               CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.DepHistoryStartDate]),
                                               CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.DepHistoryCompDate]),
                                               ref stDate, ref edDate);
                           int nDepCode = CommonMotions.cnvInt(ObjRec[(int)CommonLedgerData.GetPersonTerm.DepartmentCode]);
                           int nPersonCode = CommonMotions.cnvInt(ObjRec[(int)CommonLedgerData.GetPersonTerm.PersonCode]);
                           wrkManCode.Add(new KeyValuePair<int, int>(nDepCode, nPersonCode));
                           wrkStEdDate.Add(new KeyValuePair<DateTime, DateTime>(stDate, edDate));
                           // 今期の最初が先期の最後より大きい場合は処理しない
                           //if (dtPrevEnd < stDate) continue;
                           if (!bFirst) strSQL.Append(" Union ");
                           strSQL.Append("Select");
                           if (CommonMotions.BasePeriodYear())
                               strSQL.Append(" Base.ConstructionPeriod");
                           else
                               strSQL.Append(" Base.ConstructionYear");
                           strSQL.Append(", Base.ConstructionCode");
                           strSQL.Append(", LDetail.CompanyCode");
                           strSQL.Append(", Ledger.ConstructionStart");
                           strSQL.Append(", Ledger.ConstructionEnd");
                           strSQL.Append(", LDetail.GroupCount");
                           strSQL.Append(", LDetail.SalaryFlg");
                           strSQL.Append(", LDetail.SalaryDays");
                           strSQL.Append(", LDetail.ComponentCode");
                           strSQL.Append(" From");
                           strSQL.Append(" constructionbaseinfo As Base");
                           strSQL.Append(" Inner Join constructionledger As Ledger");
                           strSQL.Append("       On Ledger.ConstructionCode = Base.ConstructionCode");
                           strSQL.AppendFormat("  And DATE('{0}') <= DATE(Ledger.ConstructionEnd)", dtDefaultStart.ToShortDateString());
                           strSQL.Append(" Inner Join constructionledgerdetail As LDetail");
                           strSQL.Append("       On LDetail.ConstructionCode = Base.ConstructionCode");
                           strSQL.AppendFormat("  And LDetail.GroupCount = {0}", (int)ConstructionLedgerDetail.GroupCountDef.Payroll);
                           strSQL.AppendFormat("  And LDetail.ComponentCode = {0}", nDepCode);
                           strSQL.AppendFormat("  And LDetail.CompanyCode = {0}", nPersonCode);
                           strSQL.AppendFormat("  And LDetail.SalaryFlg = {0}", (int)CommonDefine.SalaryDevision.DaysInput);
                           strSQL.Append(" Where");
                           if (CommonMotions.BasePeriodYear())
                               strSQL.AppendFormat(" Base.ConstructionPeriod = {0}", TargetYear);
                           else
                               strSQL.AppendFormat(" Base.ConstructionYear = {0}", TargetYear);
                           strSQL.AppendFormat(" And Base.ConstrDepCode = {0}", nDepCode);
                           strSQL.AppendFormat(" And Base.ConstructionPersonCode = {0}", nPersonCode);
                           strSQL.Append(" And(");
                           strSQL.AppendFormat("DATE('{0}') <= DATE(Ledger.ConstructionStart)", edDate.ToShortDateString());
                           strSQL.AppendFormat(" And DATE(Ledger.ConstructionEnd) <= DATE('{0}')", dtDefaultEnd.ToShortDateString());
                           strSQL.Append(")");
                           strSQL.Append(" Union Select");
                           if (CommonMotions.BasePeriodYear())
                               strSQL.Append(" Base.ConstructionPeriod");
                           else
                               strSQL.Append(" Base.ConstructionYear");
                           strSQL.Append(", Base.ConstructionCode");
                           strSQL.Append(", LDetail.CompanyCode");
                           strSQL.Append(", Ledger.ConstructionStart");
                           strSQL.Append(", Ledger.ConstructionEnd");
                           strSQL.Append(", LDetail.GroupCount");
                           strSQL.Append(", LDetail.SalaryFlg");
                           strSQL.Append(", LDetail.SalaryDays");
                           strSQL.Append(", LDetail.ComponentCode");
                           strSQL.Append(" From");
                           strSQL.Append(" constructionbaseinfo As Base");
                           strSQL.Append(" Inner Join constructionledger As Ledger");
                           strSQL.Append("       On Ledger.ConstructionCode = Base.ConstructionCode");
                           strSQL.Append(" Inner Join constructionledgerdetail As LDetail");
                           strSQL.Append("       On LDetail.ConstructionCode = Base.ConstructionCode");
                           strSQL.AppendFormat("  And LDetail.GroupCount = {0}", (int)ConstructionLedgerDetail.GroupCountDef.Payroll);
                           strSQL.AppendFormat("  And LDetail.ComponentCode = {0}", nDepCode);
                           strSQL.AppendFormat("  And LDetail.CompanyCode = {0}", nPersonCode);
                           strSQL.AppendFormat("  And LDetail.SalaryFlg = {0}", (int)CommonDefine.SalaryDevision.DaysInput);
                           strSQL.Append(" Where");
                           if (CommonMotions.BasePeriodYear())
                               strSQL.AppendFormat(" Base.ConstructionPeriod = {0}", PrevTargetYear);
                           else
                               strSQL.AppendFormat(" Base.ConstructionYear = {0}", PrevTargetYear);
                           strSQL.AppendFormat(" And Base.ConstrDepCode = {0}", nDepCode);
                           strSQL.AppendFormat(" And Base.ConstructionPersonCode = {0}", nPersonCode);
                           strSQL.Append(" And(");
                           strSQL.AppendFormat("DATE('{0}') <= DATE(Ledger.ConstructionStart)", (stDate.AddDays(-1)).ToShortDateString());
                           strSQL.AppendFormat(" And DATE(Ledger.ConstructionEnd) <= DATE('{0}')", dtPrevEnd.ToShortDateString());
                           strSQL.Append(")");
                           bFirst = false;
+                      }
                       // データ取得
                       ArrayList ArData = new ArrayList();
                       if (!SalDB.ExecuteReader(strSQL.ToString(), ref ArData)) return;
                       foreach (object[] ObjRec in TargetList)
+                      {
                           int nDepCode = CommonMotions.cnvInt(ObjRec[(int)CommonLedgerData.GetPersonTerm.DepartmentCode]);
                           int nPersonCode = CommonMotions.cnvInt(ObjRec[(int)CommonLedgerData.GetPersonTerm.PersonCode]);
                           // 半端分の日数を取得する
                           int NextDiffDay = ArData.Cast<object[]>().Where(x => CommonMotions.cnvInt(x[0]) == TargetYear
                                                                           && CommonMotions.cnvInt(x[8]) == nDepCode
                                                                           && CommonMotions.cnvInt(x[2]) == nPersonCode)
                                                                   .Sum(y => CommonMotions.cnvInt(y[7]));
                           // 先期の半端分の日数を取得する
                           int PrevDiffDay = ArData.Cast<object[]>().Where(x => CommonMotions.cnvInt(x[0]) == PrevTargetYear
                                                                           && CommonMotions.cnvInt(x[8]) == nDepCode
                                                                           && CommonMotions.cnvInt(x[2]) == nPersonCode)
                                                                   .Sum(y => CommonMotions.cnvInt(y[7]));
                           // 同じデータを探す
                           int DateCnt = 0;
                           foreach (KeyValuePair<int, int> CurRec in wrkManCode)
+                          {
                               if (CurRec.Key == nDepCode && CurRec.Value == nPersonCode) break;
                               DateCnt++;
+                          }
                           KeyValuePair<DateTime, DateTime> CurStEd = wrkStEdDate[DateCnt];
                           DateTime dtDepMove = CommonMotions.cnvDate(ObjRec[(int)CommonLedgerData.GetPersonTerm.DepHistoryStartDate]);
                           // 今期終了日変更
                           DateTime wrkDate = CurStEd.Value.AddDays(NextDiffDay);
                           if (dtDefaultEnd.Date < wrkDate.Date) wrkDate = dtDefaultEnd;
                           ObjRec[(int)CommonLedgerData.GetPersonTerm.CompDate] = wrkDate;
                           if (dtDepMove.Date == CurStEd.Key.Date) PrevDiffDay = 0;    // 部署移動日がセットされている場合は日付を変えない
                           // 今期開始日変更
                           wrkDate = CurStEd.Key.AddDays(PrevDiffDay);
                           if (dtDefaultEnd.Date < wrkDate.Date) wrkDate = dtDefaultEnd;
                           ObjRec[(int)CommonLedgerData.GetPersonTerm.StartDate] = wrkDate;
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 計算開始・終了日のチェック入れ替え
               /// <summary>
               /// 計算開始・終了日のチェック入れ替え
               /// </summary>
               public static void CalcStartCompDate(int BusinessPeriod,
                                               DateTime dtDefaultStart, DateTime dtDefaultEnd,
                                               DateTime HireStartDate, DateTime HireCompDate,
                                               DateTime NextStartDate, DateTime NextCompDate,
                                               DateTime DepHisStDate, DateTime DepHisCompDate,
                                               ref DateTime StartDate, ref DateTime CompDate)
+              {
                   try
+                  {
                       // ----- 計算開始日セット
                       if (StartDate.Date == DateTime.MinValue.Date)
+                      {
                           // 最小値ならば今期開始をセット
                           StartDate = dtDefaultStart;
+                      }
                       //else if (dtDefaultStart.Date <= HireStartDate.Date && HireStartDate.Date <= dtDefaultEnd.Date)
                       //{
                       //    // 入社日が期内ならば開始を入社日にする
                       //    StartDate = HireStartDate;
                       //}
                       else if (dtDefaultStart.Date < StartDate.Date)
+                      {
                           // 今期工事の契約工期が今期の開始より小さい場合は今期開始をセット
                           StartDate = dtDefaultStart;
+                      }
                       // 入社日が期内ならば開始を入社日にする
                       if (dtDefaultStart.Date <= HireStartDate && HireStartDate.Date <= dtDefaultEnd.Date)
+                      {
                           StartDate = HireStartDate;
+                      }
                       // 部署移動開始日が今期ならばセットする
                       if (dtDefaultStart.Date <= DepHisStDate.Date && DepHisStDate.Date <= dtDefaultEnd.Date)
+                      {
                           if (StartDate.Date < DepHisStDate.Date) StartDate = DepHisStDate;
+                      }
                       // ----- 計算終了日セット
                       // Defaultは期末
                       CompDate = dtDefaultEnd;
                       // 退社日が期内ならば終了を退社日にする
                       if (dtDefaultStart.Date < HireCompDate.Date && HireCompDate.Date < dtDefaultEnd.Date)
+                      {
                           CompDate = HireCompDate;
+                      }
                       else if (DepHisCompDate.Date == DateTime.MaxValue.Date)
+                      {
                           // 終了がマックスは今季終了をセットする
                           CompDate = dtDefaultEnd;
+                      }
                       else if (NextStartDate.Date != DateTime.MinValue.Date)
+                      {
                           // 来季の開始があって今期の場合は開始日-1に置き換える
                           if (dtDefaultStart.Date < NextStartDate.Date && NextStartDate.Date < dtDefaultEnd.Date)
+                          {
                               CompDate = NextStartDate.AddDays(-1);
+                          }
+                      }
                       // 部署移動終了日が今期ならばセットする
                       if (dtDefaultStart.Date <= DepHisCompDate.Date && DepHisCompDate.Date <= dtDefaultEnd.Date)
+                      {
                           if (DepHisCompDate.Date < CompDate.Date) CompDate = DepHisCompDate;
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}", ex.Message);
+                  }
+              }
               #endregion
               #region グリッド行退避エリア初期化処理
               /// <summary>
               /// グリッド行退避エリア初期化処理
               /// </summary>
               public static void InitSavrGridRow(ref GridCellStyleMember[] BackUpStyle)
+              {
                   try
+                  {
                       for (int i = 0; i < BackUpStyle.Length; i++)
+                      {
                           BackUpStyle[i] = new GridCellStyleMember();
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 選択行の色を変更する
               /// <summary>
               /// 選択行の色を変更する
               /// </summary>
               public static void ChangeGridRow(DataGridViewEX dgv
                                               , DataGridViewRow CurRow
                                               , ref GridCellStyleMember[] BackUpStyle
                                               , bool bSelect = true)
+              {
                   try
+                  {
                       // カレント行バックアップ＆対象色セット
                       for (int i = 0; i < dgv.ColumnCount; i++)
+                      {
                           if (bSelect)
+                          {
                               BackUpStyle[i].DrowBackColor = CurRow.Cells[i].Style.BackColor;
                               BackUpStyle[i].DrowFont = CurRow.Cells[i].Style.Font;
                               BackUpStyle[i].DrowForeColor = CurRow.Cells[i].Style.ForeColor;
                               CurRow.Cells[i].Style.BackColor = Color.Red;
                               CurRow.Cells[i].Style.ForeColor = Color.White;
+                          }
                           else
+                          {
                               CurRow.Cells[i].Style.BackColor = BackUpStyle[i].DrowBackColor;
                               CurRow.Cells[i].Style.Font = BackUpStyle[i].DrowFont;
                               CurRow.Cells[i].Style.ForeColor = BackUpStyle[i].DrowForeColor;
+                          }
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region フォームのコントロールを列挙する
               /// <summary>
               /// フォームのコントロールを列挙する
               /// </summary>
               /// <returns></returns>
               public static Control[] GetAllControls(Control top)
+              {
                   ArrayList buf = new ArrayList();
                   foreach (Control c in top.Controls)
+                  {
                       buf.Add(c);
                       buf.AddRange(GetAllControls(c));
+                  }
                   return (Control[])buf.ToArray(typeof(Control));
+              }
               #endregion
               #region 今期以降の判定を行う
               /// <summary>
               /// 今期以降の判定を行う
               /// </summary>
               /// <returns></returns>
               public static bool CheckNowSeason(int nTarget)
+              {
                   try
+                  {
                       if (CommonMotions.BasePeriodYear())
                       {   // 営業期数
                           if (nTarget < m_systemMaster.BusinessPeriod) return false;
+                      }
                       else
                       {   // 工事年度
                           if (nTarget < m_systemMaster.ConstrYear) return false;
+                      }
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #endregion
               #region 部署コンボボックスデータ取得ＳＱＬ作成
               /// <summary>
               /// 部署コンボボックスデータ取得ＳＱＬ作成
               /// </summary>
               /// <param name="strSQL"></param>
               public static void CreateDepCombBoxSQL(ref StringBuilder strSQL
                                                       , int nTargetCount
                                                       , bool bCompBase = true
                                                       , bool bLedgerDivNo = false
                                                       , bool bConstrBase = true)
+              {
                   try
+                  {
                       if (CommonMotions.LoginUserData.PersonCode == CommonDefine.AdminCode)
+                      {
                           strSQL.Append("SELECT");
                           strSQL.Append(" A.DEPARTMENTCODE");
                           strSQL.Append(", A.DEPARTMENTSTRING");
                           strSQL.Append(", A.DISPLAYORDER");
                           strSQL.Append(", 1");
                           strSQL.Append(" From DEPARTMENTMASTER As A");
                           strSQL.AppendFormat(" Where DeleteFlg = {0}", (int)CommonDefine.DataDeleteDef.Exists);
                           return;
+                      }
                       // 今期のデータかどうかを判定する
                       bool bNowSeason = CheckNowSeason(nTargetCount);
                       strSQL.Append("SELECT");
                       strSQL.Append(" A.DEPARTMENTCODE");
                       strSQL.Append(", A.DEPARTMENTSTRING");
                       strSQL.Append(", A.DISPLAYORDER");
                       strSQL.Append(", COUNT(*)");
                       strSQL.Append(" FROM");
                       strSQL.Append(" persondepartmentmaster As AA");
                       strSQL.Append(" INNER JOIN ChgChargeDep As AB");
                       strSQL.Append("       On AB.PersonCode = AA.PersonCode");
                       strSQL.Append(" INNER JOIN DEPARTMENTMASTER As A");
                       strSQL.Append("       On A.DepartmentCode = AA.DepartmentCode");
                       if (bNowSeason)
+                      {
                           // 今期のプライマリテーブルは部署マスタ
                           //strSQL.AppendFormat(" And A.DELETEFLG = {0}", (int)CommonDefine.DataDeleteDef.Exists);
+                      }
                       else
+                      {
                           if (bConstrBase)
+                          {
                               // 過去のデータは工事情報より取得する
                               strSQL.Append(" INNER JOIN (");
                               strSQL.Append("Select");
                               strSQL.Append(" A1.SalesDepCode As DEPARTMENTCODE");
                               strSQL.Append(", A1.SalesPersonCode As PERSONCODE");
                               strSQL.Append(", B1.DetailString As DEPARTMENTSTRING");
                               strSQL.Append(", ifnull(C1.DisplayOrder, 10) As DISPLAYORDER");
                               strSQL.Append(" From Constructionbaseinfo As A1");
                               strSQL.Append("  Inner Join constructionbaseinfodetail As B1");
                               strSQL.Append("        On B1.ConstructionCode = A1.ConstructionCode");
                               strSQL.AppendFormat("  And B1.DetailNo = {0}", (int)ConstructionBaseInfoDetail.DataNoDef.SalesDepartmentName);
                               strSQL.Append("  Left Join departmentmaster As C1");
                               strSQL.Append("       On C1.DepartmentCode = A1.SalesDepCode");
                               if (CommonMotions.BasePeriodYear())
                                   strSQL.AppendFormat(" Where A1.ConstructionPeriod = {0}", nTargetCount);
                               else
                                   strSQL.AppendFormat(" Where A1.ConstructionYear = {0}", nTargetCount);
                               strSQL.Append("       And A1.SalesDepCode != 0");
                               strSQL.Append(" Union Select");
                               strSQL.Append(" A2.ConstrDepCode As DEPARTMENTCODE");
                               strSQL.Append(", A2.ConstructionPersonCode As PERSONCODE");
                               strSQL.Append(", B2.DetailString As DEPARTMENTSTRING");
                               strSQL.Append(", ifnull(C2.DisplayOrder, 10) As DISPLAYORDER");
                               strSQL.Append(" From Constructionbaseinfo As A2");
                               strSQL.Append(" Inner Join constructionbaseinfodetail As B2");
                               strSQL.Append("       On B2.ConstructionCode = A2.ConstructionCode");
                               strSQL.AppendFormat(" And B2.DetailNo = {0}", (int)ConstructionBaseInfoDetail.DataNoDef.ConstrDepartmentName);
                               strSQL.Append(" Left Join departmentmaster As C2");
                               strSQL.Append("      On C2.DepartmentCode = A2.ConstrDepCode");
                               if (CommonMotions.BasePeriodYear())
                                   strSQL.AppendFormat(" Where A2.ConstructionPeriod = {0}", nTargetCount);
                               else
                                   strSQL.AppendFormat(" Where A2.ConstructionYear = {0}", nTargetCount);
                               strSQL.Append("       And A2.ConstrDepCode != 0");
                               strSQL.Append(" Union Select");
                               strSQL.Append(" A3.ConstrSubDepCode As DEPARTMENTCODE");
                               strSQL.Append(", A3.ConstrSubPersonCode As PERSONCODE");
                               strSQL.Append(", B3.DetailString As DEPARTMENTSTRING");
                               strSQL.Append(", ifnull(C3.DisplayOrder, 10) As DISPLAYORDER");
                               strSQL.Append(" From Constructionbaseinfo As A3");
                               strSQL.Append(" Inner Join constructionbaseinfodetail As B3");
                               strSQL.Append("       On B3.ConstructionCode = A3.ConstructionCode");
                               strSQL.AppendFormat(" And B3.DetailNo = {0}", (int)ConstructionBaseInfoDetail.DataNoDef.ConstrSubDepartmentName);
                               strSQL.Append(" Left Join departmentmaster As C3");
                               strSQL.Append("      On C3.DepartmentCode = A3.ConstrSubDepCode");
                               if (CommonMotions.BasePeriodYear())
                                   strSQL.AppendFormat(" Where A3.ConstructionPeriod = {0}", nTargetCount);
                               else
                                   strSQL.AppendFormat(" Where A3.ConstructionYear = {0}", nTargetCount);
                               strSQL.Append("       And A3.ConstrSubDepCode != 0");
                               strSQL.Append(" Union Select");
                               strSQL.Append(" A4.ConstrInstrDepCode As DEPARTMENTCODE");
                               strSQL.Append(", A4.ConstructionInstructor As PERSONCODE");
                               strSQL.Append(", B4.DetailString As DEPARTMENTSTRING");
                               strSQL.Append(", ifnull(C4.DisplayOrder, 10) As DISPLAYORDER");
                               strSQL.Append(" From Constructionbaseinfo As A4");
                               strSQL.Append(" Inner Join constructionbaseinfodetail As B4");
                               strSQL.Append("       On B4.ConstructionCode = A4.ConstructionCode");
                               strSQL.AppendFormat(" And B4.DetailNo = {0}", (int)ConstructionBaseInfoDetail.DataNoDef.InstrDepartmentName);
                               strSQL.Append(" Left Join departmentmaster As C4");
                               strSQL.Append("      On C4.DepartmentCode = A4.ConstrInstrDepCode");
                               if (CommonMotions.BasePeriodYear())
                                   strSQL.AppendFormat(" Where A4.ConstructionPeriod = {0}", nTargetCount);
                               else
                                   strSQL.AppendFormat(" Where A4.ConstructionYear = {0}", nTargetCount);
                               strSQL.Append("       And A4.ConstrInstrDepCode != 0");
                               strSQL.Append(" Union Select");
                               strSQL.Append(" A5.SalesSubDepCode As DEPARTMENTCODE");
                               strSQL.Append(", A5.SalesSubPersonCode As PERSONCODE");
                               strSQL.Append(", B5.DetailString As DEPARTMENTSTRING");
                               strSQL.Append(", ifnull(C5.DisplayOrder, 10) As DISPLAYORDER");
                               strSQL.Append(" From Constructionbaseinfo As A5");
                               strSQL.Append(" Inner Join constructionbaseinfodetail As B5");
                               strSQL.Append("       On B5.ConstructionCode = A5.ConstructionCode");
                               strSQL.AppendFormat(" And B5.DetailNo = {0}", (int)ConstructionBaseInfoDetail.DataNoDef.SalesSubDepartmentName);
                               strSQL.Append(" Left Join departmentmaster As C5");
                               strSQL.Append("      On C5.DepartmentCode = A5.SalesSubDepCode");
                               if (CommonMotions.BasePeriodYear())
                                   strSQL.AppendFormat(" Where A5.ConstructionPeriod = {0}", nTargetCount);
                               else
                                   strSQL.AppendFormat(" Where A5.ConstructionYear = {0}", nTargetCount);
                               strSQL.Append("       And A5.ConstrInstrDepCode != 0");
                               strSQL.Append(") As D On D.DEPARTMENTCODE = AA.DepartmentCode");
+                          }
+                      }
                       if (bNowSeason && bCompBase)
                       {   // 対象が今期の場合で工事情報の登録を確認する時
                           strSQL.Append(" Inner Join CONSTRUCTIONBASEINFO C");
                           strSQL.Append("       On C.ConstrDepCode = A.DepartmentCode");
+                      }
                       // 台帳計算対象外は外す
                       //if (bLedgerDivNo) strSQL.Append(", PERSONINCHARGEMASTER B");
                       strSQL.Append(" WHERE");
                       strSQL.AppendFormat(" AA.PersonCode = {0}", CommonMotions.LoginUserData.PersonCode);
                       DateTime dtDefaultStart = CommonMotions.GetOpeningEndDate(nTargetCount, true);
                       DateTime dtDefaultEnd = CommonMotions.GetOpeningEndDate(nTargetCount, false);
                       if (bNowSeason)
+                      {
                           // 対象が今期の場合
                           //strSQL.AppendFormat(" And DATE(A.StartDate) <= DATE('{0}')", dtDefaultEnd.ToShortDateString());
                           // 開始日が今日より小さい
                           strSQL.AppendFormat(" And DATE(A.StartDate) <= DATE('{0}')", DateTime.Today.ToShortDateString());
                           // システム管理者以外は部署参照マスタよりデータ取得
                           if (CommonMotions.LoginUserData.PersonCode != CommonDefine.AdminCode)
+                          {
                               // 参照部署マスタより取得する
                               strSQL.Append(" And A.DEPARTMENTCODE");
                               strSQL.Append(" IN (SELECT A1.DEPARTMENTCODE FROM PERSONDEPARTMENTMASTER A1");
                               strSQL.AppendFormat(" WHERE A1.PERSONCODE = {0})", CommonMotions.LoginUserData.PersonCode);
+                          }
+                      }
                       else
+                      {
                           strSQL.AppendFormat(" AND DATE('{0}') <= DATE(AB.CompDate)", dtDefaultEnd.ToShortDateString());
                           //strSQL.AppendFormat(" AND ((DATE(AB.STARTDATE) <= DATE('{0}'))", dtDefaultEnd.ToShortDateString());
                           //strSQL.AppendFormat(" AND(DATE('{0}') <= DATE(AB.CompDate)", dtDefaultStart.ToShortDateString());
                           //strSQL.AppendFormat(" OR DATE('{0}') = DATE(AB.CompDate)))", DateTime.MinValue.ToShortDateString());
+                      }
                       if (bNowSeason)
                           strSQL.Append(" And (");
                       else
                           strSQL.Append(" And");
                       strSQL.Append(" (0 < (SELECT COUNT(*) FROM constructionbaseinfo AS BX");
                       if (CommonMotions.BasePeriodYear())
                           strSQL.AppendFormat(" Where BX.ConstructionPeriod = {0}", nTargetCount);
                       else
                           strSQL.AppendFormat(" Where BX.ConstructionYear = {0}", nTargetCount);
                       strSQL.Append("                 AND (BX.SalesDepCode = AA.DepartmentCode");
                       strSQL.Append("                 Or BX.ConstrDepCode = AA.DepartmentCode");
                       strSQL.Append("                 Or BX.ConstrSubDepCode = AA.DepartmentCode");
                       strSQL.Append("                 Or BX.ConstrInstrDepCode = AA.DepartmentCode)))");
                       if (bNowSeason)
+                      {
                           strSQL.Append(" Or (0 < (SELECT COUNT(*) FROM PERSONINCHARGEMASTER AS B");
                           strSQL.Append("                           WHERE B.DepartmentCode = AA.DepartmentCode");
                           // 台帳計算対象のみ
                           if (!bLedgerDivNo) strSQL.AppendFormat("  And B.LedgerFlg = {0}", (int)PersonInChargeMaster.LedgerDivNoDef.CalcTarget);
                           // 今期は削除されていないもののみ
                           strSQL.AppendFormat("                     And B.DeleteFlg = {0})))", (int)CommonDefine.DataDeleteDef.Exists);
+                      }
                       strSQL.Append(" GROUP BY A.DEPARTMENTCODE, A.DEPARTMENTSTRING, A.DISPLAYORDER");
                       strSQL.Append(" ORDER BY A.DISPLAYORDER ASC");
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 担当者コンボボックスデータ取得ＳＱＬ作成
               /// <summary>
               /// 担当者コンボボックスデータ取得ＳＱＬ作成
               /// </summary>
               /// <param name="strSQL"></param>
               /// <param name="nTargetYear"></param>
               public static void CreateManCombBoxSQL(ref StringBuilder strSQL
                                                       , int nTargetYear
                                                       , int nDepCode = 0
                                                       , int nPersonCode = 0
                                                       , bool bNewDataFlg = false
                                                       , bool bLedgerDivNo = false
                                                       , bool bConstrBase = true)
+              {
                   try
+                  {
                       DateTime dtDefaultStart = CommonMotions.GetOpeningEndDate(nTargetYear, true);
                       DateTime dtDefaultEnd = CommonMotions.GetOpeningEndDate(nTargetYear, false);
                       strSQL.AppendFormat("Select {0} From", IOMPersonInCharge.CreateFieldNameList("A."));
                       strSQL.Append(" personinchargemaster As A");
                       strSQL.Append(" Left Join chgchargedep As B");
                       strSQL.Append("       On B.PersonCode = A.PersonCode");
                       strSQL.Append(" WHERE");
                       strSQL.AppendFormat("     ((DATE(A.STARTDATE) <= DATE('{0}'))", dtDefaultEnd.ToShortDateString());
                       strSQL.AppendFormat("  AND (DATE('{0}') <= DATE(A.ENDDATE)", dtDefaultStart.ToShortDateString());
                       strSQL.AppendFormat("  OR   DATE('{0}') = DATE(A.ENDDATE)))", DateTime.MinValue.ToShortDateString());
                       strSQL.AppendFormat(" AND ((DATE(B.STARTDATE) <= DATE('{0}'))", dtDefaultEnd.ToShortDateString());
                       strSQL.AppendFormat("  AND (DATE('{0}') <= DATE(B.CompDate)", dtDefaultStart.ToShortDateString());
                       strSQL.AppendFormat("  OR   DATE('{0}') = DATE(B.CompDate)))", DateTime.MinValue.ToShortDateString());
                       if ((nDepCode > 0 && nPersonCode > 0) && nPersonCode != CommonDefine.AdminCode)
+                      {
                           if (CheckNowSeason(nTargetYear))
+                          {
                               strSQL.Append(" And (A.DepartmentCode in (Select C.DepartmentCode From persondepartmentmaster As C");
                               strSQL.AppendFormat(" Where C.PersonCode = {0})", nPersonCode);
                               strSQL.AppendFormat(" Or A.DepartmentCode = {0})", nDepCode);
+                          }
                           else
+                          {
                               strSQL.Append(" And A.DepartmentCode in (Select C.DepartmentCode From persondepartmentmaster As C");
                               strSQL.AppendFormat(" Where C.PersonCode = {0})", nPersonCode);
+                          }
+                      }
                       // 新規のデータは削除者を表示しない
                       if (bNewDataFlg)
+                      {
                           strSQL.AppendFormat(" And A.DELETEFLG = {0}", (int)CommonDefine.DataDeleteDef.Exists);
+                      }
                       // 開始日が今日より小さい
                       strSQL.AppendFormat(" And DATE(A.StartDate) <= DATE('{0}')", DateTime.Today.ToShortDateString());
                       if (nDepCode > 0) strSQL.AppendFormat(" AND (B.DEPARTMENTCODE = {0})", nDepCode);
                       // 台帳計算対象外
                       if (bLedgerDivNo)
+                      {
                           strSQL.AppendFormat(" And A.LedgerFlg = {0}", (int)PersonInChargeMaster.LedgerDivNoDef.CalcTarget);
+                      }
                       // 今期のデータかどうかを判定する
                       string FieldName = string.Empty;
                       if (CommonMotions.BasePeriodYear())
                           FieldName = "ConstructionPeriod";
                       else
                           FieldName = "ConstructionYear";
                       if (bConstrBase)
+                      {
                           if (CheckNowSeason(nTargetYear))
+                          {
+                          }
                           else
+                          {
                               strSQL.Append(" AND B.DepartmentCode IN(SELECT InDep.DEPARTMENTCODE FROM (");
                               strSQL.Append(" Select A1.SalesDepCode As DEPARTMENTCODE From Constructionbaseinfo As A1");
                               strSQL.AppendFormat(" Where A1.{0} = {1}", FieldName, nTargetYear);
                               strSQL.Append(" Union Select A2.ConstrDepCode As DEPARTMENTCODE From Constructionbaseinfo As A2");
                               strSQL.AppendFormat(" Where A2.{0} = {1}", FieldName, nTargetYear);
                               strSQL.Append(" Union Select A3.ConstrSubDepCode As DEPARTMENTCODE From Constructionbaseinfo As A3");
                               strSQL.AppendFormat(" Where A3.{0} = {1}", FieldName, nTargetYear);
                               strSQL.Append(" Union Select A4.ConstrInstrDepCode As DEPARTMENTCODE From Constructionbaseinfo As A4");
                               strSQL.AppendFormat(" Where A4.{0} = {1}", FieldName, nTargetYear);
                               strSQL.Append(" ) As InDep");
                               strSQL.Append(" GROUP BY InDep.DEPARTMENTCODE) ");
+                          }
+                      }
                       strSQL.Append(" Group By A.PersonCode");
                       strSQL.Append(" Order By A.DeleteFlg ASC, A.EmployeeClassFlg ASC, A.DisplayOrder ASC");
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 担当者より指定年度の所属情報を取得するＳＱＬ作成
               /// <summary>
               /// 担当者より指定年度の所属情報を取得するＳＱＬ作成
               /// </summary>
               public static void CreateMan2DepInfoSQL(ref StringBuilder strSQL, int nTargetYear, int nPersonCode, DateTime dtPettion)
+              {
                   try
+                  {
                       DateTime dtDefaultStart = CommonMotions.GetOpeningEndDate(nTargetYear, true);
                       DateTime dtDefaultEnd = DateTime.Today.Date;
                       if (!CheckNowSeason(nTargetYear))
                           dtDefaultEnd = CommonMotions.GetOpeningEndDate(nTargetYear, false);
                       strSQL.Append("Select");
                       strSQL.Append(" A.PersonCode");
                       strSQL.Append(", A.PersonName");
                       strSQL.Append(", B.DepartmentCode");
                       strSQL.Append(", B.DepartmentName");
                       strSQL.Append(" From personinchargemaster As A");
                       strSQL.Append("      Left Join chgchargedep As B");
                       strSQL.Append("           On B.PersonCode = A.PersonCode");
                       strSQL.Append(" WHERE");
                       strSQL.AppendFormat(" ((DATE(A.STARTDATE) <= DATE('{0}'))", dtDefaultEnd.ToShortDateString());
                       strSQL.AppendFormat(" AND (DATE('{0}') <= DATE(A.ENDDATE)", dtDefaultStart.ToShortDateString());
                       strSQL.AppendFormat(" OR DATE('{0}') = DATE(A.ENDDATE)))", DateTime.MinValue.ToShortDateString());
                       if (dtPettion.Date == DateTime.MinValue.Date) dtPettion = dtDefaultEnd;
                       strSQL.AppendFormat(" AND ((DATE(B.STARTDATE) <= DATE('{0}'))", dtPettion.ToShortDateString());
                       strSQL.AppendFormat(" AND(DATE('{0}') <= DATE(B.CompDate)", dtPettion.ToShortDateString());
                       strSQL.AppendFormat(" OR DATE('{0}') = DATE(B.CompDate)))", DateTime.MaxValue.ToShortDateString());
                       strSQL.AppendFormat(" AND A.PersonCode = {0}", nPersonCode);
                       strSQL.Append(" Order By B.CompDate desc");
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 担当者コードより指定年度の所属部署コードのみを取得するＳＱＬ作成
               /// <summary>
               /// 担当者コードより指定年度の所属部署コードのみを取得するＳＱＬ作成
               /// </summary>
               public static void CreateMan2DepSQL(ref StringBuilder strSQL, int nTargetYear, int nPersonCode)
+              {
                   try
+                  {
                       DateTime dtDefaultStart = CommonMotions.GetOpeningEndDate(nTargetYear, true);
                       DateTime dtDefaultEnd = CommonMotions.GetOpeningEndDate(nTargetYear, false);
                       strSQL.Append("Select B.DepartmentCode From personinchargemaster As A");
                       strSQL.Append("                Inner Join chgchargedep As B");
                       strSQL.Append("                      On B.PersonCode = A.PersonCode");
                       strSQL.AppendFormat("     Where A.PersonCode = {0}", nPersonCode);
                       strSQL.AppendFormat("     AND ((DATE(B.STARTDATE) <= DATE('{0}'))", dtDefaultEnd.ToShortDateString());
                       strSQL.AppendFormat("     AND (DATE('{0}') <= DATE(B.CompDate)", dtDefaultStart.ToShortDateString());
                       strSQL.AppendFormat("     OR DATE('{0}') = DATE(B.CompDate)))", DateTime.MinValue.ToShortDateString());
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
+                  }
+              }
               #endregion
               #region 経費率データ読込み並び
               /// <summary>
               /// 経費率データ読込み並び
               /// </summary>
               public enum ExpensesArray
+              {
                   /// <summary>
                   /// 0:経費名称
                   /// </summary>
                   ExpensesName = 0,
                   /// <summary>
                   /// 1:経費率
                   /// </summary>
                   ExpensesRaito,
                   /// <summary>
                   /// 2:経費名称コード
                   /// </summary>
                   NameCode,
                   /// <summary>
                   /// 3:部署コード
                   /// </summary>
                   DepCode,
                   /// <summary>
                   /// 4:削除フラグ（部署経費マスタ）
                   /// </summary>
                   DeleteFlg,
+              }
               #endregion
               #region 経費率リスト取得処理
               /// <summary>
               /// 経費率リストを取得する
               /// </summary>
               /// <returns></returns>
               public static bool GetExpensesList(int Preiod, int DepartmentCode, ref ArrayList ExpensesList)
+              {
                   IOMDepartmentExpenses expDB = new IOMDepartmentExpenses();
                   try
+                  {
                       // 部署経費率マスタ取得
                       StringBuilder strSQL = new StringBuilder();
                       if (CheckNowSeason(Preiod))
                       {   // 今期データ
                           strSQL.Append("SELECT");
                           strSQL.Append(" A.NAMESTRING");
                           strSQL.Append(", IFNULL(B.EXPENSESRAITO, 0)");
                           strSQL.Append(", A.NAMECODE");
                           strSQL.Append(", B.DEPARTMENTCODE");
                           strSQL.Append(", A.DeleteFlg");
                           strSQL.Append(" FROM DIVISIONMASTER AS A");
                           strSQL.Append(" LEFT JOIN (SELECT");
                           strSQL.Append("                BB.NAMECODE");
                           strSQL.Append("              , BB.DEPARTMENTCODE");
                           strSQL.Append("              , BB.EXPENSESRAITO");
                           strSQL.Append("              , BB.EXPENSESPERIOD");
                           strSQL.Append("              , BB.DisplayOrder");
                           strSQL.Append("            FROM DEPARTMENTEXPENSESMASTER AS BB) AS B");
                           strSQL.Append("      ON A.NAMECODE = B.NAMECODE");
                           strSQL.AppendFormat(" AND B.EXPENSESPERIOD = {0}", Preiod);
                           if (DepartmentCode > 0) strSQL.AppendFormat(" AND B.DEPARTMENTCODE = {0}", DepartmentCode);
                           strSQL.Append(" LEFT JOIN departmentmaster AS C");
                           strSQL.Append("      On C.DepartmentCode = B.DEPARTMENTCODE");
                           strSQL.Append(" WHERE");
                           strSQL.AppendFormat(" A.DIVISIONCODE = {0}", (int)DivisionMaster.DivisionMasterCodeDef.ConstructionExpenses);
                           strSQL.AppendFormat(" AND A.DeleteFlg = {0}", (int)CommonDefine.DataDeleteDef.Exists);
                           strSQL.Append(" And B.EXPENSESRAITO > 0.00");
                           strSQL.Append(" ORDER BY A.DISPLAYORDER, C.DISPLAYORDER");
+                      }
                       else
                       {   // 以前のデータ
                           strSQL.Append("SELECT");
                           strSQL.Append(" B.NAMESTRING");
                           strSQL.Append(", B.EXPENSESRAITO");
                           strSQL.Append(", B.NAMECODE");
                           strSQL.Append(", B.DEPARTMENTCODE");
                           strSQL.Append(", B.DeleteFlg");
                           strSQL.Append(" FROM DEPARTMENTEXPENSESMASTER AS B");
                           strSQL.Append(" INNER JOIN departmentmaster AS C");
                           strSQL.Append("        On C.DepartmentCode = B.DEPARTMENTCODE");
                           strSQL.Append(" INNER JOIN divisionmaster AS D");
                           strSQL.AppendFormat("  ON D.DIVISIONCODE = {0}", (int)DivisionMaster.DivisionMasterCodeDef.ConstructionExpenses);
                           strSQL.Append("        And D.NameCode = B.NameCode");
                           strSQL.Append(" WHERE");
                           strSQL.AppendFormat(" B.EXPENSESPERIOD = {0}", Preiod);
                           if (DepartmentCode > 0) strSQL.AppendFormat(" AND B.DEPARTMENTCODE = {0}", DepartmentCode);
                           strSQL.Append(" And B.EXPENSESRAITO > 0.00");
                           strSQL.Append(" ORDER BY D.DeleteFlg, C.DISPLAYORDER, B.DISPLAYORDER");
+                      }
                       ExpensesList.Clear();
                       if (!expDB.ExecuteReader(strSQL.ToString(), ref ExpensesList)) return false;
                       if (ExpensesList.Count == 0) return false;
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
                   finally
+                  {
                       expDB.close(); expDB = null;
+                  }
+              }
               #endregion
               #region ベースコントロールコレクションよりボタン取得
               /// <summary>
               /// ベースコントロールコレクションよりボタン取得
               /// </summary>
               public static Button GetButtton2Collection(Control.ControlCollection BasePnl, string ButtonName)
+              {
                   Button buttonRet = null;
                   try
+                  {
                       foreach (Control CurCtrl in BasePnl)
+                      {
                           // 申請ボタン取得
                           if (CurCtrl.Name.Equals(ButtonName))
+                          {
                               buttonRet = (Button)CurCtrl;
                               break;
+                          }
+                      }
                       return buttonRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return buttonRet;
+                  }
+              }
               #endregion
               #region 申請パネルより承認数ラベル取得
               /// <summary>
               /// 申請パネルより承認数ラベル取得
               /// </summary>
               public static Label GetLabel2Collection(Control.ControlCollection BasePnl, string LabelName)
+              {
                   Label LabelRet = null;
                   try
+                  {
                       foreach (Control CurCtrl in BasePnl)
+                      {
                           // 申請ボタン取得
                           if (CurCtrl.Name.Equals(LabelName))
+                          {
                               LabelRet = (Label)CurCtrl;
                               break;
+                          }
+                      }
                       return LabelRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return LabelRet;
+                  }
+              }
               #endregion
               #region 現在適応消費税を取得する
               /// <summary>
               /// 現在適応消費税を取得する
               /// </summary>
               /// <returns></returns>
               public static double AdaptationConsumptionTax()
+              {
                   double dRet = CommonMotions.SystemMasterData.ConsumptionTax;
                   try
+                  {
                       // 実装途中
                       return dRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return dRet;
+                  }
+              }
               /// <summary>
               /// 数値のYMDより期間に対応する消費税を取得する
               /// </summary>
               /// <returns></returns>
               public static double AdaptationConsumptionTax(int nYMD)
+              {
                   double dRet = CommonMotions.SystemMasterData.ConsumptionTax;
                   try
+                  {
                       if (nYMD < 1) return dRet;
                       int nYear = cnvTruncate(nYMD / 10000);
                       int nMonth = cnvTruncate((nYMD - (nYear * 10000)) / 100);
                       int nDay = nYMD - ((nYear * 10000) + (nMonth * 100));
                       DateTime dateTime = new DateTime(nYear, nMonth, nDay);
                       ConsumptionTax taxes = m_ConsumptionTax.Where(x => (x.StartDate.Date <= dateTime.Date)
                                                                           && (dateTime.Date <= x.ComplateDate.Date))
                                                               .First();
                       if (taxes != null) dRet = (double)taxes.TaxRate;
                       return dRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return dRet;
+                  }
+              }
               /// <summary>
               /// 年月日より期間に対応する消費税を取得する
               /// </summary>
               /// <returns></returns>
               public static double AdaptationConsumptionTax(DateTime dtYMD)
+              {
                   double dRet = CommonMotions.SystemMasterData.ConsumptionTax;
                   try
+                  {
                       if (dtYMD == DateTime.MaxValue || dtYMD == DateTime.MinValue) return dRet;
                       ConsumptionTax taxes = m_ConsumptionTax.Where(x => (x.StartDate.Date <= dtYMD.Date)
                                                                           && (dtYMD.Date <= x.ComplateDate.Date))
                                                               .First();
                       if (taxes != null) dRet = (double)taxes.TaxRate;
                       return dRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return dRet;
+                  }
+              }
               #endregion
               #region 担当者のデータにログイン者がアクセスできるかのチェック
               /// <summary>
               /// 担当者のデータにログイン者がアクセスできるかのチェック
               /// </summary>
               public static bool DataPermission(int ManNo)
+              {
                   IOMPersonInCharge ManDB = new IOMPersonInCharge();
                   try
+                  {
                       // 自分自身はOK
                       if (CommonMotions.LoginUserData.PersonCode == ManNo) return true;
                       // 一般者権限では自分以外のデータにアクセスできない
                       int Rank = CommonDefine.SecurityRankList[(int)CommonDefine.SecurityRankPos.NormalAuthority].Key;
                       if (Rank == CommonMotions.LoginUserSecurity.SecRank) return false;
                       // 対象者の担当者データを取得する
                       PersonInChargeMaster ManRec = new PersonInChargeMaster();
                       if (!ManDB.SelectAction(ManDB.CreatePrimarykeyString(ManNo), ref ManRec)) return false;
                       // 参照部署のチェック
                       bool bRet = false;
                       foreach (PersonDepartmentMaster CurRec in m_LoginUserRefDepartment)
+                      {
                           if (CurRec.DepartmentCode == ManRec.DepartmentCode)
+                          {
                               bRet = true;
                               break;
+                          }
+                      }
                       return bRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
                   finally
+                  {
                       ManDB.close(); ManDB = null;
+                  }
+              }
               #endregion
               #region 営業日だけのｎ日前の日付を取る
               /// <summary>
               /// 営業日だけのｎ日前の日付を取る
               /// </summary>
               public static DateTime GetPrevBusinessDate(DateTime WorktDate, int nCount, int PersonCode)
+              {
                   IOAllFreeSQL FreeDB = new IOAllFreeSQL();
                   try
+                  {
                       StringBuilder strSQL = new StringBuilder();
                       strSQL.Append("SELECT t1.d");
                       strSQL.Append("     , DATE_FORMAT(C.HOLIDAY, '%Y/%m/%d') HOLIDAY");
                       strSQL.Append("     , WEEKDAY(t1.d)");
                       strSQL.Append(" FROM");
                       strSQL.Append("     (SELECT A1.years, A2.month, A3.days");
                       strSQL.Append("           , CAST(CONCAT(A1.years, '/', A2.month, '/', A3.days) as DATE) as d");
                       strSQL.Append("      FROM yearmaster as A1");
                       strSQL.Append("          , monthmaster as A2");
                       strSQL.Append("          , daymaster as A3");
                       strSQL.Append("      Where CAST(CONCAT(A1.years, '/', A2.month, '/', A3.days) as DATE) IS NOT NULL) as t1");
                       strSQL.Append("      LEFT JOIN HOLIDAYCALENDERMASTER C ON C.HOLIDAY = t1.d");
                       strSQL.Append(" Where");
                       DateTime dtTarget = new DateTime(WorktDate.Year, WorktDate.Month, 1);
                       strSQL.AppendFormat(" (DATE('{0}') <= DATE(t1.d)", dtTarget.ToShortDateString());
                       strSQL.AppendFormat("  AND DATE(t1.d) <= DATE('{0}'))", DateTime.Today.ToShortDateString());
                       strSQL.Append(" ORDER BY t1.d Desc");
                       ArrayList arList = new ArrayList();
                       FreeDB.ExecuteReader(strSQL.ToString(), ref arList);
                       // 担当者コードより勤務シフトの月曜日を０として読み込む
                       strSQL.Clear();
                       strSQL.Append("Select");
                       strSQL.Append(" B.MonValue");
                       strSQL.Append(", B.TueValue");
                       strSQL.Append(", B.WedValue");
                       strSQL.Append(", B.ThuValue");
                       strSQL.Append(", B.FriValue");
                       strSQL.Append(", B.SatValue");
                       strSQL.Append(", B.SunValue");
                       strSQL.Append(", A.PersonCode");
                       strSQL.Append(", A.PersonName");
                       strSQL.Append(", A.EndDate");
                       strSQL.Append(" From personinchargemaster As A");
                       strSQL.Append(" Inner Join workingtime As B");
                       strSQL.Append("       On B.WorkingCode = A.WorkingCode");
                       strSQL.Append(" Where");
                       strSQL.AppendFormat(" A.Personcode = {0}", PersonCode);
                       ArrayList WeekList = new ArrayList();
                       FreeDB.ExecuteReader(strSQL.ToString(), ref WeekList);
                       object[] objWeek = null;
                       DateTime dtEnd = DateTime.Today;
                       if (WeekList.Count > 0)
+                      {
                           objWeek = (object[])WeekList[0];
                           // 退職日が無い場合は日付をＭＡＸにする
                           dtEnd = CommonMotions.cnvDate(objWeek[9]).Date == DateTime.MinValue.Date
                                                                                   ? DateTime.MaxValue.Date
                                                                                   : CommonMotions.cnvDate(objWeek[9]).Date;
+                      }
                       DateTime dtRet = DateTime.MinValue;
                       int nPrevCount = 0;
                       foreach (object[] objCalender in arList)
+                      {
                           // まず今日を探す
                           DateTime dtwork = CommonMotions.cnvDate(objCalender[0]);
                           if (DateTime.Today.Date < dtwork.Date) continue;
                           // 休日は除外する
                           DateTime dtholiday = CommonMotions.cnvDate(objCalender[1]);
                           if (DateTime.MinValue.Date != dtholiday.Date) continue;
                           // 担当者コードがある場合は勤務シフトの比較を行う
                           if (PersonCode > 0)
+                          {
                               int nWeekFlg = CommonMotions.cnvInt(objCalender[2]);
                               int nBreakDayFlg = CommonMotions.cnvInt(objWeek[nWeekFlg]);
                               // 休みの曜日は除外する
                               if (nBreakDayFlg == (int)WorkingTime.DayOfTheWeekDef.BreakDay) continue;
                               //退職日以降は除外する
                               if (dtEnd < dtwork.Date) continue;
+                          }
                           nPrevCount++;
                           if (nCount <= nPrevCount)
+                          {
                               dtRet = dtwork;
                               break;
+                          }
+                      }
                       return dtRet;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return DateTime.Today;
+                  }
                   finally
+                  {
                       FreeDB.close(); FreeDB = null;
+                  }
+              }
               #endregion
               #region 文字列の指定毎位置に改行コードを入れる
               /// <summary>
               /// 文字列の指定毎位置に改行コードを入れる
               /// </summary>
               /// <param name="InpString"></param>
               /// <param name="CutLength"></param>
               /// <returns></returns>
               public static string StringBuiltInReturn(string InpString, int CutLength)
+              {
                   try
+                  {
                       List<string> textList = new List<string>();
                       for (int i = 0; i < InpString.Length; i += CutLength)
+                      {
                           if ((i + CutLength) < InpString.Length)
                               textList.Add(InpString.Substring(i, CutLength));
                           else
                               textList.Add(InpString.Substring(i));
+                      }
                       return string.Join("\r\n", textList.ToArray());
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return string.Empty;
+                  }
+              }
               #endregion
               #region 日付から曜日を取得してマスタの休みと比較する
               /// <summary>
               /// 日付から曜日を取得してマスタの休みと比較する
               /// </summary>
               /// <returns></returns>
               public static bool MasterHolidayCheck(DateTime DispDate, WorkingTime WDataRec)
+              {
                   try
+                  {
                       // 曜日取得
                       DayOfWeek dowWork = DispDate.DayOfWeek;
                       int nBreakDayFlg = -1;
                       switch ((int)dowWork)
+                      {
                           case (int)DayOfWeek.Sunday:
                               nBreakDayFlg = WDataRec.SunValue;
                               break;
                           case (int)DayOfWeek.Monday:
                               nBreakDayFlg = WDataRec.MonValue;
                               break;
                           case (int)DayOfWeek.Tuesday:
                               nBreakDayFlg = WDataRec.TueValue;
                               break;
                           case (int)DayOfWeek.Wednesday:
                               nBreakDayFlg = WDataRec.WedValue;
                               break;
                           case (int)DayOfWeek.Thursday:
                               nBreakDayFlg = WDataRec.ThuValue;
                               break;
                           case (int)DayOfWeek.Friday:
                               nBreakDayFlg = WDataRec.FriValue;
                               break;
                           case (int)DayOfWeek.Saturday:
                               nBreakDayFlg = WDataRec.SatValue;
                               break;
+                      }
                       // 休みかを判定する
                       if (nBreakDayFlg == (int)WorkingTime.DayOfTheWeekDef.Normal) return false;
                       return true;
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}", CommonMotions.GetMethodName(), ex.Message);
                       return false;
+                  }
+              }
               #endregion
               #endregion
               #region ---------- Excel向け操作メソッド
               #region オブジェクト開放
               /// <summary>
               /// Ｃｏｍ解放
               /// </summary>
               /// <param name="o"></param>
               public static void ReleaseCom(ref Object objCom)
+              {
                   try
+                  {
                       int i = 1;
                       if (objCom != null && System.Runtime.InteropServices.Marshal.IsComObject(objCom))
+                      {
                           //参照カウントが0より大きい間・・・
                           do
+                          {
                               //ランタイム呼び出し可能ラッパーの参照カウントをデクリメント
                               i = System.Runtime.InteropServices.Marshal.ReleaseComObject(objCom);
                           } while (i > 0);
+                      }
+                  }
                   catch (Exception ex)
+                  {
                       logger.ErrorFormat("システムエラー：{0}：{1}：{2}", GetMethodName(), GetMethodName(2), ex.Message);
+                  }
                   finally
+                  {
                       objCom = null;
+                  }
+              }
               #endregion
               #endregion
               #region デバッグ用メソッド
               /// <summary>
               /// デバッグ用メソッド
               /// </summary>
               /// <param name="DebugPrint">表示文字列</param>
               public static void DebugWriteLine_TimeNow(string DebugPrint)
+              {
                   string wrkPrint = DateTime.Now.ToLongTimeString() +
                                       ((double)DateTime.Now.Millisecond / 1000.0000).ToString("#.0000");
                   Debug.WriteLine(DebugPrint + "：" + wrkPrint);
+              }
               public static void DebugWriteLine_DateTimeNow(string DebugPrint)
+              {
                   string wrkPrint = DateTime.Now.ToLongDateString() + " " +
                                       DateTime.Now.ToLongTimeString() + "." +
                                       DateTime.Now.Millisecond.ToString();
                   Debug.WriteLine(DebugPrint + "：" + wrkPrint);
+              }
               #endregion
+          }
+      }

プロジェクト

全般

プロフィール

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

h-you / trunk / src / ProcessManagement / ProcessManagement / Common / CommonMotions.cs @ 485