C# SECS 메세지를 XML 구조로 저장및 읽기 예제

값이 저장된 SECS 메세지를 저장하고 다시 읽기 위한 기능입니다.

 

테스트나 시뮬레이션 목적을 위해 필요한 기능입니다.

 

참고바랍니다.

 

class clsXml_Manager
    {
        string CurrSF = string.Empty;
        static int conIdx = 0;

        public static bool LodeSMLData()
        {
            try
            {
                XmlDocument xdoc = new XmlDocument();

                //string Path = System.IO.Directory.GetCurrentDirectory();
                //string Path = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;

                // XML 데이타를 파일에서 로드
                //xdoc.Load(Path + @"\smdtest.xml");

                if (File.Exists(clsDataManager.sSMLPath) == true)
                {
                    xdoc.Load(clsDataManager.sSMLPath);

                    // 특정 노드들을 필터링
                    XmlNodeList nodes = xdoc.SelectNodes("/PCOM_MSG_BASE");

                    foreach (XmlNode emp in nodes)
                    {
                        foreach (XmlNode child in emp.ChildNodes)
                        {
                            string AttribName = child.Name;

                            if (AttribName.CompareTo("SECS_MSG") == 0)
                            {
                                if (child.ChildNodes.Count >= 0)
                                {
                                    if (!clsDataManager.MsgStruct.ContainsKey(child.Attributes["Name"].Value))
                                        clsDataManager.MsgStruct.Add(child.Attributes["Name"].Value, child.ChildNodes);
                                    else
                                    {
                                        conIdx++;
                                        clsDataManager.MsgStruct.Add(child.Attributes["Name"].Value + "_" + conIdx, child.ChildNodes);
                                    }
                                }
                            }
                        }
                    }
                    return true;
                }
                else
                    return false;
                //saveXml();
            }
            catch (Exception)
            {
                return false;
            }
        }

        public static int Check_Msg(int nMsgID, short Stream, short Function)
        {
            int rs = 0;
            string Key = string.Empty;
            bool sflag = false;
            bool fflag = false;
            try
            {
                Key = Stream + "F" + Function;

                foreach (KeyValuePair<string, XmlNodeList> dic in clsDataManager.MsgStruct)
                {
                    string[] sTemp = dic.Key.Split('F');

                    if (Stream.ToString().CompareTo(sTemp[0]) == 0)
                        sflag = true;
                }

                if (!sflag)
                    return (int)ValidationCode.S9F3UnrecognizedStream;

                foreach (KeyValuePair<string, XmlNodeList> dic in clsDataManager.MsgStruct)
                {
                    if(dic.Key.Contains(Key))
                    {
                        rs = RekursivExport(nMsgID, dic.Value, 0);
                        if (rs == 0)
                        {
                            fflag = true;
                            break;
                        }
                    }
                }

                if (!fflag)
                    return (int)ValidationCode.S9F5UnrecognizedFunction;

                return rs;
            }
            catch (Exception ex)
            {
                return -3;
            }
        }

        private static int RekursivExport(int nMsgID, XmlNodeList Collection, int Lcnt)
        {
            clsSECSMessage csm;
            string btemp = string.Empty;
            int rs = 0;

            try
            {
                //MsgID 존재 여부 Check
                if (clsDataManager.MessageList.ContainsKey(nMsgID))
                    csm = clsDataManager.MessageList[nMsgID];
                else return (short)ErrCode.MsgIdNotExist;

                csm.CheckIndex = 0;

                for (int loop = 0; loop <= Lcnt; loop++)
                {
                    foreach (XmlNode child in Collection)
                    {
                        btemp = Convert.ToString(csm.dataBuffer[csm.CheckIndex], 2).PadLeft(8, '0');

                        //Item 매칭 여부 Check
                        FormatCode FcTemp = (FormatCode)((int)((XmlCode)Enum.Parse(typeof(XmlCode), child.Name, true)));
                        if (btemp.Substring(0, 6) != StringEnum.GetStringValue(FcTemp))
                        {
                            return (int)ValidationCode.S9F7IllegalData;
                        }

                        int LengthByte = Convert.ToInt32(btemp.Substring(6, 2), 2);
                        int nLen = clsMSG_PARSE.getItemCnt(csm.dataBuffer, LengthByte, csm.CheckIndex);
                        csm.CheckIndex = csm.CheckIndex + 1; //ItemType 만큼의 바이트를 시프트 한다.

                        //3f101로 nCnt Test

                        if (child.Name.CompareTo("L") == 0)
                        {
                            csm.CheckIndex = csm.CheckIndex + LengthByte;

                            if (child.Attributes["Count"].Value.CompareTo("n") == 0)
                            {
                                rs = RekursivExport(nMsgID, child.ChildNodes, nLen - 1);
                                if (rs < 0)
                                    return rs;
                            }
                            else if (child.Attributes["Count"].Value.CompareTo("0") != 0)
                            {
                                rs = RekursivExport(nMsgID, child.ChildNodes, 0);
                                if (rs < 0)
                                    return rs;
                            }
                            else
                            {
                                if (nLen != 0)
                                {
                                    return (int)ValidationCode.S9F7IllegalData;
                                }
                            }
                        }
                        else
                        {
                            int ByteCnt = GetByteCnt((XmlCode)Enum.Parse(typeof(XmlCode), child.Name, true));
                            if (nLen == Convert.ToInt32(child.Attributes["Count"].Value) * ByteCnt)
                            {
                                csm.CheckIndex = csm.CheckIndex + LengthByte + nLen;
                            }
                            else
                            {
                                return (int)ValidationCode.S9F11DataTooLong;
                            }
                        }
                    }
                }
                return rs;
            }
            catch (Exception ex)
            {
                return (int)ValidationCode.S9F5UnrecognizedFunction;
            }
            
        }

        private static int GetByteCnt(XmlCode ItemType)
        {
            int rs = 0;
            switch(ItemType)
            {
                case XmlCode.A:
                case XmlCode.B:
                case XmlCode.BL:
                case XmlCode.I1:
                case XmlCode.J:
                case XmlCode.U1:
                    rs = 1;
                    break;
                case XmlCode.F4:
                case XmlCode.I4:
                case XmlCode.U4:
                    rs = 4;
                    break;
                case XmlCode.F8:
                case XmlCode.I8:
                case XmlCode.U8:
                    rs = 8;
                    break;
                case XmlCode.I2:
                case XmlCode.U2:
                    rs = 2;
                    break;
            }

            return rs;
        }
    }