WCF：即使呼叫是异步的，DNS查找也会冻结UI

Question

Below is a tiny WPF test app to demonstrate the problem. By design it's a portable app that communicates with its other instances over LAN. If I compile it and run on a remote machine, then run another instance on localhost, enter the name of the remote PC and click "Test Connection" it detects the remote WCF service over TCP just fine. But if I enter some garbage name the UI freezes for a few seconds before throwing "No DNS entries exist for host blabla". And that's despite the call is supposedly asynchronous. Of course, if I make the call on a different thread it's all smooth.

await Task.Run(async () => await channel.TestConnection());

Is there a way to avoid Task.Run()? It's about scalability. If I need to test online status of hundreds or thousands of computers at once I'd like to avoid spawning new threads on the caller app.

XAML:

<Window x:Class="Wcf_Test_Connection.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Wcf_Test_Connection"
        mc:Ignorable="d"
        Title="MainWindow" SizeToContent="WidthAndHeight">
    <Grid>
        <StackPanel Margin="20" Width="150">
            <TextBlock Text="Computer name:"/>
            <TextBox x:Name="ComputerNameBox" Margin="0,10"/>
            <Button x:Name="TestConnectionButton" Content="Test Connection" Click="TestConnectionButton_Click" />
        </StackPanel>
    </Grid>
</Window>

WCF Service (Channel Factory based):

[ServiceContract]
    public interface IAccessPoint
    {
        [OperationContract]
        Task<bool> TestConnection();
    }

    public class AccessPoint : IAccessPoint
    {
        public static int Port = 4848;
        public static string ServiceAddress = "/AccessPoint";

        public static void Configure(ServiceConfiguration config)
        {
            ContractDescription contract = ContractDescription.GetContract(typeof(IAccessPoint));

            ServiceEndpoint basicEndpoint = new ServiceEndpoint(contract,
                new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:" + Port.ToString() + ServiceAddress));
            config.AddServiceEndpoint(basicEndpoint);
        }

        public static IAccessPoint NewChannel(string address)
        {
            NetTcpBinding binding = new NetTcpBinding();
            EndpointAddress endpoint = new EndpointAddress(address);
            ChannelFactory<IAccessPoint> channelFactory = new ChannelFactory<IAccessPoint>(binding, endpoint);
            IAccessPoint channel = channelFactory.CreateChannel();
            return channel;
        }

        public Task<bool> TestConnection()
        {
            return Task.FromResult(true);
        }

Code-Behind:

public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            var serviceHost = new ServiceHost(typeof(AccessPoint));
            serviceHost.Open();
        }

        private async void TestConnectionButton_Click(object sender, RoutedEventArgs e)
        {
            this.Background = Brushes.Salmon;

            var channel = AccessPoint.NewChannel("net.tcp://" + ComputerNameBox.Text + ":" + AccessPoint.Port + AccessPoint.ServiceAddress);
            try
            {
                bool result = await channel.TestConnection();
                MessageBox.Show("Connection good");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error");
            }
            finally
            {
                var client = (IClientChannel)channel;
                if (client.State != CommunicationState.Closed && client.State != CommunicationState.Faulted)
                    client.Close();
                else client.Abort();
            }

            this.Background = Brushes.White;
        }
    }

Answer 1

If I need to test online status of hundreds or thousands of computers at once I'd like to avoid spawning new threads on the caller app.

The task pool scales the degree of concurrency dynamically for you. That's why you should create tasks rather than threads.

Is there a way to avoid Task.Run() ?

Apparently you need to call the operation on a background thread in order not to block the UI thread. Remember that an async method runs synchronously like any other method until it hits an await . So depending on how an async method is actually implemented, it might still block. And obviously it does in this case so your best shot is probably to use Task.Run here after all. It is either this or using another API.