Dela via

IncrementingPollingCounter inledande återanrop är asynkront

IncrementingPollingCounter använder ett återanrop för att hämta aktuella värden för ett mått och rapporterar det via EventSource händelser. Tidigare kan det första anropet av återanropet ha inträffat synkront på vilken tråd som aktiverade EventSource; framtida anrop inträffade i en dedikerad timertråd. Från och med .NET 9 sker det första återanropet alltid asynkront i timertråden. Detta kan leda till att räknarändringar som inträffat strax efter att räknaren har aktiverats inte har observerats eftersom det första återanropet inträffar senare.

Den här ändringen kommer troligen att påverka tester som använder EventListener för att verifiera en IncrementingPollingCounter. Om testerna aktiverar räknaren och sedan omedelbart ändrar det tillstånd som avsöks av räknaren kan ändringen nu ske före första gången återanropet anropas (och gå obemärkt förbi).

Tidigare beteende

Tidigare, när en IncrementingPollingCounter aktiverades, kan den första anropet av återanropet ha inträffat synkront på tråden som utförde aktiveringsåtgärden.

Den här exempelappen anropar ombudet () => SomeInterestingValue i tråden Main i anropet till EnableEvents(). Det återanropet kommer att observera log.SomeInterestingValue är 0. Ett senare anrop från en dedikerad timertråd observeras log.SomeInterestingValue ändrat till 1 och en händelse skickas med Increment value = 1.

using System.Diagnostics.Tracing;

var log = MyEventSource.Log;
using var listener = new Listener();

log.SomeInterestingValue++;

Console.ReadKey();

class MyEventSource : EventSource
{
    public static MyEventSource Log { get; } = new();
    private IncrementingPollingCounter? _counter;
    public int SomeInterestingValue;

    private MyEventSource() : base(nameof(MyEventSource))
    {
        _counter = new IncrementingPollingCounter("counter", this, () => SomeInterestingValue);
    }
}

class Listener : EventListener
{
    protected override void OnEventSourceCreated(EventSource eventSource)
    {
        if (eventSource.Name == nameof(MyEventSource))
        {
            EnableEvents(eventSource, EventLevel.Informational, EventKeywords.None,
                new Dictionary<string, string?> { { "EventCounterIntervalSec", "1.0" } });
        }
    }

    protected override void OnEventWritten(EventWrittenEventArgs eventData)
    {
        if (eventData.EventSource.Name == "EventCounters")
        {
            var counters = (IDictionary<string, object>)eventData.Payload![0]!;
            Console.WriteLine($"Increment: {counters["Increment"]}");
        }
    }
}

Nytt beteende

Med samma kodfragment som avsnittet Föregående beteende sker den första anropet av återanropet asynkront i timertråden. Det kan inträffa eller inte innan tråden Main körs log.SomeInterestingValue++ beroende på hur operativsystemet schemalägger flera trådar.

Beroende på tidpunkten matar appen antingen ut "Increment=0" eller "Increment=1".

Version introducerad

.NET 9 RC 1

Typ av icke-bakåtkompatibel ändring

Den här ändringen är en beteendeförändring.

Orsak till ändringen

Ändringen gjordes för att lösa ett potentiellt dödläge som kan uppstå när återanropsfunktioner körs medan låset EventListener hålls.

Ingen åtgärd krävs för scenarier som använder IncrementingPollingCounters för att visualisera mått i externa övervakningsverktyg. Dessa scenarier bör fortsätta att fungera normalt.

För scenarier som utför processtestning eller annan förbrukning av räknardata via EventListenerkontrollerar du om koden förväntar sig att observera en specifik ändring av räknarvärdet som görs i samma tråd som kallas EnableEvents(). Om det gör det rekommenderar vi att du väntar på att observera minst en räknarhändelse från EventListeneroch sedan ändrar räknarvärdet. Om du till exempel vill se till att exempelkodfragmentet skriver ut "Increment=1" kan du lägga till en ManualResetEvent i EventListener, signalera den när den första räknarhändelsen tas emot och vänta på den innan du anropar log.SomeInterestingValue++.

Berörda API:er