SingletonAttribute.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
 
namespace Waher.Runtime.Inventory
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = true)]
    public class SingletonAttribute : Attribute
    {
        private static readonly Dictionary<SingletonKey, SingletonRecord> instances = new Dictionary<SingletonKey, SingletonRecord>();
 
        public SingletonAttribute()
        {
        }
 
        internal static async Task Clear()
        {
            SingletonRecord[] Objects;
 
            lock (instances)
            {
                Objects = new SingletonRecord[instances.Count];
                instances.Values.CopyTo(Objects, 0);
                instances.Clear();
            }
 
            foreach (SingletonRecord Rec in Objects)
            {
                if (Rec.Instantiated)
                {
                    try
                    {
                        if (Rec.Instance is IDisposableAsync DisposableAsync)
                            await DisposableAsync.DisposeAsync();
                        else if (Rec.Instance is IDisposable Disposable)
                            Disposable.Dispose();
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
        }
 
        public object Instantiate(bool ReturnNullIfFail, Type Type, params object[] Arguments)
        {
            SingletonKey Key = new SingletonKey(Type, Arguments);
 
            lock (instances)
            {
                if (instances.TryGetValue(Key, out SingletonRecord Rec))
                    return Rec.Instance;
            }
 
            object Object = Types.Create(ReturnNullIfFail, Type, Arguments);
            if (Object is null)
                return null;
 
            lock (instances)
            {
                if (instances.TryGetValue(Key, out SingletonRecord Rec))
                {
                    if (Object is IDisposableAsync DisposableAsync)
                    {
                        Task.Run(async () =>
                        {
                            try
                            {
                                await DisposableAsync.DisposeAsync();
                            }
                            catch (Exception ex)
                            {
                                Log.Exception(ex);
                            }
                        });
                    }
                    else if (Object is IDisposable Disposable)
                        Disposable.Dispose();
 
                    return Rec.Instance;
                }
 
                instances[Key] = new SingletonRecord(Key, true, Object);
            }
 
            return Object;
        }
 
        public static void Register(object Object, params object[] Arguments)
        {
            SingletonKey Key = new SingletonKey(Object.GetType(), Arguments);
 
            lock (instances)
            {
                if (instances.ContainsKey(Key))
                    throw new InvalidOperationException("Singleton already registered.");
 
                instances[Key] = new SingletonRecord(Key, false, Object);
            }
        }
 
        public static bool Unregister(object Object, params object[] Arguments)
        {
            SingletonKey Key = new SingletonKey(Object.GetType(), Arguments);
 
            lock (instances)
            {
                return instances.Remove(Key);
            }
        }
 
        public static void Replace(object Object, params object[] Arguments)
        {
            SingletonKey Key = new SingletonKey(Object.GetType(), Arguments);
 
            lock (instances)
            {
                instances[Key] = new SingletonRecord(Key, false, Object);
            }
        }
 
        public static bool IsRegistered(Type Type, params object[] Arguments)
        {
            SingletonKey Key = new SingletonKey(Type, Arguments);
 
            lock (instances)
            {
                return instances.ContainsKey(Key);
            }
        }
 
        public static SingletonRecord[] GetInstances()
        {
            lock (instances)
            {
                SingletonRecord[] Result = new SingletonRecord[instances.Count];
                instances.Values.CopyTo(Result, 0);
                return Result;
            }
        }
    }
}