Removed the monolithic web session class.

babelshift · babelshift · commit a9fe274c2dae · 2015-11-22T12:07:27.000-05:00
Instead, callers are required to construct whatever steam web interface they want to use through the steam web factory.
Refactored some interface/method classes to reduce repetition.
Removed the "\\" replacement in JSON response since some players can have quotes in their names and this escape is needed to parse the JSON properly. Still don't know how to handle some of the API methods returning invalid JSON with wrong "\\" escapes.
diff --git a/SteamWebAPI2/CSGOServers.cs b/SteamWebAPI2/CSGOServers.cs
@@ -8,14 +8,14 @@
 
 namespace SteamWebAPI2
 {
-    internal class CSGOServers : SteamWebRequest
+    public class CSGOServers : SteamWebInterface
     {
-        public CSGOServers(SteamWebRequestParameter developerKey)
-            : base(developerKey, "ICSGOServers_730") { }
+        public CSGOServers(string steamWebApiKey)
+            : base(steamWebApiKey, "ICSGOServers_730") { }
 
         public async Task<ServerStatusResult> GetGameServerStatusAsync()
         {
-            var gameServerStatus = await GetJsonAsync<ServerStatusResultContainer>(interfaceName, "GetGameServersStatus", 1);
+            var gameServerStatus = await CallMethodAsync<ServerStatusResultContainer>("GetGameServersStatus", 1);
             return gameServerStatus.Result;
         }
     }
diff --git a/SteamWebAPI2/DOTA2Fantasy.cs b/SteamWebAPI2/DOTA2Fantasy.cs
@@ -8,23 +8,23 @@
 
 namespace SteamWebAPI2
 {
-    internal class DOTA2Fantasy : SteamWebRequest
+    public class DOTA2Fantasy : SteamWebInterface
     {
-        public DOTA2Fantasy(SteamWebRequestParameter developerKey)
-            : base(developerKey, "IDOTA2Fantasy_570") { }
+        public DOTA2Fantasy(string steamWebApiKey)
+            : base(steamWebApiKey, "IDOTA2Fantasy_570") { }
 
         public async Task<PlayerOfficialInfoResult> GetPlayerOfficialInfo(long steamId)
         {
             List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
             parameters.Add(new SteamWebRequestParameter("accountid", steamId.ToString()));
 
-            var gameServerStatus = await GetJsonAsync<PlayerOfficialInfoResultContainer>(interfaceName, "GetPlayerOfficialInfo", 1, parameters);
+            var gameServerStatus = await CallMethodAsync<PlayerOfficialInfoResultContainer>("GetPlayerOfficialInfo", 1, parameters);
             return gameServerStatus.Result;
         }
 
         public async Task<ProPlayerListResult> GetProPlayerList()
         {
-            var proPlayerList = await GetJsonAsync<ProPlayerListResultContainer>(interfaceName, "GetProPlayerList", 1);
+            var proPlayerList = await CallMethodAsync<ProPlayerListResultContainer>("GetProPlayerList", 1);
             return proPlayerList.Results;
         }
     }
diff --git a/SteamWebAPI2/DOTA2Match.cs b/SteamWebAPI2/DOTA2Match.cs
@@ -5,35 +5,48 @@
 
 namespace SteamWebAPI2
 {
-    internal class DOTA2Match : SteamWebRequest
+    public class DOTA2Match : SteamWebInterface
     {
-        public DOTA2Match(SteamWebRequestParameter developerKey)
-            : base(developerKey, "IDOTA2Match_570")
-        { }
+        public DOTA2Match(string steamWebApiKey)
+            : base(steamWebApiKey, "IDOTA2Match_570")
+        {
+        }
 
         public async Task<LeagueResult> GetLeagueListing()
         {
-            var leagueListing = await GetJsonAsync<LeagueResultContainer>(interfaceName, "GetLeagueListing", 1);
+            var leagueListing = await CallMethodAsync<LeagueResultContainer>("GetLeagueListing", 1);
             return leagueListing.Result;
         }
 
-        public async Task<IReadOnlyCollection<LiveLeagueGame>> GetLiveLeagueGames()
+        public async Task<IReadOnlyCollection<LiveLeagueGame>> GetLiveLeagueGames(int? leagueId = null, long? matchId = null)
         {
-            var liveLeagueGames = await GetJsonAsync<LiveLeagueGameResultContainer>(interfaceName, "GetLiveLeagueGames", 1);
+            List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
+
+            if(leagueId.HasValue)
+            {
+                parameters.Add(new SteamWebRequestParameter("league_id", leagueId.Value.ToString()));
+            }
+
+            if (matchId.HasValue)
+            {
+                parameters.Add(new SteamWebRequestParameter("match_id", matchId.Value.ToString()));
+            }
+
+            var liveLeagueGames = await CallMethodAsync<LiveLeagueGameResultContainer>("GetLiveLeagueGames", 1, parameters);
             return new ReadOnlyCollection<LiveLeagueGame>(liveLeagueGames.Result.Games);
         }
 
         public async Task<MatchDetailResult> GetMatchDetails(int matchId)
         {
             List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
             parameters.Add(new SteamWebRequestParameter("match_id", matchId.ToString()));
-            var matchDetail = await GetJsonAsync<MatchDetailResultContainer>(interfaceName, "GetMatchDetails", 1, parameters);
+            var matchDetail = await CallMethodAsync<MatchDetailResultContainer>("GetMatchDetails", 1, parameters);
             return matchDetail.Result;
         }
 
         public async Task<MatchHistoryResult> GetMatchHistory()
         {
-            var matchHistory = await GetJsonAsync<MatchHistoryResultContainer>(interfaceName, "GetMatchHistory", 1);
+            var matchHistory = await CallMethodAsync<MatchHistoryResultContainer>("GetMatchHistory", 1);
             return matchHistory.Result;
         }
     }
diff --git a/SteamWebAPI2/SteamUser.cs b/SteamWebAPI2/SteamUser.cs
@@ -7,16 +7,16 @@
 
 namespace SteamWebAPI2
 {
-    internal class SteamUser : SteamWebRequest
+    public class SteamUser : SteamWebInterface
     {
-        public SteamUser(SteamWebRequestParameter developerKey)
-            : base(developerKey, "ISteamUser") { }
+        public SteamUser(string steamWebApiKey)
+            : base(steamWebApiKey, "ISteamUser") { }
 
         public async Task<PlayerSummary> GetPlayerSummaryAsync(string steamId)
         {
             List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();
             parameters.Add(new SteamWebRequestParameter("steamids", steamId));
-            var playerSummary = await GetJsonAsync<PlayerSummaryResponseContainer>(interfaceName, "GetPlayerSummaries", 2, parameters);
+            var playerSummary = await CallMethodAsync<PlayerSummaryResponseContainer>("GetPlayerSummaries", 2, parameters);
 
             if (playerSummary.Response.Players.Count > 0)
             {
diff --git a/SteamWebAPI2/SteamWebAPI2.csproj b/SteamWebAPI2/SteamWebAPI2.csproj
@@ -56,7 +56,8 @@
     <Compile Include="SteamUser.cs" />
     <Compile Include="SteamWebAPIUtil.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SteamWebSession.cs" />
+    <Compile Include="SteamWebFactory.cs" />
+    <Compile Include="SteamWebInterface.cs" />
     <Compile Include="SteamWebRequest.cs" />
     <Compile Include="SteamWebRequestParameter.cs" />
   </ItemGroup>
diff --git a/SteamWebAPI2/SteamWebAPIUtil.cs b/SteamWebAPI2/SteamWebAPIUtil.cs
@@ -8,20 +8,20 @@
 
 namespace SteamWebAPI2
 {
-    internal class SteamWebAPIUtil : SteamWebRequest
+    public class SteamWebAPIUtil : SteamWebInterface
     {
-        public SteamWebAPIUtil(SteamWebRequestParameter developerKey) 
-            : base(developerKey, "ISteamWebAPIUtil") { }
+        public SteamWebAPIUtil(string steamWebApiKey) 
+            : base(steamWebApiKey, "ISteamWebAPIUtil") { }
 
         public async Task<SteamServerInfo> GetServerInfoAsync()
         {
-            var steamServerInfo = await GetJsonAsync<SteamServerInfo>(interfaceName, "GetServerInfo", 1);
+            var steamServerInfo = await CallMethodAsync<SteamServerInfo>("GetServerInfo", 1);
             return steamServerInfo;
         }
 
         public async Task<IReadOnlyCollection<SteamInterface>> GetSupportedAPIListAsync()
         {
-            var steamApiListContainer = await GetJsonAsync<SteamApiListContainer>(interfaceName, "GetSupportedAPIList", 1);
+            var steamApiListContainer = await CallMethodAsync<SteamApiListContainer>("GetSupportedAPIList", 1);
             return new ReadOnlyCollection<SteamInterface>(steamApiListContainer.ApiList.Interfaces);
         }
     }
diff --git a/SteamWebAPI2/SteamWebFactory.cs b/SteamWebAPI2/SteamWebFactory.cs
@@ -0,0 +1,33 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SteamWebAPI2
+{
+    public class SteamWebFactory
+    {
+        private string steamWebApiKey;
+
+        public SteamWebFactory(string steamWebApiKey)
+        {
+            if (String.IsNullOrEmpty(steamWebApiKey))
+            {
+                throw new ArgumentNullException("steamWebApiKey");
+            }
+
+            this.steamWebApiKey = steamWebApiKey;
+        }
+
+        public T Create<T>() where T : class
+        {
+            if(String.IsNullOrEmpty(steamWebApiKey))
+            {
+                throw new InvalidOperationException("Steam Web API key is invalid or missing. Did you initialize it?");
+            }
+
+            return Activator.CreateInstance(typeof(T), steamWebApiKey) as T;
+        }
+    }
+}
diff --git a/SteamWebAPI2/SteamWebInterface.cs b/SteamWebAPI2/SteamWebInterface.cs
@@ -0,0 +1,31 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SteamWebAPI2
+{
+    public class SteamWebInterface
+    {
+        private readonly SteamWebRequest steamWebRequest;
+        private readonly string interfaceName;
+
+        public SteamWebInterface(string steamWebApiKey, string interfaceName)
+        {
+            Debug.Assert(!String.IsNullOrEmpty(interfaceName));
+
+            this.interfaceName = interfaceName;
+            this.steamWebRequest = new SteamWebRequest(steamWebApiKey);
+        }
+
+        internal async Task<T> CallMethodAsync<T>(string methodName, int version, IList<SteamWebRequestParameter> parameters = null)
+        {
+            Debug.Assert(!String.IsNullOrEmpty(methodName));
+            Debug.Assert(version > 0);
+
+            return await steamWebRequest.GetJsonAsync<T>(interfaceName, methodName, version, parameters);
+        }
+    }
+}
diff --git a/SteamWebAPI2/SteamWebRequest.cs b/SteamWebAPI2/SteamWebRequest.cs
@@ -11,32 +11,21 @@
 
 namespace SteamWebAPI2
 {
-    internal abstract class SteamWebRequest
+    internal class SteamWebRequest
     {
-        protected readonly string interfaceName;
-        private SteamWebRequestParameter developerKey;
+        private string steamWebApiKey;
 
-        public SteamWebRequest(SteamWebRequestParameter developerKey, string interfaceName)
+        public SteamWebRequest(string steamWebApiKey)
         {
-            // we assert here because SteamWebRequest is never constructed by the application, instead it is constructed by SteamWebSession (controlled by this library)
-            Debug.Assert(developerKey != null);
-
-            // we assert here because the name is never determined by the caller and should never be null or empty
-            Debug.Assert(!String.IsNullOrEmpty(developerKey.Name));
-
-            if (String.IsNullOrEmpty(developerKey.Value))
+            if(String.IsNullOrEmpty(steamWebApiKey))
             {
-                throw new ArgumentNullException("Steam Web API developer key value cannot be null or empty.");
+                throw new ArgumentNullException("steamWebApiKey");
             }
 
-            this.developerKey = developerKey;
-
-            Debug.Assert(!String.IsNullOrEmpty(interfaceName));
-
-            this.interfaceName = interfaceName;
+            this.steamWebApiKey = steamWebApiKey;
         }
 
-        protected async Task<T> GetJsonAsync<T>(string interfaceName, string methodName, int methodVersion)
+        public async Task<T> GetJsonAsync<T>(string interfaceName, string methodName, int methodVersion)
         {
             Debug.Assert(!String.IsNullOrEmpty(interfaceName));
             Debug.Assert(!String.IsNullOrEmpty(methodName));
@@ -45,7 +34,7 @@ protected async Task<T> GetJsonAsync<T>(string interfaceName, string methodName,
             return await GetJsonAsync<T>(interfaceName, methodName, methodVersion, null);
         }
 
-        protected async Task<T> GetJsonAsync<T>(string interfaceName, string methodName, int methodVersion, IList<SteamWebRequestParameter> parameters)
+        public async Task<T> GetJsonAsync<T>(string interfaceName, string methodName, int methodVersion, IList<SteamWebRequestParameter> parameters)
         {
             Debug.Assert(!String.IsNullOrEmpty(interfaceName));
             Debug.Assert(!String.IsNullOrEmpty(methodName));
@@ -56,18 +45,20 @@ protected async Task<T> GetJsonAsync<T>(string interfaceName, string methodName,
                 parameters = new List<SteamWebRequestParameter>();
             }
 
-            parameters.Insert(0, developerKey);
+            parameters.Insert(0, new SteamWebRequestParameter("key", steamWebApiKey));
 
             string command = BuildRequestCommand(interfaceName, methodName, methodVersion, parameters);
 
             HttpClient httpClient = new HttpClient();
             string response = await httpClient.GetStringAsync(command);
+            //byte[] responseBytes = Encoding.Default.GetBytes(response);
+            //string utf8response = Encoding.UTF8.GetString(responseBytes);
 
             // some of the responses contain invalid json so we have to correct for it here
             // this is probably not the best way to do this since we have to iterate and copy over the entire string, but it works for now
             response = response.Replace("\n", "");
             response = response.Replace("\t", "");
-            response = response.Replace("\\", "");
+            //response = response.Replace("\\", "");
             response = response.Replace("\"{", "{");
             response = response.Replace("\"}", "}");
 
@@ -84,7 +75,7 @@ protected async Task<T> GetJsonAsync<T>(string interfaceName, string methodName,
         /// <param name="methodVersion">Example: 1</param>
         /// <param name="parameters">Example: { key: 8A05823474AB641D684EBD95AB5F2E47 } </param>
         /// <returns></returns>
-        private string BuildRequestCommand(string interfaceName, string methodName, int methodVersion, IList<SteamWebRequestParameter> parameters)
+        public string BuildRequestCommand(string interfaceName, string methodName, int methodVersion, IList<SteamWebRequestParameter> parameters)
         {
             Debug.Assert(!String.IsNullOrEmpty(interfaceName));
             Debug.Assert(!String.IsNullOrEmpty(methodName));
diff --git a/SteamWebAPI2/SteamWebSession.cs b/SteamWebAPI2/SteamWebSession.cs

Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,14 @@`
`8`	`8`
`9`	`9`	`namespace SteamWebAPI2`
`10`	`10`	`{`
`11`		`- internal class CSGOServers : SteamWebRequest`
	`11`	`+ public class CSGOServers : SteamWebInterface`
`12`	`12`	`{`
`13`		`- public CSGOServers(SteamWebRequestParameter developerKey)`
`14`		`- : base(developerKey, "ICSGOServers_730") { }`
	`13`	`+ public CSGOServers(string steamWebApiKey)`
	`14`	`+ : base(steamWebApiKey, "ICSGOServers_730") { }`
`15`	`15`
`16`	`16`	`public async Task<ServerStatusResult> GetGameServerStatusAsync()`
`17`	`17`	`{`
`18`		`- var gameServerStatus = await GetJsonAsync<ServerStatusResultContainer>(interfaceName, "GetGameServersStatus", 1);`
	`18`	`+ var gameServerStatus = await CallMethodAsync<ServerStatusResultContainer>("GetGameServersStatus", 1);`
`19`	`19`	`return gameServerStatus.Result;`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,23 +8,23 @@`
`8`	`8`
`9`	`9`	`namespace SteamWebAPI2`
`10`	`10`	`{`
`11`		`- internal class DOTA2Fantasy : SteamWebRequest`
	`11`	`+ public class DOTA2Fantasy : SteamWebInterface`
`12`	`12`	`{`
`13`		`- public DOTA2Fantasy(SteamWebRequestParameter developerKey)`
`14`		`- : base(developerKey, "IDOTA2Fantasy_570") { }`
	`13`	`+ public DOTA2Fantasy(string steamWebApiKey)`
	`14`	`+ : base(steamWebApiKey, "IDOTA2Fantasy_570") { }`
`15`	`15`
`16`	`16`	`public async Task<PlayerOfficialInfoResult> GetPlayerOfficialInfo(long steamId)`
`17`	`17`	`{`
`18`	`18`	`List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();`
`19`	`19`	`parameters.Add(new SteamWebRequestParameter("accountid", steamId.ToString()));`
`20`	`20`
`21`		`- var gameServerStatus = await GetJsonAsync<PlayerOfficialInfoResultContainer>(interfaceName, "GetPlayerOfficialInfo", 1, parameters);`
	`21`	`+ var gameServerStatus = await CallMethodAsync<PlayerOfficialInfoResultContainer>("GetPlayerOfficialInfo", 1, parameters);`
`22`	`22`	`return gameServerStatus.Result;`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public async Task<ProPlayerListResult> GetProPlayerList()`
`26`	`26`	`{`
`27`		`- var proPlayerList = await GetJsonAsync<ProPlayerListResultContainer>(interfaceName, "GetProPlayerList", 1);`
	`27`	`+ var proPlayerList = await CallMethodAsync<ProPlayerListResultContainer>("GetProPlayerList", 1);`
`28`	`28`	`return proPlayerList.Results;`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,35 +5,48 @@`
`5`	`5`
`6`	`6`	`namespace SteamWebAPI2`
`7`	`7`	`{`
`8`		`- internal class DOTA2Match : SteamWebRequest`
	`8`	`+ public class DOTA2Match : SteamWebInterface`
`9`	`9`	`{`
`10`		`- public DOTA2Match(SteamWebRequestParameter developerKey)`
`11`		`- : base(developerKey, "IDOTA2Match_570")`
`12`		`- { }`
	`10`	`+ public DOTA2Match(string steamWebApiKey)`
	`11`	`+ : base(steamWebApiKey, "IDOTA2Match_570")`
	`12`	`+ {`
	`13`	`+ }`
`13`	`14`
`14`	`15`	`public async Task<LeagueResult> GetLeagueListing()`
`15`	`16`	`{`
`16`		`- var leagueListing = await GetJsonAsync<LeagueResultContainer>(interfaceName, "GetLeagueListing", 1);`
	`17`	`+ var leagueListing = await CallMethodAsync<LeagueResultContainer>("GetLeagueListing", 1);`
`17`	`18`	`return leagueListing.Result;`
`18`	`19`	`}`
`19`	`20`
`20`		`- public async Task<IReadOnlyCollection<LiveLeagueGame>> GetLiveLeagueGames()`
	`21`	`+ public async Task<IReadOnlyCollection<LiveLeagueGame>> GetLiveLeagueGames(int? leagueId = null, long? matchId = null)`
`21`	`22`	`{`
`22`		`- var liveLeagueGames = await GetJsonAsync<LiveLeagueGameResultContainer>(interfaceName, "GetLiveLeagueGames", 1);`
	`23`	`+ List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();`
	`24`	`+`
	`25`	`+ if(leagueId.HasValue)`
	`26`	`+ {`
	`27`	`+ parameters.Add(new SteamWebRequestParameter("league_id", leagueId.Value.ToString()));`
	`28`	`+ }`
	`29`	`+`
	`30`	`+ if (matchId.HasValue)`
	`31`	`+ {`
	`32`	`+ parameters.Add(new SteamWebRequestParameter("match_id", matchId.Value.ToString()));`
	`33`	`+ }`
	`34`	`+`
	`35`	`+ var liveLeagueGames = await CallMethodAsync<LiveLeagueGameResultContainer>("GetLiveLeagueGames", 1, parameters);`
`23`	`36`	`return new ReadOnlyCollection<LiveLeagueGame>(liveLeagueGames.Result.Games);`
`24`	`37`	`}`
`25`	`38`
`26`	`39`	`public async Task<MatchDetailResult> GetMatchDetails(int matchId)`
`27`	`40`	`{`
`28`	`41`	`List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();`
`29`	`42`	`parameters.Add(new SteamWebRequestParameter("match_id", matchId.ToString()));`
`30`		`- var matchDetail = await GetJsonAsync<MatchDetailResultContainer>(interfaceName, "GetMatchDetails", 1, parameters);`
	`43`	`+ var matchDetail = await CallMethodAsync<MatchDetailResultContainer>("GetMatchDetails", 1, parameters);`
`31`	`44`	`return matchDetail.Result;`
`32`	`45`	`}`
`33`	`46`
`34`	`47`	`public async Task<MatchHistoryResult> GetMatchHistory()`
`35`	`48`	`{`
`36`		`- var matchHistory = await GetJsonAsync<MatchHistoryResultContainer>(interfaceName, "GetMatchHistory", 1);`
	`49`	`+ var matchHistory = await CallMethodAsync<MatchHistoryResultContainer>("GetMatchHistory", 1);`
`37`	`50`	`return matchHistory.Result;`
`38`	`51`	`}`
`39`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,16 +7,16 @@`
`7`	`7`
`8`	`8`	`namespace SteamWebAPI2`
`9`	`9`	`{`
`10`		`- internal class SteamUser : SteamWebRequest`
	`10`	`+ public class SteamUser : SteamWebInterface`
`11`	`11`	`{`
`12`		`- public SteamUser(SteamWebRequestParameter developerKey)`
`13`		`- : base(developerKey, "ISteamUser") { }`
	`12`	`+ public SteamUser(string steamWebApiKey)`
	`13`	`+ : base(steamWebApiKey, "ISteamUser") { }`
`14`	`14`
`15`	`15`	`public async Task<PlayerSummary> GetPlayerSummaryAsync(string steamId)`
`16`	`16`	`{`
`17`	`17`	`List<SteamWebRequestParameter> parameters = new List<SteamWebRequestParameter>();`
`18`	`18`	`parameters.Add(new SteamWebRequestParameter("steamids", steamId));`
`19`		`- var playerSummary = await GetJsonAsync<PlayerSummaryResponseContainer>(interfaceName, "GetPlayerSummaries", 2, parameters);`
	`19`	`+ var playerSummary = await CallMethodAsync<PlayerSummaryResponseContainer>("GetPlayerSummaries", 2, parameters);`
`20`	`20`
`21`	`21`	`if (playerSummary.Response.Players.Count > 0)`
`22`	`22`	`{`
Original file line number	Diff line number	Diff line change
`@@ -8,20 +8,20 @@`
`8`	`8`
`9`	`9`	`namespace SteamWebAPI2`
`10`	`10`	`{`
`11`		`- internal class SteamWebAPIUtil : SteamWebRequest`
	`11`	`+ public class SteamWebAPIUtil : SteamWebInterface`
`12`	`12`	`{`
`13`		`- public SteamWebAPIUtil(SteamWebRequestParameter developerKey)`
`14`		`- : base(developerKey, "ISteamWebAPIUtil") { }`
	`13`	`+ public SteamWebAPIUtil(string steamWebApiKey)`
	`14`	`+ : base(steamWebApiKey, "ISteamWebAPIUtil") { }`
`15`	`15`
`16`	`16`	`public async Task<SteamServerInfo> GetServerInfoAsync()`
`17`	`17`	`{`
`18`		`- var steamServerInfo = await GetJsonAsync<SteamServerInfo>(interfaceName, "GetServerInfo", 1);`
	`18`	`+ var steamServerInfo = await CallMethodAsync<SteamServerInfo>("GetServerInfo", 1);`
`19`	`19`	`return steamServerInfo;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public async Task<IReadOnlyCollection<SteamInterface>> GetSupportedAPIListAsync()`
`23`	`23`	`{`
`24`		`- var steamApiListContainer = await GetJsonAsync<SteamApiListContainer>(interfaceName, "GetSupportedAPIList", 1);`
	`24`	`+ var steamApiListContainer = await CallMethodAsync<SteamApiListContainer>("GetSupportedAPIList", 1);`
`25`	`25`	`return new ReadOnlyCollection<SteamInterface>(steamApiListContainer.ApiList.Interfaces);`
`26`	`26`	`}`
`27`	`27`	`}`