public static bool ItemsToPacket(List <CPacketItem> items, bool swap, Byte[] sendBuff, out int totalSendSize)
        {
            totalSendSize = 0;
            Boolean unsigned = false;

            for (int i = 0; i < items.Count; i++)
            {
                int    typeSize = 4;
                String type     = items[i].TypeString;
                Array  packets  = TypeHandling.GetArrayByTypeName(type, items[i].Length, out typeSize, out unsigned);

                if (packets == null || packets.Length < 1 || typeSize < 0)
                {
                    String error = "타입명세실패";
                    throw new Exception(error);
                }


                if (type.Equals("char") || type.Equals("string"))
                {
                    if (items[i].InitString == null || items[i].InitString.Length == 0)
                    {
                        continue;
                    }
                    packets = Encoding.UTF8.GetBytes(items[i].InitString);
                    Buffer.BlockCopy(packets, 0, sendBuff, totalSendSize, packets.Length);
                    totalSendSize += packets.Length;
                }
                else
                {
                    String[] units = items[i].InitValues;
                    for (int k = 0; k < units.Length; k++)
                    {
                        TypeHandling.TypeName typeName = TypeHandling.getTypeKind(units[k]);

                        if (typeName == TypeHandling.TypeName.Integer)
                        {
                            if (unsigned == false)
                            {
                                if (typeSize == 1)
                                {
                                    packets.SetValue(SByte.Parse(units[k]), k);
                                }
                                else if (typeSize == 2)
                                {
                                    packets.SetValue(Int16.Parse(units[k]), k);
                                }
                                else if (typeSize == 4)
                                {
                                    packets.SetValue(Int32.Parse(units[k]), k);
                                }
                                else
                                {
                                    packets.SetValue(Int64.Parse(units[k]), k);
                                }
                            }
                            else
                            {
                                if (typeSize == 1)
                                {
                                    packets.SetValue(Byte.Parse(units[k]), k);
                                }
                                else if (typeSize == 2)
                                {
                                    packets.SetValue(UInt16.Parse(units[k]), k);
                                }
                                else if (typeSize == 4)
                                {
                                    packets.SetValue(UInt32.Parse(units[k]), k);
                                }
                                else
                                {
                                    packets.SetValue(UInt64.Parse(units[k]), k);
                                }
                            }
                        }
                        else if (typeName == TypeHandling.TypeName.HexString)
                        {
                            if (unsigned)
                            {
                                if (typeSize == 1)
                                {
                                    packets.SetValue((byte)TypeHandling.getHexNumber <byte>(units[k]), k);
                                }
                                else if (typeSize == 2)
                                {
                                    packets.SetValue((ushort)TypeHandling.getHexNumber <ushort>(units[k]), k);
                                }
                                else if (typeSize == 4)
                                {
                                    packets.SetValue((uint)TypeHandling.getHexNumber <uint>(units[k]), k);
                                }
                                else
                                {
                                    packets.SetValue((UInt64)TypeHandling.getHexNumber <ulong>(units[k]), k);
                                }
                            }
                            else
                            {
                                if (typeSize == 1)
                                {
                                    packets.SetValue((sbyte)TypeHandling.getHexNumber <sbyte>(units[k]), k);
                                }
                                else if (typeSize == 2)
                                {
                                    packets.SetValue((short)TypeHandling.getHexNumber <short>(units[k]), k);
                                }
                                else if (typeSize == 4)
                                {
                                    packets.SetValue((int)TypeHandling.getHexNumber <int>(units[k]), k);
                                }
                                else
                                {
                                    packets.SetValue((Int64)TypeHandling.getHexNumber <long>(units[k]), k);
                                }
                            }
                        }
                        else if (typeName == TypeHandling.TypeName.Float)
                        {
                            if (typeSize == 4)
                            {
                                packets.SetValue(float.Parse(units[k]), k);
                            }
                            else
                            {
                                packets.SetValue(Double.Parse(units[k]), k);
                            }
                        }
                        else if (typeName == TypeHandling.TypeName.Bin)
                        {
                            if (typeSize == 1)
                            {
                                packets.SetValue((byte)TypeHandling.getBinNumber(units[k]), k);
                            }
                            else if (typeSize == 2)
                            {
                                packets.SetValue((short)TypeHandling.getBinNumber(units[k]), k);
                            }
                            else if (typeSize == 4)
                            {
                                packets.SetValue((int)TypeHandling.getBinNumber(units[k]), k);
                            }
                            else
                            {
                                packets.SetValue((Int64)TypeHandling.getBinNumber(units[k]), k);
                            }
                        }
                    }
                    //buff = new Byte[Marshal.SizeOf(packets.GetValue(0)) * packets.Length];
                    if (swap) //전체 swap
                    {
                        if (items[i].IsSwap == false)
                        {
                            Swaper.swapWithSize(packets, sendBuff, typeSize, Buffer.ByteLength(packets), 0, totalSendSize);
                        }
                        else
                        {
                            Buffer.BlockCopy(packets, 0, sendBuff, totalSendSize, Buffer.ByteLength(packets));
                        }
                    }
                    else //일부만 swap
                    {
                        if (items[i].IsSwap)
                        {
                            Swaper.swapWithSize(packets, sendBuff, typeSize, Buffer.ByteLength(packets), 0, totalSendSize);
                        }
                        else
                        {
                            Buffer.BlockCopy(packets, 0, sendBuff, totalSendSize, Buffer.ByteLength(packets));
                        }
                    }
                    totalSendSize += Buffer.ByteLength(packets);
                }
            }

            /*
             * if(_sendBuff.Equals(PacketBuffer)){ //만일 _sendBuff가 Packet버퍼와 같을 때, 사이즈를 조정한다.(초기사이즈->실제사이즈)
             *  Byte[] buff = new Byte[totalSendSize];
             *  Buffer.BlockCopy(_sendBuff, 0, buff, 0, totalSendSize);
             *  PacketBuffer = buff;
             * }
             */
            return(true);
        }
        /// <summary>
        /// Items의 내용을 바꾸어 packet으로 변경한다.
        /// Send할 패킷을 만드는 데 사용된다.
        /// </summary>
        /// <param name="items"></param>
        /// <param name="funcList">사용될 function의 리스트. function은 String들을 argument로 받고, String[]을 리턴하는 function들이다.</param>
        /// <param name="varList">사용될 variables의 리스트. 같은 CPacketItem의 다른 item들을 찾아보고, 찾을 수 없다면 이 리스트에서 찾는다.</param>
        /// <param name="swap">전체적으로 swap을 할 것인지를 묻는다. 이 arguemnt가 true인데 단일 item이 IsSwap에 true가 되어있다면 다른 것과는 반대로 동작한다. 즉, swap되지 않는다</param>
        /// <param name="dataBuff">패킷데이터가 저장될 버퍼</param>
        /// <param name="dataSize">전체 크기</param>
        /// <returns></returns>
        public void ItemsToPacket(List <CPacketItem> items, Dictionary <String, InitVarFunc> funcList, Dictionary <String, VariableInfo> varList, bool swap, Byte[] dataBuff, out int dataSize)
        {
            dataSize = 0;
            Boolean unsigned = false;
            Dictionary <String, VariableInfo> vars = new Dictionary <string, VariableInfo>(); // = new Dictionary<string, string[]>(varList);

            for (int i = 0; i < items.Count; i++)                                             //static 하게 정의된 item의 요소는 변수로 사용가능하다.
            {
                if (items[i].InitValues.Length > 0)
                {
                    vars.Add(items[i].Name, new VariableInfo(items[i].Name, items[i].InitValues));
                }
            }
            for (int i = 0; i < varList.Count; i++)
            {
                if (vars.Keys.Contains(varList.Keys.ElementAt(i)))
                {
                    continue;                                               //같은 변수명이면 같은 패킷에 속한 것이 적용된다.
                }
                else
                {
                    vars.Add(varList.Keys.ElementAt(i), varList.Values.ElementAt(i));
                }
            }


            for (int i = 0; i < items.Count; i++)
            {
                int typeSize = 4;

                String type    = items[i].TypeString;
                Array  packets = TypeHandling.GetArrayByTypeName(type, items[i].Length, out typeSize, out unsigned);

                //Byte[] buff;
                if (items[i].Function.Exists)
                {
                    items[i].InitValues = runFunction(funcList, vars, items[i].Function);
                }
                else if (items[i].Var.Exists)
                {
                    String refName = items[i].Var.Name;
                    if (vars.Keys.Contains(refName))
                    {
                        if (vars[refName].Values != null && vars[refName].Values.Length > 0)
                        {
                            items[i].InitValues = vars[items[i].Var.Name].Values;
                        }
                        else
                        {
                            throw new Exception("변수" + refName + "가 존재하지 않거나 값이 설정되지 않았습니다.");
                        }
                    }
                }

                if (type.Equals("char") || type.Equals("string"))
                {
                    if (items[i].InitString == null || items[i].InitString.Length == 0)
                    {
                        continue;
                    }
                    packets = Encoding.UTF8.GetBytes(items[i].InitString);
                    Buffer.BlockCopy(packets, 0, dataBuff, dataSize, packets.Length);
                    dataSize += packets.Length;
                }
                else
                {
                    for (int k = 0; k < items[i].InitValues.Length; k++)
                    {
                        TypeHandling.TypeName typeName = TypeHandling.getTypeKind(items[i].InitValues[k]);
                        if (typeName == TypeHandling.TypeName.Integer)
                        {
                            if (unsigned == false)
                            {
                                if (typeSize == 1)
                                {
                                    packets.SetValue(SByte.Parse(items[i].InitValues[k]), k);
                                }
                                else if (typeSize == 2)
                                {
                                    packets.SetValue(Int16.Parse(items[i].InitValues[k]), k);
                                }
                                else if (typeSize == 4)
                                {
                                    packets.SetValue(Int32.Parse(items[i].InitValues[k]), k);
                                }
                                else
                                {
                                    packets.SetValue(Int64.Parse(items[i].InitValues[k]), k);
                                }
                            }
                            else
                            {
                                if (typeSize == 1)
                                {
                                    packets.SetValue(Byte.Parse(items[i].InitValues[k]), k);
                                }
                                else if (typeSize == 2)
                                {
                                    packets.SetValue(UInt16.Parse(items[i].InitValues[k]), k);
                                }
                                else if (typeSize == 4)
                                {
                                    packets.SetValue(UInt32.Parse(items[i].InitValues[k]), k);
                                }
                                else
                                {
                                    packets.SetValue(UInt64.Parse(items[i].InitValues[k]), k);
                                }
                            }
                        }
                        else if (typeName == TypeHandling.TypeName.HexString)
                        {
                            if (typeSize == 1)
                            {
                                packets.SetValue(TypeHandling.getHexNumber <byte>(items[i].InitValues[k]), k);
                            }
                            else if (typeSize == 2)
                            {
                                packets.SetValue(TypeHandling.getHexNumber <ushort>(items[i].InitValues[k]), k);
                            }
                            else if (typeSize == 4)
                            {
                                packets.SetValue(TypeHandling.getHexNumber <uint>(items[i].InitValues[k]), k);
                            }
                            else
                            {
                                packets.SetValue(TypeHandling.getHexNumber <ulong>(items[i].InitValues[k]), k);
                            }
                        }
                        else if (typeName == TypeHandling.TypeName.Float)
                        {
                            if (typeSize == 4)
                            {
                                packets.SetValue(float.Parse(items[i].InitValues[k]), k);
                            }
                            else
                            {
                                packets.SetValue(Double.Parse(items[i].InitValues[k]), k);
                            }
                        }
                        else if (typeName == TypeHandling.TypeName.Bin)
                        {
                            if (typeSize == 1)
                            {
                                packets.SetValue((byte)TypeHandling.getBinNumber(items[i].InitValues[k]), k);
                            }
                            else if (typeSize == 2)
                            {
                                packets.SetValue((short)TypeHandling.getBinNumber(items[i].InitValues[k]), k);
                            }
                            else if (typeSize == 4)
                            {
                                packets.SetValue((int)TypeHandling.getBinNumber(items[i].InitValues[k]), k);
                            }
                            else
                            {
                                packets.SetValue((Int64)TypeHandling.getBinNumber(items[i].InitValues[k]), k);
                            }
                        }
                    }
                    //buff = new Byte[Marshal.SizeOf(packets.GetValue(0)) * packets.Length];
                    if (swap)//전체 swap
                    {
                        if (items[i].IsSwap == false)
                        {
                            Swaper.swapWithSize(packets, dataBuff, typeSize, Buffer.ByteLength(packets), 0, dataSize);
                        }
                        else
                        {
                            Buffer.BlockCopy(packets, 0, dataBuff, dataSize, Buffer.ByteLength(packets));
                        }
                    }
                    else //각각 swap
                    {
                        if (items[i].IsSwap)
                        {
                            Swaper.swapWithSize(packets, dataBuff, typeSize, Buffer.ByteLength(packets), 0, dataSize);
                        }
                        else
                        {
                            Buffer.BlockCopy(packets, 0, dataBuff, dataSize, Buffer.ByteLength(packets));
                        }
                    }
                    dataSize += Buffer.ByteLength(packets);
                }
            }

            /*
             * if(_sendBuff.Equals(PacketBuffer)){ //만일 _sendBuff가 Packet버퍼와 같을 때, 사이즈를 조정한다.(초기사이즈->실제사이즈)
             *  Byte[] buff = new Byte[totalSendSize];
             *  Buffer.BlockCopy(_sendBuff, 0, buff, 0, totalSendSize);
             *  PacketBuffer = buff;
             * }
             */
        }