使用预处理器指令在异步方法中引发异常

Question

I have a task to clean the project of compiler's warnings. Currently I am working on cs file that is used in solutions for ASP.NET and Xamarin. There I have a method:

    public override async SomeReturnTypeItem LoginAsync()
    {
#if __MOBILE__
        throw new NotSupportedException("Windows authentication is not supported in mobile version");
#endif
    //some code
    }

In Xamarin solution I have a warning that code under #endif is unreachable. If I replace #endif with #else and put #endif to the end of method, I receive a warning that method lacks await operator and will run synchronously. How can I make this method free of warnings?

Answer 1

The simplest fix would be

public override async SomeReturnTypeItem LoginAsync()
{
#if __MOBILE__
    throw new NotSupportedException("Windows authentication is not supported in mobile version");
#else
    //some code using await
#endif
}

But that's probably not exactly the behaviour you want, because if __MOBILE__ is defined, the method will return a faulted Task instead of throwing right away. The difference can sometimes prove very big, mostly if you store the Task for later use instead of awaiting it right away (for instance if you want to start several tasks and let them run concurrently).

To remedy this, you should put the exception throwing code in a method and the async implementation in another:

public override SomeReturnTypeItem LoginAsync()
{
#if __MOBILE__
    throw new NotSupportedException("Windows authentication is not supported in mobile version");
#else
    return LoginAsyncImpl();
#endif
}

private async SomeReturnTypeItem LoginAsync()
{
    //some code using await
} 

Of course, if you're not using await at all, you just shouldn't mark your method as async in the first place!

public override omeReturnTypeItem LoginAsync()
{
#if __MOBILE__
    throw new NotSupportedException("Windows authentication is not supported in mobile version");
#else
    //some code not using await
#endif
}

Note that a non-async code can still return a Task . That's useful for instance if you implement an interface or base class that make some methods return task so that the implementation could be really asynchronous, but your specific implementation happens to be synchronous.

public override Task SomeMethodAsync()
{
    // do some  synchronous stuff
    return Task.FromResutl(true);
}

Answer 2

It's kinda ugly, but you could do this:

    public override
#if !__MOBILE__
    async
#endif
    SomeReturnTypeItem LoginAsync() {
#if __MOBILE__
    throw new NotSupportedException("Windows authentication is not supported in mobile version");
#else
    //some code
#endif
    }

This is assuming you actually have the await keyword somewhere in "some code". If not, then you should just remove async .

Or, you can simply use a #pragma directive to suppress the warning: #pragma warning

Answer 3

The solution that I used is to cheat compiler.

    public override async SomeReturnTypeItem LoginAsync()
    {
#if __MOBILE__
        bool isMobile = true;
        if (isMobile)
        {
            throw new NotSupportedException("Windows authentication is not supported in mobile version");
        }
#endif
        //some async code
    }

Visual Stuidio says that async code is unreachable heuristically, but compiler is satisfied. Of course it is a little bit ugly, but it works. However thank you guys for trying to help)