1942 lines
59 KiB
C#
1942 lines
59 KiB
C#
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace SPC.Kiosk.Common
|
|
{
|
|
#region ASCII 제어 문자 정의
|
|
/// <summary>
|
|
/// Control Char
|
|
/// </summary>
|
|
public static class Ctrl_CHAR
|
|
{
|
|
|
|
/// <summary>
|
|
/// NULL [00]0x00
|
|
/// </summary>
|
|
public static char Null = (char)Ctrl_ASCII.Null;
|
|
/// <summary>
|
|
/// SOH [01]0x01
|
|
/// </summary>
|
|
public static char SOH = (char)Ctrl_ASCII.SOH;
|
|
/// <summary>
|
|
/// STX [02]0x02
|
|
/// </summary>
|
|
public static char STX = (char)Ctrl_ASCII.STX;
|
|
/// <summary>
|
|
/// ETX [03]0x03
|
|
/// </summary>
|
|
public static char ETX = (char)Ctrl_ASCII.ETX;
|
|
/// <summary>
|
|
/// EOT [04]0x04
|
|
/// </summary>
|
|
public static char EOT = (char)Ctrl_ASCII.EOT;
|
|
/// <summary>
|
|
/// ENQ [05]0x05
|
|
/// </summary>
|
|
public static char ENQ = (char)Ctrl_ASCII.ENQ;
|
|
/// <summary>
|
|
/// ACK [06]0x06
|
|
/// </summary>
|
|
public static char ACK = (char)Ctrl_ASCII.ACK;
|
|
/// <summary>
|
|
/// BEL [07]0x07
|
|
/// </summary>
|
|
public static char BEL = (char)Ctrl_ASCII.BEL;
|
|
/// <summary>
|
|
/// BS [08]0x08
|
|
/// </summary>
|
|
public static char BS = (char)Ctrl_ASCII.BS;
|
|
/// <summary>
|
|
/// HT [09]0x09
|
|
/// </summary>
|
|
public static char HT = (char)Ctrl_ASCII.HT;
|
|
/// <summary>
|
|
/// LF [0A]0x10
|
|
/// </summary>
|
|
public static char LF = (char)Ctrl_ASCII.LF;
|
|
/// <summary>
|
|
/// VT [0B]0x11
|
|
/// </summary>
|
|
public static char VT = (char)Ctrl_ASCII.VT;
|
|
/// <summary>
|
|
/// FF [0C]0x12
|
|
/// </summary>
|
|
public static char FF = (char)Ctrl_ASCII.FF;
|
|
/// <summary>
|
|
/// CR [0D]0x13
|
|
/// </summary>
|
|
public static char CR = (char)Ctrl_ASCII.CR;
|
|
/// <summary>
|
|
/// SO [0E]0x14
|
|
/// </summary>
|
|
public static char SO = (char)Ctrl_ASCII.SO;
|
|
/// <summary>
|
|
/// SI [0F]0x15
|
|
/// </summary>
|
|
public static char SI = (char)Ctrl_ASCII.SI;
|
|
/// <summary>
|
|
/// DLE [10]0x16
|
|
/// </summary>
|
|
public static char DLE = (char)Ctrl_ASCII.DLE;
|
|
/// <summary>
|
|
/// DC1 [11]0x17
|
|
/// </summary>
|
|
public static char DC1 = (char)Ctrl_ASCII.DC1;
|
|
/// <summary>
|
|
/// DC2 [12]0x18
|
|
/// </summary>
|
|
public static char DC2 = (char)Ctrl_ASCII.DC2;
|
|
/// <summary>
|
|
/// DC3 [13]0x19
|
|
/// </summary>
|
|
public static char DC3 = (char)Ctrl_ASCII.DC3;
|
|
/// <summary>
|
|
/// DC4 [14]0x20
|
|
/// </summary>
|
|
public static char DC4 = (char)Ctrl_ASCII.DC4;
|
|
/// <summary>
|
|
/// NAK [15]0x21
|
|
/// </summary>
|
|
public static char NAK = (char)Ctrl_ASCII.NAK;
|
|
/// <summary>
|
|
/// SYN [16]0x22
|
|
/// </summary>
|
|
public static char SYN = (char)Ctrl_ASCII.SYN;
|
|
/// <summary>
|
|
/// ETB [17]0x23
|
|
/// </summary>
|
|
public static char ETB = (char)Ctrl_ASCII.ETB;
|
|
/// <summary>
|
|
/// CAN [18]0x24
|
|
/// </summary>
|
|
public static char CAN = (char)Ctrl_ASCII.CAN;
|
|
/// <summary>
|
|
/// EM [19]0x25
|
|
/// </summary>
|
|
public static char EM = (char)Ctrl_ASCII.EM;
|
|
/// <summary>
|
|
/// SUB [1A]0x26
|
|
/// </summary>
|
|
public static char SUB = (char)Ctrl_ASCII.SUB;
|
|
/// <summary>
|
|
/// ESC [1B]0x27
|
|
/// </summary>
|
|
public static char ESC = (char)Ctrl_ASCII.ESC;
|
|
/// <summary>
|
|
/// FS [1C]0x28
|
|
/// </summary>
|
|
public static char FS = (char)Ctrl_ASCII.FS;
|
|
/// <summary>
|
|
/// GS [1D]0x29
|
|
/// </summary>
|
|
public static char GS = (char)Ctrl_ASCII.GS;
|
|
/// <summary>
|
|
/// RS [1E]0x30
|
|
/// </summary>
|
|
public static char RS = (char)Ctrl_ASCII.RS;
|
|
/// <summary>
|
|
/// US [1F]0x32
|
|
/// </summary>
|
|
public static char US = (char)Ctrl_ASCII.US;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Control Byte
|
|
/// </summary>
|
|
public static class Ctrl_BYTE
|
|
{
|
|
/// <summary>
|
|
/// NULL
|
|
/// </summary>
|
|
public static byte Null = (byte)Ctrl_ASCII.Null;
|
|
/// <summary>
|
|
/// SOH
|
|
/// </summary>
|
|
public static byte SOH = (byte)Ctrl_ASCII.SOH;
|
|
/// <summary>
|
|
/// STX
|
|
/// </summary>
|
|
public static byte STX = (byte)Ctrl_ASCII.STX;
|
|
/// <summary>
|
|
/// ETX
|
|
/// </summary>
|
|
public static byte ETX = (byte)Ctrl_ASCII.ETX;
|
|
/// <summary>
|
|
/// EOT
|
|
/// </summary>
|
|
public static byte EOT = (byte)Ctrl_ASCII.EOT;
|
|
/// <summary>
|
|
/// ENQ
|
|
/// </summary>
|
|
public static byte ENQ = (byte)Ctrl_ASCII.ENQ;
|
|
/// <summary>
|
|
/// ACK
|
|
/// </summary>
|
|
public static byte ACK = (byte)Ctrl_ASCII.ACK;
|
|
/// <summary>
|
|
/// BEL
|
|
/// </summary>
|
|
public static byte BEL = (byte)Ctrl_ASCII.BEL;
|
|
/// <summary>
|
|
/// BS
|
|
/// </summary>
|
|
public static byte BS = (byte)Ctrl_ASCII.BS;
|
|
/// <summary>
|
|
/// HT
|
|
/// </summary>
|
|
public static byte HT = (byte)Ctrl_ASCII.HT;
|
|
/// <summary>
|
|
/// LF
|
|
/// </summary>
|
|
public static byte LF = (byte)Ctrl_ASCII.LF;
|
|
/// <summary>
|
|
/// VT
|
|
/// </summary>
|
|
public static byte VT = (byte)Ctrl_ASCII.VT;
|
|
/// <summary>
|
|
/// FF
|
|
/// </summary>
|
|
public static byte FF = (byte)Ctrl_ASCII.FF;
|
|
/// <summary>
|
|
/// CR
|
|
/// </summary>
|
|
public static byte CR = (byte)Ctrl_ASCII.CR;
|
|
/// <summary>
|
|
/// SO
|
|
/// </summary>
|
|
public static byte SO = (byte)Ctrl_ASCII.SO;
|
|
/// <summary>
|
|
/// SI
|
|
/// </summary>
|
|
public static byte SI = (byte)Ctrl_ASCII.SI;
|
|
/// <summary>
|
|
/// DLE
|
|
/// </summary>
|
|
public static byte DLE = (byte)Ctrl_ASCII.DLE;
|
|
/// <summary>
|
|
/// DC1
|
|
/// </summary>
|
|
public static byte DC1 = (byte)Ctrl_ASCII.DC1;
|
|
/// <summary>
|
|
/// DC2
|
|
/// </summary>
|
|
public static byte DC2 = (byte)Ctrl_ASCII.DC2;
|
|
/// <summary>
|
|
/// DC3
|
|
/// </summary>
|
|
public static byte DC3 = (byte)Ctrl_ASCII.DC3;
|
|
/// <summary>
|
|
/// DC4
|
|
/// </summary>
|
|
public static byte DC4 = (byte)Ctrl_ASCII.DC4;
|
|
/// <summary>
|
|
/// NAK
|
|
/// </summary>
|
|
public static byte NAK = (byte)Ctrl_ASCII.NAK;
|
|
/// <summary>
|
|
/// SYN
|
|
/// </summary>
|
|
public static byte SYN = (byte)Ctrl_ASCII.SYN;
|
|
/// <summary>
|
|
/// ETB
|
|
/// </summary>
|
|
public static byte ETB = (byte)Ctrl_ASCII.ETB;
|
|
/// <summary>
|
|
/// CAN
|
|
/// </summary>
|
|
public static byte CAN = (byte)Ctrl_ASCII.CAN;
|
|
/// <summary>
|
|
/// EM
|
|
/// </summary>
|
|
public static byte EM = (byte)Ctrl_ASCII.EM;
|
|
/// <summary>
|
|
/// SUB
|
|
/// </summary>
|
|
public static byte SUB = (byte)Ctrl_ASCII.SUB;
|
|
/// <summary>
|
|
/// ESC
|
|
/// </summary>
|
|
public static byte ESC = (byte)Ctrl_ASCII.ESC;
|
|
/// <summary>
|
|
/// FS
|
|
/// </summary>
|
|
public static byte FS = (byte)Ctrl_ASCII.FS;
|
|
/// <summary>
|
|
/// GS
|
|
/// </summary>
|
|
public static byte GS = (byte)Ctrl_ASCII.GS;
|
|
/// <summary>
|
|
/// RS
|
|
/// </summary>
|
|
public static byte RS = (byte)Ctrl_ASCII.RS;
|
|
/// <summary>
|
|
/// US
|
|
/// </summary>
|
|
public static byte US = (byte)Ctrl_ASCII.US;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cotrol Char String Type
|
|
/// </summary>
|
|
public static class Ctrl_STRING
|
|
{
|
|
/// <summary>
|
|
/// NULL
|
|
/// </summary>
|
|
public static string Null = "";
|
|
/// <summary>
|
|
/// SOH
|
|
/// </summary>
|
|
public static string SOH = Convert.ToString((char)Ctrl_ASCII.SOH);
|
|
/// <summary>
|
|
/// STX
|
|
/// </summary>
|
|
public static string STX = Convert.ToString((char)Ctrl_ASCII.STX);
|
|
/// <summary>
|
|
/// ETX
|
|
/// </summary>
|
|
public static string ETX = Convert.ToString((char)Ctrl_ASCII.ETX);
|
|
/// <summary>
|
|
/// EOT
|
|
/// </summary>
|
|
public static string EOT = Convert.ToString((char)Ctrl_ASCII.EOT);
|
|
/// <summary>
|
|
/// ENQ
|
|
/// </summary>
|
|
public static string ENQ = Convert.ToString((char)Ctrl_ASCII.ENQ);
|
|
/// <summary>
|
|
/// ACK
|
|
/// </summary>
|
|
public static string ACK = Convert.ToString((char)Ctrl_ASCII.ACK);
|
|
/// <summary>
|
|
/// BEL
|
|
/// </summary>
|
|
public static string BEL = Convert.ToString((char)Ctrl_ASCII.BEL);
|
|
/// <summary>
|
|
/// BS
|
|
/// </summary>
|
|
public static string BS = Convert.ToString((char)Ctrl_ASCII.BS);
|
|
/// <summary>
|
|
/// HT
|
|
/// </summary>
|
|
public static string HT = Convert.ToString((char)Ctrl_ASCII.HT);
|
|
/// <summary>
|
|
/// LF
|
|
/// </summary>
|
|
public static string LF = Convert.ToString((char)Ctrl_ASCII.LF);
|
|
/// <summary>
|
|
/// VT
|
|
/// </summary>
|
|
public static string VT = Convert.ToString((char)Ctrl_ASCII.VT);
|
|
/// <summary>
|
|
/// FF
|
|
/// </summary>
|
|
public static string FF = Convert.ToString((char)Ctrl_ASCII.FF);
|
|
/// <summary>
|
|
/// CR
|
|
/// </summary>
|
|
public static string CR = Convert.ToString((char)Ctrl_ASCII.CR);
|
|
/// <summary>
|
|
/// SO
|
|
/// </summary>
|
|
public static string SO = Convert.ToString((char)Ctrl_ASCII.SO);
|
|
/// <summary>
|
|
/// SI
|
|
/// </summary>
|
|
public static string SI = Convert.ToString((char)Ctrl_ASCII.SI);
|
|
/// <summary>
|
|
/// DLE
|
|
/// </summary>
|
|
public static string DLE = Convert.ToString((char)Ctrl_ASCII.DLE);
|
|
/// <summary>
|
|
/// DC1
|
|
/// </summary>
|
|
public static string DC1 = Convert.ToString((char)Ctrl_ASCII.DC1);
|
|
/// <summary>
|
|
/// DC2
|
|
/// </summary>
|
|
public static string DC2 = Convert.ToString((char)Ctrl_ASCII.DC2);
|
|
/// <summary>
|
|
/// DC3
|
|
/// </summary>
|
|
public static string DC3 = Convert.ToString((char)Ctrl_ASCII.DC3);
|
|
/// <summary>
|
|
/// DC4
|
|
/// </summary>
|
|
public static string DC4 = Convert.ToString((char)Ctrl_ASCII.DC4);
|
|
/// <summary>
|
|
/// NAK
|
|
/// </summary>
|
|
public static string NAK = Convert.ToString((char)Ctrl_ASCII.NAK);
|
|
/// <summary>
|
|
/// SYN
|
|
/// </summary>
|
|
public static string SYN = Convert.ToString((char)Ctrl_ASCII.SYN);
|
|
/// <summary>
|
|
/// ETB
|
|
/// </summary>
|
|
public static string ETB = Convert.ToString((char)Ctrl_ASCII.ETB);
|
|
/// <summary>
|
|
/// CAN
|
|
/// </summary>
|
|
public static string CAN = Convert.ToString((char)Ctrl_ASCII.CAN);
|
|
/// <summary>
|
|
/// EM
|
|
/// </summary>
|
|
public static string EM = Convert.ToString((char)Ctrl_ASCII.EM);
|
|
/// <summary>
|
|
/// SUB
|
|
/// </summary>
|
|
public static string SUB = Convert.ToString((char)Ctrl_ASCII.SUB);
|
|
/// <summary>
|
|
/// ESC
|
|
/// </summary>
|
|
public static string ESC = Convert.ToString((char)Ctrl_ASCII.ESC);
|
|
/// <summary>
|
|
/// FS
|
|
/// </summary>
|
|
public static string FS = Convert.ToString((char)Ctrl_ASCII.FS);
|
|
/// <summary>
|
|
/// GS
|
|
/// </summary>
|
|
public static string GS = Convert.ToString((char)Ctrl_ASCII.GS);
|
|
/// <summary>
|
|
/// RS
|
|
/// </summary>
|
|
public static string RS = Convert.ToString((char)Ctrl_ASCII.RS);
|
|
/// <summary>
|
|
/// US
|
|
/// </summary>
|
|
public static string US = Convert.ToString((char)Ctrl_ASCII.US);
|
|
}
|
|
#endregion
|
|
public static class CommonConverter
|
|
{
|
|
#region For DB string
|
|
/// <summary>
|
|
/// 실수로 변환
|
|
/// </summary>
|
|
/// <param name="o">입력객체</param>
|
|
/// <returns>실수</returns>
|
|
public static float rDBToFloat(this object o)
|
|
{
|
|
float result;
|
|
try
|
|
{
|
|
if (o == DBNull.Value || o == null) result = 0F;
|
|
else
|
|
{
|
|
if (!float.TryParse(o.ToString(), out result)) result = 0F;
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
|
|
result = 0F;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// 정수로 변환
|
|
/// </summary>
|
|
/// <param name="o"></param>
|
|
/// <returns></returns>
|
|
public static int rDBToInt(this object o)
|
|
{
|
|
int result;
|
|
try
|
|
{
|
|
if (o == DBNull.Value || o == null) result = 0;
|
|
else
|
|
{
|
|
if (!Int32.TryParse(o.ToString(), out result)) result = 0;
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
|
|
result = 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 문자로 변환
|
|
/// </summary>
|
|
/// <param name="o"></param>
|
|
/// <returns></returns>
|
|
public static char rDBToChar(this object o)
|
|
{
|
|
char result;
|
|
try
|
|
{
|
|
if (o == DBNull.Value)
|
|
result = Ctrl_CHAR.Null;
|
|
else
|
|
result = o.ToString()[0];
|
|
|
|
}
|
|
catch
|
|
{
|
|
result = Ctrl_CHAR.Null;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// 문자열로 변환
|
|
/// </summary>
|
|
/// <param name="o"></param>
|
|
/// <returns></returns>
|
|
public static string rDBToString(this object o)
|
|
{
|
|
string result;
|
|
try
|
|
{
|
|
if (o == DBNull.Value || o == null)
|
|
result = string.Empty;
|
|
else
|
|
result = o.ToString();
|
|
|
|
}
|
|
catch
|
|
{
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region Hexa & Bit
|
|
/// <summary>
|
|
/// 숫자를 16진수 문자열로
|
|
/// </summary>
|
|
/// <param name="_inInt"></param>
|
|
/// <returns></returns>
|
|
public static string rToHexString(this int _inInt)
|
|
{
|
|
try
|
|
{
|
|
return (Convert.ToString(_inInt, 16)).ToUpper().PadLeft(2, '0');
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Byte를 16진수 문자열로
|
|
/// </summary>
|
|
/// <param name="_inByte"></param>
|
|
/// <returns></returns>
|
|
public static string rToHexString(this byte _inByte)
|
|
{
|
|
try
|
|
{
|
|
return ((int)_inByte).rToHexString();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Char를 16진수 문자열로
|
|
/// </summary>
|
|
/// <param name="_inChar"></param>
|
|
/// <returns></returns>
|
|
public static string rToHexString(this char _inChar)
|
|
{
|
|
try
|
|
{
|
|
return ((int)_inChar).rToHexString();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Char배열을 Hex문자열로
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <returns></returns>
|
|
public static string rToHexString(this char[] _inChars)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
foreach (char _inChar in _inChars)
|
|
{
|
|
result += ((int)_inChar).rToHexString();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Byte배열을 Hex문자열로
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <returns></returns>
|
|
public static string rToHexString(this byte[] _inBytes)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
foreach (byte _inByte in _inBytes)
|
|
{
|
|
result += ((int)_inByte).rToHexString();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Integer배열을 Hex문자열로
|
|
/// </summary>
|
|
/// <param name="_inInts"></param>
|
|
/// <returns></returns>
|
|
public static string rToHexString(this int[] _inInts)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
foreach (int _inInt in _inInts)
|
|
{
|
|
result += _inInt.rToHexString();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 정수를 Bit문자열로
|
|
/// </summary>
|
|
/// <param name="_inInt"></param>
|
|
/// <returns></returns>
|
|
public static string rToBitString(this int _inInt)
|
|
{
|
|
try
|
|
{
|
|
return (Convert.ToString(_inInt, 2)).PadLeft(8, '0');
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Byte를 Bit문자열로
|
|
/// </summary>
|
|
/// <param name="_inByte"></param>
|
|
/// <returns></returns>
|
|
public static string rToBitString(this byte _inByte)
|
|
{
|
|
try
|
|
{
|
|
return ((int)_inByte).rToBitString();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Char를 Bit문자열로
|
|
/// </summary>
|
|
/// <param name="_inChar"></param>
|
|
/// <returns></returns>
|
|
public static string rToBitString(this char _inChar)
|
|
{
|
|
try
|
|
{
|
|
return ((int)_inChar).rToBitString();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Char배열을 비트 문자열로
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <returns></returns>
|
|
public static string rToBitString(this char[] _inChars)
|
|
{
|
|
return _inChars.rToByte().rToBitString();
|
|
}
|
|
/// <summary>
|
|
/// Byte배열을 Bit문자열로
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <returns></returns>
|
|
public static string rToBitString(this byte[] _inBytes)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
for (int i = 0; i < _inBytes.Length; i++)
|
|
{
|
|
result += _inBytes[i].rToBitString();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Bit문자열을 Bool 배열로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArray(this string _inString)
|
|
{
|
|
return _inString.ToCharArray().rToBoolArray(false);
|
|
}
|
|
/// <summary>
|
|
/// Bit문자열을 Bool 배열로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <param name="_Height2Low">상위비트가 앞에 오도록</param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArray(this string _inString, bool _Height2Low)
|
|
{
|
|
return _inString.ToCharArray().rToBoolArray(_Height2Low);
|
|
}
|
|
/// <summary>
|
|
/// Bit문자열을 옵션에 따라 Boolean 배열로
|
|
/// </summary>
|
|
/// <param name="_getBit">입력Char배열</param>
|
|
/// <param name="_Height2Low">상위비트가 앞에 오도록</param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArray(this char[] _getBit, bool _Height2Low)
|
|
{
|
|
bool[] result = null;
|
|
try
|
|
{
|
|
if (_Height2Low)
|
|
{
|
|
result = new bool[_getBit.Length];
|
|
for (int i = 0; i < _getBit.Length; i++)
|
|
{
|
|
result[i] = _getBit[i] == '1';
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
result = new bool[_getBit.Length];
|
|
int pos = 0;
|
|
for (int i = 7; i > -1; i--)
|
|
{
|
|
result[pos] = _getBit[i] == '1';
|
|
pos++;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 정수를 Bit값을 Boolean 배열로 (LowBit 가 0)
|
|
/// </summary>
|
|
/// <param name="_inInt"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArray(this int _inInt)
|
|
{
|
|
bool[] result = null;
|
|
try
|
|
{
|
|
result = _inInt.rToBitString().rToBoolArray();
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// 정수의 Bit값을 Boolean 배열로 (HighBit 가 0)
|
|
/// </summary>
|
|
/// <param name="_inInt"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArrayHL(this int _inInt)
|
|
{
|
|
bool[] result = null;
|
|
try
|
|
{
|
|
result = _inInt.rToBitString().rToBoolArray(true);
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Byte의 Byte값을 Boolean 배열로 (LowBit 가 0)
|
|
/// </summary>
|
|
/// <param name="_inByte"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArray(this byte _inByte)
|
|
{
|
|
return ((int)_inByte).rToBoolArray();
|
|
}
|
|
/// <summary>
|
|
/// Byte의 Bit값을 Boolean 배열로 (HighBit 가 0)
|
|
/// </summary>
|
|
/// <param name="_inByte"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArrayHL(this byte _inByte)
|
|
{
|
|
return ((int)_inByte).rToBoolArrayHL();
|
|
}
|
|
/// <summary>
|
|
/// Char값을 Boolean 배열로 (LowBit 가 0)
|
|
/// </summary>
|
|
/// <param name="_inChar"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArray(this char _inChar)
|
|
{
|
|
return ((int)_inChar).rToBoolArray();
|
|
}
|
|
/// <summary>
|
|
/// Char값을 Boolean 배열로 (HighBit 가 0)
|
|
/// </summary>
|
|
/// <param name="_inChar"></param>
|
|
/// <returns></returns>
|
|
public static bool[] rToBoolArrayHL(this char _inChar)
|
|
{
|
|
return ((int)_inChar).rToBoolArrayHL();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 정수문자열을 정수로(int)
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static int rToInteger(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
if (_inString.rIsInteger()) return int.Parse(_inString);
|
|
else return 0;
|
|
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 정수문자열을 정수로(long)
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static long rToLongInteger(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
if (_inString.rIsInteger()) return long.Parse(_inString);
|
|
else return 0;
|
|
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 16진수 문자열을 정수로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static int rHexStrToInt(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
if (_inString.StartsWith("0x")) _inString = _inString.Substring(_inString.IndexOf("x") + 1);
|
|
return Convert.ToInt16(_inString, 16);
|
|
|
|
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 16진수 문자열을 Byte로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static byte rHexStrToByte(this string _inString)
|
|
{
|
|
return (byte)_inString.rHexStrToInt();
|
|
}
|
|
/// <summary>
|
|
/// 16진수 문자열을 Byte배열로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rHexStrToBytes(this string _inString)
|
|
{
|
|
byte[] result = null;
|
|
try
|
|
{
|
|
if (_inString.Length % 2 == 1) _inString.PadLeft(_inString.Length + 1, '0');
|
|
result = new byte[_inString.Length / 2];
|
|
for (int i = 0; i < _inString.Length / 2; i++)
|
|
{
|
|
result[i] = (byte)_inString.Substring(i * 2, 2).rHexStrToInt();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// 16진수 문자열을 Integer String으로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static string rHexStringToIntStr(this string _inString)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
if (_inString.Length % 2 == 1) _inString.PadLeft(_inString.Length + 1, '0');
|
|
for (int i = 0; i < _inString.Length / 2; i++)
|
|
{
|
|
result += ((char)_inString.Substring(i * 2, 2).rHexStrToInt()).ToString();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 16진수 문자열을 CHar로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static char rHexStrToChar(this string _inString)
|
|
{
|
|
return (char)_inString.rHexStrToInt();
|
|
}
|
|
/// <summary>
|
|
/// 비트문자열을 정수로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static int rBitStrToInt(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToInt16(_inString, 2);
|
|
|
|
}
|
|
catch
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 비트문자열을 Byte로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static byte rBitStrToByte(this string _inString)
|
|
{
|
|
return (byte)_inString.rBitStrToInt();
|
|
}
|
|
/// <summary>
|
|
/// 비트배열을 정수로
|
|
/// </summary>
|
|
/// <param name="_inBools">8개짜리 bool배열</param>
|
|
/// <param name="_Height2Low"></param>
|
|
/// <returns></returns>
|
|
public static int rToInteger(this bool[] _inBools, bool _Height2Low)
|
|
{
|
|
int result = 0;
|
|
try
|
|
{
|
|
string _bits = String.Empty;
|
|
if (_Height2Low)
|
|
{
|
|
for (int i = 0; i < _inBools.Length; i++)
|
|
{
|
|
_bits += _inBools[i] ? "1" : "0";
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
for (int i = 7; i > -1; i--)
|
|
{
|
|
_bits += _inBools[i] ? "1" : "0";
|
|
}
|
|
}
|
|
result = _bits.rBitStrToInt();
|
|
}
|
|
catch
|
|
{
|
|
result = 0;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Highbit가 먼저인 Boolean 배열을 Integer로
|
|
/// </summary>
|
|
/// <param name="_inBools"></param>
|
|
/// <returns></returns>
|
|
public static int rHLtoInt(this bool[] _inBools)
|
|
{
|
|
return _inBools.rToInteger(true);
|
|
}
|
|
/// <summary>
|
|
/// Lowbit가 먼저인 Boolean 배열을 Integer로
|
|
/// </summary>
|
|
/// <param name="_inBools"></param>
|
|
/// <returns></returns>
|
|
public static int rToInteger(this bool[] _inBools)
|
|
{
|
|
return _inBools.rToInteger(false);
|
|
}
|
|
/// <summary>
|
|
/// Boolrean 배열을 Byte로
|
|
/// </summary>
|
|
/// <param name="_inBools"></param>
|
|
/// <param name="_Height2Low">true=High가 첫번째,false=Lowbit가 첫번째</param>
|
|
/// <returns></returns>
|
|
public static byte rToByte(this bool[] _inBools, bool _Height2Low)
|
|
{
|
|
return (byte)_inBools.rToInteger(_Height2Low);
|
|
}
|
|
/// <summary>
|
|
/// Highbit가 먼저인 Boolean 배열을 Byte로
|
|
/// </summary>
|
|
/// <param name="_inBools"></param>
|
|
/// <returns></returns>
|
|
public static byte rHLtoByte(this bool[] _inBools)
|
|
{
|
|
return (byte)_inBools.rToInteger(true);
|
|
}
|
|
/// <summary>
|
|
/// Lowbit가 먼저인 Boolrean 배열을 Byte로
|
|
/// </summary>
|
|
/// <param name="_inBools"></param>
|
|
/// <returns></returns>
|
|
public static byte rToByte(this bool[] _inBools)
|
|
{
|
|
return (byte)_inBools.rToInteger(false);
|
|
}
|
|
/// <summary>
|
|
/// char 배열을 byte배열로
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rToByte(this char[] _inChars)
|
|
{
|
|
byte[] result = null;
|
|
try
|
|
{
|
|
result = new byte[_inChars.Length];
|
|
for (int i = 0; i < _inChars.Length; i++)
|
|
{
|
|
result[i] = (byte)_inChars[i];
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// byte배열을 char배열로
|
|
/// </summary>
|
|
/// <param name="_inByte"></param>
|
|
/// <returns></returns>
|
|
public static char[] rToChar(this byte[] _inByte)
|
|
{
|
|
char[] result = null;
|
|
try
|
|
{
|
|
result = new char[_inByte.Length];
|
|
for (int i = 0; i < _inByte.Length; i++)
|
|
{
|
|
result[i] = (char)_inByte[i];
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region MakeLRC
|
|
/// <summary>
|
|
/// LRC Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <returns></returns>
|
|
public static string rMakeLRC(this string _Data)
|
|
{
|
|
return rMakeLRC(_Data, CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// LRC Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static string rMakeLRC(this string _Data, CodeType _CodeType)
|
|
{
|
|
try
|
|
{
|
|
//long makeCheckSum = 0;
|
|
//byte[] DataBytes = _Data.rToByteArray();
|
|
//foreach (byte abyte in DataBytes) makeCheckSum += abyte;
|
|
//string checksum = makeCheckSum.ToString("X2");
|
|
return rMakeLRC(_Data.rToByteArray(_CodeType)).ToString();
|
|
|
|
}
|
|
catch
|
|
{
|
|
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// LRC Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <returns></returns>
|
|
public static byte rMakeLRC(this byte[] _Data)
|
|
{
|
|
try
|
|
{
|
|
byte LRC = _Data[0];
|
|
for (int i = 1; i < _Data.Length; i++)
|
|
{
|
|
LRC = (byte)(LRC ^ _Data[i]);
|
|
}
|
|
return LRC;
|
|
}
|
|
catch
|
|
{
|
|
return 0x00;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// LRC Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <returns></returns>
|
|
public static char rMakeLRC(this char[] _Data)
|
|
{
|
|
try
|
|
{
|
|
return (char)rMakeLRC(_Data.rToByte());
|
|
|
|
}
|
|
catch
|
|
{
|
|
return (char)0x00;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Checksum Make
|
|
/// <summary>
|
|
/// Checksum Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <returns></returns>
|
|
public static string rCheckSum(this string _Data)
|
|
{
|
|
return rCheckSum(_Data, CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// Checksum Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static string rCheckSum(this string _Data, CodeType _CodeType)
|
|
{
|
|
try
|
|
{
|
|
//long makeCheckSum = 0;
|
|
//byte[] DataBytes = _Data.rToByteArray();
|
|
//foreach (byte abyte in DataBytes) makeCheckSum += abyte;
|
|
//string checksum = makeCheckSum.ToString("X2");
|
|
return rCheckSum(_Data.rToByteArray(_CodeType)).rToEncString(_CodeType);
|
|
|
|
}
|
|
catch
|
|
{
|
|
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Checksum Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rCheckSum(this byte[] _Data)
|
|
{
|
|
try
|
|
{
|
|
long makeCheckSum = 0;
|
|
foreach (byte abyte in _Data) makeCheckSum += abyte;
|
|
string checksum = makeCheckSum.ToString("X2");
|
|
return checksum.Substring(checksum.Length - 2, 2).rToByteArray();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Checksum Make
|
|
/// </summary>
|
|
/// <param name="_Data"></param>
|
|
/// <returns></returns>
|
|
public static char[] rCheckSum(this char[] _Data)
|
|
{
|
|
try
|
|
{
|
|
return rCheckSum(_Data.rToByte()).rToChar();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Encodings & Decoding
|
|
/// <summary>
|
|
/// 문자열을 Char배열로(Encodeing by Default)
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns>코드페이지 오류시 null</returns>
|
|
public static char[] rToEncChar(this string _inString)
|
|
{
|
|
return _inString.rToEncChar(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// 문자열을 Char배열로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns>코드페이지 오류시 null</returns>
|
|
public static char[] rToEncChar(this string _inString, CodeType _CodeType)
|
|
{
|
|
return _inString.rToByteArray(_CodeType).rToChar();
|
|
}
|
|
/// <summary>
|
|
/// 문자열을 Byte배열로(Encodeing by Default)
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns>코드페이지 오류시 null</returns>
|
|
public static byte[] rToByteArray(this string _inString)
|
|
{
|
|
return _inString.rToByteArray(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// 문자열을 Byte배열로
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rToByteArray(this string _inString, CodeType _CodeType)
|
|
{
|
|
return _CodeType.rGetEncoding().GetBytes(_inString);
|
|
}
|
|
/// <summary>
|
|
/// 문자열로 CodeType 형식 구하기
|
|
/// </summary>
|
|
/// <param name="_Encoding"></param>
|
|
/// <returns></returns>
|
|
public static CodeType rGetCodeType(this Encoding _Encoding)
|
|
{
|
|
CodeType result = CodeType.Default;
|
|
try
|
|
{
|
|
switch (_Encoding.ToString())
|
|
{
|
|
case "ASCII":
|
|
result = CodeType.ASCII;
|
|
break;
|
|
case "BigEndianUnicode":
|
|
result = CodeType.BigEdianUnicode;
|
|
break;
|
|
case "Unicode":
|
|
result = CodeType.Unicode;
|
|
break;
|
|
case "UTF7":
|
|
result = CodeType.UTF7;
|
|
break;
|
|
case "UTF8":
|
|
result = CodeType.UTF8;
|
|
break;
|
|
case "UTF32":
|
|
result = CodeType.UTF32;
|
|
break;
|
|
case "Default":
|
|
result = CodeType.Default;
|
|
break;
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return result;
|
|
}
|
|
/// <summary>
|
|
/// Code Type에
|
|
/// 맞는 Encoding 가져오기
|
|
/// </summary>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns>Encoding</returns>
|
|
public static Encoding rGetEncoding(this CodeType _CodeType)
|
|
{
|
|
Encoding result = Encoding.Default;
|
|
try
|
|
{
|
|
switch (_CodeType)
|
|
{
|
|
case CodeType.ASCII:
|
|
result = Encoding.ASCII;
|
|
break;
|
|
case CodeType.BigEdianUnicode:
|
|
result = Encoding.BigEndianUnicode;
|
|
break;
|
|
case CodeType.Unicode:
|
|
result = Encoding.Unicode;
|
|
break;
|
|
case CodeType.UTF7:
|
|
result = Encoding.UTF7;
|
|
break;
|
|
case CodeType.UTF8:
|
|
result = Encoding.UTF8;
|
|
break;
|
|
case CodeType.UTF32:
|
|
result = Encoding.UTF32;
|
|
break;
|
|
case CodeType.Default:
|
|
result = Encoding.Default;
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = Encoding.Default;
|
|
}
|
|
return result;
|
|
|
|
}
|
|
/// <summary>
|
|
/// Char배열을 문자열로(Encodeing by Default)
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <returns>코드페이지 오류시 빈문자열</returns>
|
|
public static string rToEncString(this char[] _inChars)
|
|
{
|
|
return _inChars.rToByte().rToEncString(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// Char배열을 문자열로
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns>코드페이지 오류시 빈문자열</returns>
|
|
public static string rToEncString(this char[] _inChars, CodeType _CodeType)
|
|
{
|
|
return _inChars.rToByte().rToEncString(_CodeType);
|
|
}
|
|
/// <summary>
|
|
/// Byte배열을 문자열로(Encodeing by Default)
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <returns>코드페이지 오류시 빈문자열</returns>
|
|
public static string rToEncString(this byte[] _inBytes)
|
|
{
|
|
return _inBytes.rToEncString(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// Byte배열을 문자열로
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns>코드페이지 오류시 빈문자열</returns>
|
|
public static string rToEncString(this byte[] _inBytes, CodeType _CodeType)
|
|
{
|
|
string result = null;
|
|
try
|
|
{
|
|
|
|
switch (_CodeType)
|
|
{
|
|
case CodeType.ASCII:
|
|
result = Encoding.ASCII.GetString(_inBytes);
|
|
break;
|
|
case CodeType.BigEdianUnicode:
|
|
result = Encoding.BigEndianUnicode.GetString(_inBytes);
|
|
break;
|
|
case CodeType.Unicode:
|
|
result = Encoding.Unicode.GetString(_inBytes);
|
|
break;
|
|
case CodeType.UTF7:
|
|
result = Encoding.UTF7.GetString(_inBytes);
|
|
break;
|
|
case CodeType.UTF8:
|
|
result = Encoding.UTF8.GetString(_inBytes);
|
|
break;
|
|
case CodeType.UTF32:
|
|
result = Encoding.UTF32.GetString(_inBytes);
|
|
break;
|
|
case CodeType.Default:
|
|
result = Encoding.Default.GetString(_inBytes);
|
|
break;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString">입력문자열</param>
|
|
/// <returns>오류시 빈문자열</returns>
|
|
public static string rBase64Encode(this string _inString)
|
|
{
|
|
return _inString.rBase64Encode(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString">입력문자열</param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns>코드페이지 오류시 빈문자열</returns>
|
|
public static string rBase64Encode(this string _inString, CodeType _CodeType)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToBase64String(_inString.rToByteArray(_CodeType));
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inBytes">엔코딩한 문자열 Byte배열</param>
|
|
/// <returns>오류시 빈문자열</returns>
|
|
public static string rBase64Encode(this byte[] _inBytes)
|
|
{
|
|
try
|
|
{
|
|
return Convert.ToBase64String(_inBytes);
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inChars">엔코딩한 문자열 Byte배열</param>
|
|
/// <returns>오류시 빈문자열</returns>
|
|
public static string rBase64Encode(this char[] _inChars)
|
|
{
|
|
try
|
|
{
|
|
return _inChars.rToByte().rBase64Encode();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <returns></returns>
|
|
public static char[] rBase64EncodeChars(this byte[] _inBytes)
|
|
{
|
|
try
|
|
{
|
|
return rBase64Encode(_inBytes).ToCharArray();
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static char[] rBase64EncodeChars(this string _inString)
|
|
{
|
|
return _inString.rBase64Encode(CodeType.Default).ToCharArray();
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static char[] rBase64EncodeChars(this string _inString, CodeType _CodeType)
|
|
{
|
|
return _inString.rBase64Encode(_CodeType).ToCharArray();
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rBase64EncodeBytes(this string _inString)
|
|
{
|
|
return _inString.rBase64EncodeChars().rToByte();
|
|
}
|
|
/// <summary>
|
|
/// Base64 인코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rBase64EncodeBytes(this string _inString, CodeType _CodeType)
|
|
{
|
|
return _inString.rBase64EncodeChars(_CodeType).rToByte();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString">입력문자열</param>
|
|
/// <returns>오류시 빈문자열</returns>
|
|
public static byte[] rBase64DecodeBytes(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
return Convert.FromBase64String(_inString);
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inBytes">입력문자열</param>
|
|
/// <returns>코드페이지 오류시 빈문자열</returns>
|
|
public static byte[] rBase64DecodeBytes(this byte[] _inBytes)
|
|
{
|
|
return _inBytes.rToChar().rBase64DecodeBytes();
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rBase64DecodeBytes(this char[] _inChars)
|
|
{
|
|
try
|
|
{
|
|
return Convert.FromBase64CharArray(_inChars, 0, _inChars.Length);
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static string rBase64Decode(this string _inString)
|
|
{
|
|
return _inString.rBase64Decode(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static string rBase64Decode(this string _inString, CodeType _CodeType)
|
|
{
|
|
return _inString.rBase64DecodeBytes().rToEncString(_CodeType);
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <returns></returns>
|
|
public static string rBase64Decode(this byte[] _inBytes)
|
|
{
|
|
return _inBytes.rToChar().rBase64Decode();
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <returns></returns>
|
|
public static string rBase64Decode(this char[] _inChars)
|
|
{
|
|
return _inChars.rBase64Decode(CodeType.Default);
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inBytes"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static string rBase64Decode(this byte[] _inBytes, CodeType _CodeType)
|
|
{
|
|
return _inBytes.rToChar().rBase64Decode(_CodeType);
|
|
}
|
|
/// <summary>
|
|
/// Base64 디코딩을 합니다
|
|
/// </summary>
|
|
/// <param name="_inChars"></param>
|
|
/// <param name="_CodeType"></param>
|
|
/// <returns></returns>
|
|
public static string rBase64Decode(this char[] _inChars, CodeType _CodeType)
|
|
{
|
|
try
|
|
{
|
|
return Convert.FromBase64CharArray(_inChars, 0, _inChars.Length).rToEncString(_CodeType);
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region 컨트롤 문자를 컨트롤 문자명으로 찾기
|
|
/// <summary>
|
|
/// Find Cotrol ANSI by Cotrol Code Name
|
|
/// </summary>
|
|
/// <param name="_inCode"></param>
|
|
/// <returns></returns>
|
|
public static Ctrl_ASCII rGetControlANSI(this string _inCode)
|
|
{
|
|
try
|
|
{
|
|
return (Ctrl_ASCII)Array.IndexOf(Enum.GetNames(typeof(Ctrl_ASCII)), _inCode.ToUpper().Replace("<", "").Replace(">", ""));
|
|
|
|
}
|
|
catch
|
|
{
|
|
return Ctrl_ASCII.Null;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Find Cotrol ANSI by Cotrol Code Name
|
|
/// </summary>
|
|
/// <param name="_inCode"></param>
|
|
/// <returns></returns>
|
|
public static char rGetControlChar(this string _inCode)
|
|
{
|
|
return (char)(_inCode.Replace("<", "").Replace(">", "").rGetControlANSI());
|
|
}
|
|
/// <summary>
|
|
/// Find Cotrol ANSI by Cotrol Code Name
|
|
/// </summary>
|
|
/// <param name="_inCode"></param>
|
|
/// <returns></returns>
|
|
public static byte rGetControlByte(this string _inCode)
|
|
{
|
|
return (byte)(_inCode.Replace("<", "").Replace(">", "").rGetControlANSI());
|
|
}
|
|
/// <summary>
|
|
/// Find Cotrol ANSI by Cotrol Code Name
|
|
/// </summary>
|
|
/// <param name="_inCode"></param>
|
|
/// <returns></returns>
|
|
public static string rGetControlString(this string _inCode)
|
|
{
|
|
try
|
|
{
|
|
return _inCode.Equals(string.Empty) ? string.Empty : Convert.ToString(_inCode.Replace("<", "").Replace(">", "").rGetControlChar());
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// ASCII Control Code to CodeName
|
|
/// 문자에 대한 ASCII control 코드명 구하기
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static string rReplaceANSIToTag(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
_inString = _inString.Replace("\0", "<Null>");
|
|
foreach (string ctrlCode in Enum.GetNames(typeof(Ctrl_ASCII)))
|
|
{
|
|
|
|
if (!ctrlCode.Equals(string.Empty))
|
|
_inString = _inString.Replace(ctrlCode.rGetControlString(), string.Format("<{0}>", ctrlCode));
|
|
}
|
|
return _inString;
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// CodeName to ASCII Control Code
|
|
/// 문자열을 바이트 표시 문자열로 변환
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static string rReplaceToANSI(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
foreach (string ctrlCode in Enum.GetNames(typeof(Ctrl_ASCII)))
|
|
{
|
|
|
|
if (!ctrlCode.Equals(string.Empty))
|
|
_inString = _inString.Replace(string.Format("<{0}>", ctrlCode), ctrlCode.rGetControlString());
|
|
}
|
|
return _inString;
|
|
|
|
}
|
|
catch
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 바이트 표시 형식 문자열을 바이트 배열로 반환
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static byte[] rReplaceToByte(this string _inString)
|
|
{
|
|
try
|
|
{
|
|
string strbuff = _inString;
|
|
foreach (string ctrlCode in Enum.GetNames(typeof(Ctrl_ASCII)))
|
|
{
|
|
|
|
if (!ctrlCode.Equals(string.Empty))
|
|
strbuff = strbuff.Replace(string.Format("<{0}>", ctrlCode), ctrlCode.rGetControlString());
|
|
}
|
|
string[] inChars = strbuff.Split('<');
|
|
byte[] result = new byte[0];
|
|
byte[] makeBlock = new byte[0];
|
|
foreach (string aChar in inChars)
|
|
{
|
|
if (aChar.StartsWith("0x"))
|
|
{
|
|
string[] inChars2 = aChar.Split('>');
|
|
foreach (string aChar2 in inChars2)
|
|
{
|
|
if (!aChar2.Equals(string.Empty))
|
|
{
|
|
if (aChar2.StartsWith("0x"))
|
|
{
|
|
makeBlock = new byte[] { aChar2.Replace("0x", "").rHexStrToByte() };
|
|
}
|
|
else
|
|
{
|
|
makeBlock = aChar2.rToByteArray();
|
|
}
|
|
int addPos = result.Length;
|
|
Array.Resize(ref result, result.Length + makeBlock.Length);
|
|
Array.Copy(makeBlock, 0, result, addPos, makeBlock.Length);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
makeBlock = aChar.rToByteArray();
|
|
int addPos = result.Length;
|
|
Array.Resize(ref result, result.Length + makeBlock.Length);
|
|
Array.Copy(makeBlock, 0, result, addPos, makeBlock.Length);
|
|
}
|
|
}
|
|
return result;
|
|
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region byte수를 문자열로 표시
|
|
/// <summary>
|
|
/// 바이트수를 문자열로 표시
|
|
/// </summary>
|
|
/// <param name="_inInt">바이트수</param>
|
|
/// <returns></returns>
|
|
public static string rByteCountToString(this int _inInt)
|
|
{
|
|
return rByteCountToString((long)_inInt);
|
|
}
|
|
/// <summary>
|
|
/// 바이트수를 문자열로 표시
|
|
/// </summary>
|
|
/// <param name="_inLong">바이트수</param>
|
|
/// <returns></returns>
|
|
public static string rByteCountToString(this long _inLong)
|
|
{
|
|
return rByteCountToString((double)_inLong);
|
|
}
|
|
/// <summary>
|
|
/// 바이트수를 문자열로 표시
|
|
/// </summary>
|
|
/// <param name="_inDeouble"></param>
|
|
/// <returns></returns>
|
|
public static string rByteCountToString(this double _inDeouble)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
result = string.Format("{0}Bytes", _inDeouble.ToString("#,##0"));
|
|
if (_inDeouble > 512d)
|
|
{
|
|
if (_inDeouble > (1024d * 512d))
|
|
{
|
|
if (_inDeouble > (1024d * 1024d * 512d))
|
|
{
|
|
if (_inDeouble > (1024d * 1024d * 1024d * 512d))
|
|
{
|
|
result = string.Format("{0}TB", (_inDeouble / 1024d / 1024d / 1024d / 1024d).ToString("#,##0.00"));
|
|
}
|
|
else
|
|
{
|
|
result = string.Format("{0}GB", (_inDeouble / 1024d / 1024d / 1024d).ToString("#,##0.00"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = string.Format("{0}MB", (_inDeouble / 1024d / 1024d).ToString("#,##0.00"));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = string.Format("{0}KB", (_inDeouble / 1024d).ToString("#,##0.00"));
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return result;
|
|
}
|
|
#endregion
|
|
/// <summary>
|
|
/// 문자열 중 숫자만 뽑기
|
|
/// </summary>
|
|
/// <param name="_inString"></param>
|
|
/// <returns></returns>
|
|
public static string rGetOnlyNum(this string _inString)
|
|
{
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
if (_inString != null && _inString.Length > 0)
|
|
{
|
|
char[] getChars = _inString.ToCharArray();
|
|
foreach (char getChar in getChars)
|
|
{
|
|
if (getChar.rIsNum())
|
|
{
|
|
result += getChar;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
|
|
result = string.Empty;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
} |