C#

private static DateTime NextWeekDay(DateTime date, string expectedDayOfWeek, DateTimeFormatInfo dateFormat)
{
    int expectedDayIndex = Array.IndexOf(dateFormat.AbbreviatedDayNames, expectedDayOfWeek);
    if (expectedDayIndex != -1)
    {
        int dayOfWeek = (int)date.DayOfWeek;
        if (dayOfWeek != expectedDayIndex)
        {
            int daysToAdd = expectedDayIndex - dayOfWeek;
            if (daysToAdd < 0) daysToAdd += 7;
            date = date.AddDays(daysToAdd);
        }
    }
    
    return date;
}

DateTime today = DateTime.Today;
DataTable dt = ds.Tables[0];
DateTimeFormatInfo dateFormat = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture);

foreach (DataRow row in dt.Rows)
{
    string budgetType = row[0].ToString();
    switch (budgetType)
    {
        ...
        case "Weekly (52)":
        {
            DateTime date = today.AddDays(1 - today.Day);
            
            string expectedDayOfWeek = row[1].ToString();
            date = NextWeekDay(date, expectedDayOfWeek, dateFormat);
            
            int max = (4 * f);
            for (int n = 0; n < max; n++)
            {
                list.Add(date);
                date = date.AddDays(7);
            }
            break;
        }
        ...
    }
}

public static WeakDictionary<TKey, TValue> Get<TKey, TValue>()
    where TValue : class
    where TKey : notnull
{
    var k = new Key(typeof(TKey), typeof(TValue));
    if (!caches.TryGetValue(k, out var result))
    {
        lock (caches)
        {
            if (!caches.TryGetValue(k, out result))
            {
                result = new WeakDictionary<TKey, TValue>();
                caches[k] = result;
            }
        }
    }
    return (WeakDictionary<TKey, TValue>)result;
}

record class Key(Type key, Type value);
readonly static ConcurrentDictionary<Key, IWeakCache> caches = new();

Super Lloyd wrote:

Though I wonder why it's available only to records.

with expression - C# reference | Microsoft Docs[^]

Beginning with C# 10, a left-hand operand of a with expression can also be of a structure type or an anonymous type.

record User(int Id, string LastName);

public record User {
  public int Id { get; set; }
  public string LastName { get; set; }
}

public record User {
  public int Id { get; init; } // immutable field, post init.
  public string LastName { get; set; }
}

// code generation creates the record as a struct, which has mutable fields
record struct ... 

/// ...and...

readonly record struct ... 
// code generation creates the record as an immutable struct, similar to record using positional syntax.

IEnumerable

public string getDetails(int ddIndex)
{
    FeederTableQuery q = lines.[ddIndex];
    return q.ConductorName.ToString();
}

Error (active)	CS1001	Identifier expected	

lines[ddIndex]

Error (active)	CS0021	Cannot apply indexing with [] to an expression of type 'IEnumerable<FeederTableQuery>

FeederTableQuery q = lines.ElementAt((int)ddlIndex);