Please support VS 2022, thank you :-)

First, great work on this Nuget. Love the warnings!

It appears when the Nuget package is installed it's installed as a true dependency to the project and not a development dependency.

Here is an example of another analyzer inclusion in the project. The AsyncFixer installs itself as PrivateAssets with all which prevents its dependencies and inclusion in the output of the project.

	  <PackageReference Include="AsyncFixer" Version="1.1.6">
	    <PrivateAssets>all</PrivateAssets>
	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
	  </PackageReference>

The Lindhart.Analyser.MissingAwaitWarning package installs itself into the project like the below.
And because of this, it causes the System.Threading.Tasks.Extensions to be added as a dependency to the project at v4.3.0. Also it includes the library in the output.

	  <PackageReference Include="Lindhart.Analyser.MissingAwaitWarning" Version="1.2.0" />

Is it possible to update the Nuget to be development only asset? Or is this behavior by design?

I expected that the it would be able to find Task assigned to variable but still never awaited.

You can test it on this project

So far no analyzer was able to detect this problem. I would gladly help, but unfortunately I would need some "write your analyzer for dummies" manual.

Hi,

I am working on some code that uses IAsyncDisposable. This returns an ValueTask (without type argument).

In the code of your analyzer has those explicitly commented out because those types do not exist in .netstandard1.3. Point is that your analyzer does not need the types at all as you only do string comparison on the full names of the types.

I created a pull request where the type list is stored as string. I use this fixed version at the moment and it works great.

#29

Many thanks for this analyzer, it is helping me greatly at the moment.

NOTE: See the added example below for more details.

I had expected the following example to give a warning, but it doesn't:

`using System.Threading.Tasks;

namespace ACF.UI.LoanOrigination.Gateway
{

public interface ICallee
{
	bool ProblemSolved { get; }
	Task<int> SolveProblemAsync();
}

public class Callee : ICallee
{
	public bool ProblemSolved { get; set; }

	public async Task<int> SolveProblemAsync()
	{
		await Task.Delay(10);
		ProblemSolved = true;
		return 1;
	}
}

public class Caller
{
	public bool DoCall()
	{
		ICallee xxx = new Callee();

		// This analyser will give a warning at the following line
		var i = xxx.SolveProblemAsync(); // This is most likely an undesired fire and forget. 

		return xxx.ProblemSolved; // Will return false - we expected it to return true
	}
}

}
`
It's not a "fire and forget", but I'd like to know that I missed the await here.

Some lambda functions which does not constitute a fire and forget still causes warnings.
Examples:

        public interface ICallee { Task<int> DoSomethingAsync(); }

        public class Callee : ICallee
        {
            public async Task<int> DoSomethingAsync() => await Task.FromResult(0);
        }

        public class Caller
        {
            public async Task DoCall()
            {
                ICallee xxx = new Callee();
                
                // Functions that should not give warning but does
                DoSomething(() => xxx.DoSomethingAsync());
                Func<Func<Task>> func = () => () => xxx.DoSomethingAsync();
            }

            public void DoSomething(Func<Task> action){}

           // This should not give warning but does
            public Task TestThis(ICallee test) => test.DoSomethingAsync());
        }
        public class CallerHolder
        {
            public ICallee Callee { get; set; }
        }

In this code there are no fire and forget. Yet three warnings are given.

Hi!

Thanks for a very useful tool! It helped to fix a couple of very important bugs in the project I'm working at.

However, the following use cases don't seem to be covered by the analyzer:

    public static class Program
    {
        public static void Main()
        {
            Parallel.For(0, 5, i => Run2Async(i));

            void LocalFunc() => RunAsync();
            LocalFunc();

            Do();

            Console.WriteLine("Hello World!");
        }

        private static Task RunAsync()
        {
            return Task.CompletedTask;
        }

        private static Task<int> Run2Async(int i)
        {
            return Task.FromResult(i);
        }

        private static void Do() => RunAsync();
    }

I.e. expression-bodied functions and lambdas as arguments are not detected.

The analyzer works fine if the body is expanded, e.g.:

            void LocalFunc()
            {
                RunAsync();
            }

I have tested that with the NuGet versions 1.2.1 and 2.0.0-beta2. Neither the strict analyzer option did help.

Is it something that can be fixed in future versions?

Firstly, thanks for making this library... it really helped me clean up my code! 😃

With other analyser rules I can control them in .editorconfig like this:

dotnet_diagnostic.CA1012.severity = warning

How do I do that for this analyser rule? What is its code?

I created a little test project to show the issue:

using System;
using System.Threading.Tasks;
using NUnit.Framework;

namespace ConsoleApp3
{
    class TestClass
    {
        [Test]
        public async Task DoStuffTest() //Gives a warning here, even though the ImportantMethod is awaited
        {
            var service = new SomeService();
            Assert.ThrowsAsync<NotImplementedException>(async () => await service.ImportantMethod());
        }
    }

    public class SomeService
    {
        public async Task ImportantMethod()
        {
            throw new NotImplementedException();
        }
    }
}

Hi,

Do you plan on releasing a version for VS2019? Would really appreciate it :)

This scenario is not detected:

myNullableObject?.DoSomethingAsync();

when re-written this way, it works correctly:

var o = myNullableObject;
if(o != null)
   o.DoSomethingAsync();

In the following example the missing await before the call of a delegate does not give a warning, even though the delegate returns an unawaited Task.

    public Task Write(Func<Stream, Task> write)
    {
        log.Add("write");
        Stream = new UnclosedStream();
        write(Stream); // <-- here, a missing await
        return Task.CompletedTask;
    }

_Originally posted by @thomaseyde in #33 (comment) - edited by @ykoksen _

Hi,

Thanks for sharing this tool, it's very helpful.

Currently, this analyzer doesn't support null-conditional.
Example:
xxx?.DoSomethingAsync();
Should give a warning when not awaited.

Are you planning to add support for this expression in future versions?

Hi! I'm having a hard time figuring out how to integrate it into my solution. So maybe this could just go in the readme section. This is related to a solution with multiple projects (23 in my case)
When I add the package to a project, any unused tasks in that project are warned immediately, which is great. If there is another project that references this project, unused tasks in that project are also found. However if I continue going upwards, the errors are no longer found. Example:

Domain (has nuget package)

Service (references Domain)

Web (references Service)

Errors are correctly found in Domain and in Service, but not on Web.

Could we get a clarification on how/where we should add the nuget package so that we're sure that all of our solution is analyzed?