public string PostInventorySyn()
{
NetLog.Write("MES库存同步SAP（初始化）" + " ");
var oldBatchs = GetFDIInventorySynBacths("");
List <FDIInventorySynBacth> Batchs = new List <FDIInventorySynBacth>();
var oldMains = GetFDIInventorySyns("");
List <FDIInventorySyn> Mains = new List <FDIInventorySyn>();
foreach (var m in oldMains)
{
FDIInventorySyn main = new FDIInventorySyn();
main.CopyDataItem(m);
main.Batchs = new List <FDIInventorySynBacth>();
foreach (var d in oldBatchs.Where(c => c.ItemCode == m.ItemCode))
{
FDIInventorySynBacth detial = new FDIInventorySynBacth();
detial.CopyDataItem(d);
main.Batchs.Add(detial);
}
Mains.Add(main);
}
string jsonText = SafeConverter.JsonSerializeObject(Mains);
return(jsonText);
}
private void AddLog(NetLog netLog)
{
int i = gridLog.Rows.Add(netLog.TimeAsString(), netLog.LogMessage);
_logToGridRows[netLog] = gridLog.Rows[i];
gridLog.ClearSelection();
}
//连接
public void connect(string ip, int port)
{
//连接前先关闭
if (tcpClient != null && tcpClient.Client != null)
{
tcpClient.Client.Close();
tcpClient.Close();
tcpClient = null;
}
if (!connected())
{
try
{
setNetStatus(NetParams.LINKING);
this.ip = ip;
this.port = port;
IPAddress address = IPAddress.Parse(ip);
var iPEndPoint = new IPEndPoint(address, port);
Log.info(this, "-connect() " + "第" + tryNum + "次连接服务器 [" + iPEndPoint + "] [Start]");
tcpClient = new TcpClient();
tcpClient.NoDelay = true;
tcpClient.SendTimeout = 3000; //3秒
tcpClient.ReceiveTimeout = 3000; //3秒
tcpClient.BeginConnect(address, port, ConnectCallBack, this);
}
catch (Exception ex)
{
NetLog.error(this, "-connect() 连接服务器异常：" + ex);
//失败重连
retryConnect();
}
}
}
void HandleDebugMessage(NetIncomingMessage message)
{
switch (message.MessageType)
{
case NetIncomingMessageType.DebugMessage:
{
NetLog.DebugFormat("{0} {1}", appIdentifier, message.ReadString());
break;
}
case NetIncomingMessageType.ErrorMessage:
{
NetLog.ErrorFormat("{0}, {1}", appIdentifier, message.ReadString());
break;
}
case NetIncomingMessageType.WarningMessage:
{
NetLog.WarnFormat("{0}, {1}", appIdentifier, message.ReadString());
break;
}
case NetIncomingMessageType.VerboseDebugMessage:
{
NetLog.DebugFormat("{0}, {1}", appIdentifier, message.ReadString());
break;
}
}
}
private void button2_Click(object sender, EventArgs e)
{
// Helper helper = new Helper("Data Source=172.128.2.1/veims;User ID=zte;Password=zsfyqch;");
string txtConn =
"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=F:\\项目\\db\\ovehicles.mdb";
conn = new OleDbConnection(txtConn);
string txtCommand = "SELECT O_VEHICLES.* FROM O_VEHICLES";
OleDbDataAdapter da = new OleDbDataAdapter(txtCommand, conn);
DataSet ds = new DataSet("ds");
da.Fill(ds, "Student");
DataTable ff = ds.Tables[0];
string sql = "";
foreach (DataRow dr in ff.Rows)
{
sql += string.Format(@"insert into ZTE.VEHICLE_ITEM (ID, CLXH, CLMC, FDJXH, FDJSCC, MANUF, CLSB, FILENAME, PF, CLLB, VIN, BZ, JKC)
values ({0}, '{1}', '{2}', '{3}', '{4}', '{5}', '{6}', to_date('{7}', 'YYYY-MM-DD'), {8}, '{9}', '{10}', '{11}', '{12}');\r\n",
dr["ID"], dr["CLXH"], dr["CLMC"], dr["FDJXH"], dr["FDJSCC"], dr["MANUF"], dr["CLSB"], dr["FILENAME"], dr["PF"], dr["CLLB"], dr["VIN"], dr["BZ"], dr["JKC"]);
}
NetLog.WriteTextLog("insert", sql, DateTime.Now);
//NPOIExcelHelper.DataTableToExcel(ff, "测试", "D:/myt5.xls");
}
private void Form1_Load(object sender, EventArgs e)
{
NetLog.LogAdded += (o, args) => { AddLog((NetLog)o); };
NetLog.LogChanged += (o, args) =>
{
NetLog log = o as NetLog;
if (log != null)
{
if (_logToGridRows.ContainsKey(log))
{
_logToGridRows[log].Cells[1].Value = log.LogMessage;
}
}
else
{
FillLog();
}
};
_netInfo = new NetInfo();
_netInfo.MonitoringStarted += NetInfoOnMonitoringStarted;
_netInfo.MonitoringStopped += NetInfoOnMonitoringStopped;
_netInfo.Disconnected += NetInfoOnDisconnected;
_netInfo.Connected += NetInfoOnConnected;
SetMonitoring(true);
// Info panel
ShowInfo(_showInfo);
lblSoftwareInfo.Text = $"Version {AppInfo.AppVersionString}\n\n{AppInfo.AppCopyright}";
lblDescription.Text = AppInfo.AppDescription;
}
public override Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
Task <HttpResponseMessage> res = null;
try
{
//从请求头中获取 Authorization
if (controllerContext.Request.Headers.Authorization != null)
{
string key = controllerContext.Request.Headers.Authorization.Scheme;
if (!string.IsNullOrWhiteSpace(key) && !"null".Equals(key))
{
userDataContent = new UserDataContent()
{
userID = Helper.CodeVerificationHelper.ExplainUserID(key)
};
}
}
res = base.ExecuteAsync(controllerContext, cancellationToken);
}
catch (VerificationException ex)
{
}
catch (Exception ex)
{
NetLog.WriteTextLog(" err: " + ex.Message);
}
return(res);
}
private void send(byte[] data)
{
if (connected())
{
/*lock (dataList)
* {
* //添加数据到发送队列
* dataList.AddLast(data);
* if (dataList.Count == 1)
* {
* //当前即为第一个数据则发送
* sendAnsy(data);
* }
* }*/
try
{
Log.info(this, "-Send 成功发送数据 " + data.Length + "bytes: " + " ServerTimestamp:" + ServerTime.Instance.Timestamp);
tcpClient.Client.Send(data);
}
catch (Exception ex)
{
NetLog.error(this, "-send() 发送数据出错," + ex);
close();
}
}
else
{
NetLog.error(this, "-send() 网络未连接,关闭网络请重新连接");
close();
}
}
public string GetMaterialInfo(string jsMaterialInfo)
{
NetLog.Write("GetRawMaterialInfo" + " " + jsMaterialInfo);
List <FDIGetMaterialInfo> mains = new List <FDIGetMaterialInfo>();
try
{
mains = SafeConverter.JsonDeserializeObject <List <FDIGetMaterialInfo> >(jsMaterialInfo);
foreach (var main in mains)
{
var check = GetFDIGetMaterialInfos($"ItemCode = '{main.ItemCode}'");
foreach (var c in check)
{
DelFDIGetMaterialInfo(c.PKNO);
}
main.PKNO = CBaseData.NewGuid();
AddFDIGetMaterialInfo(main);
}
}
catch (Exception ex)
{
NetLog.Error("GetRawMaterialInfo error", ex);
return("error: " + ex.Message);
}
return("OK");
}
public static void initNet(int bitLen = 128, string charset = "utf-8")
{
bool flag = false;
int[] array = NetParams.bitList;
for (int i = 0; i < array.Length; i++)
{
int num = array[i];
if (num == bitLen)
{
flag = true;
break;
}
}
if (!flag)
{
NetLog.info("NetParams-initNet()", "指定的位元：" + bitLen + "值不是32、64、128其中的一个！");
}
else
{
NetParams.bitmapLen = (short)(bitLen / 8);
NetLog.info("NetParams-initNet()", "bitmapLen:" + NetParams.bitmapLen);
if (charset != null && charset.Trim().Length > 0)
{
NetParams.encode = charset;
}
}
}
MMOServer(int port)
{
m_plugin = new Plugin(Environment.CurrentDirectory);
Init();
NetAppConfiguration config = new NetAppConfiguration("MMO Mahjong", port);
config.MaximumConnections = 128;
config.Port = port;
config.ServerName = Environment.MachineName + " server";
m_log = new NetLog();
m_log.IgnoreTypes = NetLogEntryTypes.None;
m_log.LogEvent += new EventHandler <NetLogEventArgs>(OnLogEvent);
Server = new NetServer(config, m_log);
Server.StatusChanged += new EventHandler <NetStatusEventArgs>(OnStatusChange);
Server.ConnectionRequest += new EventHandler <NetConnectRequestEventArgs>(OnConnectionRequest);
while (true)
{
Server.Heartbeat();
NetMessage msg;
while ((msg = Server.ReadMessage()) != null)
{
HandleMessage(msg);
}
System.Threading.Thread.Sleep(1);
}
}
static void Main(string[] args)
{
var logger = new NetLog();
logger.Error("This is an error, testing with time");
System.Console.ReadLine(); // for debugging
}
public Program()
{
NetAppConfiguration myConfig = new NetAppConfiguration("MMO Mahjong", 14242);
NetLog log = new NetLog();
NetClient Client = new NetClient(myConfig, log);
Client.Connect("localhost", 14242); // takes IP number or hostnameHow to detect connects/disconnects
Client.StatusChanged += new EventHandler <NetStatusEventArgs>(StatusChanged); // to track connect/disconnect etc
bool keepGoing = true;
while (keepGoing)
{
Client.Heartbeat();
NetMessage msg;
while ((msg = Client.ReadMessage()) != null)
{
string str = msg.ReadString(); // <- for example
System.Console.WriteLine("You got a packet containing: " + str);
Thread.Sleep(1);
}
}
}
/// <summary>
/// 获取统计数据
/// </summary>
private void GetStatistics()
{
try
{
WebSiteDataInfo websitedatemodel = null;
if (IsRedis == "1")
{
websitedatemodel = mRedis.GetTotayInvestMoney();
}
else
{
websitedatemodel = new WebSiteDataBLL().GetWebSiteData();
}
if (websitedatemodel != null)
{
this.Amount = websitedatemodel.TotalAmount ?? 0;
this.UserCount = websitedatemodel.TotalUser ?? 0;
this.EarnedInterest = websitedatemodel.EarnedInterest ?? 0;
}
this.TodayAmount = new SubscribeBLL().GetSubscribeTotalAmount();
CalcDQWebSite();
}
catch (Exception ex)
{
NetLog.WriteLoginHandler("统计异常", ex.Message + "|" + ex.StackTrace);
}
}
void HandleDebugMessage(NetIncomingMessage message)
{
switch (message.MessageType)
{
case NetIncomingMessageType.DebugMessage:
{
NetLog.Debug(message.ReadString());
break;
}
case NetIncomingMessageType.ErrorMessage:
{
NetLog.Error(message.ReadString());
break;
}
case NetIncomingMessageType.WarningMessage:
{
NetLog.Warn(message.ReadString());
break;
}
case NetIncomingMessageType.VerboseDebugMessage:
{
NetLog.Debug(message.ReadString());
break;
}
}
}
public void Update()
{
if (null == mNetServer)
{
return;
}
NetIncomingMessage message;
while (null != (message = mNetServer.ReadMessage()))
{
try
{
switch (message.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
{
HandleDebugMessage(message);
break;
}
case NetIncomingMessageType.ConnectionApproval:
{
HandleConnectionApproval(message);
break;
}
case NetIncomingMessageType.StatusChanged:
{
HandleStatusChanged(message);
break;
}
case NetIncomingMessageType.Data:
{
HandleData(message);
break;
}
default:
{
NetLog.WarnFormat(
"{0} Unhandled message type:{1}, bytes:{2}",
appIdentifier,
message.MessageType,
message.LengthBytes);
break;
}
}
}
catch (Exception e)
{
NetLog.Exception(appIdentifier, e);
}
mNetServer.Recycle(message);
}
}
void HandleData(NetIncomingMessage message)
{
ushort id = ushort.MaxValue;
ByteBuffer byteBuffer = null;
try
{
id = message.ReadUInt16();
ushort len = message.ReadUInt16();
byteBuffer = ByteBufferPool.Alloc(len);
message.ReadBytes(byteBuffer.Data, 0, len);
var result = dispatcher.Fire(message.SenderConnection, (MessageID)id, byteBuffer, message);
if (result != MessageHandleResult.Processing)
{
ByteBufferPool.Dealloc(ref byteBuffer);
}
}
catch (Exception e)
{
ByteBufferPool.Dealloc(ref byteBuffer);
NetLog.Exception("HandleData throws exception", e);
if (id != ushort.MaxValue)
{
NetLog.Error("Caught exception when processing message " + (MessageID)id);
}
else
{
NetLog.Error("Caught exception when processing message");
}
}
}
private void WriteLog(ExceptionContext context)
{
if (context == null)
{
return;
}
NetLog.Error("", context.Exception);
}
public void BasicMissingOpenBracketTest()
{
netlog_section.Logger.Layout.Value = "#date] #severity - #message";
var message = "An Error occurred";
var logger = new NetLog(netlog_section);
var ouput = logger.Error(message);
}
public void ProcessShouldProcessTheFile()
{
NetLog log = new NetLog(@"D:\workspaces\elite\edt\backup\logs", new ConsoleFactory());
SystemModel[] results = log.Process();
Assert.AreNotEqual(results.Length, 0);
}
private void tbClearLog_Click(object sender, EventArgs e)
{
NetLog.Clear();
if (_netInfo.IsMonitoring)
{
AddLog("Monitoring...");
}
}
void HandleConnectionApproval(NetIncomingMessage message)
{
NetConnection conn = message.SenderConnection;
mConfig.onIncommingConnection(conn);
conn.Approve();
NetLog.DebugFormat("{0} Approve connection {1}", appIdentifier, conn.RemoteEndPoint);
}
private async Task ReceiveLogOff(CMsgClientLoggedOff loggedOff)
{
await NetLog.InfoAsync($"Logged off: {(Result)loggedOff.eresult} ({loggedOff.eresult})").ConfigureAwait(false);
await LoggedOff.InvokeAsync(this, new LogOffEventArgs((Result)loggedOff.eresult));
_gracefulLogoff = true;
}
private async Task AutoLoginToFriends(CMsgClientLogonResponse response)
{
if (response.eresult == 1 && GetConfig <SteamNetworkConfig>().AutoLoginFriends&& SteamId.FromCommunityId(response.client_supplied_steamid).IsIndividualAccount)
{
await NetLog.InfoAsync("Logging into friends").ConfigureAwait(false);
await SetPersonaStateAsync(PersonaState.Online).ConfigureAwait(false);
}
}
public void BasicUnsupportedSymbolTest()
{
netlog_section.Logger.Layout.Value = "[#date] severity + #message";
var message = "An Error occurred";
var logger = new NetLog(netlog_section);
var ouput = logger.Error(message);
}
protected override void OnExit(ExitEventArgs e)
{
AppExit(e.ApplicationExitCode);
#if !DEBUG
NetLog.Write("============系统 " + ((e.ApplicationExitCode == 0) ? "正常" : "异常(" + e.ApplicationExitCode + ")") + " 退出=========");
#endif
}
private async Task RunHeartbeatAsync(int interval, CancellationToken token)
{
#region Valve sucks at naming enum members
/*
* Let me tell you a story about 10/14/2017
* So I was working on this lib ironing out some kinks, rewriting the connection code
* when I finally completed it and decided to test it. So I pop open a console just to
* find obvious bugs like the whole thing exploding for no reason. Suddenly at about 5:08 PM
* it starts working properly. Stuff starts printing in the console and it's working properly.
* It works correctly until about 20 seconds later when the console window vanishes and up pops an error
* "IOException: Unable to transfer data" bla bla bla BASICALLY the connection was aborted.
* This brought up another bug in my TCP client where I wouldn't actually tell anyone the connection disconnected,
* but who cares about that. This brought in a more important problem: Steam drops my connection even though my heart is beating
* So I try a WebSocket. Same thing. Check the headers (because there's nothing the in body), everything lines up.
* I reference the SteamKit, everything related to serialization is in order. Everything is right except one thing.
* One small piece that nobody would notice.
* The correct message type for a heartbeat is "ClientHeartBeat", not "Heartbeat"...
* I found this out after 3 hours. Please kill me.
*
*
* TLDR: Valve sucks at naming enum members.
*/
#endregion
// cache the data so we don't serialize 500 times per session. Our session ID will never change and neither will our Steam ID
var beat = NetworkMessage.CreateProtobufMessage(MessageType.ClientHeartBeat, new CMsgClientHeartBeat()).WithClientInfo(SteamId, SessionId).Serialize();
try
{
await NetLog.DebugAsync($"Heartbeat started on a {interval} ms interval").ConfigureAwait(false);
while (!token.IsCancellationRequested)
{
await Task.Delay(interval, token).ConfigureAwait(false);
try
{
await SendAsync(beat).ConfigureAwait(false);
}
catch (Exception ex)
{
await NetLog.ErrorAsync($"The heartbeat task encountered an unknown exception while sending the heartbeat message", ex).ConfigureAwait(false);
}
}
}
catch (OperationCanceledException)
{
await NetLog.DebugAsync("Heartbeat stopped").ConfigureAwait(false);
}
catch (Exception ex)
{
await NetLog.ErrorAsync($"The heartbeat task encountered an unknown exception", ex).ConfigureAwait(false);
}
}
private async Task ProcessEncryptResult(NetworkMessage message)
{
ChannelEncryptResult encryptResult = message.Deserialize <ChannelEncryptResult>();
if (encryptResult.Result == Result.OK)
{
await NetLog.DebugAsync("Channel encrypted").ConfigureAwait(false);
await _connection.CompleteAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Sends an array of bytes to Steam
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
protected internal async Task SendAsync(byte[] message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
await NetLog.DebugAsync($"Sending {message.Length} byte message.").ConfigureAwait(false);
await Socket.SendAsync(Encryption.Encrypt(message)).ConfigureAwait(false);
}
/// <summary>
/// Sends a message to Steam
/// </summary>
/// <param name="message">The message to send</param>
/// <returns>An awaitable task</returns>
protected internal async Task SendAsync(NetworkMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
await NetLog.VerboseAsync($"Sending {(message.Protobuf ? "protobuf" : "struct")} message with type {message.MessageType}");
await SendAsync(message.WithClientInfo(_steamId, _sessionId).Serialize()).ConfigureAwait(false);
}
public IPlayer(String dns, int port)
{
NetAppConfiguration myConfig = new NetAppConfiguration("MMO Mahjong");
m_log = new NetLog();
Init();
m_client = new NetClient(myConfig, m_log);
m_client.Connect(dns, port);
m_client.StatusChanged += new EventHandler <NetStatusEventArgs>(StatusChanged);
Application.Idle += new EventHandler(ApplicationLoop);
}
private async Task OnDisconnectingInternalAsync(Exception ex)
{
await NetLog.DebugAsync("Cancelling all jobs").ConfigureAwait(false);
await _jobs.CancelAllJobs().ConfigureAwait(false);
await OnDisconnectingAsync(ex).ConfigureAwait(false);
await NetLog.DebugAsync("Disconnecting client").ConfigureAwait(false);
await DisconnectAsync().ConfigureAwait(false);
}
public void Update()
{
if (null == mNetClient)
{
return;
}
NetIncomingMessage message;
while (null != (message = mNetClient.ReadMessage()))
{
try
{
switch (message.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.ErrorMessage:
case NetIncomingMessageType.WarningMessage:
case NetIncomingMessageType.VerboseDebugMessage:
{
HandleDebugMessage(message);
break;
}
case NetIncomingMessageType.StatusChanged:
{
HandleStatusChanged(message);
break;
}
case NetIncomingMessageType.Data:
{
HandleData(message);
break;
}
default:
{
NetLog.WarnFormat(
"Unhandled message type:{0}, bytes:{1}",
message.MessageType,
message.LengthBytes);
break;
}
}
}
catch (Exception e)
{
NetLog.Exception(e);
}
mNetClient.Recycle(message);
}
}
public void ComplexFileLoggerTest()
{
netlog_section.Logger.Layout.Value = "[#date][[#severity - #message] - [#assembly]]";
var message = "An Error occurred";
var assembly = "NetLog.Test";
var severity = "ERROR";
var expected = "[" + DateTime.Now.ToString("MM/dd/yyyy") + "][[" + severity
+ " - " + message + "] - [" + assembly + "]]";
var logger = new NetLog(netlog_section);
var output = logger.Error(message);
Assert.AreEqual(expected, output);
}
public void ComplexFileLoggerTest3()
{
netlog_section.Logger.Layout.Value = "[#date][[#severity - #message] - [#assembly - #file [#method]]]";
var message = "An Error occurred";
var assembly = "NetLog.Test";
var file = @"c:\Repositories\netlog\NetLog.Test\NetLogTests.cs";
var severity = "ERROR";
var method = "Void ComplexFileLoggerTest3()";
var expected = "[" + DateTime.Now.ToString("MM/dd/yyyy") + "][[" + severity
+ " - " + message + "] - [" + assembly + " - " + file + " [" + method + "]]]";
var logger = new NetLog(netlog_section);
var output = logger.Error(message);
Assert.AreEqual(expected, output);
}
public void ComplexMissingOpenBracketTest()
{
netlog_section.Logger.Layout.Value = "[[[#date]][[#severity - #message]] - [[#assembly] - #file [#method]]]]";
var message = "An Error occurred";
var logger = new NetLog(netlog_section);
var ouput = logger.Error(message);
}
