C#

public class Thumbnail
{
    public Bitmap thumbnail;
    public string filename;
    public int index;
}

void LoadThumbnails()
{
    backgroundWorker1.RunWorkerAsync();
}

void BackgroundWorker1DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
    List<Thumbnail> thumbnailList = new List<Thumbnail>();

    for (var i = 0; i < fileList.Count; i++)
    {
        Thumbnail item = new Thumbnail();
        item.thumbnail = MakeThumbnail(fileList[i], thumbnailSize, thumbnailSize);
        item.filename = Path.GetFileName(fileList[i]);
        item.index = i;
        thumbnailList.Add(item);

        if ((thumbnailList.Count == batchSize) || (i == (fileList.Count - 1)))
        {
            backgroundWorker1.ReportProgress(i, thumbnailList);
            thumbnailList = new List<Thumbnail>();
        }
    }
}

void BackgroundWorker1ProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e)
{
    List<Thumbnail> thumbnailList = (List<Thumbnail>)e.UserState;
    listView1.BeginUpdate();

    for (var i = 0; i < thumbnailList.Count; i++)
    {
        imageList1.Images.Add(thumbnailList[i].thumbnail);
        ListViewItem caption = new ListViewItem(thumbnailList[i].filename);
        caption.ImageIndex = thumbnailList[i].index;
        listView1.Items.Add(caption);
    }

    listView1.EndUpdate();

    if (thumbnailList.Count > 0)
    {
        Text = "Loading " + thumbnailList[thumbnailList.Count - 1].index + " of " + fileList.Count + " pictures - Thumbnails";
    }
}

void BackgroundWorker1RunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
{
    if (fileList.Count == 1) Text = "1 picture - Thumbnails";
    else if (fileList.Count > 1) Text = fileList.Count + " pictures - Thumbnails";
}

if (MethodA()){
  if (MethodB(){
    if (MethodC(){
    }
  }
}

if (!MethodA() || !MethodB() || !MethodC())
{
     // one of the methods returned false
}
else
{
     // all methods returned true
}

bool methodAsuccess = MethodA();
bool methodBsuccess = methodAsuccess && MethodB();
bool methodCsuccess = methodBsuccess && MethodC();

List<Func<bool>> methods = new List<Func<bool>>() { MethodA, MethodB, MethodC /* or more */ };

int step = 0; // declaration outside of the for-statement to be accessible after

for (; step < methods.Count && methods[step](); step++);

if (step == methods.Count)
   // all methods returned true
else
   // method at index <step> failed

public abstract class SettingBase
{
  public string Key { get; set; }
  public string Description { get; set; }
}
public abstract SettingBase<T> : SettingBase
{
  public T SettingValue { get; set; }
  public T MinValue { get; set; }
  public T MaxValue { get; set; }
}

public class SettingDouble : SettingBase<double>
{
}
public class SettingInt : SettingBase<int>
{
}
...
public List<SettingBase> MySettings { get; set; }

public interface ISetting
{
   object SettingValue { get; set; }
   object MinValue { get; set; }
   object MaxValue { get; set; }
   string Key { get; set; }
   string Description { get; set; }
}

public class Setting<T> : ISetting
{
   public T SettingValue { get; set; }
   public T MinValue { get; set; }
   public T MaxValue { get; set; }
   public string Key { get; set; }
   public string Description { get; set; }

   object ISetting.SettingValue
   {
      get => SettingValue;
      set {
         var xlate = value as T;
         if(xlate != null)
         {
            SettingValue = t;
         }
         else
         {
            throw new Exception($"Invalid type assignment for Setting<{typeof(T)}>.SettingValue ");
         }
      }
   }

   object ISetting.MinValue 
   {
      get => MinValue;
      set {
         var xlate = value as T;
         if(xlate != null)
         {
            MinValue = t;
         }
         else
         {
            throw new Exception($"Invalid type assignment for Setting<{typeof(T)}>.MinValue");
         }
      }
   }

   object ISetting.MaxValue  
   {
      get => MaxValue;
      set {
         var xlate = value as T;
         if(xlate != null)
         {
            MaxValue= t;
         }
         else
         {
            throw new Exception($"Invalid type assignment for Setting<{typeof(T)}>.MaxValue");
         }
      }
   }
}

public List<ISetting> MySettings { get; set; }

var xlate = value as T;

Kevin Marois wrote:

Anyone have a better idea?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]