c# how to refresh my targeting list

I would suggest having the script that controls your enemy send a message to the TargetMob script when they die. I expect the Mob script will already have a reference to the player so I suggest attaching the TargetMob script to the player object. Then, in the Mob script:

 player.SendMessage("RemoveTarget", transform);

(Obviously replacing 'player' with whatever your variable is called.

Then, in TargetMob add a new method like this:

 public void RemoveTarget(Transform target) {
     targets.RemoveAt(targets.IndexOf(target));
 }

I hope this solves your problem

You'd be better off doing that in a different way. Rather than finding the enemies like you do, attach a script to each enemy that records it in an available list and removes itself when destroyed.

Here is my base class I use for things like this:

  using System.Collections.Generic;
  using UnityEngine;

 public class MonoCollection<T> : MonoBehaviour where T : MonoCollection<T>
 {
     public static List<T> all = new List<T>();
     
     protected virtual void OnEnableEx()
     {
     }
     
     protected virtual void OnDisableEx()
     {
     }
     
     protected  void OnEnable()
     {
         all.Add(this as T);
         OnEnableEx();
     }
     
     protected  void OnDisable()
     {
         all.Remove(this as T);
         OnDisableEx();
     }
 }

So lets say you make an Enemy class

     public class Enemy : MonoCollection<Enemy>
     {
            public string type;

            //Presuming you want functionality in OnEnable write an override 
            //of OnEnableEx() or call the base function
            new void OnEnable()
            {
                base.OnEnable(); // Make sure to call the base if you write your own OnEnable
            }
     }

Now you can get your enemies like this:

        foreach(var enemy in Enemy.all)

Note that if you are sorting based on distance your method is significanly slower than using Linq and OrderBy. This is due to the fact that .Sort needs to call the predicate for each comparison which uses as Sqrt in your case, Linq only calls each one once. The fastest way to write that sort is:

     using System.Linq;

     ...


     var myPosition = transform.position;  
     var sortedOrder = Enemy.all.OrderBy(e=>Vector3.Distance(e.transform.position, myPosition); //.ToArray() or .ToList() if you need them all
     var closest = sortedOrder.FirstOrDefault();

Now it's even faster if you write a Linq extension for MinBy, then it's just a single pass through the list:

     public static T MinBy<T,TR>(this IEnumerable<T> source, Func<T, TR> clause, IComparer<TR> comparer=null)
     {
                     T result = default(T);
                     TR min = default(TR);
                     bool doneOne;
                     IComparer<TR> = Comparer<TR>.Default;
                     foreach(var item in source)
                     {
                         var current = clause(item);
                         if(!doneOne || comparer.Compare(min, current) > 0)
                         {
                              min=current;
                              result = item;
                              doneOne = true;
                         }
                     }
                     return result;
             }

Now you can do:

      var myPosition = transform.position;
      var closest = Enemy.all.MinBy(e=>Vector3.Distance(e.transform.position, myPosition);