Fouten en waarschuwingen oplossen in asynchrone methoden die gebruikmaken van de await-operator

In dit artikel worden de volgende compilerfouten behandeld:

• CS1983: Aangezien dit een asynchrone methode is, moet de retourexpressie van het type 'T' in plaats van 'Task<T>' zijn.
• CS1985: Kan niet worden gebruikt in een catch-blok.
• CS1986: 'await' vereist dat het type een geschikte methodeGetAwaiter heeft.
• CS1989: Async lambda-expressies kunnen niet worden geconverteerd naar expressiestructuren.
• CS1991: 'Type' kan gebeurtenis niet implementeren omdat het een Windows Runtime-gebeurtenis is en 'gebeurtenis' een reguliere .NET-gebeurtenis is.
• CS1992: De operator 'await' kan alleen worden gebruikt in een methode of lambda-expressie die is gemarkeerd met de wijzigingsfunctie 'async'.
• CS1994: De modifier 'async' kan alleen worden gebruikt in methoden met een hoofdtekst.
• CS1995: De operator 'await' mag alleen worden gebruikt in een query-expressie binnen de eerste verzamelingsexpressie van de eerste component 'from' of in de verzamelingsexpressie van een 'join-component.
• CS1996: Kan niet wachten in de hoofdtekst van een vergrendelingsinstructie.
• CS1997: Omdat de functie een asynchrone methode is die een waarde retourneert, mag een retourwoord niet worden gevolgd door een objectexpressie.
• CS1998: Deze asynchrone methode mist operatorsawait en wordt synchroon uitgevoerd. U kunt de operator 'await' gebruiken om niet-blokkerende API-aanroepen te wachten of 'await Task.Run(...)' om CPU-afhankelijk werk uit te voeren op een achtergrondthread.
• CS4001: De expressie kan niet worden afgewacht.
• CS4003: 'await' kan niet worden gebruikt als een id binnen een asynchrone methode of lambda-expressie.
• CS4005: Async-methoden kunnen geen aanwijzertypeparameters hebben.
• CS4006: __arglist is niet toegestaan in de parameterlijst met asynchrone methoden.
• CS4007: Het exemplaar van het type kan niet worden bewaard over de grens 'await' of 'yield' .
• CS4008: Kan niet wachten op 'void'.
• CS4009: Een ongeldige of niet-geretourneerde ingangspunt kan niet asynchroon zijn.
• CS4010: Kan asynchrone expressie niet converteren naar delegatetype. Een asynchrone expressie kan void, Task of Task<T> retourneren, waarvan geen van deze geconverteerd kan worden naar type.
• CS4011: 'await' vereist dat het retourtype van '{1}.GetAwaiter()' geschikte leden 'IsCompleted', 'OnCompleted' en 'GetResult' heeft en 'INotifyCompletion' of 'ICriticalNotifyCompletion' implementeert.
• CS4012: Parameters van het type kunnen niet worden gedeclareerd in asynchrone methoden of asynchrone lambda-expressies.
• CS4014: Omdat deze aanroep niet wordt gewacht, gaat de uitvoering van de huidige methode door voordat de aanroep is voltooid. Overweeg de await operator toe te passen op het resultaat van de aanroep.
• CS4015: MethodImplOptions.Syncd kan niet worden toegepast op een asynchrone methode.
• CS4016: Omdat dit een asynchrone methode is, moet de retourexpressie van een taakachtig type zijn in plaats van het gedeclareerde type.
• CS4027: Het expressietype implementeert geen vereist lid.
• CS4028: 'await' vereist dat het type een geschikte 'GetAwaiter'-methode heeft. Ontbreekt er een using-instructie voor 'Systeem'?
• CS4029: Kan geen expressie van het type 'void' retourneren.
• CS4030: Beveiligingskenmerk kan niet worden toegepast op een Async-methode.
• CS4031: Async-methoden zijn niet toegestaan in een interface, klasse of structuur met het kenmerk SecurityCritical of SecuritySafeCritical.
• CS4032: De operator 'await' kan alleen worden gebruikt binnen een asynchrone methode. U kunt deze methode markeren met de wijzigingsfunctie 'async' en het retourtype wijzigen in 'Task<T>'.
• CS4033: De operator 'await' kan alleen worden gebruikt binnen een asynchrone methode. Overweeg deze methode te markeren met de modifier 'async' en het retourtype te wijzigen in 'Task'.
• CS4034: De operator 'await' kan alleen worden gebruikt binnen een asynchrone methode. Overweeg deze methode te markeren met de modifier 'async'.
• CS8031: Async-lambda-expressie geconverteerd naar een taak-retournerende gedelegeerde kan geen waarde retourneren.
• CS8100: De operator 'await' kan niet worden gebruikt in een initialisatiefunctie voor statische scriptvariabelen.
• CS8177: Async-methoden kunnen geen lokale door-verwijzingsvariabelen hebben.
• CS8178: Een verwijzing die wordt geretourneerd door een aanroepmethode, kan niet worden bewaard over de grens 'await' of 'yield.
• CS8204: Voor het type dat moet worden gebruikt als een AsyncMethodBuilder voor typedoel, moet de taakeigenschap het doeltype retourneren in plaats van het gedeclareerde type.
• CS8403: Methode met een iteratorblok moet 'async' zijn om IAsyncEnumerable<T> te retourneren.
• CS8411: Asynchrone foreach-instructie kan niet worden uitgevoerd op variabelen van het type omdat het type geen geschikte openbare instantie of extensiedefinitie voor vereist lid bevat.
• CS8892: Methode wordt niet gebruikt als invoerpunt omdat er een synchroon toegangspunt is gevonden.
• CS8935: Het kenmerk AsyncMethodBuilder is niet toegestaan op anonieme methoden zonder expliciet retourtype.
• CS8940: Er werd een generiek taakachtig retourtype verwacht, maar het type dat in het kenmerk 'AsyncMethodBuilder' gevonden werd, was niet geschikt. Het moet een ongebonden generiek type van arity één zijn, en het omvattende type (indien aanwezig) moet niet-generiek zijn.
• CS9123: De operator '&' mag niet worden gebruikt voor parameters of lokale variabelen in asynchrone methoden.
• CS9330: 'MethodImplAttribute.Async' kan niet handmatig worden toegepast op methoden. Markeer de methode 'async'.

Vereisten voor await-expressies

• CS1985: Kan niet awaiten in een catch-blok.
• CS1986: 'await' vereist dat het type een geschikte methodeGetAwaiter heeft.
• CS1992: De operator 'await' kan alleen worden gebruikt wanneer deze zich in een methode of lambda-expressie bevindt die is gemarkeerd met deasync ''-wijzigingsfunctie.
• CS1995: De operator 'await' mag alleen worden gebruikt in een query-expressie binnen de eerste verzamelingsexpressie van de eerste component 'from' of in de verzamelingsexpressie van een 'join-component.
• CS1996: Kan geen 'await' gebruiken in de body van een lock-instructie.
• CS4008: Kan niet wachten op 'void'.
• CS4032: De operator 'await' kan alleen worden gebruikt binnen een asynchrone methode. Overweeg deze methode te markeren met de modifier 'async' en het retourtype te wijzigen in 'Task<T>'.
• CS4033: De operator 'await' kan alleen worden gebruikt binnen een asynchrone methode. Overweeg deze methode te markeren met de modifier 'async' en het retourtype te wijzigen in 'Task'.
• CS4034: De operator 'await' kan alleen worden gebruikt binnen een asynchrone methode. Overweeg deze methode te markeren met de modifier 'async'.
• CS8178: Een verwijzing die door deze aanroep wordt geretourneerd, kan niet worden bewaard over de grens 'await' of 'yield' .
• CS8411: Asynchrone foreach-instructie kan niet worden uitgevoerd op variabelen van het type omdat het type geen geschikte openbare instantie of extensiedefinitie voor vereist lid bevat.
• CS4001: Kan await-expressie niet uitvoeren.
• CS4003: 'await' kan niet worden gebruikt als een id binnen een asynchrone methode of lambda-expressie.
• CS4007: Een instantie van dit type kan niet worden behouden over de grens van 'await' of 'yield'.
• CS4011: 'await' vereist dat het retourtype 'GetAwaiter()' geschikte leden 'IsCompleted', 'OnCompleted' en 'GetResult' heeft en 'INotifyCompletion' of 'ICriticalNotifyCompletion' implementeert.
• CS4027: Type implementeert niet vereist element.
• CS4028: 'await' vereist dat het type een geschikte 'GetAwaiter'-methode heeft. Ontbreekt er een using directive voor 'System'?
• CS8100: De operator 'await' kan niet worden gebruikt in een initialisatiefunctie voor statische scriptvariabelen.

In de volgende items wordt uitgelegd hoe u elke fout kunt corrigeren. Zie await voor meer informatie over de operator en het wachtpatroon.

• Voeg de async wijzigingsfunctie toe aan de methode of lambda-expressie die de await expressie bevat (CS1992, CS4032, CS4033, CS4034). Voor de compiler is de async modifier vereist, zodat deze de statusmachine kan genereren die asynchrone ophanging en hervatting afhandelt. De drie varianten van deze fout bieden contextspecifieke suggesties voor het juiste retourtype.
• Verplaats expressies uit de await-blokken wanneer u zich richt op C# 5 of eerder (catch). Vanaf C# 6 ondersteunt de compiler zowel await in catch als in finally blokken. Deze fout wordt niet meer geproduceerd in C# 6 en hoger.
• Verplaats expressies uit instructie blokken (CS1996). Asynchrone opschorting tijdens het vasthouden van een vergrendeling verhoogt het risico op een deadlock. De vergrendeling wordt vastgehouden over thread-overschakelingen waar andere code mogelijk wacht op dezelfde vergrendeling.
• Herstructureer query-expressies zodat deze await alleen worden weergegeven in de eerste verzamelingsexpressie van de eerste from component of in de verzamelingsexpressie van een join component (CS1995). Andere query-clausules worden omgezet in lambda-expressies die geen ondersteuning bieden voor asynchrone opschorting.
• Wijzig het type van de verwachte expressie zodat het een toegankelijke GetAwaiter() methode weergeeft die het patroon voor de wachter volgt (CS1986, CS4028). Het type kan het patroon rechtstreeks of via een extensiemethode implementeren. Als de GetAwaiter methode bestaat maar u een using instructie Systemmist, produceert de compiler het specifiekere CS4028-bericht in plaats van CS1986.
• Zorg ervoor dat het type wachter dat wordt geretourneerd door GetAwaiter() de leden IsCompleted, OnCompleted, en GetResult heeft en INotifyCompletion of ICriticalNotifyCompletion implementeert (CS4011, CS4027). De await expressie is afhankelijk van deze leden om de voltooiingsstatus te controleren, vervolgen te registreren en resultaten op te halen.
• Wijzig het retourtype van de aangeroepen methode van void in of TaskTask<TResult> zodat het resultaat kan worden verwacht (CS4008). U kunt niet wachten op een voidretourmethode omdat er geen taakobject is om voltooiing bij te houden of uitzonderingen door te geven.
• Wijzig de verwachte expressie in een type dat het wachterpatroon (CS4001) ondersteunt. Typen zoals int, string, en andere ingebouwde typen hebben geen GetAwaiter-methode en kunnen niet rechtstreeks worden gewacht.
• Sla het resultaat van een ref-terugkerende methode-aanroep op in een lokale variabele voordat u await (CS8178) gebruikt. Een verwijzing die door een methode wordt geretourneerd, kan niet over een await grens worden bewaard omdat de asynchrone statusmachine de verwijzing kan onderbreken en hervatten op een andere thread of context, wat de verwijzing ongeldig maakt.
• Implementeer IAsyncEnumerable<T> op het verzamelingstype of voeg een toegankelijke GetAsyncEnumerator methode toe die een type retourneert met Current en MoveNextAsync leden (CS8411). De await foreach instructie vereist dat het verzamelingstype het asynchrone enumerable patroon volgt.
• Wijzig een lokale variabele of parameter die in een await-methode of lambda-expressie async genoemd is (CS4003). Binnen asynchrone contexten await is een contextueel trefwoord en kan niet worden gebruikt als id.
• Verplaats de await expressie uit de initialisatiefunctie van de statische scriptvariabele en naar een methodebody (CS8100). Statische initializers worden uitgevoerd buiten een asynchrone context, dus await is niet beschikbaar op die locatie.
• Herstructureer de code zodat ref struct instanties niet hoeven te worden bewaard over een await- of yield-grens (CS4007). De asynchrone statusmachine slaat lokale variabelen op de heap op en ref struct typen zijn standaard gestapeld. Ze kunnen niet veilig worden verplaatst naar heapopslag tussen ophangpunten.

Handtekeningvereisten voor Async-methode

• CS1983: Aangezien dit een asynchrone methode is, moet de retourexpressie van het type T zijn in plaats van 'Task<T>'.
• CS1994: De modifier 'async' kan alleen worden gebruikt in methoden met een hoofdtekst.
• CS4009: Een ongeldige of niet-geretourneerde ingangspunt kan niet asynchroon zijn.
• CS8892: Methode wordt niet gebruikt als invoerpunt omdat er een synchroon toegangspunt is gevonden.
• CS8935: Het kenmerk AsyncMethodBuilder is niet toegestaan op anonieme methoden zonder expliciet retourtype.
• CS8940: Er werd een generiek taakachtig retourtype verwacht, maar het type gevonden in het kenmerk AsyncMethodBuilder was niet geschikt. Het moet een niet-gebonden generiek type van ariteit één zijn, en het bevattende type (indien aanwezig) moet niet-generiek zijn.
• CS8403: Methode met een iteratorblok moet 'async' zijn om '{1}' te retourneren.
• CS9330: 'MethodImplAttribute.Async' kan niet handmatig worden toegepast op methoden. Markeer de methode 'async'.
• CS4005: Async-methoden kunnen geen aanwijzertypeparameters hebben.
• CS4006: __arglist is niet toegestaan in de lijst met parameters van asynchrone methoden.
• CS4010: Kan asynchrone lambda niet converteren naar delegate-type. Een asynchrone lambda kan void, Task of Task<T> retourneren, die geen van allen converteerbaar zijn naar een retourtype.
• CS4012: Parameters van het type kunnen niet worden gedeclareerd in asynchrone methoden of asynchrone lambda-expressies.
• CS4015: MethodImplOptions.Syncd kan niet worden toegepast op een asynchrone methode.
• CS4016: Omdat dit een asynchrone methode is, moet de retourexpressie van het taaktype zijn in plaats van het type.
• CS8031: Een naar een taak retournerende gedelegeerde geconverteerde async-lambda-expressie kan geen waarde teruggeven.
• CS8204: Om een type te kunnen gebruiken als AsyncMethodBuilder, dient de Task-eigenschap het verplicht type te retourneren in plaats van het gedeclareerde type.

In de volgende items wordt uitgelegd hoe u elke fout kunt corrigeren. Voor meer informatie over asynchrone methodedeclaraties, zie de async modifier en Async-returntypes.

• Wijzig de retourexpressie zodat deze overeenkomt met het onderliggende resultaattype van de asynchrone methode (CS1983, CS4016). Wanneer een asynchrone methode retourneertTask<T>, moet de instructie een waarde van het type returnopgeven, niet Tomdat de Task<T> door de compiler gegenereerde statusmachine de waarde automatisch in een taak verpakt. CS1983 treedt op wanneer de methode een waarde retourneert en de uitdrukking is Task<T>; T behandelt het algemene geval waarin het returnuitdrukkingstype niet overeenkomt.
• Verwijder de async wijzigingsfunctie uit methoden die geen hoofdtekst hebben, zoals abstracte methoden of interfacemethodedeclaraties (CS1994). Voor de async wijzigingsfunctie is een methodebody vereist, zodat de compiler de implementatie van de statusmachine kan genereren.
• Wijzig het retourtype van een asynchroon toegangspunt in Task of Task<TResult> (CS4009). Vanaf C# 7.1 kan de -methode zijn, maar moet deze wel of retourneren, en zijn geen geldige entry point-handtekeningen.
• Verwijder of wijzig de naam van één toegangspunt wanneer het project zowel een synchrone als een asynchrone Main methode (CS8892) bevat. De compiler selecteert het synchrone toegangspunt en geeft deze waarschuwing uit voor de asynchrone kandidaat die wordt genegeerd.
• Voeg een expliciet retourtype toe aan de lambda-expressie voordat u het [AsyncMethodBuilder] kenmerk (CS8935) toepast. De compiler kan het opbouwtype niet oplossen voor een anonieme methode waarvan het retourtype wordt afgeleid, omdat het kenmerk moet worden vergeleken met een specifiek retourtype tijdens het compileren.
• Wijzig het type dat is opgegeven in het [AsyncMethodBuilder] kenmerk in een ongebonden generiek type met ariteit één, zoals MyTaskMethodBuilder<> in plaats van MyTaskMethodBuilder<T> of een niet-generiek type (CS8940). Het type dat de bouwer bevat, indien van toepassing, moet ook niet-generiek zijn. Voor de compiler is deze vorm vereist, zodat het de builder kan maken voor elk concreet taakachtig retourtype.
• Vervang het handmatige [MethodImpl(MethodImplOptions.Async)] kenmerk door het async trefwoord in de methodedeclaratie (CS9330). De MethodImplOptions.Async vlag is gereserveerd voor intern runtimegebruik en kan niet rechtstreeks in gebruikerscode worden toegepast.
• Voeg de async modifier toe aan methoden die iteratorblokken bevatten en die IAsyncEnumerable<T> of IAsyncEnumerator<T> retourneren (CS8403). Zonder de async wijzigingsfunctie behandelt de compiler de methode als een synchrone iterator en kan de asynchrone stroomstatusmachine niet genereren.
• Aanwijzerparameters verwijderen uit asynchrone methoden (CS4005). Aanwijzers verwijzen naar vaste geheugenlocaties die niet veilig kunnen worden bewaard op asynchrone ophangpunten, waarbij de uitvoering op een andere thread kan worden hervat.
• Verwijderen __arglist uit asynchrone methodeparameterlijsten (CS4006). Lijsten met argumenten voor variabele lengte zijn afhankelijk van stack-gebaseerde aanroepconventies die niet compatibel zijn met de asynchrone toestandsmachine die aan de heap is toegewezen.
• Verwijder ref, inof out parameters en parameters van ref struct typen zoals Span<T> of ReadOnlySpan<T>, uit asynchrone methoden of asynchrone lambda-expressies (CS4012). Deze parametertypen zijn stack-gebonden en kunnen niet veilig worden vastgelegd in de heap-toegewezen asynchrone status machine sluiting.
• Wijzig het type doeldelegatie zodat deze overeenkomt met het retourtype van de asynchrone lambda (CS4010). Een asynchrone lambda kan void, Task of Task<TResult> retourneren, en de compiler kan deze niet converteren naar willekeurige gedelegeerdentypen die verschillende retourtypen verwachten.
• Verwijder de return expressie uit een asynchrone lambda die is toegewezen aan een niet-generieke Task-terugkerende gemachtigde, of wijzig het type delegate naar Func<Task<T>> zodat de lambda een waarde kan retourneren (CS8031). Een niet-generieke Task-terugkerende gedelegeerde vertegenwoordigt een asynchrone bewerking zonder resultaat, dus het retourneren van een waarde veroorzaakt een typefout.
• Verwijder het [MethodImpl(MethodImplOptions.Synchronized)] kenmerk uit asynchrone methoden (CS4015). De Synchronized optie verkrijgt een vergrendeling voor de volledige uitvoering van de methode, maar een asynchrone methode onderbreekt en hervat mogelijk op verschillende threads, waardoor de semantiek van de vergrendeling niet is gedefinieerd.
• Corrigeer het aangepaste AsyncMethodBuilder-type zodat de Task-eigenschap hetzelfde type retourneert als het gedeclareerde retourtype van de asynchrone methode (CS8204). De compiler gebruikt de eigenschap van de Task builder om het uiteindelijke taakobject te verkrijgen, zodat een type mismatch voorkomt dat de toestandsmachine correct functioneert.

Asynchrone praktijken

• CS1989: Asynchrone lambda-expressies kunnen niet worden omgezet naar expressiebomen.
• CS1991: 'Type' kan gebeurtenis niet implementeren omdat het een Windows Runtime-gebeurtenis is en 'gebeurtenis' een reguliere .NET-gebeurtenis is.
• CS1997: Omdat de functie een asynchrone methode is die een waarde retourneert, mag een retourwoord niet worden gevolgd door een objectexpressie.
• CS1998: Deze asynchrone methode mist operatorsawait en wordt synchroon uitgevoerd. U kunt de operator 'await' gebruiken om niet-blokkerende API-aanroepen te wachten of 'await Task.Run(...)' om CPU-afhankelijk werk uit te voeren op een achtergrondthread.
• CS4014: Omdat deze aanroep niet wordt gewacht, gaat de uitvoering van de huidige methode door voordat de aanroep is voltooid. Overweeg de await operator toe te passen op het resultaat van de aanroep.
• CS8177: Async-methoden kunnen geen lokale variabelen met referentie hebben.
• CS9123: De operator '&' mag niet worden gebruikt voor parameters of lokale variabelen in asynchrone methoden.
• CS4029: Kan geen expressie van het type 'void' retourneren.
• CS4030: Beveiligingskenmerk kan niet worden toegepast op een Async-methode.
• CS4031: Async-methoden zijn niet toegestaan in een interface, klasse of structuur met het kenmerk SecurityCritical of SecuritySafeCritical.

In de volgende items wordt uitgelegd hoe u elke fout kunt corrigeren. Zie Asynchrone programmering met asynchroon programmeren en wachten en de await operator voor meer informatie.

• Voeg de await operator toe aan elke aanroep die Task of Task<TResult> retourneert, of negeer expliciet het resultaat met _ = als fire-and-forgetgedrag echt is bedoeld (CS4014). Zonder await wordt elke uitzondering die door de asynchrone bewerking wordt gegenereerd stilletjes genegeerd, terwijl de aanroepende methode doorgaat met uitvoeren voordat de bewerking is voltooid, wat subtiele fouten in de volgorde en correctheid kan veroorzaken.
• Verwijder de return expressie uit een asynchrone methode waarvan het retourtype (niet-algemeen) is Task of wijzig het retourtype in Task<T> wanneer de methode een waarde moet retourneren (CS1997). In een asynchrone methode die Task retourneert, genereert de compiler de taakomslag. Het retourneren van een waarde leidt tot een typefout, omdat de signatuur van de methode belooft dat er geen resultaat is.
• Voeg ten minste één await expressie toe aan de hoofdtekst van de methode of verwijder de async wijziging en retourneer de taak rechtstreeks (CS1998). Een async methode zonder await expressies wordt volledig synchroon uitgevoerd, wat onnodige state-machine-overhead veroorzaakt. Als de methode opzettelijk een synchrone bewerking verpakt, elimineert het weglaten van async en het expliciet retourneren van de taak die overhead.
• Herschrijf de lambda-expressie zodat deze niet wordt gebruikt async wanneer deze is toegewezen aan een expressiestructuurtype zoals Expression<Func<...>> (CS1989). Expressiestructuren vertegenwoordigen code als gegevensstructuren die de compiler kan analyseren of vertalen, maar de complexe statusmachine die async produceert, kan niet worden vastgelegd in een expressiestructuur.
• Wijzig de implementatie van gebeurtenissen, zodat zowel de interfacedeclaratie als de implementatieklasse ermee akkoord gaan of de gebeurtenis gebruikmaakt van Windows Runtime-semantiek of reguliere .NET-semantiek (CS1991). Deze fout is van toepassing op windows Runtime-interopscenario's waarbij een WinRT-gebeurtenis niet kan worden geïmplementeerd als een reguliere .NET-gebeurtenis of omgekeerd.
• Verwijder het adres van de operator (&) uit expressies die verwijzen naar parameters of lokale variabelen in asynchrone methoden (CS9123). De asynchrone statusmachine kan vastgelegde variabelen tijdens de ophanging verplaatsen naar de heap, waardoor alle aanwijzers die zijn verkregen via adres-of, ongeldig zouden maken.
• Verwijder door-verwijzing lokale variabelen uit asynchrone methoden, of zorg ervoor dat ze geen grensgebied (CS8177) omvatten. De asynchrone toestandsmachine legt lokale variabelen vast in heap-gealloceerde afsluitingen, en referenties naar stacklocaties kunnen niet veilig worden bewaard over suspensiemomenten heen. In C# 13 en hoger zijn ref lokale variabelen toegestaan in asynchrone methoden, zolang ze geen await grens overschrijden, en deze fout treedt dan niet op.
• Verwijder de return instructie die het resultaat van een voidretourmethode retourneert of wijzig de aangeroepen methode om een waarde (CS4029) te retourneren. U kunt dit niet gebruiken return SomeVoidMethod(); omdat void dit geen type is dat als waarde kan worden geretourneerd. Verwijder het return trefwoord en roep de methode aan als een zelfstandige instructie of wijzig de handtekening van de aangeroepen methode om een concreet type te retourneren.
• Verwijder beveiligingskenmerken zoals [SecurityCritical] of [SecuritySafeCritical] van asynchrone methoden (CS4030) of verwijder de async wijzigingsfunctie uit methoden in typen die zijn gemarkeerd met deze kenmerken (CS4031). De beveiligingsaantekeningen voor codetoegang zijn van toepassing op de declaratiemethode, maar de door de compiler gegenereerde asynchrone statuscomputer wordt uitgevoerd in een afzonderlijke context waarin deze beveiligingsaantekeningen niet kunnen worden afgedwongen.