Läs på engelska

Dela via

Kompilatorfel CS8352

  • Artikel

Det går inte att använda variabeln "variabel" i den här kontexten eftersom den kan exponera refererade variabler utanför deras deklarationsomfång.

Det här felet indikerar potentiellt odefinierat beteende när det finns en risk för åtkomst till en stackallokerad variabel när den redan har tagits bort från stacken.

Så här åtgärdar du det här felet

Du åtgärdar CS8352 genom att se till att variabelns omfång är minst lika brett som variabeln som refererar till den. Det gör du genom att allokera lagringen på en heap eller i stacken i samtalskontexten.

Exempel

Följande exempel genererar CS8352:

class Program
{
    static public Span<int> CreateSpanWithValue(int size, int value)
    {
        Span<int> localSpan = stackalloc int[size];
        localSpan[0] = value;
        return localSpan;    // CS8352
    }                        // localSpan refers to stack memory that's been reclaimed.

    static public void Main()
    {
        Span<int> localSpan = CreateSpanWithValue(5, 10);
        localSpan[2] = 14;
        foreach(var item in localSpan)
        {
            Console.WriteLine(item.ToString());  // Reading from deleted object
        }
    }
    // Example of output:
    // 284945320
    // 149
    // 149
    // 1369466325
    // 284945320
}

Följande exempel flyttar stackallokeringen så att dess omfång matchar Span.
Den här exempellösningen fungerar eftersom det minnesintervall som refererar till allokeras i stacken, men i anropskontexten:

class Program
{
    static public void FillSpanWithValue(Span<int> span, int value)
    {
        span[0] = value;
    }

    static public void Main()
    {
        Span<int> localSpan = stackalloc int[5];
        FillSpanWithValue(localSpan, 10);
        localSpan[2] = 14;
        foreach(var item in localSpan)
        {
            Console.WriteLine(item.ToString());
        }
    }
    // Output:
    // 10
    // 0
    // 14
    // 0
    // 0
}

I följande exempel används nyckelordet new för att skapa objektet på heap i stället för stack.
Den här exempellösningen fungerar eftersom minnet som Span refererar till fortfarande är giltigt när det har allokerats på heapen, inte på en stack efter att ha återvänt från CreateSpanWithValue metoden:

class Program
{
    static public Span<int> CreateSpanWithValue(int size, int value)
    {
        Span<int> localSpan = new int[size];
        localSpan[1] = value;
        return localSpan;
    }

    static public void Main()
    {
        var span = CreateSpanWithValue(5, 10);
        span[2] = 14;
        foreach(var item in span)
        {
            Console.WriteLine(item.ToString());
        }
    }
    // Output:
    //0
    //10
    //14
    //0
    //0
}

Se även