public static void Serialize <T>(Session session, MemoryStream destination, T packet) where T : Packet
{
byte[] idBytes = ConverterUtility.GetBytes(packet.GetPacketId());
destination.Write(idBytes, 0, idBytes.Length);
packet.Serialize(destination);
ProtoRegister.ReturnPacket(packet);
}
private void ConvertAndSetResult()
{
tbx_Fritz.Clear();
string input = tbx_Schacharena.Text;
if (input.Length == 0)
{
return;
}
if (ProcessSpecialInput(input))
{
return;
}
try
{
tbx_Fritz.Text = ConverterUtility.ConvertFromSchacharenaToFritz(input);
tbx_Fritz.BackColor = SystemColors.Control;
}
catch (ConverterException ex)
{
tbx_Fritz.Text = ex.Message + Environment.NewLine + Environment.NewLine
+ ex.StackTrace + Environment.NewLine + Environment.NewLine
+ "In SchacharenaZuFritz " + Version + Environment.NewLine + Environment.NewLine
+ "Input was:" + Environment.NewLine + input;
tbx_Fritz.BackColor = Color.Tomato;
}
}
public static List <Result> GetNewsList(string company, string fromDate, string toDate)
{
List <Result> newsResult = new List <Result>();
try
{
int retry = _retry;
string _fDate = ConverterUtility.ParseDate(fromDate);
string _tDate = ConverterUtility.ParseDate(toDate);
string facet = getCompanyFacet(company);
while (retry > 0)
{
LoggerUtility.WriteLog("Searching Data: ", "Params : \n Company :" + company + "\n Facet : " + facet + "\n From Date : " + _fDate + "\n To Date : " + _tDate + "\n Retry : " + retry);
var _result = getNewsList(company, facet, _fDate, _tDate);
Thread.Sleep(_delay);
if (_result != null && _result.Count > 0)
{
newsResult = _result;
retry = 0;
}
else
{
retry--;
_fDate = ConverterUtility.AddDays(_fDate, -2);
_tDate = ConverterUtility.AddDays(_tDate, 2);
}
}
}
catch (Exception ex)
{
LoggerUtility.WriteLog("Error in Getting News List", ex.Message);
}
return(newsResult);
}
internal override void Publish(Exception e)
{
LogEntity logEntity = new LogEntity();
logEntity.LogType = "error";
logEntity.Message = e.Message;
logEntity.JsonMessage = ConverterUtility.WriteFromObject(e);
_logRepository.Create(logEntity);
}
public void WriteError(string message, Exception ex)
{
LogEntity logEntity = new LogEntity();
logEntity.LogType = "error";
logEntity.Message = ex.Message;
logEntity.JsonMessage = ConverterUtility.WriteFromObject(ex);
_logRepository.Create(logEntity);
}
public static Packet Deserialize(Session session, MemoryStream source, out object customErrorData)
{
customErrorData = null;
long begin = source.Position;
byte[] buffer = new byte[4];
source.Read(buffer, 0, sizeof(int));
int id = ConverterUtility.GetInt32(buffer);
Packet packet = ProtoRegister.GetPacket(id);
packet.DeSerialize(source);
return(packet);
}
private void TestInternal(int fileIndex)
{
const string folder = "Test/";
string inputPath = folder + "input" + fileIndex + ".txt";
string input = File.ReadAllText(inputPath);
string expectedPath = folder + "expected" + fileIndex + ".txt";
string expected = File.ReadAllText(expectedPath);
string actual = ConverterUtility.ConvertFromSchacharenaToFritz(input);
Console.WriteLine(actual);
Assert.AreEqual(expected.Trim(), actual.Trim());
}
public void Send <T>(T packet) where T : Packet
{
if (_socket == null)
{
string errorMessage = "session not initialize.";
if (ErrorHandler != null)
{
ErrorHandler(this, SessionErrorCode.StateError, errorMessage);
return;
}
throw new Exception(errorMessage);
}
if (packet == null)
{
string errorMessage = "Packet is invalid.";
if (ErrorHandler != null)
{
ErrorHandler(this, SessionErrorCode.StateError, errorMessage);
return;
}
throw new Exception(errorMessage);
}
try
{
int length = 0;
int packetLength = 0;
byte[] packetBuffer = new byte[_defaultMaxPacketLength];//TODO:内存池;
using (MemoryStream memoryStream = new MemoryStream(packetBuffer, true))
{
memoryStream.Seek(_defaultPacketLength, SeekOrigin.Begin);
SessionUtil.Serialize(this, memoryStream, packet);
length = (int)memoryStream.Position;
}
packetLength = length - _defaultPacketLength;
ConverterUtility.GetBytes(packetLength).CopyTo(packetBuffer, 0);
Send(packetBuffer, 0, length);
}
catch (Exception exception)
{
_active = false;
if (ErrorHandler != null)
{
ErrorHandler(this, SessionErrorCode.SerializeError, exception.ToString());
return;
}
throw;
}
}
private bool Process()
{
if (_receiver.ReceivedLength != _receiver.Length)
{
throw new Exception(string.Format("Receive length '{0}' is not equal to length '{1}'.", _receiver.ReceivedLength.ToString(), _receiver.Length.ToString()));
}
if (_receiver.Length < _defaultPacketLength)
{
throw new Exception(string.Format("Length '{0}' is smaller than length header.", _receiver.Length.ToString()));
}
if (_receiver.Length == _defaultPacketLength)
{
int packetLength = ConverterUtility.GetInt32(_receiver.GetBuffer());
if (packetLength <= 0)
{
string errorMessage = string.Format("Packet length '{0}' is invalid.", packetLength.ToString());
if (ErrorHandler != null)
{
ErrorHandler(this, SessionErrorCode.HeaderError, errorMessage);
return(false);
}
throw new Exception(errorMessage);
}
_receiver.Length += packetLength;
if (_receiver.Length > _receiver.BufferSize)
{
string errorMessage = string.Format("Length '{0}' is larger than buffer size '{1}'.", _receiver.Length.ToString(), _receiver.BufferSize.ToString());
if (ErrorHandler != null)
{
ErrorHandler(this, SessionErrorCode.OutOfRangeError, errorMessage);//未接收完成,继续;
return(false);
}
throw new Exception(errorMessage);
}
return(true);
}
Packet packet = null;
try
{
int packetLength = _receiver.Length - _defaultPacketLength;
object customErrorData = null;
using (MemoryStream memoryStream = new MemoryStream(_receiver.GetBuffer(), _defaultPacketLength, packetLength, false))
{
lock (thisLock)
{
packet = SessionUtil.Deserialize(this, memoryStream, out customErrorData);
}
}
_receiver.Reset(_defaultPacketLength);
if (packet == null)
{
if (CustomErrorHandler != null)
{
CustomErrorHandler(this, customErrorData);
}
}
else
{
if (ReceiveHandler != null)
{
ReceiveHandler(this, packet);
}
}
}
catch (Exception exception)
{
_active = false;
if (ErrorHandler != null)
{
ErrorHandler(this, SessionErrorCode.DeserializeError, exception.ToString());
return(false);
}
throw;
}
return(true);
}
