C#

System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.ArgumentOutOfRangeException: Index was out of range. Must be non-negative and less than the size of the collection.

   at System.ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument argument, ExceptionResource resource)
   at System.ThrowHelper.ThrowArgumentOutOfRangeException()
   at System.Collections.Generic.List`1.get_Item(Int32 index)
   at test1.MainForm.BackgroundWorker1ProgressChanged(Object sender, ProgressChangedEventArgs e)
   at System.ComponentModel.BackgroundWorker.OnProgressChanged(ProgressChangedEventArgs e)
   at System.ComponentModel.BackgroundWorker.ProgressReporter(Object arg)
   --- End of inner exception stack trace ---
   at System.RuntimeMethodHandle.InvokeMethod(Object target, Object[] arguments, Signature sig, Boolean constructor)
   at System.Reflection.RuntimeMethodInfo.UnsafeInvokeInternal(Object obj, Object[] parameters, Object[] arguments)
   at System.Reflection.RuntimeMethodInfo.UnsafeInvoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
   at System.Delegate.DynamicInvokeImpl(Object[] args)
   at System.Delegate.DynamicInvoke(Object[] args)
   at System.Windows.Forms.Control.InvokeMarshaledCallbackDo(ThreadMethodEntry tme)
   at System.Windows.Forms.Control.InvokeMarshaledCallbackHelper(Object obj)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Windows.Forms.Control.InvokeMarshaledCallback(ThreadMethodEntry tme)
   at System.Windows.Forms.Control.InvokeMarshaledCallbacks()
   at System.Windows.Forms.Control.WndProc(Message& m)
   at System.Windows.Forms.Control.ControlNativeWindow.OnMessage(Message& m)
   at System.Windows.Forms.Control.ControlNativeWindow.WndProc(Message& m)
   at System.Windows.Forms.NativeWindow.DebuggableCallback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)
   at System.Windows.Forms.UnsafeNativeMethods.DispatchMessageW(MSG& msg)
   at System.Windows.Forms.Application.ComponentManager.System.Windows.Forms.UnsafeNativeMethods.IMsoComponentManager.FPushMessageLoop(IntPtr dwComponentID, Int32 reason, Int32 pvLoopData)
   at System.Windows.Forms.Application.ThreadContext.RunMessageLoopInner(Int32 reason, ApplicationContext context)
   at System.Windows.Forms.Application.ThreadContext.RunMessageLoop(Int32 reason, ApplicationContext context)
   at System.Windows.Forms.Application.Run(Form mainForm)
   at test1.Program.Main(String[] args)

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

    for (var i = 0; i < fileList.Count; i++)
    {
        Bitmap thumbnail = MakeThumbnail(fileList[i], thumbnailSize, thumbnailSize);
        thumbnailList.Add(thumbnail);

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

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

    if (thumbnailList.Count > 0)
    {
        foreach (Bitmap thumbnail in thumbnailList)
        {
            imageList1.Images.Add(thumbnail);
            ListViewItem caption = new ListViewItem(Path.GetFileName(fileList[counter]));
            caption.ImageIndex = counter;
            listView1.Items.Add(caption);
            counter++;
        }
    }

    listView1.EndUpdate();
}

&& (batchSize < fileList.Count)

|| (i == (fileList.Count - 1)

if (thumbnailList.Count > 0)

at System.Collections.Generic.List`1.get_Item(Int32 index)
at test1.MainForm.BackgroundWorker1ProgressChanged(Object sender, ProgressChangedEventArgs e)

fileList[counter]

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; }