1659 lines
35 KiB
C#
1659 lines
35 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Management;
|
|
using System.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net.Sockets;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace AIMSExtension
|
|
{
|
|
public static class GPFunctions
|
|
{
|
|
public static int CInt<T>(T t)
|
|
{
|
|
int result = 0;
|
|
try
|
|
{
|
|
result = Convert.ToInt32(t);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
result = 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static int IntParse<T>(T t)
|
|
{
|
|
bool flag = t == null;
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
result = GPFunctions.IntParse(t.ToString());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static int IntParse(string strnum)
|
|
{
|
|
strnum = strnum.Trim();
|
|
bool flag = strnum == null || strnum.Length == 0;
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
int length = strnum.Length;
|
|
int num = length;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
string text = strnum.Substring(i, 1);
|
|
bool flag2 = text.CompareTo("0") < 0 || text.CompareTo("9") > 0;
|
|
if (flag2)
|
|
{
|
|
num = i;
|
|
break;
|
|
}
|
|
}
|
|
bool flag3 = num == 0;
|
|
if (flag3)
|
|
{
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
result = Convert.ToInt32(strnum.Substring(0, num));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool CBool(string val)
|
|
{
|
|
bool flag = val == null;
|
|
bool result;
|
|
if (flag)
|
|
{
|
|
result = false;
|
|
}
|
|
else
|
|
{
|
|
val = val.Trim().ToLower();
|
|
bool flag2 = val == "true" || val == "false";
|
|
if (flag2)
|
|
{
|
|
result = bool.Parse(val);
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = GPFunctions.CDecimal<string>(val).CompareTo(decimal.Zero) == 0;
|
|
result = !flag3;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool CBool<T>(T t)
|
|
{
|
|
bool flag = t == null;
|
|
return !flag && GPFunctions.CBool(t.ToString());
|
|
}
|
|
|
|
public static long CLng<T>(T t)
|
|
{
|
|
long result = 0L;
|
|
try
|
|
{
|
|
result = Convert.ToInt64(t);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
result = 0L;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static decimal CDecimal<T>(T t)
|
|
{
|
|
decimal result = 0m;
|
|
try
|
|
{
|
|
result = Convert.ToDecimal(t);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
result = 0m;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static double CDbl<T>(T t)
|
|
{
|
|
double num = 0.0;
|
|
try
|
|
{
|
|
num = Convert.ToDouble(t);
|
|
bool flag = num != 0.0;
|
|
if (flag)
|
|
{
|
|
bool flag2 = num > 0.0;
|
|
if (flag2)
|
|
{
|
|
num = Math.Round(num + 1E-08, 6);
|
|
}
|
|
else
|
|
{
|
|
num = Math.Round(num - 1E-08, 6);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
num = 0.0;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
public static DateTime CDate<T>(T t)
|
|
{
|
|
DateTime result = new DateTime(1, 1, 1);
|
|
try
|
|
{
|
|
result = Convert.ToDateTime(t);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static DateTime CDate2(string yyyyMMddHHmmss)
|
|
{
|
|
int length = yyyyMMddHHmmss.Length;
|
|
bool flag = length < 8;
|
|
DateTime result;
|
|
if (flag)
|
|
{
|
|
result = new DateTime(1, 1, 1);
|
|
}
|
|
else
|
|
{
|
|
int hour = 0;
|
|
int minute = 0;
|
|
int second = 0;
|
|
int year = Convert.ToInt32(yyyyMMddHHmmss.Substring(0, 4));
|
|
int month = Convert.ToInt32(yyyyMMddHHmmss.Substring(4, 2));
|
|
int day = Convert.ToInt32(yyyyMMddHHmmss.Substring(6, 2));
|
|
bool flag2 = length == 8;
|
|
if (flag2)
|
|
{
|
|
result = new DateTime(year, month, day);
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = length >= 10;
|
|
if (flag3)
|
|
{
|
|
hour = Convert.ToInt32(yyyyMMddHHmmss.Substring(8, 2));
|
|
}
|
|
bool flag4 = length >= 12;
|
|
if (flag4)
|
|
{
|
|
minute = Convert.ToInt32(yyyyMMddHHmmss.Substring(10, 2));
|
|
}
|
|
bool flag5 = length >= 14;
|
|
if (flag5)
|
|
{
|
|
second = Convert.ToInt32(yyyyMMddHHmmss.Substring(12, 2));
|
|
}
|
|
result = new DateTime(year, month, day, hour, minute, second);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string CStr<T>(T t)
|
|
{
|
|
bool flag = t == null;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
result = t.ToString();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string CStr<T>(T t, int len)
|
|
{
|
|
string text = GPFunctions.CStr<T>(t);
|
|
return (len > text.Length) ? text : text.Substring(0, len);
|
|
}
|
|
|
|
public static string CStrEx<T>(T t)
|
|
{
|
|
string text = GPFunctions.CStr<T>(t);
|
|
bool flag = string.IsNullOrWhiteSpace(text);
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
result = Regex.Replace(text, "^\\s+|\\s+$", "");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string CStrEx<T>(T t, int len)
|
|
{
|
|
string text = GPFunctions.CStr<T>(t);
|
|
bool flag = string.IsNullOrWhiteSpace(text);
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
text = Regex.Replace(text, "^\\s+|\\s+$", "");
|
|
result = ((len > text.Length) ? text : text.Substring(0, len));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static int GetNvarcharLength(string str)
|
|
{
|
|
bool flag = string.IsNullOrWhiteSpace(str);
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = 0;
|
|
}
|
|
else
|
|
{
|
|
byte[] bytes = Encoding.Default.GetBytes(str);
|
|
result = bytes.Length;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string GetVarcharLengthStr(string str, int len)
|
|
{
|
|
bool flag = string.IsNullOrWhiteSpace(str);
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
byte[] bytes = Encoding.Default.GetBytes(str);
|
|
int num = bytes.Length;
|
|
bool flag2 = num <= len;
|
|
if (flag2)
|
|
{
|
|
result = str;
|
|
}
|
|
else
|
|
{
|
|
bool flag3 = bytes[len - 1] <= 127;
|
|
if (flag3)
|
|
{
|
|
result = Encoding.Default.GetString(bytes, 0, len);
|
|
}
|
|
else
|
|
{
|
|
result = Encoding.Default.GetString(bytes, 0, len - 1);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string Trim(string strnum)
|
|
{
|
|
string text = strnum.Trim();
|
|
bool flag = string.IsNullOrWhiteSpace(strnum);
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
result = Regex.Replace(strnum, "^\\s+|\\s+$", "");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool IsMail(string fmail)
|
|
{
|
|
Regex regex = new Regex("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
|
|
return regex.IsMatch(fmail);
|
|
}
|
|
|
|
public static bool IsIPv4Adress(string ipstr)
|
|
{
|
|
int[] array = GPFunctions.StringToIntArray(ipstr, '.');
|
|
bool flag = array.Length != 4;
|
|
bool result;
|
|
if (flag)
|
|
{
|
|
result = false;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
int num = array[i];
|
|
bool flag2 = i == 0;
|
|
if (flag2)
|
|
{
|
|
bool flag3 = num < 1 || num > 255;
|
|
if (flag3)
|
|
{
|
|
result = false;
|
|
return result;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag4 = num < 0 || num > 255;
|
|
if (flag4)
|
|
{
|
|
result = false;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool IsMobile(string mobile)
|
|
{
|
|
Regex regex = new Regex("[1-9]\\d{10}");
|
|
return regex.IsMatch(mobile);
|
|
}
|
|
|
|
public static bool IsMobile(long mobile)
|
|
{
|
|
return mobile >= 10000000000L && mobile <= 99999999999L;
|
|
}
|
|
|
|
public static bool IsAllNumber(string inStr)
|
|
{
|
|
string text = GPFunctions.CStrEx<string>(inStr);
|
|
int length = text.Length;
|
|
bool flag = length == 0;
|
|
bool result;
|
|
if (flag)
|
|
{
|
|
result = false;
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
char c = text[i];
|
|
bool flag2 = c != '.' && (c < '0' || c > '9');
|
|
if (flag2)
|
|
{
|
|
result = false;
|
|
return result;
|
|
}
|
|
}
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool IsAscIIString(string input)
|
|
{
|
|
bool flag = true;
|
|
bool flag2 = string.IsNullOrWhiteSpace(input);
|
|
bool result;
|
|
if (flag2)
|
|
{
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
int length = input.Length;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
char value = input[i];
|
|
bool flag3 = Convert.ToByte(value) > 127;
|
|
if (flag3)
|
|
{
|
|
flag = false;
|
|
break;
|
|
}
|
|
}
|
|
result = flag;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static bool IsVariableString(string input)
|
|
{
|
|
Regex regex = new Regex("^[_a-zA-Z]\\w*$");
|
|
bool flag = string.IsNullOrWhiteSpace(input);
|
|
return !flag && regex.IsMatch(input);
|
|
}
|
|
|
|
public static string SqlDateStr(DateTime d)
|
|
{
|
|
bool flag = d.Year <= 1;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "NULL";
|
|
}
|
|
else
|
|
{
|
|
result = string.Format("'{0}'", GPFunctions.DateTimeStr(d));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string SqlDateStr(object dateObj)
|
|
{
|
|
bool flag = dateObj == DBNull.Value;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "NULL";
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = dateObj.GetType().Name == "DateTime";
|
|
if (flag2)
|
|
{
|
|
DateTime d = Convert.ToDateTime(dateObj);
|
|
result = GPFunctions.SqlDateStr(d);
|
|
}
|
|
else
|
|
{
|
|
string text = "NULL";
|
|
DateTime d;
|
|
bool flag3 = DateTime.TryParse(dateObj.ToString(), out d);
|
|
if (flag3)
|
|
{
|
|
text = GPFunctions.SqlDateStr(d);
|
|
}
|
|
result = text;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string DateStr(DateTime d)
|
|
{
|
|
return d.ToString("yyyy/MM/dd");
|
|
}
|
|
|
|
public static string DateTimeStr(DateTime d)
|
|
{
|
|
bool flag = d.Hour + d.Minute + d.Second == 0;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = d.ToString("yyyy/MM/dd");
|
|
}
|
|
else
|
|
{
|
|
result = d.ToString("yyyy/MM/dd HH:mm:ss");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string Now()
|
|
{
|
|
return DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");
|
|
}
|
|
|
|
public static string Today()
|
|
{
|
|
return DateTime.Now.Date.ToString("yyyy/MM/dd");
|
|
}
|
|
|
|
public static int GetTimeStamp(DateTime d)
|
|
{
|
|
return Convert.ToInt32(d.Subtract(DateTime.Parse("1970/1/1")).TotalSeconds);
|
|
}
|
|
|
|
public static int GetUnixTimeStamp(DateTime d)
|
|
{
|
|
return Convert.ToInt32(d.Subtract(DateTime.Parse("1970/1/1 8:0:0")).TotalSeconds);
|
|
}
|
|
|
|
public static string BigIntToTimestamp(long i64)
|
|
{
|
|
string text = i64.ToString("X2");
|
|
int length = text.Length;
|
|
return "0x0000000000000000".Substring(0, 18 - length) + text;
|
|
}
|
|
|
|
public static DateTime IntToTime(int totalSeconds)
|
|
{
|
|
return DateTime.Parse("1970/1/1").AddSeconds((double)(totalSeconds + 86400));
|
|
}
|
|
|
|
public static long TimeOf()
|
|
{
|
|
return GPFunctions.TimeOf(DateTime.Now);
|
|
}
|
|
|
|
public static long TimeOf(DateTime t)
|
|
{
|
|
DateTime d = new DateTime(1970, 1, 1);
|
|
return (long)(t - d).TotalSeconds;
|
|
}
|
|
|
|
public static DateTime OracleTime()
|
|
{
|
|
DateTime now = DateTime.Now;
|
|
return new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second);
|
|
}
|
|
|
|
public static DateTime OracleTime(DateTime d)
|
|
{
|
|
return new DateTime(d.Year, d.Month, d.Day, d.Hour, d.Minute, d.Second);
|
|
}
|
|
|
|
public static Dictionary<string, string> StringToDict(string str, string rowdeli, string coldeli)
|
|
{
|
|
string text = str.Trim();
|
|
string[] array = Regex.Split(str, rowdeli);
|
|
int num = array.Length;
|
|
Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
string[] array2 = Regex.Split(array[i], coldeli);
|
|
bool flag = array2.Length > 1;
|
|
if (flag)
|
|
{
|
|
string text2 = array2[0].Trim();
|
|
bool flag2 = text2.Length > 0;
|
|
if (flag2)
|
|
{
|
|
dictionary[text2] = array2[1].Trim();
|
|
}
|
|
}
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
public static Dictionary<string, string> StringToDict(string str, char rowdeli, char coldeli)
|
|
{
|
|
string text = str.Trim();
|
|
string[] array = text.Split(new char[]
|
|
{
|
|
rowdeli
|
|
});
|
|
int num = array.Length;
|
|
Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
string[] array2 = array[i].Split(new char[]
|
|
{
|
|
coldeli
|
|
});
|
|
bool flag = array2.Length > 1;
|
|
if (flag)
|
|
{
|
|
string text2 = array2[0].Trim();
|
|
bool flag2 = text2.Length > 0;
|
|
if (flag2)
|
|
{
|
|
dictionary[text2] = array2[1].Trim();
|
|
}
|
|
}
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
public static Dictionary<string, int> StringToDictInt(string str, char rowdeli, char coldeli)
|
|
{
|
|
string text = str.Trim();
|
|
string[] array = text.Split(new char[]
|
|
{
|
|
rowdeli
|
|
});
|
|
int num = array.Length;
|
|
Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
string[] array2 = array[i].Split(new char[]
|
|
{
|
|
coldeli
|
|
});
|
|
bool flag = array2.Length > 1;
|
|
if (flag)
|
|
{
|
|
string text2 = array2[0].Trim();
|
|
bool flag2 = text2.Length > 0;
|
|
if (flag2)
|
|
{
|
|
dictionary[text2] = GPFunctions.CInt<string>(array2[1].Trim());
|
|
}
|
|
}
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
public static string DictionaryToString<TKey, TValue>(Dictionary<TKey, TValue> dic, string rowdeli, string coldeli)
|
|
{
|
|
int num = dic.Count;
|
|
string[] array = new string[num];
|
|
num = 0;
|
|
foreach (KeyValuePair<TKey, TValue> current in dic)
|
|
{
|
|
string[] arg_57_0 = array;
|
|
int expr_26 = num++;
|
|
string arg_52_0 = "{0}{1}{2}";
|
|
object arg_52_1 = current.Key;
|
|
TValue value = current.Value;
|
|
arg_57_0[expr_26] = string.Format(arg_52_0, arg_52_1, coldeli, value.ToString());
|
|
}
|
|
return string.Join(rowdeli, array);
|
|
}
|
|
|
|
public static string DictionaryToString(IDictionary dic, string rowdeli, string coldeli)
|
|
{
|
|
int num = dic.Count;
|
|
string[] array = new string[num];
|
|
num = 0;
|
|
foreach (DictionaryEntry dictionaryEntry in dic)
|
|
{
|
|
bool flag = dictionaryEntry.Value.GetType().Name.IndexOf("Dictionary") >= 0;
|
|
if (flag)
|
|
{
|
|
Type[] genericArguments = dictionaryEntry.Value.GetType().GetGenericArguments();
|
|
bool flag2 = genericArguments.Length == 2;
|
|
if (flag2)
|
|
{
|
|
string arg = GPFunctions.DictionaryToString((IDictionary)dictionaryEntry.Value, rowdeli, coldeli);
|
|
array[num++] = string.Format("{0}{1}{{{2}}}", dictionaryEntry.Key, coldeli, arg);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
array[num++] = string.Format("{0}{1}{2}", dictionaryEntry.Key, coldeli, dictionaryEntry.Value.ToString());
|
|
}
|
|
}
|
|
return string.Join(rowdeli, array);
|
|
}
|
|
|
|
public static string SortedKeyValue(string str, char colchar, char rowchar)
|
|
{
|
|
SortedDictionary<string, string> sortedDictionary = new SortedDictionary<string, string>();
|
|
string[] array = str.Split(new char[]
|
|
{
|
|
rowchar
|
|
});
|
|
string[] array2 = array;
|
|
for (int i = 0; i < array2.Length; i++)
|
|
{
|
|
string text = array2[i];
|
|
bool flag = text.Length > 0;
|
|
if (flag)
|
|
{
|
|
string[] array3 = text.Split(new char[]
|
|
{
|
|
colchar
|
|
});
|
|
bool flag2 = array3.Length == 2;
|
|
if (flag2)
|
|
{
|
|
string text2 = array3[0].Trim();
|
|
bool flag3 = text2.Length > 0;
|
|
if (flag3)
|
|
{
|
|
sortedDictionary[text2] = array3[1];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return GPFunctions.SortedKeyValue(sortedDictionary, colchar, rowchar);
|
|
}
|
|
|
|
public static string SortedKeyValue(SortedDictionary<string, string> d, char colchar, char rowchar)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
int num = 0;
|
|
string value = (rowchar == '\0') ? "" : rowchar.ToString();
|
|
foreach (KeyValuePair<string, string> current in d)
|
|
{
|
|
bool flag = num > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(value);
|
|
}
|
|
else
|
|
{
|
|
num++;
|
|
}
|
|
stringBuilder.Append(current.Key + colchar.ToString() + current.Value);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string SortedKeyValue(Dictionary<string, string> d, char colchar, char rowchar)
|
|
{
|
|
SortedDictionary<string, string> sortedDictionary = new SortedDictionary<string, string>();
|
|
foreach (KeyValuePair<string, string> current in d)
|
|
{
|
|
sortedDictionary.Add(current.Key, current.Value);
|
|
}
|
|
return GPFunctions.SortedKeyValue(sortedDictionary, colchar, rowchar);
|
|
}
|
|
|
|
public static string Random(int n)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
int seed = Convert.ToInt32((DateTime.Now - new DateTime(0L)).TotalMilliseconds);
|
|
Random random = new Random(seed);
|
|
string text = "1234567890ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz!@$%^&*()-_=+[]{}|\\;:’”,.<>?/`~";
|
|
for (int i = 0; i < n; i++)
|
|
{
|
|
int index = random.Next(90);
|
|
stringBuilder.Append(text[index]);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string RandomInt(int n)
|
|
{
|
|
int seed = Convert.ToInt32((DateTime.Now - new DateTime(0L)).TotalMilliseconds);
|
|
Random random = new Random(seed);
|
|
int num = (int)Math.Pow(10.0, (double)n) - 1;
|
|
string text = random.Next(num).ToString();
|
|
num = text.Length;
|
|
bool flag = num == n;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = text;
|
|
}
|
|
else
|
|
{
|
|
result = "00000".Substring(0, n - num) + text;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string SqlEncode(string s)
|
|
{
|
|
return s.Replace("'", "''");
|
|
}
|
|
|
|
public static string JsonString(string keyval)
|
|
{
|
|
return "\"" + keyval + "\"";
|
|
}
|
|
|
|
public static string EncodeJsonValue(string s)
|
|
{
|
|
bool flag = s == null || s == "";
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
result = s.Replace("\"", "\\\"").Replace(Convert.ToString('\r'), "\\r").Replace(Convert.ToString('\n'), "\\n");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string HtmlDecode(string s)
|
|
{
|
|
return s.Replace("&", "&").Replace("<", "<").Replace(">", ">").Replace(" ", " ").Replace("'", "'").Replace(""", "\"");
|
|
}
|
|
|
|
public static string RepeatString(string s, int num)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
stringBuilder.Append(s);
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static int[] StringToIntArray(string ints)
|
|
{
|
|
return GPFunctions.StringToIntArray(ints, ',');
|
|
}
|
|
|
|
public static int[] StringToIntArray(string ints, char delimeter)
|
|
{
|
|
return GPFunctions.StringToListInt(ints, delimeter).ToArray();
|
|
}
|
|
|
|
public static string[] StringToStringArray(string strs)
|
|
{
|
|
return GPFunctions.StringToStringArray(strs, ',');
|
|
}
|
|
|
|
public static string[] StringToStringArray(string strs, char delimeter)
|
|
{
|
|
return GPFunctions.StringToListString(strs, delimeter).ToArray();
|
|
}
|
|
|
|
public static List<string> StringToListString(string strs, char delimeter)
|
|
{
|
|
List<string> list = new List<string>();
|
|
string[] array = strs.Split(new char[]
|
|
{
|
|
delimeter
|
|
});
|
|
int i = 0;
|
|
int num = array.Length;
|
|
while (i < num)
|
|
{
|
|
string text = array[i].Trim();
|
|
bool flag = text.Length > 0;
|
|
if (flag)
|
|
{
|
|
list.Add(text);
|
|
}
|
|
i++;
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static List<int> StringToListInt(string ints, char delimeter)
|
|
{
|
|
List<int> list = new List<int>();
|
|
string[] array = ints.Split(new char[]
|
|
{
|
|
delimeter
|
|
});
|
|
int i = 0;
|
|
int num = array.Length;
|
|
while (i < num)
|
|
{
|
|
string text = array[i].Trim();
|
|
bool flag = text.Length > 0;
|
|
if (flag)
|
|
{
|
|
list.Add(Convert.ToInt32(text));
|
|
}
|
|
i++;
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static string InSQLStringInt(string idsstr, char deli)
|
|
{
|
|
string a = idsstr.Replace(" ", "");
|
|
bool flag = a == "";
|
|
if (flag)
|
|
{
|
|
throw new Exception(string.Format("Invalid Parameter(idsstr={0})。", idsstr));
|
|
}
|
|
string[] array = idsstr.Split(new char[]
|
|
{
|
|
deli
|
|
});
|
|
Dictionary<int, int> dictionary = new Dictionary<int, int>();
|
|
int i = 0;
|
|
int num = array.Length;
|
|
while (i < num)
|
|
{
|
|
int key = GPFunctions.CInt<string>(array[i]);
|
|
dictionary[key] = 1;
|
|
i++;
|
|
}
|
|
return string.Join<int>(",", dictionary.Keys);
|
|
}
|
|
|
|
public static string InSQLStringDecimal(string idsstr, char deli)
|
|
{
|
|
string a = idsstr.Replace(" ", "");
|
|
bool flag = a == "";
|
|
if (flag)
|
|
{
|
|
throw new Exception(string.Format("Invalid Parameter(idsstr={0})。", idsstr));
|
|
}
|
|
string[] array = idsstr.Split(new char[]
|
|
{
|
|
deli
|
|
});
|
|
Dictionary<string, decimal> dictionary = new Dictionary<string, decimal>();
|
|
decimal value = 0m;
|
|
int i = 0;
|
|
int num = array.Length;
|
|
while (i < num)
|
|
{
|
|
value = GPFunctions.CDecimal<string>(array[i]);
|
|
dictionary[value.ToString()] = value;
|
|
i++;
|
|
}
|
|
return string.Join(",", dictionary.Keys);
|
|
}
|
|
|
|
public static string GetIdsTable(string ids)
|
|
{
|
|
string[] idarr = ids.Split(new char[]
|
|
{
|
|
','
|
|
});
|
|
return GPFunctions.GetIdsTable(idarr);
|
|
}
|
|
|
|
public static string GetIdsTable(string ids, char deli)
|
|
{
|
|
string[] idarr = ids.Split(new char[]
|
|
{
|
|
deli
|
|
});
|
|
return GPFunctions.GetIdsTable(idarr);
|
|
}
|
|
|
|
public static string GetIdsTable(string[] idarr)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < idarr.Length; i++)
|
|
{
|
|
bool flag = i > 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(" UNION ");
|
|
}
|
|
stringBuilder.Append(string.Format("SELECT {0} as xh, {1} as id", i, idarr[i]));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static byte[] HexStringToBytes(string hexstr)
|
|
{
|
|
hexstr = hexstr.Trim();
|
|
int num = hexstr.Length;
|
|
bool flag = num % 2 != 0;
|
|
if (flag)
|
|
{
|
|
hexstr += " ";
|
|
num++;
|
|
}
|
|
int num2 = num / 2;
|
|
byte[] array = new byte[num2];
|
|
for (int i = 0; i < num2; i++)
|
|
{
|
|
string value = hexstr.Substring(i * 2, 2);
|
|
array[i] = Convert.ToByte(Convert.ToInt16(value, 16));
|
|
}
|
|
return array;
|
|
}
|
|
|
|
public static byte[] HexStringToBytes(string hexstr, char seperator)
|
|
{
|
|
string[] array = hexstr.Trim().Split(new char[]
|
|
{
|
|
seperator
|
|
});
|
|
int num = array.Length;
|
|
byte[] array2 = new byte[num];
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
string value = array[i];
|
|
array2[i] = Convert.ToByte(Convert.ToInt32(value, 16));
|
|
}
|
|
return array2;
|
|
}
|
|
|
|
public static int BytesIndexOf(byte[] source, int startPos, byte[] pattern)
|
|
{
|
|
int num = source.Length;
|
|
int num2 = pattern.Length;
|
|
bool flag = num < num2;
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = -1;
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = num2 == 1;
|
|
if (flag2)
|
|
{
|
|
byte b = pattern[0];
|
|
for (int i = startPos; i < num; i++)
|
|
{
|
|
bool flag3 = source[i] == b;
|
|
if (flag3)
|
|
{
|
|
result = i;
|
|
return result;
|
|
}
|
|
}
|
|
result = -1;
|
|
}
|
|
else
|
|
{
|
|
for (int j = startPos; j < num - num2 + 1; j++)
|
|
{
|
|
for (int k = 0; k < num2; k++)
|
|
{
|
|
bool flag4 = source[j + k] != pattern[k];
|
|
if (flag4)
|
|
{
|
|
break;
|
|
}
|
|
bool flag5 = k == num2 - 1;
|
|
if (flag5)
|
|
{
|
|
result = j;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
result = -1;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static int BytesIndexOf(List<byte> source, int startPos, byte[] pattern)
|
|
{
|
|
int count = source.Count;
|
|
int num = pattern.Length;
|
|
bool flag = count < num;
|
|
int result;
|
|
if (flag)
|
|
{
|
|
result = -1;
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = num == 1;
|
|
if (flag2)
|
|
{
|
|
byte b = pattern[0];
|
|
for (int i = startPos; i < count; i++)
|
|
{
|
|
bool flag3 = source[i] == b;
|
|
if (flag3)
|
|
{
|
|
result = i;
|
|
return result;
|
|
}
|
|
}
|
|
result = -1;
|
|
}
|
|
else
|
|
{
|
|
for (int j = startPos; j < count - num + 1; j++)
|
|
{
|
|
for (int k = 0; k < num; k++)
|
|
{
|
|
bool flag4 = source[j + k] != pattern[k];
|
|
if (flag4)
|
|
{
|
|
break;
|
|
}
|
|
bool flag5 = k == num - 1;
|
|
if (flag5)
|
|
{
|
|
result = j;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
result = -1;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string BytesToDecimalString(byte[] bits, char deli = ' ')
|
|
{
|
|
int num = bits.Length;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
bool flag = i == 0;
|
|
if (flag)
|
|
{
|
|
stringBuilder.Append(bits[i].ToString().PadLeft(3));
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(string.Format("{0}{1}", deli, bits[i].ToString().PadLeft(3)));
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string BytesToHexString(byte[] bits)
|
|
{
|
|
int num = bits.Length;
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
stringBuilder.Append(bits[i].ToString("x2"));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string BytesToHexString(byte[] bits, int length)
|
|
{
|
|
int num = bits.Length;
|
|
bool flag = num > length;
|
|
if (flag)
|
|
{
|
|
num = length;
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
stringBuilder.Append(bits[i].ToString("x2"));
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string BytesToHexString(byte[] bits, char seperator)
|
|
{
|
|
return GPFunctions.BytesToHexString(bits, seperator, bits.Length);
|
|
}
|
|
|
|
public static string BytesToHexString(byte[] bits, char seperator, int length)
|
|
{
|
|
int num = bits.Length;
|
|
bool flag = num > length;
|
|
if (flag)
|
|
{
|
|
num = length;
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
bool flag2 = i == 0;
|
|
if (flag2)
|
|
{
|
|
stringBuilder.Append(bits[i].ToString("X2"));
|
|
}
|
|
else
|
|
{
|
|
stringBuilder.Append(seperator.ToString() + bits[i].ToString("X2"));
|
|
}
|
|
}
|
|
return stringBuilder.ToString();
|
|
}
|
|
|
|
public static string StringToHexString(string s, string charset)
|
|
{
|
|
Encoding encoding = Encoding.GetEncoding(charset);
|
|
byte[] bytes = encoding.GetBytes(s);
|
|
return GPFunctions.BytesToHexString(bytes);
|
|
}
|
|
|
|
public static string StringToHexString(string s, Encoding encode)
|
|
{
|
|
byte[] bytes = encode.GetBytes(s);
|
|
return GPFunctions.BytesToHexString(bytes);
|
|
}
|
|
|
|
public static string HexStringToString(string hex, Encoding encode)
|
|
{
|
|
bool flag = hex == null;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = hex.Length == 0;
|
|
if (flag2)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
byte[] bytes = GPFunctions.HexStringToBytes(hex);
|
|
result = encode.GetString(bytes);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string HexStringToString(string hex, string charset)
|
|
{
|
|
bool flag = hex == null;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = hex.Length == 0;
|
|
if (flag2)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
byte[] bytes = GPFunctions.HexStringToBytes(hex);
|
|
Encoding encoding = Encoding.GetEncoding(charset);
|
|
result = encoding.GetString(bytes);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string ConvertCodeString(string tbdstr, string charset1, string charset2)
|
|
{
|
|
bool flag = tbdstr == null;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
bool flag2 = tbdstr.Length == 0;
|
|
if (flag2)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
Encoding encoding = Encoding.GetEncoding(charset1);
|
|
Encoding encoding2 = Encoding.GetEncoding(charset2);
|
|
byte[] bytes = encoding.GetBytes(tbdstr);
|
|
byte[] bytes2 = Encoding.Convert(encoding, encoding2, bytes);
|
|
string @string = encoding2.GetString(bytes2);
|
|
result = @string;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string Utf8ToGBK(string utf8)
|
|
{
|
|
Encoding encoding = Encoding.GetEncoding("UTF-8");
|
|
Encoding encoding2 = Encoding.GetEncoding("GBK");
|
|
byte[] bytes = encoding.GetBytes(utf8);
|
|
byte[] bits = Encoding.Convert(encoding, encoding2, bytes);
|
|
return GPFunctions.BytesToHexString(bits, '%');
|
|
}
|
|
|
|
public static string GetHostName()
|
|
{
|
|
return Dns.GetHostName();
|
|
}
|
|
|
|
//public static List<MyKeyValue> GetNetworkAdpaterID()
|
|
//{
|
|
// List<MyKeyValue> list = new List<MyKeyValue>();
|
|
// NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
|
|
// NetworkInterface[] array = allNetworkInterfaces;
|
|
// for (int i = 0; i < array.Length; i++)
|
|
// {
|
|
// NetworkInterface networkInterface = array[i];
|
|
// MyKeyValue myKeyValue = new MyKeyValue();
|
|
// myKeyValue.Key = networkInterface.Name;
|
|
// string text = networkInterface.GetPhysicalAddress().ToString();
|
|
// bool flag = text.Length > 0 && !text.StartsWith("00");
|
|
// if (flag)
|
|
// {
|
|
// byte[] bits = GPFunctions.HexStringToBytes(text);
|
|
// text = GPFunctions.BytesToHexString(bits, ':');
|
|
// myKeyValue.Value = text.ToUpper();
|
|
// list.Add(myKeyValue);
|
|
// }
|
|
// }
|
|
// return list;
|
|
//}
|
|
|
|
//public static List<string> GetMacAddress()
|
|
//{
|
|
// List<string> list = new List<string>();
|
|
// ManagementClass managementClass = new ManagementClass("Win32_NetworkAdapterConfiguration");
|
|
// ManagementObjectCollection instances = managementClass.GetInstances();
|
|
// using (ManagementObjectCollection.ManagementObjectEnumerator enumerator = instances.GetEnumerator())
|
|
// {
|
|
// while (enumerator.MoveNext())
|
|
// {
|
|
// ManagementObject managementObject = (ManagementObject)enumerator.Current;
|
|
// bool flag = managementObject["IPEnabled"].ToString() == "True";
|
|
// if (flag)
|
|
// {
|
|
// string text = managementObject["MacAddress"].ToString();
|
|
// bool flag2 = !text.StartsWith("00");
|
|
// if (flag2)
|
|
// {
|
|
// list.Add(managementObject["MacAddress"].ToString());
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// bool flag3 = list.Count == 0;
|
|
// if (flag3)
|
|
// {
|
|
// list.Add("98-2C-BC-1C-6B-A5");
|
|
// }
|
|
// return list;
|
|
//}
|
|
|
|
public static List<string> GetIPAddress()
|
|
{
|
|
List<string> list = new List<string>();
|
|
IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
|
|
IPAddress[] addressList = hostEntry.AddressList;
|
|
for (int i = 0; i < addressList.Length; i++)
|
|
{
|
|
IPAddress iPAddress = addressList[i];
|
|
bool flag = iPAddress.AddressFamily == AddressFamily.InterNetwork;
|
|
if (flag)
|
|
{
|
|
list.Add(iPAddress.ToString());
|
|
}
|
|
}
|
|
bool flag2 = list.Count == 0;
|
|
if (flag2)
|
|
{
|
|
list.Add("127.0.0.1");
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static List<string> GetIPAddress(string ipstr)
|
|
{
|
|
List<string> list = new List<string>();
|
|
IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
|
|
IPAddress[] addressList = hostEntry.AddressList;
|
|
for (int i = 0; i < addressList.Length; i++)
|
|
{
|
|
IPAddress iPAddress = addressList[i];
|
|
bool flag = iPAddress.AddressFamily == AddressFamily.InterNetwork;
|
|
if (flag)
|
|
{
|
|
string text = iPAddress.ToString();
|
|
bool flag2 = text.CompareTo(ipstr) == 0;
|
|
if (flag2)
|
|
{
|
|
list.Clear();
|
|
list.Add(text);
|
|
break;
|
|
}
|
|
list.Add(text);
|
|
}
|
|
}
|
|
bool flag3 = list.Count == 0;
|
|
if (flag3)
|
|
{
|
|
list.Add("127.0.0.1");
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static List<string> GetIPAddress(string ipstr, string excludedIP)
|
|
{
|
|
List<string> list = new List<string>();
|
|
IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName());
|
|
IPAddress[] addressList = hostEntry.AddressList;
|
|
for (int i = 0; i < addressList.Length; i++)
|
|
{
|
|
IPAddress iPAddress = addressList[i];
|
|
bool flag = iPAddress.AddressFamily == AddressFamily.InterNetwork;
|
|
if (flag)
|
|
{
|
|
string text = iPAddress.ToString();
|
|
bool flag2 = ipstr.Length > 0 && text.CompareTo(ipstr) == 0;
|
|
if (flag2)
|
|
{
|
|
list.Clear();
|
|
list.Add(text);
|
|
break;
|
|
}
|
|
bool flag3 = !text.StartsWith(excludedIP);
|
|
if (flag3)
|
|
{
|
|
list.Add(text);
|
|
}
|
|
}
|
|
}
|
|
bool flag4 = list.Count == 0;
|
|
if (flag4)
|
|
{
|
|
list.Add("127.0.0.1");
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static uint IPToUInt32(string ip)
|
|
{
|
|
string[] array = ip.Split(new char[]
|
|
{
|
|
'.'
|
|
});
|
|
bool flag = array.Length != 4;
|
|
uint result;
|
|
if (flag)
|
|
{
|
|
result = 0u;
|
|
}
|
|
else
|
|
{
|
|
byte[] array2 = new byte[4];
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
array2[3 - i] = Convert.ToByte(array[i]);
|
|
}
|
|
result = BitConverter.ToUInt32(array2, 0);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static string GetCMDResult(string cmd, string parameters)
|
|
{
|
|
Process process = null;
|
|
string result = string.Empty;
|
|
try
|
|
{
|
|
process = Process.Start(new ProcessStartInfo(cmd, parameters)
|
|
{
|
|
CreateNoWindow = true,
|
|
UseShellExecute = false,
|
|
RedirectStandardOutput = true
|
|
});
|
|
result = process.StandardOutput.ReadToEnd();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new Exception(string.Format("GetCMDResult '{0} {1}' Exception: {2}", cmd, parameters, ex.Message));
|
|
}
|
|
finally
|
|
{
|
|
bool flag = process != null;
|
|
if (flag)
|
|
{
|
|
process.Close();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static List<string[]> GetMyIPMacInfo(string infos = "")
|
|
{
|
|
List<string[]> list = new List<string[]>();
|
|
bool flag = string.IsNullOrEmpty(infos);
|
|
if (flag)
|
|
{
|
|
infos = GPFunctions.GetCMDResult("ipconfig", "-all");
|
|
}
|
|
string[] array = infos.Split(new char[]
|
|
{
|
|
'\n',
|
|
'\r'
|
|
}, StringSplitOptions.RemoveEmptyEntries);
|
|
string text = "";
|
|
string text2 = "";
|
|
string text3 = "";
|
|
string text4 = "";
|
|
string[] array2 = array;
|
|
int i = 0;
|
|
while (i < array2.Length)
|
|
{
|
|
string text5 = array2[i];
|
|
bool flag2 = text5.Contains(". :");
|
|
if (flag2)
|
|
{
|
|
string[] array3 = text5.Split(new char[]
|
|
{
|
|
':'
|
|
}, StringSplitOptions.RemoveEmptyEntries);
|
|
string text6 = array3[1].Trim();
|
|
bool flag3 = text6.Length == 0;
|
|
if (!flag3)
|
|
{
|
|
text6 = array3[0].Trim(new char[]
|
|
{
|
|
' ',
|
|
'.'
|
|
});
|
|
bool flag4 = text6.Contains("IPv4");
|
|
if (flag4)
|
|
{
|
|
text6 = GPFunctions.ReadNumberString(array3[1]);
|
|
bool flag5 = GPFunctions.IsIPv4Adress(text6);
|
|
if (flag5)
|
|
{
|
|
text2 = text6;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag6 = text6.StartsWith("物理地址");
|
|
if (flag6)
|
|
{
|
|
text3 = array3[1].Trim();
|
|
}
|
|
else
|
|
{
|
|
bool flag7 = text6.StartsWith("Physical");
|
|
if (flag7)
|
|
{
|
|
text3 = array3[1].Trim();
|
|
}
|
|
else
|
|
{
|
|
bool flag8 = text6.StartsWith("描述");
|
|
if (flag8)
|
|
{
|
|
text4 = array3[1].Trim();
|
|
}
|
|
else
|
|
{
|
|
bool flag9 = text6.StartsWith("Description ");
|
|
if (flag9)
|
|
{
|
|
text4 = array3[1].Trim();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool flag10 = !text5.StartsWith(" ") && text5.EndsWith(":");
|
|
if (flag10)
|
|
{
|
|
int num = text5.IndexOf(" ");
|
|
bool flag11 = num > 0;
|
|
if (flag11)
|
|
{
|
|
bool flag12 = text.Length > 0 && text3.Length > 0 && text4.Length > 0 && text2.Length > 0;
|
|
if (flag12)
|
|
{
|
|
list.Add(new string[]
|
|
{
|
|
text,
|
|
text4,
|
|
text3,
|
|
text2
|
|
});
|
|
}
|
|
text = text5.Substring(num).Trim(new char[]
|
|
{
|
|
':',
|
|
' '
|
|
});
|
|
text2 = "";
|
|
text3 = "";
|
|
text4 = "";
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
bool flag13 = text.Length > 0 && text3.Length > 0 && text4.Length > 0 && text2.Length > 0;
|
|
if (flag13)
|
|
{
|
|
list.Add(new string[]
|
|
{
|
|
text,
|
|
text4,
|
|
text3,
|
|
text2
|
|
});
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static string ReadNumberString(string strnum)
|
|
{
|
|
strnum = strnum.Trim();
|
|
bool flag = strnum == null || strnum.Length == 0;
|
|
string result;
|
|
if (flag)
|
|
{
|
|
result = "";
|
|
}
|
|
else
|
|
{
|
|
List<char> list = new List<char>();
|
|
int length = strnum.Length;
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
char c = strnum[i];
|
|
bool flag2 = c == '.' || (c >= '0' && c <= '9');
|
|
if (!flag2)
|
|
{
|
|
break;
|
|
}
|
|
list.Add(c);
|
|
}
|
|
result = string.Join<char>("", list);
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|