private void forEachList(object obj)
{
HandelControls theHandelControls = HandelControls.createHandelControls();
TheRemoteDataArray theRemoteDataArray = obj as TheRemoteDataArray;
for (int i = 0; i < theRemoteDataArray.THE_REMOTE_DATA.Count; i++)
{
TheRemoteData theRemoteData = new TheRemoteData();
theRemoteData.RemoteAddress = theRemoteDataArray.THE_REMOTE_DATA[i].RemoteAddress;
theRemoteData.RemoteValue = theRemoteDataArray.THE_REMOTE_DATA[i].RemoteValue;
theRemoteData.quility = theRemoteDataArray.THE_REMOTE_DATA[i].quility;
theRemoteData.LastestModify = theRemoteDataArray.THE_REMOTE_DATA[i].LastestModify;
theHandelControls.UpdataOrAddNowData(theHandelControls.toReadSqlLiteData(theRemoteData, theRemoteDataArray.DEVICE_ADDRESS.ToList(), theRemoteDataArray.THE_TYPE_NAME), theRemoteDataArray.THE_TYPE_NAME);//遥信存入数据库
}
}
/// <summary>
/// 封装删除的方法
/// </summary>
/// <param name="dt">操作的表名</param>
/// <param name="name">选中的列明</param>
/// <param name="byt">操作标识</param>
/// <param name="msg">要提示的消息</param>
public void deleteSelectRow(DataGridView dt, string name, byte byt, string msg)
{
if (dt.SelectedRows.Count <= 0)
{
HandelControls.Msg("请选择要删除的数据");
return;
}
if (HandelControls.Msg(msg, MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.Yes)
{
List <byte> bytes = new List <byte>();
bytes.Add(byt);
string id = dt.SelectedRows[0].Cells[name].Value.ToString();
bytes.AddRange(ByteWithString.intTo4Byte(int.Parse(id)).ToList());
theScoket.theSocketSend <byte[]>(0x32, bytes.ToArray());
}
}
/// <summary>
/// 接收
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public ClientReport clientReportSerialize(byte[] data)
{
HandelControls theHandelControls = HandelControls.createHandelControls();
ClientReport theClientReport = new ClientReport();
try
{
theClientReport.HEAD_FIELD = data[0];
theClientReport.REPORT_LENGTH = data.Skip(1).Take(4).ToArray();
byte[] dataLength = data.Skip(1).Take(4).ToArray();
int dataLengthInt = returnByteLengthRight(dataLength);
data = data.Skip(0).Take(dataLengthInt).ToArray();
theClientReport.CONTROL_FIELD = data[5];
// theClientReport.REPORT_BODY = data.Skip(6).Take(dataLengthInt-8);
theClientReport.END_FIELD = data[data.Length - 1];
data = data.Skip(6).Take(dataLengthInt - 8).ToArray();
int fileCount = 0; //默认文件长度；
int nowIndex = 0; //当前位置；
int dataCount = 0;
TheCatalog theCatalog = new TheCatalog(); //文件目录
CatalogFiles theCatalogFiles = new CatalogFiles(); //文件
TheRemoteDataArray theRemoteDataArray = new TheRemoteDataArray(); //遥信
ResponseValueData theResponseValue = new ResponseValueData(); //设定值
switch (theClientReport.CONTROL_FIELD)
{
case 0x02:
returnLoginInfo theReturnLoginInfo = new returnLoginInfo();
byte[] theByte = data;
theReturnLoginInfo.isOk = theByte[0];
theClientReport.REPORT_BODY = theReturnLoginInfo;
break;
case 0x03:
byte[] checkData = data;
DeviceData theTreeArrayData = new DeviceData();
theTreeArrayData.theDeviceData = new List <DeviceDataInfo>();
int count = checkData[0];
checkData = checkData.Skip(1).ToArray();
while (count > 0)
{
DeviceDataInfo theDeviceDataInfo = new DeviceDataInfo();
int ct = checkData.Skip(nowIndex).Take(1).ToArray()[0];//设备名称长度
theDeviceDataInfo.DeviceName = checkData.Skip(nowIndex + 1).Take(ct).ToArray <byte>();
theDeviceDataInfo.DeviceAddress = checkData.Skip(nowIndex + ct + 1).Take(2).ToArray <byte>();
theDeviceDataInfo.DeviceStatue = checkData.Skip(nowIndex + ct + 3).Take(1).ToArray()[0];
theDeviceDataInfo.DeviceLastOnline = checkData.Skip(nowIndex + ct + 4).Take(7).ToArray();
nowIndex += ct + 11;
theTreeArrayData.theDeviceData.Add(theDeviceDataInfo);
count--;
}
theClientReport.REPORT_BODY = theTreeArrayData;
break;
case 0x05:
byte[] checkCatalogData = data;
theCatalog.DEVICE_ADDRESS = checkCatalogData.Take(2).ToArray <byte>(); //设备地址
theCatalog.FILES_COUNT = checkCatalogData[2]; //文件数量
fileCount = theCatalog.FILES_COUNT;
theCatalog.THE_CATALOG_FILES = new List <CatalogFiles>();
byte[] nowCatalogData = checkCatalogData.Skip(3).Take(checkCatalogData.Length - 2).ToArray <byte>();
while (fileCount > 0)
{
CatalogFiles catalogFiles = new CatalogFiles();
catalogFiles.FILE_LENGTH = nowCatalogData[nowIndex];
catalogFiles.FILE_NAME = nowCatalogData.Skip(nowIndex + 1).Take(catalogFiles.FILE_LENGTH).ToArray <byte>();
theCatalog.THE_CATALOG_FILES.Add(catalogFiles);
nowIndex += catalogFiles.FILE_LENGTH + 1;
fileCount--;
}
theClientReport.REPORT_BODY = theCatalog;
break;
case 0x07:
byte[] updateCatalogData = data;
theCatalogFiles.DeviceAddress = updateCatalogData.Take(2).ToArray <byte>(); //文件地址
theCatalogFiles.FILE_LENGTH = updateCatalogData[2]; //文件名长度
theCatalogFiles.FILE_NAME = updateCatalogData.Skip(3).Take(theCatalogFiles.FILE_LENGTH).ToArray <byte>(); //文件名
int fileContent = theCatalogFiles.FILE_NAME.Length + 3;
theCatalogFiles.FILE_CONTENT = updateCatalogData.Skip(fileContent).ToArray <byte>(); //文件长度
theClientReport.REPORT_BODY = theCatalogFiles;
break;
case 0x10: //遥信返回（不带时标）
byte[] notHaveTimeMark = data;
theRemoteDataArray.DEVICE_ADDRESS = notHaveTimeMark.Take(2).ToArray <byte>();
theRemoteDataArray.THE_COUNT = notHaveTimeMark[2];
theRemoteDataArray.THE_TYPE_NAME = "遥信";
fileCount = theRemoteDataArray.THE_COUNT;
theRemoteDataArray.THE_REMOTE_DATA = new List <TheRemoteData>();
notHaveTimeMark = notHaveTimeMark.Skip(3).ToArray <byte>();
while (fileCount > 0)
{
TheRemoteData theRemoteData = new TheRemoteData();
theRemoteData.RemoteAddress = notHaveTimeMark.Skip(nowIndex).Take(2).ToArray <byte>();
theRemoteData.RemoteValue = notHaveTimeMark.Skip(nowIndex + 2).Take(1).ToArray <byte>();
nowIndex = nowIndex + 3;
fileCount--;
theRemoteDataArray.THE_REMOTE_DATA.Add(theRemoteData);
}
theClientReport.REPORT_BODY = theRemoteDataArray;
theThreadMethod = new Thread(forEachList);
theThreadMethod.IsBackground = true;
theThreadMethod.Start(theRemoteDataArray);
break;
case 0x11: //遥信返回（带时标）
byte[] haveTimeMark = data;
theRemoteDataArray.DEVICE_ADDRESS = haveTimeMark.Take(2).ToArray <byte>();
theRemoteDataArray.THE_COUNT = haveTimeMark[2];
theRemoteDataArray.THE_COUNT = haveTimeMark[2];
theRemoteDataArray.THE_TYPE_NAME = "遥信";
fileCount = theRemoteDataArray.THE_COUNT;
theRemoteDataArray.THE_REMOTE_DATA = new List <TheRemoteData>();
haveTimeMark = haveTimeMark.Skip(3).ToArray <byte>();
while (fileCount > 0)
{
TheRemoteData theRemoteData = new TheRemoteData();
theRemoteData.RemoteAddress = haveTimeMark.Skip(nowIndex).Take(2).ToArray <byte>();
theRemoteData.RemoteValue = haveTimeMark.Skip(nowIndex + 2).Take(1).ToArray <byte>();
theRemoteData.LastestModify = haveTimeMark.Skip(nowIndex + 3).Take(7).ToArray <byte>();
nowIndex = nowIndex + 10;
fileCount--;
theRemoteDataArray.THE_REMOTE_DATA.Add(theRemoteData);
}
theClientReport.REPORT_BODY = theRemoteDataArray;
theThreadMethod = new Thread(forEachList);
theThreadMethod.IsBackground = true;
theThreadMethod.Start(theRemoteDataArray);
break;
case 0x12: //遥测
byte[] telemeteringTimeMark = data;
theRemoteDataArray.DEVICE_ADDRESS = telemeteringTimeMark.Take(2).ToArray <byte>();
theRemoteDataArray.THE_COUNT = telemeteringTimeMark[2];
theRemoteDataArray.THE_TYPE_NAME = "遥测";
fileCount = theRemoteDataArray.THE_COUNT;
theRemoteDataArray.THE_REMOTE_DATA = new List <TheRemoteData>();
telemeteringTimeMark = telemeteringTimeMark.Skip(3).ToArray <byte>();
while (fileCount > 0)
{
TheRemoteData theRemoteData = new TheRemoteData();
theRemoteData.LastestModify = new byte[] { 0x00 };
theRemoteData.RemoteAddress = telemeteringTimeMark.Skip(nowIndex).Take(2).ToArray <byte>();
theRemoteData.RemoteValue = telemeteringTimeMark.Skip(nowIndex + 2).Take(2).ToArray <byte>();
theRemoteData.quility = telemeteringTimeMark.Skip(nowIndex + 4).Take(1).ToArray <byte>()[0];
nowIndex = nowIndex + 5;
fileCount--;
theRemoteDataArray.THE_REMOTE_DATA.Add(theRemoteData);
}
theClientReport.REPORT_BODY = theRemoteDataArray;
theThreadMethod = new Thread(forEachList);
theThreadMethod.IsBackground = true;
theThreadMethod.Start(theRemoteDataArray);
break;
case 0x14:
byte[] responseValueTimeMark = data;
theResponseValue.DEVICE_ADDRESS = responseValueTimeMark.Take(2).ToArray <byte>();
theResponseValue.VALUE_TYPE = responseValueTimeMark[2];
theResponseValue.VALUE_COUNT = responseValueTimeMark[3];
fileCount = theResponseValue.VALUE_COUNT;
theResponseValue.theResponseValueArray = new List <ResponseValue>();
responseValueTimeMark = responseValueTimeMark.Skip(4).ToArray <byte>();
while (fileCount > 0)
{
ResponseValue rsponseValue = new ResponseValue();
rsponseValue.VALUE_ADDRESS = responseValueTimeMark.Skip(nowIndex).Take(2).ToArray <byte>();
int length = responseValueTimeMark.Skip(nowIndex + 2).Take(1).ToArray <byte>()[0];
rsponseValue.VALUE = responseValueTimeMark.Skip(nowIndex + 3).Take(length).ToArray <byte>();
nowIndex = nowIndex + 3 + length;
theResponseValue.theResponseValueArray.Add(rsponseValue);
fileCount--;
}
theClientReport.REPORT_BODY = theResponseValue;
break;
case 0x0a:
byte[] contentText = data;
ReportContentText theReportContent = new ReportContentText();
theReportContent.ReportType = contentText[0];
theReportContent.ReportDateTime = contentText.Skip(1).Take(7).ToArray <byte>();
theReportContent.ReportContent = contentText.Skip(8).ToArray <byte>();
theClientReport.REPORT_BODY = theReportContent;
break;
case 0x21:
byte[] writeBytes = data;
WriteFile theWriteFile = new WriteFile();
theWriteFile.DEVICE_ADDRESS = writeBytes.Take(2).ToArray();
theWriteFile.FILE_LENGTH = writeBytes.Skip(2).Take(1).ToArray()[0];
theWriteFile.FILE_NAME = writeBytes.Skip(3).Take(theWriteFile.FILE_LENGTH).ToArray();
theWriteFile.FILE_COUNT = writeBytes.Skip(3 + theWriteFile.FILE_LENGTH).ToArray();
break;
case 0x23: //接收变电站
List <ConvertingStation> theConvertingStationArray = new List <ConvertingStation>();
dataCount = returnByteLengthRight(data.Take(4).ToArray());
data = data.Skip(4).ToArray();
while (dataCount > 0)
{
ConvertingStation theConvertingStation = new ConvertingStation();
int convertingNameLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theConvertingStation.stationName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingNameLength).ToArray(), "utf-8");
nowIndex += convertingNameLength;
int remarksLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theConvertingStation.stationRemarks = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(remarksLength).ToArray(), "utf-8");
nowIndex += remarksLength;
theConvertingStation.stationID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
dataCount--;
theConvertingStationArray.Add(theConvertingStation);
}
theClientReport.REPORT_BODY = theConvertingStationArray;
break;
case 0x24: //接收母线
List <Generatrix> theGeneratrixArray = new List <Generatrix>();
dataCount = returnByteLengthRight(data.Take(4).ToArray());
data = data.Skip(4).ToArray();
while (dataCount > 0)
{
Generatrix theGeneratrix = new Generatrix();
int convertingNameLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theGeneratrix.GeneratrixName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingNameLength).ToArray(), "utf-8");
nowIndex += convertingNameLength;
int remarksLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theGeneratrix.GeneratrixNumber = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(remarksLength).ToArray(), "utf-8");
nowIndex += remarksLength;
theGeneratrix.GeneratrixID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
int convertingLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theGeneratrix.GeneratrixToName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingLength).ToArray(), "utf-8");
nowIndex += convertingLength;
theGeneratrix.GeneratrixToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
dataCount--;
theGeneratrixArray.Add(theGeneratrix);
}
theClientReport.REPORT_BODY = theGeneratrixArray;
break;
case 0x25: //接收线路
List <Circuit> theCircuitArray = new List <Circuit>();
dataCount = returnByteLengthRight(data.Take(4).ToArray());
data = data.Skip(4).ToArray();
while (dataCount > 0)
{
Circuit theCircuit = new Circuit();
int convertingNameLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theCircuit.CircuitName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingNameLength).ToArray(), "utf-8");
nowIndex += convertingNameLength;
int remarksLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theCircuit.CircuitNumber = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(remarksLength).ToArray(), "utf-8");
nowIndex += remarksLength;
theCircuit.CircuitID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
int convertingLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theCircuit.CircuitToName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingLength).ToArray(), "utf-8");
nowIndex += convertingLength;
theCircuit.CircuitToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
dataCount--;
theCircuitArray.Add(theCircuit);
}
theClientReport.REPORT_BODY = theCircuitArray;
break;
case 0x26: //接收检测点
List <Detection> theDetectionArray = new List <Detection>();
dataCount = returnByteLengthRight(data.Take(4).ToArray());
data = data.Skip(4).ToArray();
while (dataCount > 0)
{
Detection theDetection = new Detection();
int convertingNameLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.DetectionName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingNameLength).ToArray(), "utf-8");
nowIndex += convertingNameLength;
int theNumber = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.DetectionNumber = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(theNumber).ToArray(), "utf-8");
nowIndex += theNumber;
theDetection.DetectionID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
int detectionToSecondName = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.DetectionToSecondName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(detectionToSecondName).ToArray(), "utf-8");
nowIndex += detectionToSecondName;
theDetection.DetectionToSecondID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
theDetection.RemoteA = ByteWithString.byteToHexStr(data.Skip(nowIndex).Take(2).ToArray());
nowIndex += 2;
theDetection.RemoteB = ByteWithString.byteToHexStr(data.Skip(nowIndex).Take(2).ToArray());
nowIndex += 2;
theDetection.RemoteC = ByteWithString.byteToHexStr(data.Skip(nowIndex).Take(2).ToArray());
nowIndex += 2;
int circuitLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.DetectionToName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(circuitLength).ToArray(), "utf-8");
nowIndex += circuitLength;
theDetection.DetectionToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
dataCount--;
theDetectionArray.Add(theDetection);
}
theClientReport.REPORT_BODY = theDetectionArray;
break;
case 0x33:
List <DeviceDataSetting> theDeviceDataArray = new List <DeviceDataSetting>();
dataCount = returnByteLengthRight(data.Take(4).ToArray());
data = data.Skip(4).ToArray();
while (dataCount > 0)
{
DeviceDataSetting theDetection = new DeviceDataSetting();
int convertingNameLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.DeviceDataName = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(convertingNameLength).ToArray(), "utf-8"); //ok
nowIndex += convertingNameLength;
theDetection.DeviceDataID = ByteWithString.byteToHexStr(data.Skip(nowIndex).Take(2).ToArray()).ToString();
nowIndex += 2;
theDetection.LastDateTime = ByteWithString.ConvertCP56TIME2aToDateTime(data.Skip(nowIndex).Take(7).ToArray()).ToString("yyyy-MM-dd HH:mm:ss");
nowIndex += 7;
int ALength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.TheRemoteA = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(ALength).ToArray(), "utf-8");
nowIndex += ALength;
theDetection.RemoteAToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
int BLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.TheRemoteB = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(BLength).ToArray(), "utf-8");
nowIndex += BLength;
theDetection.RemoteBToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
int CLength = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray());
nowIndex += 4;
theDetection.TheRemoteC = ByteWithString.bytetoCodeString(data.Skip(nowIndex).Take(CLength).ToArray(), "utf-8");
nowIndex += CLength;
theDetection.RemoteCToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
theDetection.DeviceDataToID = returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()).ToString();
nowIndex += 4;
dataCount--;
theDeviceDataArray.Add(theDetection);
}
theClientReport.REPORT_BODY = theDeviceDataArray;
break;
case 0x35:
List <int> valueBuilder = new List <int>();
valueBuilder.Add(returnByteLengthRight(data.Skip(0).Take(4).ToArray()));
valueBuilder.Add(returnByteLengthRight(data.Skip(4).Take(4).ToArray()));
valueBuilder.Add(returnByteLengthRight(data.Skip(8).Take(4).ToArray()));
theClientReport.REPORT_BODY = valueBuilder;
break;
case 0x38:
Hitch theHitch = new Hitch();
theHitch.COUNT = dataCount = returnByteLengthRight(data.Take(4).ToArray());
theHitch.NOW_ID = new List <int>();
data = data.Skip(4).ToArray();
while (dataCount > 0)
{
theHitch.NOW_ID.Add(returnByteLengthRight(data.Skip(nowIndex).Take(4).ToArray()));
nowIndex += 4;
dataCount--;
}
theClientReport.REPORT_BODY = theHitch;
break;
default: break;
}
theClientReport.VALIDATE_FIELD = data.Skip(data.Length - 2).Take(1).ToArray()[0];
theClientReport.END_FIELD = 0x16;
}
catch (Exception msg)
{
Log.LogWrite(msg);
}
return(theClientReport);
}
public void GetFileData(CatalogFiles catalogFiles)
{
theScoket.sendInfo(theScoket.clientReportUnSerialize(HandelControls.CreateClientReport <CatalogFiles>(0x06, catalogFiles)));
}
private string filePath = ConfigurationManager.AppSettings["FilePath_FileCatalog"].ToString();//存放的目录
#endregion
#region 验证登陆
/// <summary>
/// 验证是否登陆成功
/// </summary>
/// <param name="getFromObject"></param>
/// <param name="theSettingGrop"></param>
/// <returns></returns>
public bool Loging(ConcentratorControlClient getFromObject, SettingGrop theSettingGrop)
{
bool isLogin = false;
if (getFromObject.btn_Connect.Text == StringInfo.btn_OK)
{
if (getFromObject.user_Txt.Text.Trim().Length <= 0 || getFromObject.Pws_Txt.Text.Trim().Length <= 0)
{
HandelControls.Msg("用户名密码不能为空", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(isLogin);
}
if (!Regex.IsMatch(getFromObject.IP_Txt.Text, @"((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)") || !Regex.IsMatch(getFromObject.Port_Txt.Text.Trim(), @"^[0-9]{4,10}$"))
{
HandelControls.Msg("连地址或端口不正确", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return(isLogin);
}
getFromObject.btn_Connect.Enabled = false;
getFromObject.btn_Connect.Text = "连接中...";
UserInfo theUserInfo = new UserInfo()
{
IP_ADDRESS = getFromObject.IP_Txt.Text,
PORT_NUMBER = getFromObject.Port_Txt.Text,
USER_NAME = getFromObject.user_Txt.Text,
PASSWORD = getFromObject.Pws_Txt.Text
};
if (theScoket.createSocket(theUserInfo))
{
isLogin = true;
BtnRestore(getFromObject, StringInfo.btn_NO, StringInfo.Img_OK);
getFromObject.btn_Connect.Enabled = true;
//开始总召
//if (checkBox1.Checked)
//{
// byte[] bys = GetTagToByteArray();
// if (bys != null && bys.Length > 1)
// {
// theScoket.theSocketSend<byte[]>(0x09, bys);
// }
//}
}
else
{
BtnRestore(getFromObject, StringInfo.btn_OK, StringInfo.Img_NO);
getFromObject.btn_Connect.Enabled = true;
if (theSettingGrop != null)
{
theSettingGrop.ClearArray();
}
theScoket.CloseThread();
HandelControls.Msg("连接失败，请检查服务器是否开启", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
else
{
if (MessageBox.Show("是否确定断开", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
if (theSettingGrop != null)
{
theSettingGrop.ClearArray();
}
theScoket.CloseThread();
cellStaue(getFromObject.deviceDataGridView);
BtnRestore(getFromObject, StringInfo.btn_NO_Ing, StringInfo.Img_OK);
getFromObject.btn_Connect.Enabled = false;
theScoket.stopSocket();
getFromObject.clearAllData();
Thread.Sleep(3000);
getFromObject.btn_Connect.Enabled = true;
BtnRestore(getFromObject, StringInfo.btn_OK, StringInfo.Img_NO);
}
}
return(isLogin);
}
public bool theSocketSend <T>(byte bty, T t)
{
return(sendInfo(theScoket.clientReportUnSerialize(HandelControls.CreateClientReport <T>(bty, t))));
}