[RFC] changed events to take func so the end user can make usage of T…

…ask in the Events, Released Version 1.2.0

Lavalink.NET/Client/Client.cs

@@ -10,6 +10,7 @@
 using Lavalink.NET.Websocket;
 using System.Threading;
 using Lavalink.NET.Player;
+using System.Net.WebSockets;
 
 namespace Lavalink.NET
 {
@@ -57,32 +58,32 @@ public abstract class Client
 		/// <summary>
 		/// Event that gets triggerd when a Message from Lavalink is received.
 		/// </summary>
-		public event MessageEvent Message;
+		public event Func<dynamic, Task> Message;
 
 		/// <summary>
 		/// Event that gets triggerd when this Client is ready to use.
 		/// </summary>
-		public event EventHandler Ready;
+		public event Func<Task> Ready;
 
 		/// <summary>
 		/// Event that gets triggerd when this Client Websocket Connection Disconnects.
 		/// </summary>
-		public event CloseEvent Disconnect;
+		public event Func<WebSocketCloseStatus, string, Task> Disconnect;
 
 		/// <summary>
 		/// Event that gets triggerd when this Client encounters an Error.
 		/// </summary>
-		public event ErrorEvent Error;
+		public event Func<Exception, Task> Error;
 
 		/// <summary>
 		/// Event what emits debug messages.
 		/// </summary>
-		public event DebugEvent Debug;
+		public event Func<string, Task> Debug;
 
 		/// <summary>
 		/// Event that gets triggerd when a Stats Message from Lavalink is received.
 		/// </summary>
-		public event StatsEvent Stats;
+		public event Func<Stats, Task> Stats;
 
 		/// <summary>
 		/// The Store of all Players from this Client.
@@ -261,55 +262,73 @@ private async Task<bool> ConnectVoiceAsync(ulong guildID)
 			return await Task.FromResult(true);
 		}
 
-		private void WebsocketMessage(object sender, MessageEventArgs e)
+		private Task WebsocketMessage(string message)
 		{
-			dynamic lavalinkEvent = JObject.Parse(e.Message);
+			dynamic lavalinkEvent = JObject.Parse(message);
 
-			Debug(this, new DebugEventArgs($"Received Websocket message from Lavalink with OP \"{lavalinkEvent.op}\""));
+			Debug($"Received Websocket message from Lavalink with OP \"{lavalinkEvent.op}\"");
 
-			Message?.Invoke(this, new MessageEventArgs(lavalinkEvent));
+			Message?.Invoke(lavalinkEvent);
 
 			if (lavalinkEvent.op == "event")
 			{
 				if (lavalinkEvent.guildId != null)
 				{
-					Debug(this, new DebugEventArgs($"Received Player Event with GuildID {lavalinkEvent.guildId}, emit event on player."));
+					Debug($"Received Player Event with GuildID {lavalinkEvent.guildId}, emit event on player.");
 					Player.Player player = Players.GetPlayer(Convert.ToUInt64(lavalinkEvent.guildId));
 					player.EmitEvent(lavalinkEvent);
 				} else {
-					Debug(this, new DebugEventArgs($"Received Lavalink event with \"event\" op but no guild id\n{lavalinkEvent}"));
+					Debug($"Received Lavalink event with \"event\" op but no guild id\n{lavalinkEvent}");
 				}
 			} else if (lavalinkEvent.op == "stats")
 			{
-				Stats?.Invoke(this, JsonConvert.DeserializeObject<StatsEventArgs>(e.Message));
+				Stats?.Invoke(JsonConvert.DeserializeObject<Stats>(message));
 			} else if (lavalinkEvent.op == "playerUpdate")
 			{
 				Player.Player player = Players.GetPlayer(Convert.ToUInt64(lavalinkEvent.guildId));
 				player.Position = Convert.ToUInt64(lavalinkEvent.state.position);
 			}
+
+			return Task.CompletedTask;
 		}
 
-		private void ErrorHandler(object sender, Types.ErrorEventArgs args)
+		private Task ErrorHandler(Exception error)
 		{
-			var message = $"Encountered following exeption while executing events {args.Error.Message}";
+			var message = $"Encountered following exeption while executing events {error.Message}";
 			EmitLogs(LogLevel.Error, message);
-			Error?.Invoke(this, args);
+			Error?.Invoke(error);
+
+			return Task.CompletedTask;
+		}
+
+		private Task DebugHandler(string message)
+		{
+			EmitLogs(LogLevel.Debug, message);
+
+			return Task.CompletedTask;
 		}
 
-		private void DebugHandler(object sender, DebugEventArgs args) 
-			=> EmitLogs(LogLevel.Debug, args.Message);
+		private Task ReadyHandler()
+		{
+			EmitLogs(LogLevel.Info, "LavalinkClient succesfully initialized");
 
-		private void ReadyHandler(object sender, EventArgs args)
-			=> EmitLogs(LogLevel.Info, "LavalinkClient succesfully initialized");
+			return Task.CompletedTask;
+		}
 
-		private void ConnectionFailedHandler(object sender, ConnectionFailedArgs args)
+		private Task ConnectionFailedHandler(Exception error)
 		{
-			var message = $"Connection refused with following message \"{args.Exception.Message}\".";
+			var message = $"Connection refused with following message \"{error.Message}\".";
 			EmitLogs(LogLevel.Error, message);
-			Error?.Invoke(this, new Types.ErrorEventArgs(new Exception(message)));
+			Error?.Invoke(new Exception(message));
+
+			return Task.CompletedTask;
 		}
 
-		private void DisconnectHandler(object sender, CloseEventArgs args) 
-			=> EmitLogs(LogLevel.Error, $"Websocket Connection Closed with following reason \"{args.Reason}\" and StatusCode \"{args.Status}\"");
+		private Task DisconnectHandler(WebSocketCloseStatus closeStatus, string closeReason)
+		{
+			EmitLogs(LogLevel.Error, $"Websocket Connection Closed with following reason \"{closeReason}\" and StatusCode \"{closeStatus}\"");
+
+			return Task.CompletedTask;
+		}
 	}
 }

Lavalink.NET/Lavalink.NET.csproj

@@ -33,7 +33,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
     <PackageTags>Lavalink</PackageTags>
     <Description>A C# Library to interact with Lavalink</Description>
     <PackageId>Lavalink.NET</PackageId>
-    <Version>1.1.0</Version>
+    <Version>1.2.0</Version>
     <FileVersion>1.0.0</FileVersion>
     <AssemblyVersion>1.0.0</AssemblyVersion>
   </PropertyGroup>

Lavalink.NET/Library/Libraryinfo.cs

@@ -9,6 +9,6 @@ abstract class Libraryinfo
 		/// <summary>
 		/// The Version of this Library
 		/// </summary>
-		static public string Version = "1.1.0";
+		static public string Version = "1.2.0";
     }
 }

Lavalink.NET/Player/Player.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using Lavalink.NET.Types;
 using Newtonsoft.Json;
 
@@ -12,17 +13,17 @@ public class Player
 		/// <summary>
 		/// Event to call on Track Ending.
 		/// </summary>
-		public event TrackEndEvent End;
+		public event Func<TrackEndEvent, Task> End;
 
 		/// <summary>
 		/// Event to call on Track Exeption.
 		/// </summary>
-		public event TrackExceptionEvent Exeption;
+		public event Func<TrackExceptionEvent, Task> Exeption;
 
 		/// <summary>
 		/// Event to call on Track Stuck.
 		/// </summary>
-		public event TrackStuckEvent Stuck;
+		public event Func<TrackStuckEvent, Task> Stuck;
 
 		/// <summary>
 		/// The GuildID of this player.
@@ -226,30 +227,36 @@ internal void EmitEvent(dynamic lavalinkEvent)
 			switch (lavalinkEvent.type)
 			{
 				case "TrackEndEvent":
-					End(this, JsonConvert.DeserializeObject<TrackEndEventArgs>(lavalinkEvent));
+					End(JsonConvert.DeserializeObject<TrackEndEvent>(lavalinkEvent));
 					break;
 				case "TrackExeptionEvent":
-					Exeption(this, JsonConvert.DeserializeObject<TrackExceptionEventArgs>(lavalinkEvent));
+					Exeption(JsonConvert.DeserializeObject<TrackExceptionEvent>(lavalinkEvent));
 					break;
 				case "TrackStuckEvent":
-					Stuck(this, JsonConvert.DeserializeObject<TrackStuckEventArgs>(lavalinkEvent));
+					Stuck(JsonConvert.DeserializeObject<TrackStuckEvent>(lavalinkEvent));
 					break;
 			}
 		}
 
-		private void PlayerEndEvent(object sender, TrackEndEventArgs e)
+		private Task PlayerEndEvent(TrackEndEvent e)
 		{
 			Status = Status.ENDED;
+
+			return Task.CompletedTask;
 		}
 
-		private void PlayerExeptionEvent(object sender, TrackExceptionEventArgs e)
+		private Task PlayerExeptionEvent(TrackExceptionEvent e)
 		{
 			Status = Status.ERRORED;
+
+			return Task.CompletedTask;
 		}
 
-		private void PlayerStuckEvent(object sender, TrackStuckEventArgs e)
+		private Task PlayerStuckEvent(TrackStuckEvent e)
 		{
 			Status = Status.STUCK;
+
+			return Task.CompletedTask;
 		}
     }
 }