Discord.Net + MagicOnion, heheh

SStilau Hey! So I am working on a discord bot that I want to intergrate into a server u...

T

TeBeCo•11/20/23, 5:25 PM

    public static Task Main()
-        => new Program().MainAsync();
-
-    private async Task MainAsync()
-    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {
                        services
                            .AddSingleton(client)
                            .AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()))
                            .AddSingleton<InteractionHandler>()
                            .AddTransient<ITestService, TestService>();

                        services.AddGrpc();
                        services.AddMagicOnion();
                    }
                ).Build();
            
            await RunAsync(host);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
-    }

    public static Task Main()
-        => new Program().MainAsync();
-
-    private async Task MainAsync()
-    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {
                        services
                            .AddSingleton(client)
                            .AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()))
                            .AddSingleton<InteractionHandler>()
                            .AddTransient<ITestService, TestService>();

                        services.AddGrpc();
                        services.AddMagicOnion();
                    }
                ).Build();
            
            await RunAsync(host);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
-    }

    public static Task Main()
-        => new Program().MainAsync();
-
-    private async Task MainAsync()
-    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {
                        services
                            .AddSingleton(client)
                            .AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()))
                            .AddSingleton<InteractionHandler>()
                            .AddTransient<ITestService, TestService>();

                        services.AddGrpc();
                        services.AddMagicOnion();
                    }
                ).Build();
            
            await RunAsync(host);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
-    }

    public static Task Main()
-        => new Program().MainAsync();
-
-    private async Task MainAsync()
-    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {
                        services
                            .AddSingleton(client)
                            .AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()))
                            .AddSingleton<InteractionHandler>()
                            .AddTransient<ITestService, TestService>();

                        services.AddGrpc();
                        services.AddMagicOnion();
                    }
                ).Build();
            
            await RunAsync(host);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
-    }

T

TeBeCo•11/20/23, 5:25 PM

you don't need all that in .net

T

TeBeCo•11/20/23, 5:27 PM

you can have direct code / no main

T

TeBeCo•11/20/23, 5:27 PM

and

Main

Main

Main

Main properly support async now

T

TeBeCo•11/20/23, 5:27 PM

$main

TTeBeCo $main

M

MODiX•11/20/23, 5:27 PM

$mains

T

TeBeCo•11/20/23, 5:27 PM

$mains

TTeBeCo $mains

M

MODiX•11/20/23, 5:27 PM

The possible signatures for

Main

Main

Main

Main are

public static void Main() { }
public static int Main() { }
public static void Main(string[] args) { }
public static int Main(string[] args) { }
public static async Task Main() { }
public static async Task<int> Main() { }
public static async Task Main(string[] args) { }
public static async Task<int> Main(string[] args) { }

public static void Main() { }
public static int Main() { }
public static void Main(string[] args) { }
public static int Main(string[] args) { }
public static async Task Main() { }
public static async Task<int> Main() { }
public static async Task Main(string[] args) { }
public static async Task<int> Main(string[] args) { }

public static void Main() { }
public static int Main() { }
public static void Main(string[] args) { }
public static int Main(string[] args) { }
public static async Task Main() { }
public static async Task<int> Main() { }
public static async Task Main(string[] args) { }
public static async Task<int> Main(string[] args) { }

public static void Main() { }
public static int Main() { }
public static void Main(string[] args) { }
public static int Main(string[] args) { }
public static async Task Main() { }
public static async Task<int> Main() { }
public static async Task Main(string[] args) { }
public static async Task<int> Main(string[] args) { }

public

public

is not required (can be any accessibility).

Top-level statements are compiled into a

Main

Main

Main

Main method and will use an appropriate signature depending on the body.

https://docs.microsoft.com/en-US/dotnet/csharp/fundamentals/program-structure/main-command-line

Main() and command-line arguments - C#

Learn about Main() and command-line arguments. The 'Main' method is the entry point of an executable program.

T

TeBeCo•11/20/23, 5:28 PM

        await client.LoginAsync(TokenType.Bot, Token);
-       await client.StartAsync();
        
        client.Log += Log;
        client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };

+       await client.RunAsync();
-       await Task.Delay(-1);

        await client.LoginAsync(TokenType.Bot, Token);
-       await client.StartAsync();
        
        client.Log += Log;
        client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };

+       await client.RunAsync();
-       await Task.Delay(-1);

        await client.LoginAsync(TokenType.Bot, Token);
-       await client.StartAsync();
        
        client.Log += Log;
        client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };

+       await client.RunAsync();
-       await Task.Delay(-1);

        await client.LoginAsync(TokenType.Bot, Token);
-       await client.StartAsync();
        
        client.Log += Log;
        client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };

+       await client.RunAsync();
-       await Task.Delay(-1);

T

TeBeCo•11/20/23, 5:30 PM

   services
+      .AddHostedService<InteractionHandler>()
-      .AddSingleton<InteractionHandler>()
+      .AddHostedService<DiscordSocketClientHostedService>()

.............
// Move all that in DiscordSocketClientHostedService.StartAsync()
+ await client.LoginAsync(TokenType.Bot, Token);
+ await client.StartAsync();
+
+ client.Log += Log;
+ client.Ready += async () =>
+ {
+      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
+ };
..........

-    private async Task RunAsync(IHost host)
-    {
-        using var serviceScope = host.Services.CreateScope();
-        var serviceProvider = serviceScope.ServiceProvider;
-        
-
-        var commands = serviceProvider
-            .GetRequiredService<InteractionService>();
-        var client = serviceProvider
-            .GetRequiredService<DiscordSocketClient>();
-
-        await serviceProvider
-            .GetRequiredService<InteractionHandler>()
-            .InitializeAsync();
-
-        
-        await client.LoginAsync(TokenType.Bot, Token);
-        await client.StartAsync();
-        
-        client.Log += Log;
-        client.Ready += async () =>
-        {
-            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
-        };
-        
-        await Task.Delay(-1);
-    }

   services
+      .AddHostedService<InteractionHandler>()
-      .AddSingleton<InteractionHandler>()
+      .AddHostedService<DiscordSocketClientHostedService>()

.............
// Move all that in DiscordSocketClientHostedService.StartAsync()
+ await client.LoginAsync(TokenType.Bot, Token);
+ await client.StartAsync();
+
+ client.Log += Log;
+ client.Ready += async () =>
+ {
+      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
+ };
..........

-    private async Task RunAsync(IHost host)
-    {
-        using var serviceScope = host.Services.CreateScope();
-        var serviceProvider = serviceScope.ServiceProvider;
-        
-
-        var commands = serviceProvider
-            .GetRequiredService<InteractionService>();
-        var client = serviceProvider
-            .GetRequiredService<DiscordSocketClient>();
-
-        await serviceProvider
-            .GetRequiredService<InteractionHandler>()
-            .InitializeAsync();
-
-        
-        await client.LoginAsync(TokenType.Bot, Token);
-        await client.StartAsync();
-        
-        client.Log += Log;
-        client.Ready += async () =>
-        {
-            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
-        };
-        
-        await Task.Delay(-1);
-    }

   services
+      .AddHostedService<InteractionHandler>()
-      .AddSingleton<InteractionHandler>()
+      .AddHostedService<DiscordSocketClientHostedService>()

.............
// Move all that in DiscordSocketClientHostedService.StartAsync()
+ await client.LoginAsync(TokenType.Bot, Token);
+ await client.StartAsync();
+
+ client.Log += Log;
+ client.Ready += async () =>
+ {
+      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
+ };
..........

-    private async Task RunAsync(IHost host)
-    {
-        using var serviceScope = host.Services.CreateScope();
-        var serviceProvider = serviceScope.ServiceProvider;
-        
-
-        var commands = serviceProvider
-            .GetRequiredService<InteractionService>();
-        var client = serviceProvider
-            .GetRequiredService<DiscordSocketClient>();
-
-        await serviceProvider
-            .GetRequiredService<InteractionHandler>()
-            .InitializeAsync();
-
-        
-        await client.LoginAsync(TokenType.Bot, Token);
-        await client.StartAsync();
-        
-        client.Log += Log;
-        client.Ready += async () =>
-        {
-            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
-        };
-        
-        await Task.Delay(-1);
-    }

   services
+      .AddHostedService<InteractionHandler>()
-      .AddSingleton<InteractionHandler>()
+      .AddHostedService<DiscordSocketClientHostedService>()

.............
// Move all that in DiscordSocketClientHostedService.StartAsync()
+ await client.LoginAsync(TokenType.Bot, Token);
+ await client.StartAsync();
+
+ client.Log += Log;
+ client.Ready += async () =>
+ {
+      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
+ };
..........

-    private async Task RunAsync(IHost host)
-    {
-        using var serviceScope = host.Services.CreateScope();
-        var serviceProvider = serviceScope.ServiceProvider;
-        
-
-        var commands = serviceProvider
-            .GetRequiredService<InteractionService>();
-        var client = serviceProvider
-            .GetRequiredService<DiscordSocketClient>();
-
-        await serviceProvider
-            .GetRequiredService<InteractionHandler>()
-            .InitializeAsync();
-
-        
-        await client.LoginAsync(TokenType.Bot, Token);
-        await client.StartAsync();
-        
-        client.Log += Log;
-        client.Ready += async () =>
-        {
-            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
-        };
-        
-        await Task.Delay(-1);
-    }

TTeBeCo ```diff services + .AddHostedService<InteractionHandler>() - .AddSi...

S

StilauOP•11/20/23, 9:07 PM

But idk if this solved my issue tho, having the bot be a websocket server aswell?

T

TeBeCo•11/20/23, 9:08 PM

i'm not sure i understand that sentence correclty, WDYM by

having the bot be a websocket server aswell?

is that a quesiton or a fact ?

T

TeBeCo•11/20/23, 9:08 PM

i was pointing out a way to seriosuly simplify your code

T

TeBeCo•11/20/23, 9:10 PM

same code:

try
{
  var client = new DiscordSocketClient();
            
  using var hostBuilder = Host
    .CreateDefaultBuilder()
    .ConfigureServices((_, services) =>
    {
      services.AddSingleton<DiscordSocketClientHostedService>();
      services.AddHostedService<InteractionHandlerHostedService>();
      services.AddTransient<ITestService, TestService>();

      services.AddGrpc();
      services.AddMagicOnion();
    });

  var host = hostBuilder.Build();
  await host.RunAsync();
}
catch (Exception ex)
{
  Console.WriteLine(ex);
}

public class DiscordSocketClientHostedService : BackgroundService
{
  private readonly DiscordSocketClient _discordSocketClient;

  public class DiscordSocketClientHostedService(DiscordSocketClient discordSocketClient) => _discordSocketClient = discordSocketClient;

  public override Task ExecureAsync(CancellationToken ct)
  {
    await _client.LoginAsync(TokenType.Bot, Token);

    client.Log += Log;
    client.Ready += async () =>
    {
      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
    };

    await _client.StartAsync();
  }
}

try
{
  var client = new DiscordSocketClient();
            
  using var hostBuilder = Host
    .CreateDefaultBuilder()
    .ConfigureServices((_, services) =>
    {
      services.AddSingleton<DiscordSocketClientHostedService>();
      services.AddHostedService<InteractionHandlerHostedService>();
      services.AddTransient<ITestService, TestService>();

      services.AddGrpc();
      services.AddMagicOnion();
    });

  var host = hostBuilder.Build();
  await host.RunAsync();
}
catch (Exception ex)
{
  Console.WriteLine(ex);
}

public class DiscordSocketClientHostedService : BackgroundService
{
  private readonly DiscordSocketClient _discordSocketClient;

  public class DiscordSocketClientHostedService(DiscordSocketClient discordSocketClient) => _discordSocketClient = discordSocketClient;

  public override Task ExecureAsync(CancellationToken ct)
  {
    await _client.LoginAsync(TokenType.Bot, Token);

    client.Log += Log;
    client.Ready += async () =>
    {
      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
    };

    await _client.StartAsync();
  }
}

try
{
  var client = new DiscordSocketClient();
            
  using var hostBuilder = Host
    .CreateDefaultBuilder()
    .ConfigureServices((_, services) =>
    {
      services.AddSingleton<DiscordSocketClientHostedService>();
      services.AddHostedService<InteractionHandlerHostedService>();
      services.AddTransient<ITestService, TestService>();

      services.AddGrpc();
      services.AddMagicOnion();
    });

  var host = hostBuilder.Build();
  await host.RunAsync();
}
catch (Exception ex)
{
  Console.WriteLine(ex);
}

public class DiscordSocketClientHostedService : BackgroundService
{
  private readonly DiscordSocketClient _discordSocketClient;

  public class DiscordSocketClientHostedService(DiscordSocketClient discordSocketClient) => _discordSocketClient = discordSocketClient;

  public override Task ExecureAsync(CancellationToken ct)
  {
    await _client.LoginAsync(TokenType.Bot, Token);

    client.Log += Log;
    client.Ready += async () =>
    {
      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
    };

    await _client.StartAsync();
  }
}

try
{
  var client = new DiscordSocketClient();
            
  using var hostBuilder = Host
    .CreateDefaultBuilder()
    .ConfigureServices((_, services) =>
    {
      services.AddSingleton<DiscordSocketClientHostedService>();
      services.AddHostedService<InteractionHandlerHostedService>();
      services.AddTransient<ITestService, TestService>();

      services.AddGrpc();
      services.AddMagicOnion();
    });

  var host = hostBuilder.Build();
  await host.RunAsync();
}
catch (Exception ex)
{
  Console.WriteLine(ex);
}

public class DiscordSocketClientHostedService : BackgroundService
{
  private readonly DiscordSocketClient _discordSocketClient;

  public class DiscordSocketClientHostedService(DiscordSocketClient discordSocketClient) => _discordSocketClient = discordSocketClient;

  public override Task ExecureAsync(CancellationToken ct)
  {
    await _client.LoginAsync(TokenType.Bot, Token);

    client.Log += Log;
    client.Ready += async () =>
    {
      await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
    };

    await _client.StartAsync();
  }
}

T

TeBeCo•11/20/23, 9:14 PM

pretty sure Discord.Net has a HostedService existing

S

StilauOP•11/20/23, 9:15 PM

I really appreciate the tips on how to simplify the code, don't get me wrong.

My original question was how I could implement MagicOnion, a websocket library into the bot.

I wanted the bot to act like a websocket server for other clients to connect into if that makes sense.

T

TeBeCo•11/20/23, 9:16 PM

with the same decoupling at startup of the above in fact

T

TeBeCo•11/20/23, 9:16 PM

splitting it into dedicated code (avoiding the mixup Main/Program)

T

TeBeCo•11/20/23, 9:16 PM

should work given what i'm reading from their page

S

StilauOP•11/20/23, 9:17 PM

Ahhh okay, I'll give it a try.
So just try running most of it from the Main method?

T

TeBeCo•11/20/23, 9:18 PM

T

TeBeCo•11/20/23, 9:18 PM

that's their readme

TTeBeCo Click to see attachment

S

StilauOP•11/20/23, 9:35 PM

So like this instead?

public class Program
{
    public static Task Main()
        => new Program().MainAsync();

    private async Task MainAsync()
    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {

                        services.AddSingleton(client);
                        services.AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()));
                        services.AddHostedService<DiscordSocketClientHostedService>();
                        services.AddTransient<ITestService, TestService>();
                        services.AddSingleton<InteractionHandler>();
                        services.AddMagicOnion();
                        services.AddGrpc();
                    }
                ).Build();

            await host.Services
                .GetRequiredService<InteractionHandler>()
                .InitializeAsync();
            
            await host.RunAsync();
            await Task.Delay(-1);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}

public class DiscordSocketClientHostedService : BackgroundService
{
    private readonly DiscordSocketClient _client;
    private readonly IServiceProvider _serviceProvider;
    
    private const ulong DiscordGuildId = 0;
    private const string Token = "NotGonnaGetTHECHANCE";
    
    public DiscordSocketClientHostedService(
        DiscordSocketClient client, 
        IServiceProvider serviceProvider
    )
    {
        _client = client;
        _serviceProvider = serviceProvider;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var commands = _serviceProvider
            .GetRequiredService<InteractionService>();
        
        await _client.LoginAsync(TokenType.Bot, Token);
        await _client.StartAsync();
        
        _client.Log += Log;
        _client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };
    }
    
    private Task Log(LogMessage log)
    {
        Console.WriteLine(log.Message);
        return Task.CompletedTask;
    }
}

public class Program
{
    public static Task Main()
        => new Program().MainAsync();

    private async Task MainAsync()
    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {

                        services.AddSingleton(client);
                        services.AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()));
                        services.AddHostedService<DiscordSocketClientHostedService>();
                        services.AddTransient<ITestService, TestService>();
                        services.AddSingleton<InteractionHandler>();
                        services.AddMagicOnion();
                        services.AddGrpc();
                    }
                ).Build();

            await host.Services
                .GetRequiredService<InteractionHandler>()
                .InitializeAsync();
            
            await host.RunAsync();
            await Task.Delay(-1);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}

public class DiscordSocketClientHostedService : BackgroundService
{
    private readonly DiscordSocketClient _client;
    private readonly IServiceProvider _serviceProvider;
    
    private const ulong DiscordGuildId = 0;
    private const string Token = "NotGonnaGetTHECHANCE";
    
    public DiscordSocketClientHostedService(
        DiscordSocketClient client, 
        IServiceProvider serviceProvider
    )
    {
        _client = client;
        _serviceProvider = serviceProvider;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var commands = _serviceProvider
            .GetRequiredService<InteractionService>();
        
        await _client.LoginAsync(TokenType.Bot, Token);
        await _client.StartAsync();
        
        _client.Log += Log;
        _client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };
    }
    
    private Task Log(LogMessage log)
    {
        Console.WriteLine(log.Message);
        return Task.CompletedTask;
    }
}

public class Program
{
    public static Task Main()
        => new Program().MainAsync();

    private async Task MainAsync()
    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {

                        services.AddSingleton(client);
                        services.AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()));
                        services.AddHostedService<DiscordSocketClientHostedService>();
                        services.AddTransient<ITestService, TestService>();
                        services.AddSingleton<InteractionHandler>();
                        services.AddMagicOnion();
                        services.AddGrpc();
                    }
                ).Build();

            await host.Services
                .GetRequiredService<InteractionHandler>()
                .InitializeAsync();
            
            await host.RunAsync();
            await Task.Delay(-1);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}

public class DiscordSocketClientHostedService : BackgroundService
{
    private readonly DiscordSocketClient _client;
    private readonly IServiceProvider _serviceProvider;
    
    private const ulong DiscordGuildId = 0;
    private const string Token = "NotGonnaGetTHECHANCE";
    
    public DiscordSocketClientHostedService(
        DiscordSocketClient client, 
        IServiceProvider serviceProvider
    )
    {
        _client = client;
        _serviceProvider = serviceProvider;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var commands = _serviceProvider
            .GetRequiredService<InteractionService>();
        
        await _client.LoginAsync(TokenType.Bot, Token);
        await _client.StartAsync();
        
        _client.Log += Log;
        _client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };
    }
    
    private Task Log(LogMessage log)
    {
        Console.WriteLine(log.Message);
        return Task.CompletedTask;
    }
}

public class Program
{
    public static Task Main()
        => new Program().MainAsync();

    private async Task MainAsync()
    {
        try
        {
            var client = new DiscordSocketClient();
            
            using var host = Host.CreateDefaultBuilder()
                .ConfigureServices((_, services) =>
                    {

                        services.AddSingleton(client);
                        services.AddSingleton(i => new InteractionService(i.GetRequiredService<DiscordSocketClient>()));
                        services.AddHostedService<DiscordSocketClientHostedService>();
                        services.AddTransient<ITestService, TestService>();
                        services.AddSingleton<InteractionHandler>();
                        services.AddMagicOnion();
                        services.AddGrpc();
                    }
                ).Build();

            await host.Services
                .GetRequiredService<InteractionHandler>()
                .InitializeAsync();
            
            await host.RunAsync();
            await Task.Delay(-1);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}

public class DiscordSocketClientHostedService : BackgroundService
{
    private readonly DiscordSocketClient _client;
    private readonly IServiceProvider _serviceProvider;
    
    private const ulong DiscordGuildId = 0;
    private const string Token = "NotGonnaGetTHECHANCE";
    
    public DiscordSocketClientHostedService(
        DiscordSocketClient client, 
        IServiceProvider serviceProvider
    )
    {
        _client = client;
        _serviceProvider = serviceProvider;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var commands = _serviceProvider
            .GetRequiredService<InteractionService>();
        
        await _client.LoginAsync(TokenType.Bot, Token);
        await _client.StartAsync();
        
        _client.Log += Log;
        _client.Ready += async () =>
        {
            await commands.RegisterCommandsToGuildAsync(DiscordGuildId);
        };
    }
    
    private Task Log(LogMessage log)
    {
        Console.WriteLine(log.Message);
        return Task.CompletedTask;
    }
}

S

StilauOP•11/22/23, 9:58 AM

Hey!
I still need some help with this.

I've done some changes, but I can still not get it to work.
This is my current code: https://pastecord.com/olofinitob

All help is deeply appreciated.
My goal is to send data from and to a game server, but I want the websocket server to be on the discord bot.

So I don't need to do:

Game Server -> Magic Onion Server -> Discord Bot
Wise Versa

How can I do so?
It looks like Magic Onion is mostly made for Asp.Net apps, but this is a console app trollq

T

TeBeCo•11/22/23, 11:58 AM

i'd start with ... do not use a console app

T

TeBeCo•11/22/23, 11:58 AM

make it either an aspnetcore app

T

TeBeCo•11/22/23, 11:58 AM

or a worker

T

TeBeCo•11/22/23, 11:58 AM

a worker is the same host base as aspnetcore without the webserver

T

TeBeCo•11/22/23, 11:59 AM

so 99% of what is built for aspnetcore would work

T

TeBeCo•11/22/23, 11:59 AM

that's part of the change i suggested in fact

T

TeBeCo•11/22/23, 11:59 AM

dotnet new worker -n NameGoesHere

dotnet new worker -n NameGoesHere

dotnet new worker -n NameGoesHere

dotnet new worker -n NameGoesHere

T

TeBeCo•11/22/23, 11:59 AM

side point

T

TeBeCo•11/22/23, 11:59 AM

making it a webapi / aspnetcore will allow you to have an access to your how bot remotely / telemetry / liveness etc ...

TTeBeCo making it a webapi / aspnetcore will allow you to have an access to your how bot...

S

StilauOP•11/22/23, 12:13 PM

Am I able to run the bot on a ASP app?

T

TeBeCo•11/22/23, 12:22 PM

yes

T

TeBeCo•11/22/23, 12:22 PM

aspnetcore is a glorified worker + web server

T

TeBeCo•11/22/23, 12:22 PM

worker is a glorified console app with a lot of goodies

T

TeBeCo•11/22/23, 12:23 PM

you maybe don't know it but your code basically reinvented the wheel

T

TeBeCo•11/22/23, 12:23 PM

you sort of re invented "worker"

T

TeBeCo•11/22/23, 12:23 PM

(this template is not know a lot so no surprise there)

S

StilauOP•11/22/23, 12:24 PM

I've worked with like ASP api's, etc before.
But never something like this lmao

T

TeBeCo•11/22/23, 12:24 PM

but the most important part is that you probably don't know what are

IHostedService/BackgroundService

IHostedService/BackgroundService

IHostedService/BackgroundService

IHostedService/BackgroundService

T

TeBeCo•11/22/23, 12:24 PM

which are code that is being used to start stuff at startup when eventhing starts with proper auto DI

T

TeBeCo•11/22/23, 12:25 PM

or long run in the background

S

StilauOP•11/22/23, 12:25 PM

aahh

T

TeBeCo•11/22/23, 12:25 PM

which is what your code was trying to do manually

S

StilauOP•11/22/23, 12:25 PM

So I was basically trying to make an ASP app in a console app

S

StilauOP•11/22/23, 12:25 PM

ish

T

TeBeCo•11/22/23, 12:25 PM

S

StilauOP•11/22/23, 12:25 PM

without the web server part

Discord.Net + MagicOnion, heheh

Similar Threads

Similar Threads

Similar Threads