C# IClient.Send方法代码示例

        public void ExecuteRequest(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:Storage:ExecuteRequest()");
            var request = bnet.protocol.storage.ExecuteRequest.ParseFrom(packetIn.Payload.ToArray());
            //Logger.Debug("request:\n{0}", request.ToString());
            
            bnet.protocol.storage.ExecuteResponse response = null;
            switch (request.QueryName)
            {
                case "GetGameAccountSettings":
                    response = GameAccountSettings(request);
                    break;
                case "LoadAccountDigest":
                    response = LoadAccountDigest(request);
                    break;
                case "GetHeroDigests":
                    response = GetHeroDigest(request);
                    break;
                case "GetToonSettings":
                    response = GetToonSettings(request);
                    break;
                default:
                    Logger.Warn("Unhandled ExecuteRequest: {0}", request.QueryName);
                    break;
            }                
            
            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }

        public void ListFactories(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:GameMaster:ListFactories()");

            var description = bnet.protocol.game_master.GameFactoryDescription.CreateBuilder().SetId(14249086168335147635);

            var atributes = new bnet.protocol.attribute.Attribute[4]
                                {
                                    bnet.protocol.attribute.Attribute.CreateBuilder().SetName("min_players").SetValue(bnet.protocol.attribute.Variant.CreateBuilder().SetIntValue(2)).Build(),
                                    bnet.protocol.attribute.Attribute.CreateBuilder().SetName("max_players").SetValue(bnet.protocol.attribute.Variant.CreateBuilder().SetIntValue(4)).Build(),
                                    bnet.protocol.attribute.Attribute.CreateBuilder().SetName("num_teams").SetValue(bnet.protocol.attribute.Variant.CreateBuilder().SetIntValue(1)).Build(),
                                    bnet.protocol.attribute.Attribute.CreateBuilder().SetName("version").SetValue(bnet.protocol.attribute.Variant.CreateBuilder().SetStringValue("0.3.0")).Build()
                                };

            description.AddRangeAttribute(atributes);
            description.AddStatsBucket(bnet.protocol.game_master.GameStatsBucket.CreateBuilder()
                                           .SetBucketMin(0)
                                           .SetBucketMax(4294967296F)
                                           .SetWaitMilliseconds(1354)
                                           .SetGamesPerHour(0)
                                           .SetActiveGames(1)
                                           .SetActivePlayers(1)
                                           .SetFormingGames(0)
                                           .SetWaitingPlayers(0).Build());

            var response = bnet.protocol.game_master.ListFactoriesResponse.CreateBuilder().AddDescription(description).SetTotalResults(1).Build();

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }

        public void Bind(IClient client, Packet packetIn)
        {
            var request = bnet.protocol.connection.BindRequest.ParseFrom(packetIn.Payload.ToArray());

            // supply service id's requested by client using service-hashes.
            var requestedServiceIDs = new List<uint>(); 
            foreach (var serviceHash in request.ImportedServiceHashList)
            {
                var serviceID = ServiceManager.GetServerServiceIDByHash(serviceHash);
                Logger.Trace("RPC:Bind() - Hash: 0x{0}  ID: {1,4}  Service: {2} ", serviceHash.ToString("X8"), serviceID, ServiceManager.GetServerServiceByID(serviceID) != null ? ServiceManager.GetServerServiceByID(serviceID).GetType().Name : "N/A");
                requestedServiceIDs.Add(serviceID);
            }

            // read services supplied by client..
            foreach (var service in request.ExportedServiceList)
            {
                if (!client.Services.ContainsKey(service.Id))
                    client.Services.Add(service.Id, service.Hash);
            }

            var builder = bnet.protocol.connection.BindResponse.CreateBuilder();
            foreach (var serviceId in requestedServiceIDs) builder.AddImportedServiceId(serviceId);
            var response = builder.Build();

            var packet =
                new Packet(
                    new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint) response.SerializedSize),
                    response.ToByteArray());

            client.Send(packet);
        }

        public void ListFactoriesRequest(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:GameMaster:ListFactoriesRequest()");
            //var reqb = bnet.protocol.game_master.ListFactoriesRequest.ParseFrom(packetIn.Payload.ToArray());
            var varib1 = bnet.protocol.attribute.Variant.CreateBuilder();
            varib1.SetIntValue(2);
            var vari1 = varib1.Build();
            var varib2 = bnet.protocol.attribute.Variant.CreateBuilder();
            varib2.SetIntValue(4);
            var vari2 = varib2.Build();
            var varib3 = bnet.protocol.attribute.Variant.CreateBuilder();
            varib3.SetIntValue(1);
            var vari3 = varib3.Build();
            var varib4 = bnet.protocol.attribute.Variant.CreateBuilder();
            varib4.SetStringValue("0.3.0");
            var vari4 = varib4.Build();
            var attrb1 = bnet.protocol.attribute.Attribute.CreateBuilder();
            attrb1.SetName("min_players");
            attrb1.SetValue(vari1);
            var attr1 = attrb1.Build();
            var attrb2 = bnet.protocol.attribute.Attribute.CreateBuilder();
            attrb2.SetName("max_players");
            attrb2.SetValue(vari2);
            var attr2 = attrb2.Build();
            var attrb3 = bnet.protocol.attribute.Attribute.CreateBuilder();
            attrb3.SetName("num_teams");
            attrb3.SetValue(vari3);
            var attr3 = attrb3.Build();
            var attrb4 = bnet.protocol.attribute.Attribute.CreateBuilder();
            attrb4.SetName("version");
            attrb4.SetValue(vari4);
            var attr4 = attrb4.Build();
            var statsb = bnet.protocol.game_master.GameStatsBucket.CreateBuilder();
            statsb.SetBucketMin(0);
            statsb.SetBucketMax(4.2949673e+009f);
            statsb.SetWaitMilliseconds(1000);
            statsb.SetGamesPerHour(0);
            statsb.SetActiveGames(50);
            statsb.SetActivePlayers(60);
            statsb.SetFormingGames(0);
            statsb.SetWaitingPlayers(0);
            var stats = statsb.Build();
            var factb = bnet.protocol.game_master.GameFactoryDescription.CreateBuilder(); // CoopFactoryID - 14249086168335147635 was value on bnet forum error log
            factb.SetId(14249086168335147635);
            factb.AddStatsBucket(stats);
            factb.AddAttribute(attr1);
            factb.AddAttribute(attr2);
            factb.AddAttribute(attr3);
            factb.AddAttribute(attr4);
            var fact = factb.Build();
            var respb = bnet.protocol.game_master.ListFactoriesResponse.CreateBuilder();
            respb.SetTotalResults(1);
            respb.AddDescription(fact);
            var response = respb.Build(); // Seems rescount is optional

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());
            client.Send(packet);
        }

        public FileExplorerForm(IServerUIHandler UIHandler, IClient c)
        {
            Client = c;
            UIHost = UIHandler;
            InitializeComponent();

            Image uiFolder = UIHandler.GetImage("folder.png");
            Image uiFolder2 = UIHandler.GetImage("folder2.png");
            Image uiFile = UIHandler.GetImage("file.png");
            Image uiDrive = UIHandler.GetImage("drive.png");
            Image uiError = UIHandler.GetImage("error.png");

            if(uiFolder != null)
                images.Images.Add("Folder", uiFolder);
            if (uiFolder2 != null)
                images.Images.Add("Folder2", uiFolder2);
            if (uiFile!=null)
                images.Images.Add("File", uiFile);
            if(uiDrive!=null)
                images.Images.Add("Drive", uiDrive);
            if(uiError != null)
                images.Images.Add("Error", uiError);

            lvFileView.SmallImageList = images;
            lvFileBucket.SmallImageList = images;
            c.Send((byte)NetworkCommand.FileManager, (byte)FileManagerCommand.Update, string.Empty);
        }

        private static void SendResponse(IClient client, int requestId, IMessage message)
        {
            var packet = new Packet(
                new Header(0xfe, 0x0, requestId, (uint)message.SerializedSize),
                message.ToByteArray());

            client.Send(packet);
        }

 public override void Handle(IClient client)
 {
     RealmManager.Instance.PostAsync(mgr =>
     {
         var realms = mgr.GetRealms(x => true);
         client.PostAsync(() => client.Send(RealmPackets.BuildRealmList(realms)));
     });
 }

 public static void StartPing(IClient c)
 {
     if (Handler.ContainsKey(c.ID))
         return;
     Stopwatch sw = new Stopwatch();
     Handler.Add(c.ID, sw);
     c.Send((byte)NetworkCommand.Ping);
     sw.Start();
 }

        public void GetConfiguration(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:Exchange:GetConfiguration()");
            var response = bnet.protocol.exchange.GetConfigurationResponse.CreateBuilder().Build();

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }

 public static void Start(IClient c)
 {
     if(!formHandler.ContainsKey(c.ID))
     {
         TaskManagerForm f = new TaskManagerForm(c, UIHost);
         f.FormClosed += F_FormClosed;
         formHandler.Add(c.ID, f);
         f.Show();
         c.Send((byte)NetworkCommand.TaskManager, (byte)TaskManagerCommand.GetProcesses);
     }
 }

        public void ToonListRequest(IClient client, Packet packetIn)
        {            
            Logger.Trace("RPC:ToonExternal:ToonListRequest()");
            var response = bnet.protocol.toon.external.ToonListResponse.CreateBuilder().Build();

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }

        public static void HandleRealmlist(IClient client, IncomingAuthPacket packet)
        {
            Contract.Requires(client != null);
            Contract.Requires(packet != null);

            var unk = packet.ReadInt32(); // ignored

            List<string> realmNames = RealmList.GetRealmNames();

            var realmsSize = 0;
            foreach (string realmName in realmNames)
            {
                Realm realm = RealmList.GetRealm(realmName);
                realmsSize += 3;
                // +1 for the null character at the end
                realmsSize += realm.Name.Length + 1;
                realmsSize += realm.Address.Length + 1;
                realmsSize += 6;
                if ((realm.Color & 4) != 0)
                    realmsSize += 5;
            }

            using (var outPacket = new OutgoingAuthPacket(GruntOpCodes.RealmList, 10 + realmsSize))
            {
                outPacket.Write((short)(6 + realmsSize + 2));
                outPacket.Write(0);
                outPacket.Write((short)realmNames.Count);
                foreach (string realmName in realmNames)
                {
                    Realm realm = RealmList.GetRealm(realmName);
                    var numChars = realm.GetNumChars(client.UserData.SRP.Username);

                    outPacket.Write(realm.Icon);
                    outPacket.Write(realm.Lock);
                    outPacket.Write(realm.Color);
                    outPacket.WriteCString(realm.Name);
                    outPacket.WriteCString(realm.Address);
                    outPacket.Write(realm.PopulationLevel);
                    outPacket.Write(numChars);
                    outPacket.Write(realm.TimeZone);
                    outPacket.Write((byte)0x2C);
                    if ((realm.Color & 0x04) != 0)
                    {
                        outPacket.Write((byte)0);
                        outPacket.Write((byte)0);
                        outPacket.Write((byte)0);
                        outPacket.Write((short)0);
                    }
                }
                outPacket.Write((byte)0x10);
                outPacket.Write((byte)0x00);
                client.Send(outPacket);
            }
        }

        public void SubscribeToFollowers(IClient client, Packet packetIn)
        {
            var response = bnet.protocol.followers.SubscribeToFollowersResponse.CreateBuilder().Build();

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            Logger.Trace("RPC:Followers:Subscribe()");
            client.Send(packet);
        }

        public void OpenColumnRequest(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:Storage:OpenColumnRequest()");
            var response = bnet.protocol.storage.OpenColumnResponse.CreateBuilder().Build();

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }

        public void Subscribe(IClient client, Packet packetIn)
        {
            Logger.Trace("RPC:ChannelInvitation:Subscribe()");
            var response = bnet.protocol.channel_invitation.SubscribeResponse.CreateBuilder().Build();

            var packet = new Packet(
                new Header(0xfe, 0x0, packetIn.Header.RequestID, (uint)response.SerializedSize),
                response.ToByteArray());

            client.Send(packet);
        }