static void Main(string[] args)
{
ObjectFactory.Init();
byte[] sresult = null;
int[] int_inttest = new int[] { 100000, 5556, 55964636, 54564, 2131, 0, 3333, 66, 644, 444 };
sresult = ObjectFactory.ToBytes(typeof(int[]), int_inttest);
int[] int_outtest = null;
int_outtest = (int[])ObjectFactory.ToObjact(typeof(int[]), sresult);
string[] str_inttest = new string[] { "asfdasfasfas", "阿斯蒂芬阿三豆腐块阿斯弗", "发哈可是大后方恐惧哈市", "啊开始就好付款计划v卡收费的卡上的机会附加费感觉哈是官方的环境啊是的高房价哈斯夺冠翻噶实践活动覆盖较好啊是固定火箭发射轨道" };
sresult = ObjectFactory.ToBytes(typeof(string[]), str_inttest);
string[] str_outtest = null;
str_outtest = (string[])ObjectFactory.ToObjact(typeof(string[]), sresult);
bool[] bool_inttest = new bool[] { true, false, true, false, true, true, true, true, false, false, false, false };
sresult = ObjectFactory.ToBytes(typeof(bool[]), bool_inttest);
MainPacket <cc> tp = new MainPacket <cc>();
tp.CommandType = cc.v1;
tp.Data = sresult;
var bytes = ObjectFactory.ToBytes(tp.GetType(), tp);
object obj = ObjectFactory.ToObjact(tp.GetType(), bytes);
// tp1.CreatePacketFromBytes(tempb);
}
public void Send(IPEndPoint remoteEP, MainPacket <T> packet)
{
packet.Data = Convert.Encode(packet.Data);
var sendBytes = packet.GetBytes();
udpClient.Send(sendBytes, sendBytes.Length, remoteEP);
}
public async Task <MainPacket <Brewery> > Breweries(int page, string established)
{
HttpClient client = new HttpClient();
var uri = new Uri(
string.Format($"http://api.brewerydb.com/v2/breweries?p={page}&established={established}&key={ApiKeys.ApiKey}"));
var response = await client.GetAsync(uri);
MainPacket <Brewery> weatherData = null;
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
weatherData = JsonConvert.DeserializeObject <MainPacket <Brewery> >(content); //WeatherItem.FromJson(content);
}
return(weatherData);
}
public void Switch(SimpleTcpClient <T> sender, MainPacket <T> packet)
{
if (CommandRouter.ContainsKey(packet.CommandType))
{
var router = CommandRouter[packet.CommandType];
var ptype = router.DefaultType;
var _packet = ObjectFactory.ToObjact(ptype, packet.Data);
var methodInfo = router.Action.GetType().GetMethod("Invoke");
var paramInfo = methodInfo.GetParameters()[0].ParameterType;
var message = Activator.CreateInstance(paramInfo);
var message_type = message.GetType();
message_type.GetField("Socket").SetValue(message, sender);
message_type.GetField("Packet").SetValue(message, _packet);
methodInfo.Invoke(router.Action, new object[] { message });
}
}
public void Switch(UdpServer <T> udpServer, IPEndPoint remoteEP, MainPacket <T> packet)
{
if (CommandRouter.ContainsKey(packet.CommandType))
{
var router = CommandRouter[packet.CommandType];
var ptype = router.DefaultType;
var _packet = ObjectFactory.ToObjact(ptype, packet.Data);
var methodInfo = router.Action.GetType().GetMethod("Invoke");
var paramInfo = methodInfo.GetParameters()[0].ParameterType;
var message = Activator.CreateInstance(paramInfo);
var message_type = message.GetType();
message_type.GetField("UdpServer").SetValue(message, udpServer);
message_type.GetField("RemoteEndPoint").SetValue(message, remoteEP);
message_type.GetField("Packet").SetValue(message, _packet);
methodInfo.Invoke(router.Action, new object[] { message });
}
}
private void Receive_Callback(IAsyncResult ar)
{
var uc = ar.AsyncState as UdpClient;
var remoteEP = new IPEndPoint(1, 1);
var receveBytes = uc.EndReceive(ar, ref remoteEP);
try
{
MainPacket <T> mp = new MainPacket <T>();
PacketHelper.CreatePacketFromBytes(receveBytes, ref mp);
Switch(this, remoteEP, mp);
}
catch (Exception)
{
throw;
}
uc.BeginReceive(Receive_Callback, uc);
}
public void Send(MainPacket <T> packet)
{
packet.Data = Convert.Encode(packet.Data);
var bytesSendData = packet.GetBytes();
if (ns == null)
{
throw new Exception("is not connected.");
}
if (!ns.CanWrite)
{
throw new Exception("stream can't write!");
}
lock (ns)
{
ns.Write(bytesSendData, 0, bytesSendData.Length);
ns.Flush();
}
}
internal async void GetWeatherForLocation()
{
WeatherCollection.Clear();
if (string.IsNullOrEmpty(LocationEnteredByUser))
{
return;
}
MainPacket <Brewery> weatherData = await Breweries(1, "2010");
if (weatherData != null)
{
foreach (var brewery in weatherData.Data.Take(10))
{
WeatherCollection.Add(brewery);
}
}
}
private void PM_ReceivePacket(MainPacket <T> packet)
{
packet.Data = Convert.Decode(packet.Data);
ReceivePacket?.Invoke(this, packet);
}
/// <summary>
/// 发送数据包
/// </summary>
/// <param name="packet"></param>
public void Send(MainPacket <T> packet)
{
Client.Send(packet);
}
public Par2RecoverySet ReadRecoverySet()
{
//int readsize = (int)Math.Min((long)buffer_size, fileInfo.Length);
int readsize = (int)fileInfo.Length;
byte[] bytes = ReadBytes(readsize);
int index = 0;
int file_offset = 0;
//while (BaseStream.Position < BaseStream.Length)
{
do
{
index = ToolKit.IndexOf(bytes, packet_magic, index);
if (index < 0)
{
break;
}
PacketHeader header = PacketHeader.Create(bytes, index);
switch (GetPacketType(header.type))
{
case PacketType.CreatorPacket:
CreatorPacket createPacket = CreatorPacket.Create(header, bytes, index + header.GetSize());
par2RecoverySet.AddCreatorPacket(createPacket);
index += createPacket.GetSize() - header.GetSize();
break;
case PacketType.DescriptionPacket:
FileDescriptionPacket descPacket = FileDescriptionPacket.Create(header, bytes, index + header.GetSize());
par2RecoverySet.AddDescriptionPacket(descPacket);
index += descPacket.GetSize() - header.GetSize();
break;
case PacketType.MainPacket:
MainPacket mainPacket = MainPacket.Create(header, bytes, index + header.GetSize());
par2RecoverySet.AddMainPacket(mainPacket);
index += mainPacket.GetSize() - header.GetSize();
break;
case PacketType.RecoveryPacket:
RecoveryPacket recoveryPacket = RecoveryPacket.Create(header, bytes, index + header.GetSize(), fileInfo.FullName, file_offset);
par2RecoverySet.AddRecoveryPacket(recoveryPacket);
index += recoveryPacket.GetSize() - header.GetSize();
break;
case PacketType.VerificationPacket:
FileVerificationPacket verPacket = FileVerificationPacket.Create(header, bytes, index + header.GetSize());
par2RecoverySet.AddVerificationPacket(verPacket);
index += verPacket.GetSize() - header.GetSize();
break;
case PacketType.Unknown:
// Unknown packettype
break;
}
} while (index >= 0);
index = 0;
readsize = (int)Math.Min((long)buffer_size, BaseStream.Length - BaseStream.Position);
file_offset += bytes.Length;
bytes = ReadBytes(readsize);
}
return(par2RecoverySet);
}
