etiqueta = etiqueta.SubString(0, 1) + new string('-', etiqueta.Length - 2);

using System;
using System.IO;
using System.Xml.Serialization;
using UnityEngine;
 
namespace GTAMapper.Extensions
{
    public static class SerializerHelper
    {
        public static string Serialize<T>(this T data, SerializeFormat format = SerializeFormat.XML)
        {
            switch (format)
            {
                case SerializeFormat.XML:
                    return SerializeToXml(data);
 
                case SerializeFormat.JSON:
                    return SerializeToJson(data);
 
                default:
                    return string.Empty;
            }
        }
 
        public static T Deserialize<T>(this string data, SerializeFormat format = SerializeFormat.XML)
        {
            switch (format)
            {
                case SerializeFormat.XML:
                    return DeserializeToXml<T>(data);
 
                case SerializeFormat.JSON:
                    return DeserializeFromJson<T>(data);
 
                default:
                    return default(T);
            }
        }
 
        /*public static string SerializeToXml<T>(T data)
        {
            var serializer = new DataContractSerializer(data.GetType());
            var builder = new StringBuilder();
            var writer = XmlWriter.Create(builder);
            serializer.WriteObject(writer, data);
            writer.Flush();
            return builder.ToString();
        }*/
 
        private static string SerializeToXml<T>(T data)
        {
            var xmlSerializer = new XmlSerializer(typeof(T));
            // xmlSerializer.WriteProcessingInstruction("xml", "version='1.0'");
 
            using (var stringWriter = new StringWriter())
            {
                xmlSerializer.Serialize(stringWriter, data);
                return stringWriter.ToString();
            }
        }
 
        /*public static T DeserializeToXml<T>(string data)
        {
            var serializer = new DataContractSerializer(data.GetType());
            var writer = XmlReader.Create(GenerateStreamFromString(data));
            var result = serializer.ReadObject(writer);
            return (T)result;
        }*/
 
        private static T DeserializeToXml<T>(string data)
        {
            try
            {
                var xmlSerializer = new XmlSerializer(data.GetType());
                using (var stream = GenerateStreamFromString(data))
                {
                    var result = xmlSerializer.Deserialize(stream);
                    return (T)result;
                }
            }
            catch (Exception ex)
            {
                Debug.LogException(ex);
                Debug.Log(data);
                return default(T);
            }
        }
 
        private static Stream GenerateStreamFromString(string s)
        {
            // using
            var stream = new MemoryStream();
            var writer = new StreamWriter(stream, System.Text.Encoding.UTF8);
 
            writer.Write(s);
            writer.Flush();
            stream.Position = 0;
 
            return stream;
        }
 
        private static string SerializeToJson<T>(T data)
        {
            //return JsonConvert.SerializeObject(data);
            throw new NotImplementedException();
        }
 
        private static T DeserializeFromJson<T>(string data)
        {
            //return JsonConvert.DeserializeObject<T>(data);
            throw new NotImplementedException();
        }
    }
 
    public enum SerializeFormat
    {
        XML = 1,
        JSON = 2
    }
}

using System.Collections.Concurrent;
using UnityEngine;
 
namespace GTAMapper.Extensions.Threading
{
    public class SendMessageHelper : MonoBehaviour
    {
        private static ConcurrentQueue<SendMessageContext> QueuedMessages = new ConcurrentQueue<SendMessageContext>();
 
        public static void RegisterSendMessage(SendMessageContext context)
        {
            QueuedMessages.Enqueue(context);
        }
 
        private void Update()
        {
            if (QueuedMessages.Count > 0)
            {
                SendMessageContext context = null;
 
                if (!QueuedMessages.TryDequeue(out context))
                    return;
 
                context.Target.SendMessage(context.MethodName, context.Value, context.Options);
            }
        }
    }
}

using UnityEngine;
 
namespace GTAMapper.Extensions.Threading
{
    public class SendMessageContext
    {
        public MonoBehaviour Target;
        public string MethodName;
        public object Value;
        public SendMessageOptions Options = SendMessageOptions.RequireReceiver;
 
        public SendMessageContext(MonoBehaviour target, string methodName, object value, SendMessageOptions options)
        {
            this.Target = target;
            this.MethodName = methodName;
            this.Value = value;
            this.Options = options;
        }
    }
}

using UnityEngine;
 
namespace GTAMapper.Extensions.Threading
{
    public static class SendMessageExtensions
    {
        public static SendMessageContext SendSafeMessage(this MonoBehaviour monoBehaviour, string methodName, object value = null, SendMessageOptions sendMessageOptions = default(SendMessageOptions))
        {
            return new SendMessageContext(monoBehaviour, methodName, value, sendMessageOptions);
        }
    }
}

this.SendSafeMessage("pepito")

public void pepito() {
    // Moar code que seguirá ejecutándose en el mismo hilo desde el que se llamo "SendSafeMessage"
}

using GTAMapper.Extensions.Threading;
using System;
using UnityEngine;
 
namespace GTAMapper.Utils.Debugging
{
    public static class ThreadedDebug
    {
        private static double TimeRunning
        {
            get
            {
                return (DateTime.Now - System.Diagnostics.Process.GetCurrentProcess().StartTime).TotalSeconds;
            }
        }
 
        public static void Log(object obj, bool jumpBack = true)
        {
            Debug.Log($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + obj.ToString());
        }
 
        public static void LogFormat(string str, params object[] objs)
        {
            LogFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, true, objs);
        }
 
        public static void LogFormat(string str, bool jumpBack = true, params object[] objs)
        {
            Debug.LogFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, objs);
        }
 
        public static void LogWarning(object obj, bool jumpBack = true)
        {
            Debug.LogWarning($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + obj.ToString());
        }
 
        public static void LogWarningFormat(string str, params object[] objs)
        {
            LogWarningFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, true, objs);
        }
 
        public static void LogWarningFormat(string str, bool jumpBack = true, params object[] objs)
        {
            Debug.LogWarningFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, objs);
        }
 
        public static void LogError(object obj, bool jumpBack = true)
        {
            Debug.LogError($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + obj.ToString());
        }
 
        public static void LogErrorFormat(string str, params object[] objs)
        {
            LogErrorFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, true, objs);
        }
 
        public static void LogErrorFormat(string str, bool jumpBack = true, params object[] objs)
        {
            Debug.LogErrorFormat($"[{ThreadMarker.Name} | {TimeRunning.ToString("F2")}] " + str, objs);
        }
 
        public static void LogException(System.Exception ex, bool jumpBack = true)
        {
            Debug.LogException(ex);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Threading;
 
namespace GTAMapper.Extensions.Threading
{
    public class ThreadMarker : IDisposable
    {
        //[ThreadStatic]
        //private static string __Name = $"Unity Thread #{Thread.CurrentThread.ManagedThreadId}";
 
        private static Dictionary<int, string> ThreadNames = new Dictionary<int, string>();
 
        public static string Name
        {
            get
            {
                lock (ThreadNames)
                {
                    try
                    {
                        return ThreadNames[Thread.CurrentThread.ManagedThreadId];
                    }
                    catch
                    {
                        return $"Unity Thread #{Thread.CurrentThread.ManagedThreadId}";
                    }
                }
            }
        }
 
        public ThreadMarker(string name)
        {
            lock (ThreadNames)
            {
                ThreadNames.AddOrSet(Thread.CurrentThread.ManagedThreadId, name);
            }
 
            // __Name = name;
        }
 
        public void Dispose()
        {
            ThreadNames.Remove(Thread.CurrentThread.ManagedThreadId);
            // __Name = "Un-Owned";
        }
    }
}

using System;
 
namespace GTAMapper.Extensions.Threading
{
    public class NamedHandler<TArg>
    {
        public readonly Func<string, TArg> Handler;
 
        public NamedHandler(Func<string, TArg> handler)
        {
            Handler = arg =>
            {
                using (new ThreadMarker(arg))
                {
                    return handler(arg);
                }
            };
        }
    }
}

int TaskId = new Random().Next();
 
ThreadPool.QueueUserWorkItem(new NamedHandler<WaitCallback>(name => new WaitCallback(BackgroundRunner)).Handler($"Ninja #{TaskId}"));