C#

private void ShadowedTextPaint(int num)
  {
     ...
     using (Graphics g = this.CreateGraphics())
     {
        ...
     }
  }

public class Jef {
    public int a;
    public int b;
}
public class Test {
    List<Jef> list = new List<Jef>();

    private void test1() {
        list.First().b = 13;
        list.First(j => j.a == 12).b = 14;
    }
}

int index = cR.SubCategories.IndexOf(subCategory);
if (index == -1)
{
    cR.SubCategories.Add(subCategory);
}
else
{
    cR.SubCategories.RemoveAt(index);
    cR.SubCategories.Insert(index, subCategory);
}

int index = cR.SubCategories.IndexOf(subCategory);
if (index == -1)
{
    cR.SubCategories.Add(subCategory);
}
else
{
    cR.SubCategories[index] = subCategory;
}

public readonly struct SubCategory : IEquatable<SubCategory>
{
    public SubCategory(int id, string name) => (Id, Name) = (id, name);
    public int Id { get; }
    public string Name { get; }
    public override int GetHashCode() => Id;
    public override bool Equals(object obj) => obj is SubCategory other && Equals(other);
    public bool Equals(SubCategory other) => Id == other.Id;
}

public class SubCategoryList : IEnumerable<SubCategory>
{
    private SubCategory[] _categories = new SubCategory[4];
    private int _length;
    
    public int Count => _length;
    public int Capacity => _categories.Length;
    public ref SubCategory this[int index] => ref _categories[index];
    
    public ref SubCategory FindOrAdd(int id)
    {
        for (int index = 0; index < _length; index++)
        {
            if (_categories[index].Id == id)
            {
                return ref _categories[index];
            }
        }
        
        Add(new SubCategory(id, null));
        return ref _categories[_length - 1];
    }
    
    public void Add(SubCategory value)
    {
        if (_length == _categories.Length)
        {
            int newSize = _length * 2;
            Array.Resize(ref _categories, newSize);
        }
        
        _categories[_length] = value;
        _length++;
    }
    
    public IEnumerator<SubCategory> GetEnumerator()
    {
        SubCategory[] categories = _categories;
        int length = _length;
        
        for (int index = 0; index < length; index++)
        {
            yield return categories[index];
        }
    }
    
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

public class Category
{
    public SubCategoryList SubCategories { get; } = new SubCategoryList();
}

var cR = new Category
{
    SubCategories = 
    {
        new SubCategory(1, "C1"),
        new SubCategory(2, "C2"),
        new SubCategory(3, "C3"),
    }
};

cR.SubCategories.FindOrAdd(2) = new SubCategory(2, "X2");
cR.SubCategories.FindOrAdd(42) = new SubCategory(42, "Z42");

var index = category.SubCategories.IndexOf(category.SubCategories.First(sc => sc.Id == subCategory.Id));

private void OnPingSuccess()
{
    ...
}

private void OnPingFailure()
{
    ...
}

private async Task MonitorServer(IPAddress address, TimeSpan frequency, CancellationToken cancellationToken)
{
    Ping ping = new Ping();
    while (!cancellationToken.IsCancellationRequested)
    {
        PingResult result = await ping.SendPingAsync(address);
        
        if (pingresult.Status == IPStatus.Success)
        {
            OnPingSuccess();
        }
        else
        {
            OnPingFailure();
        }
        
        await Task.Delay(frequency, cancellationToken);
    }
}

private CancellationTokenSource _cancellationTokenSource;

protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);
    _cancellationTokenSource = new CancellationTokenSource();
    _ = MonitorServer(IPAddress.Parse("10.10.9.15"), TimeSpan.FromMinutes(1), _cancellationTokenSource.Token);
}

protected override void OnClosed(EventArgs e)
{
    base.OnClosed();
    _cancellationTokenSource?.Cancel();
}

if (dt != null)
{
    DataTable dtbl = dView != null ? dView.ToTable() : dt.Clone();
    dtbl.WriteXml(...);
}