public Task <ReceivedMessage> SendAsync(string sessionKey, ProtocolBase protocol)
{
// 获取session
if (!SessionsCenter.Instance.TryGetValue(sessionKey, out WebSocketSession targetSession))
{
return(null);
}
// 保存Task,方便下次回调
var callBack = new CallbackOption <ReceivedMessage>();
Add(callBack.Id, callBack);
// 修改 taskId
protocol.taskId = callBack.Id;
var task = callBack.Run(() =>
{
// 发送数据
targetSession.Send(JsonConvert.SerializeObject(protocol));
});
return(task);
}
/// <summary>
/// This method is called by the Main static method to perform the
/// DNS resolutions requested by the user demonstrating the callback
/// options specified.
/// </summary>
/// <param name="host">An IP address or host name to resolve</param>
/// <param name="methodToUse">The callback option to demonstrate</param>
private void DoResolve(string host, CallbackOption methodToUse)
{
resultsDisplayed = false;
IPHostEntry hostInformation = null;
Resolver resolver = new Resolver();
switch (methodToUse)
{
case CallbackOption.UseInterface:
{
Console.WriteLine("Resolving...");
// By passing an interface that this object supports, the called
// method can notify this object of the results
try
{
resolver.Resolve(host, (IResolveCallback)this);
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Bad host name (SocketException)");
resultsDisplayed = true;
}
break;
}
case CallbackOption.UseSynchronousDelegate:
{
Console.WriteLine("Resolving...");
// By passing a delegate wrapping the HostResolved method, the
// called object can notify this object of the result in a synchronous
// or asynchronous manner, depending on how it is constructed.
ResolveCallbackDelegate cb = new ResolveCallbackDelegate(HostResolved);
resolver.Resolve(host, cb);
break;
}
case CallbackOption.UseAsynchronousDelegateWithWait:
{
Console.Write("Resolving");
// By wrapping a synchronous long-running method (DNS resolution)
// with a delegate, this object can call that method
// asynchronously and show progress (in this case) or do other
// work while it executes. In this scenario, it waits on the
// result using the WaitHandle provided by IAsyncResult.
ResolveDelegate synchMethod = new ResolveDelegate(resolver.Resolve);
// The BeginInvoke method is supplied by the C# compiler...
// The IntelliSense engine does not display this at design time.
IAsyncResult ar = synchMethod.BeginInvoke(host, null, null);
// Write another period for each 100ms interval of wait time.
while (!ar.AsyncWaitHandle.WaitOne(100, false))
{
Console.Write(".");
}
Console.WriteLine();
// If any exceptions are raised by the called method, they won't
// be thrown until the results are obtained.
try
{
// The EndInvoke method is supplied by the C# compiler...
// The IntelliSense engine does not display this at design time.
hostInformation = synchMethod.EndInvoke(ar);
DisplayResults(hostInformation);
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Bad host name (SocketException)");
resultsDisplayed = true;
}
break;
}
case CallbackOption.UseAsynchronousDelegateWithCallback:
{
Console.WriteLine("Resolving...");
ResolveDelegate synchMethod = new ResolveDelegate(resolver.Resolve);
AsyncCallback cb = new AsyncCallback(this.AsyncCustomCallbackMethod);
// Begin the method's execution...when finished, the callback will be
// called.
IAsyncResult ar = synchMethod.BeginInvoke(host, cb, null);
break;
}
case CallbackOption.UseFrameworkSuppliedSynchronousMethod:
{
Console.WriteLine("Resolving...");
// This calls the synchronous version of a framework-defined class
// that also explicitly supports asynchronous invocation.
try
{
hostInformation = Dns.Resolve(host);
DisplayResults(hostInformation);
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Bad host name (SocketException)");
resultsDisplayed = true;
}
break;
}
case CallbackOption.UseFrameworkSuppliedAsynchronousMethodWithWait:
{
Console.Write("Resolving");
IAsyncResult ar = Dns.BeginResolve(host, null, null);
// Write another period for each 100ms interval of wait time.
while (!ar.AsyncWaitHandle.WaitOne(100, false))
{
Console.Write(".");
}
Console.WriteLine();
// If any exceptions are raised by the called method, they won't
// be thrown until the results are obtained.
try
{
hostInformation = Dns.EndResolve(ar);
DisplayResults(hostInformation);
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Bad host name (SocketException)");
resultsDisplayed = true;
}
break;
}
case CallbackOption.UseFrameworkSuppliedAsynchronousMethodWithCallback:
{
Console.WriteLine("Resolving...");
AsyncCallback cb = new AsyncCallback(this.AsyncFrameworkCallbackMethod);
// Begin the call...when it is finished, the callback method will be
// called.
IAsyncResult ar = Dns.BeginResolve(host, cb, null);
break;
}
default:
Console.WriteLine("Not Implemented Yet");
break;
}
// If this method ends now, there is no guarantee that the host information
// will be displayed before the next prompt to the user for more hosts to
// resolve is shown. In order to force the wait, put the thread to sleep
// for 100ms intervals until the output has been displayed.
while (!resultsDisplayed)
{
// For the synchronous options, this will never get executed
// because the results will have been displayed before execution
// reaches this point.
System.Threading.Thread.Sleep(100);
}
}
static void Main()
{
ResolveConsole app = new ResolveConsole();
string userInput;
do
{
Console.WriteLine("Please enter an IP address or host name to " +
"resolve, or the letter 'x' to quit.");
userInput = Console.ReadLine().ToLower().Trim();
// If the user wants to quit, then exit the main loop.
if (userInput == "x")
{
break;
}
// Validate the user input, and reprompt the user if invalid.
UriHostNameType hostType = Uri.CheckHostName(userInput);
if (hostType == UriHostNameType.Dns || hostType == UriHostNameType.IPv4 ||
hostType == UriHostNameType.IPv6)
{
string host = userInput;
// Prompt the user for the method to use when resolving the host.
// The methods supported are defined in the CallbackOption enumeration.
object enumValue;
do
{
// First, show the user what valid options exist.
string[] names = Enum.GetNames(typeof(CallbackOption));
int[] values = (int[])Enum.GetValues(typeof(CallbackOption));
Console.WriteLine("Valid Options Are:");
for (int index = 0; index < values.Length; index++)
{
Console.WriteLine("{0,2} = {1}", values[index], names[index]);
} // end option enumeration (for loop)
// Prompt the user
Console.Write("Please indicate the method you would like " +
"to use to receive results: ");
userInput = Console.ReadLine().Trim();
// Cast to an int value, if possible...otherwise retain string input.
try
{
enumValue = int.Parse(userInput);
} // end try
catch (Exception)
{
enumValue = userInput;
} // end catch
// Validate the user input and reprompt if invalid.
} while (!Enum.IsDefined(typeof(CallbackOption), enumValue)); // end option loop
// Parse the input to an entry in the CallbackOption enumeration.
CallbackOption methodToUse = (CallbackOption)Enum.Parse(
typeof(CallbackOption), userInput, true
);
app.DoResolve(host, methodToUse);
} // end valid host entered.
else
{
Console.WriteLine("The IP address or host name you entered was " +
"formatted incorrectly, please try again.");
} // end invalid host entered.
// Continue looping until the user wants to quit.
} while (true); // end primary loop.
app = null;
} // end Main method
