TPL Async Await in Console Apps
Let’s try to apply SRP, and get rid of mutable state to increase code maintainability. It inflates C# code a little bit, but usually makes sense. 

Demo:

  IEnumerable&lt;Member&gt; members = new Member[] { new Member("n","e") };
  await members
      .SubscribeAsync()
      .LogAsync(Console.Out);


Where Member could be immutable:

public class Member
{
    public Member(string n, string e)
    {
        N = n.Trim();
        E = e.Trim();
    }

    public string N { get; }
    public string E { get; }
    public override string ToString() =&gt; $"N={N}, E={E}";
}


We will use this universal helper class to log task exceptions:

static class Logging
{
    public static async Task LogAsync(this Task task, TextWriter writer)
    {
        try
        {
            await task;
        }            
        catch (AggregateException ex)
        {
            foreach (var exx in ex.Flatten().InnerExceptions)
                await writer.WriteLineAsync(exx.Message);
        }
        catch(Exception ex)
        {
            await writer.WriteLineAsync(ex.Message);
        }
    }
}


Now subscription helpers:

static class Subscription
{
    public static Task SubscribeAsync(this IEnumerable&lt;Member&gt; members) =&gt;
        Task.WhenAll(from member in members
                     select member.SubscribeAsync());

    public static Task&lt;SubscriptionResponse&gt; SubscribeAsync(this Member member) =&gt;
        new SubscriptionRequest(member).ExecuteAsync();
}


Subscription request:

public class SubscriptionRequest
{
    const string RequestUrl = "";

    public SubscriptionRequest(Member member)
    {
        Member = member;
    }

    public async Task&lt;SubscriptionResponse&gt; ExecuteAsync()
    {
        using (var client = new HttpClient())
            try
            {
                var response = await client.PostAsync(RequestUrl, Content);
                var responseBody = await response.Content.ReadAsStringAsync();
                return new SubscriptionResponse(responseBody);
            }
            catch(Exception ex)
            {
                throw new SubscriptionException(Member, ex);
            }            
    }

    FormUrlEncodedContent Content =&gt; new FormUrlEncodedContent(Kvps);
    IEnumerable&lt;KeyValuePair&lt;string, string&gt;&gt; Kvps =&gt; new[]
    {
        new KeyValuePair&lt;string, string&gt;("e", Member.E),
        new KeyValuePair&lt;string, string&gt;("n", Member.N),
        new KeyValuePair&lt;string, string&gt;("boolean", "true")
    };

    Member Member { get; } 
}


And response:

public class SubscriptionResponse
{
    public SubscriptionResponse(string body)
    {
        Body = body;
        if (!Success)
            throw new InvalidOperationException(body);
    }

    public bool Subscribed =&gt; Body == "1";
    public bool AlreadySubscribed =&gt; Body == "Member present";
    bool Success =&gt; Subscribed || AlreadySubscribed;
    string Body { get; }
}


The only missing part:

public class SubscriptionException : Exception
{
    public SubscriptionException(Member member, Exception error) :
        base($"{member} subscription failed, error: {error.Message}", error)
    {
    }
}


P.S. Generally speaking, C# is a pretty verbose language, so it is often punishing good programming practices…