public async Task <Rpc.Test.Interface.DataEnumForReturn> GreetEnumReturn()
{
var _writer_ = NetPool.DataWriterPool.Alloc();
try
{
_writer_.Write((int)IGreeterRpc_Enum.GreetEnumReturn);
using (var _reader_ = await SendRequestAndReceive(_writer_))
{
return(NetDataSerializer.Deserialize <Rpc.Test.Interface.DataEnumForReturn>(_reader_));
}
}
finally
{
NetPool.DataWriterPool.Free(_writer_);
}
}
public async Task <Common.UserInfo> GetUserInfo()
{
var _writer_ = NetPool.DataWriterPool.Alloc();
try
{
_writer_.Write((int)ILoginRpc_Enum.GetUserInfo);
using (var _reader_ = await SendRequestAndReceive(_writer_))
{
return(NetDataSerializer.Deserialize <Common.UserInfo>(_reader_));
}
}
finally
{
NetPool.DataWriterPool.Free(_writer_);
}
}
public async Task <System.Tuple <int, System.Net.Sockets.SocketFlags> > GreetTuple(System.Tuple <string, string> value)
{
var _writer_ = NetPool.DataWriterPool.Alloc();
try
{
_writer_.Write((int)IGreeterRpc_Enum.GreetTuple);
NetDataSerializer.Serialize <System.Tuple <string, string> >(_writer_, value);
using (var _reader_ = await SendRequestAndReceive(_writer_))
{
return(NetDataSerializer.Deserialize <System.Tuple <int, System.Net.Sockets.SocketFlags> >(_reader_));
}
}
finally
{
NetPool.DataWriterPool.Free(_writer_);
}
}
public async Task <System.Collections.Generic.Dictionary <int, int> > GreetDictionary(System.Collections.Generic.Dictionary <string, string> value)
{
var _writer_ = NetPool.DataWriterPool.Alloc();
try
{
_writer_.Write((int)IGreeterRpc_Enum.GreetDictionary);
NetDataSerializer.Serialize <System.Collections.Generic.Dictionary <string, string> >(_writer_, value);
using (var _reader_ = await SendRequestAndReceive(_writer_))
{
return(NetDataSerializer.Deserialize <System.Collections.Generic.Dictionary <int, int> >(_reader_));
}
}
finally
{
NetPool.DataWriterPool.Free(_writer_);
}
}
public async Task <bool> Invoke(object _target_, NetDataReader _reader_, NetDataWriter _writer_)
{
ISession session = _target_ as ISession;
var typeEnum = (IGreeterRpc_Enum)_reader_.ReadInt32();
switch (typeEnum)
{
case IGreeterRpc_Enum.Greet:
{
var name = _reader_.ReadString();
var _result_ = await(session as IGreeterRpc).Greet(name);
_writer_.Write(_result_);
}
break;
case IGreeterRpc_Enum.GreetClass:
{
var dataClass = NetDataSerializer.Deserialize <Rpc.Test.Interface.DataClass>(_reader_);
var _result_ = await(session as IGreeterRpc).GreetClass(dataClass);
NetDataSerializer.Serialize <Rpc.Test.Interface.DataClass>(_writer_, _result_);
}
break;
case IGreeterRpc_Enum.GreetInterfaceSerializeClass:
{
var dataClass = _reader_.Read <Rpc.Test.Interface.InterfaceSerializeClass>();
var _result_ = await(session as IGreeterRpc).GreetInterfaceSerializeClass(dataClass);
_writer_.Write <Rpc.Test.Interface.InterfaceSerializeClass>(_result_);
}
break;
case IGreeterRpc_Enum.SessionParameter:
{
var _result_ = await(session as IGreeterRpc).SessionParameter(session);
_writer_.Write(_result_);
}
break;
default: return(false);
}
return(true);
}
private T TestBase <T>(T data)
{
var writer = NetPool.DataWriterPool.Alloc();
try
{
NetDataSerializer.Serialize <T>(writer, data);
}
finally
{
NetPool.DataWriterPool.Free(writer);
}
byte[] buffer = writer.CopyData();
var reader = new NetDataReader(buffer);
return(NetDataSerializer.Deserialize <T>(reader));
}
public async Task <bool> Invoke(object _target_, NetDataReader _reader_, NetDataWriter _writer_)
{
ISession session = _target_ as ISession;
var typeEnum = (ILoginRpc_Enum)_reader_.ReadInt32();
switch (typeEnum)
{
case ILoginRpc_Enum.GetUserInfo:
{
var _result_ = await GetUserInfo();
NetDataSerializer.Serialize <Common.UserInfo>(_writer_, _result_);
}
break;
case ILoginRpc_Enum.Join:
{
var _result_ = await Join();
_writer_.Write(_result_);
}
break;
case ILoginRpc_Enum.Login:
{
var id = _reader_.ReadString();
var _result_ = await Login(id);
_writer_.Write(_result_);
}
break;
default: return(false);
}
return(true);
}
public void Serialize(NetDataWriter _writer_, GenericDataStruct <T> _value_, NetDataSerializerOptions options)
{
NetDataSerializer.Serialize <T>(_writer_, _value_.GenericValue);
}
public void Serialize(NetDataWriter _writer_, RoomInfo _value_, NetDataSerializerOptions options)
{
_writer_.Write(_value_.Name);
NetDataSerializer.Serialize <SampleGameCommon.RoomSlotInfo[]>(_writer_, _value_.Slots);
_writer_.Write(_value_.Id);
}
public void Serialize(NetDataWriter _writer_, GenericClass <T> _value_, NetDataSerializerOptions options)
{
NetDataSerializer.Serialize <T>(_writer_, _value_.SlotId);
}
public async Task <bool> Invoke(object _target_, NetDataReader _reader_, NetDataWriter _writer_)
{
ISession session = _target_ as ISession;
var typeEnum = (IGreeterRpc_Enum)_reader_.ReadInt32();
switch (typeEnum)
{
case IGreeterRpc_Enum.Greet:
{
var name = _reader_.ReadString();
var _result_ = await(session as IGreeterRpc).Greet(name);
_writer_.Write(_result_);
}
break;
case IGreeterRpc_Enum.GreetClass:
{
var dataClass = NetDataSerializer.Deserialize <Rpc.Test.Interface.DataClass>(_reader_);
var _result_ = await(session as IGreeterRpc).GreetClass(dataClass);
NetDataSerializer.Serialize <Rpc.Test.Interface.DataClass>(_writer_, _result_);
}
break;
case IGreeterRpc_Enum.GreetDictionary:
{
var value = NetDataSerializer.Deserialize <System.Collections.Generic.Dictionary <string, string> >(_reader_);
var _result_ = await(session as IGreeterRpc).GreetDictionary(value);
NetDataSerializer.Serialize <System.Collections.Generic.Dictionary <int, int> >(_writer_, _result_);
}
break;
case IGreeterRpc_Enum.GreetEnum:
{
var dataEnum = NetDataSerializer.Deserialize <Rpc.Test.Interface.DataEnum>(_reader_);
await(session as IGreeterRpc).GreetEnum(dataEnum);
}
break;
case IGreeterRpc_Enum.GreetEnumOther:
{
var flags = NetDataSerializer.Deserialize <System.Net.Sockets.SocketFlags>(_reader_);
await(session as IGreeterRpc).GreetEnumOther(flags);
}
break;
case IGreeterRpc_Enum.GreetEnumReturn:
{
var _result_ = await(session as IGreeterRpc).GreetEnumReturn();
NetDataSerializer.Serialize <Rpc.Test.Interface.DataEnumForReturn>(_writer_, _result_);
}
break;
case IGreeterRpc_Enum.GreetInterfaceSerializeClass:
{
var dataClass = _reader_.Read <Rpc.Test.Interface.InterfaceSerializeClass>();
var _result_ = await(session as IGreeterRpc).GreetInterfaceSerializeClass(dataClass);
_writer_.Write <Rpc.Test.Interface.InterfaceSerializeClass>(_result_);
}
break;
case IGreeterRpc_Enum.GreetTuple:
{
var value = NetDataSerializer.Deserialize <System.Tuple <string, string> >(_reader_);
var _result_ = await(session as IGreeterRpc).GreetTuple(value);
NetDataSerializer.Serialize <System.Tuple <int, System.Net.Sockets.SocketFlags> >(_writer_, _result_);
}
break;
case IGreeterRpc_Enum.SessionParameter:
{
var _result_ = await(session as IGreeterRpc).SessionParameter(session);
_writer_.Write(_result_);
}
break;
default: return(false);
}
return(true);
}
