public static void Main()
{
ISingleton IObj1 = null, IObj2 = null;
int data = 0;
//IObj1=Singleton.calling();
Thread t1 = new Thread(() => { IObj1 = Singleton.calling(); });
t1.Start();
Thread.Sleep(2000);
if (IObj1 != null)
{
data = IObj1.getData();
Console.WriteLine(data);
IObj1.setData(8);
data = IObj1.getData();
Console.WriteLine(data);
}
Thread t2 = new Thread(() => { IObj2 = Singleton.calling(); });
t2.Start();
Thread.Sleep(2000);
if (IObj2 != null)
{
data = IObj2.getData();
Console.WriteLine(data);
IObj2.setData(9);
data = IObj2.getData();
Console.WriteLine(data);
}
}
public static void RemoveInstance(ISingleton instance)
{
if (instance != null)
{
instances.Remove(instance);
}
}
private static ISingleton CreateInstance(Type type)
{
ISingleton singleton = null;
if (type.IsSameOrSubClass(typeof(Singleton)))
{
singleton = Activator.CreateInstance(type) as Singleton;
}
else if (type.IsSameOrSubClass(typeof(SingletonMono)))
{
var component = UnityEngine.Object.FindObjectOfType(type);
if (UnityEngine.Object.FindObjectsOfType(type).Length > 1)
{
throw new Exception($"Singleton: There should never be more than one SingletonMono instacne, type= {type.Name}.");
}
if (component == null)
{
GameObject go = new GameObject();
go.name = "[Singelton] " + type.Name;
go.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
component = go.AddComponent(type);
}
singleton = component as SingletonMono;
}
return(singleton);
}
void LoadSingletonClasses()
{
LoadedData.singletonList = new Dictionary <Type, ISingleton>();
Type[] types = new Type[0];
Type t = typeof(ISingleton);
types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(s => s.GetTypes())
.Where(p => t.IsAssignableFrom(p)).ToArray();
for (int i = 0; i < types.Length; i++)
{
ConstructorInfo info = types[i].GetConstructor(new Type[0]);
ISingleton inst = null;
if (info != null)
{
inst = info.Invoke(new object[0]) as ISingleton;
MonoBehaviour singleton = new GameObject(inst.GetType().FullName).AddComponent(inst.GetType()) as MonoBehaviour;
DontDestroyOnLoad(singleton.gameObject);
ISingleton castedSingleton = singleton as ISingleton;
castedSingleton.RunOnCreated();
LoadedData.singletonList.Add(types[i], castedSingleton);
}
}
}
public override void OnInspectorGUI()
{
++EditorGUI.indentLevel;
SingletonRoot script = (SingletonRoot)target;
mConstantRepaint = false;
for (int i = 0; i < script.singletonInstances.Count; ++i)
{
ISingleton inst = script.singletonInstances[i];
if (inst is MonoBehaviour)
{
continue;
}
Type type = inst.GetType();
string name = inst.GetType().FullName;
bool foldout = EditorGUILayout.Foldout(Foldout(name), name);
if (foldout)
{
SingletonRoot.IEditorDrawer drawer;
if (SingletonRoot.editorDrawers.TryGetValue(type, out drawer))
{
mConstantRepaint |= drawer.constantRepaint;
drawer.Draw(inst);
}
}
Foldout(name, foldout);
}
--EditorGUI.indentLevel;
}
public MainWindow(ICalculateService calculateService,
ISingleton singleton)
{
_calculateService = calculateService;
this.singleton = singleton;
InitializeComponent();
}
/// <summary>
///
/// </summary>
/// <param name="target"></param>
/// <returns>Returns true if the validation was a success.</returns>
public bool OnAwake(ISingleton target)
{
if (object.ReferenceEquals(target, null))
{
throw new System.ArgumentNullException("target");
}
_target = target;
//first test if we have the appropriate configuration
if (_target.component.GetComponentsAlt <ISingleton>().Count() > 1 && !_target.component.HasComponent <SingletonManager>())
{
Debug.LogWarning("Gameobject with multiple Singletons exists without a SingletonManager attached, adding a SingletonManager with default destroy settings.", target.component);
_target.component.AddComponent <SingletonManager>();
}
//now set up singleton reference
if (_target.component.IsActiveAndEnabled())
{
this.EnforceThisAsSingleton();
_target.ComponentDestroyed += this.OnComponentDestroyed;
GameLoopEntry.LevelWasLoaded += this.OnLevelWasLoaded;
return(true);
}
else
{
//remove self if it were added
this.RemoveThisAsSingleton();
return(false);
}
}
/// <summary>
/// 销毁单例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="singleton"></param>
public static void Dispose(this ISingleton singleton)
{
if (singleton != null)
{
singleton.OnDispose();
}
}
public ScopesController(IServiceOne testingServiceOne, IServiceTwo testingServiceTwo, ISingleton singleton, IScoped scoped, ITransient transient)
{
this.testingServiceOne = testingServiceOne;
this.testingServiceTwo = testingServiceTwo;
this.singleton = singleton;
this.scoped = scoped;
this.transient = transient;
}
public SomeController(ITransient transient, IScoped scoped, ISingleton singleton,
Func <ITransient> transientFactory)
{
Transient = transient;
Scoped = scoped;
Singleton = singleton;
TransientFactory = transientFactory;
}
public HomeController(ITransient transientService1, ITransient transientService2, ISingleton singletonService1, ISingleton singletonService2, IScoped scopedService1, IScoped scopedService2)
{
this.transientService1 = transientService1;
this.transientService2 = transientService2;
this.singletonService1 = singletonService1;
this.singletonService2 = singletonService2;
this.scopedService1 = scopedService1;
this.scopedService2 = scopedService2;
}
public ClassConsumer(ISingleton dependency)
{
if (dependency == null)
{
throw new ArgumentException("dependency not founded");
}
this._dependency = dependency;
}
public TestController(ITransient injectedTransientItem, ISingleton injectedSingletonItem, IScoped injectedScopedItem, ILogger <TestController> injectedLogger)
{
_theTransient = injectedTransientItem;
_theSingleton = injectedSingletonItem;
_theScoped = injectedScopedItem;
_theLogger = injectedLogger;
_theLogger.LogDebug($"The TestController that was created");
_theLogger.LogDebug($"The Transient that was injected has data: {injectedTransientItem.Data}");
}
public GenerateController(
ITransient transient,
IScoped scoped,
ISingleton singleton)
{
_transient = transient;
_scoped = scoped;
_singleton = singleton;
}
public SampleService(IFoo foo, IBar bar, ISingleton singleton, ITransient transient, IAsyncClass asyncClass)
{
_id = Guid.NewGuid();
_foo = foo ?? throw new ArgumentNullException(nameof(foo));
_bar = bar ?? throw new ArgumentNullException(nameof(bar));
_singleton = singleton ?? throw new ArgumentNullException(nameof(singleton));
_transient = transient ?? throw new ArgumentNullException(nameof(transient));
_asyncClass = asyncClass ?? throw new ArgumentNullException(nameof(asyncClass));
}
public void LifecycleWarningTest()
{
IWindsorContainer container = new WindsorContainer();
container.Register(
Component.For <ISingleton>().ImplementedBy <Singleton>().LifestyleSingleton(),
Component.For <ITransient>().ImplementedBy <Transient>().LifestyleTransient()
);
ISingleton singleton = container.Resolve <ISingleton>();
}
public AdminUserController(ApplicationDbContext db, IWebHostEnvironment hostEnvironment)
{
_db = db;
_hostEnvironment = hostEnvironment;
UserVM = new ApplicationUserViewModel()
{
ApplicationUser = new ApplicationUser()
};
_iSingleTon = Singleton.GetInstance;
}
public static void Remove(ISingleton singleton)
{
if (root.singletonInstances.Remove(singleton))
{
if (singleton is MonoBehaviour)
{
GameObject.Destroy(((MonoBehaviour)singleton).gameObject);
}
SingletonLog.InfoFormat("{0} Removed", singleton.GetType().FullName);
}
}
public CountriesController(ApplicationDbContext context)
{
_context = context;
this.UnitOfWork = new UnitOfWork(_context);
CountriesVM = new CountryViewModel()
{
Country = new Country(),
Total = 0
};
_iSingleton = Singleton.GetInstance;
}
public ProductController(ITransient transient1, ITransient transient2, ISingleton singleton1, ISingleton singleton2, IScoped scoped1, IScoped scoped2)
{
_transient1 = transient1;
_transient2 = transient2;
_singleton1 = singleton1;
_singleton2 = singleton2;
_scoped1 = scoped1;
_scoped2 = scoped2;
}
public static void AddInstance(ISingleton instance)
{
if (instance == null)
{
return;
}
if (instances.Contains(instance) == false)
{
instances.Add(instance);
}
}
public AuthorsController(ApplicationDbContext context, IWebHostEnvironment hostEnvironment)
{
_context = context;
_hostEnvironment = hostEnvironment;
AuthorsVM = new AuthorViewModel()
{
Author = new Author(),
Authors = new List <Author>(),
PagingInfo = new PagingInfo()
};
_iSingleTon = Singleton.GetInstance;
}
public BooksController(ApplicationDbContext context, IWebHostEnvironment hostEnvironment)
{
_context = context;
_hostEnvironment = hostEnvironment;
BooksVM = new BooksViewModel()
{
Books = new List <Book>(),
Book = new Book(),
GenresViewModels = new List <GenresViewModel>()
};
_iSingleton = Singleton.GetInstance;
}
private readonly Dictionary <string, ISingleton> SingletonPool = new Dictionary <string, ISingleton>(); //单例池字典
/// <summary> 添加单例 </summary>
public void Add(ISingleton obj)
{
string name = obj.ToString();
if (!SingletonPool.ContainsKey(name))
{
SingletonPool.Add(name, obj);
}
else
{
Debug.Log($"已具有相同名称的实例:{name}");
}
}
public Combined(ISingleton first, ITransient second)
{
if (first == null)
{
throw new ArgumentNullException("first");
}
if (second == null)
{
throw new ArgumentNullException("second");
}
Instances++;
}
/// <summary> 删除指定单例 </summary>
public void Delete(ISingleton obj)
{
string name = obj.ToString();
if (SingletonPool.ContainsKey(name))
{
SingletonPool[name].Clear();
SingletonPool.Remove(name);
}
else
{
Debug.Log($"实例不存在:{name}");
}
}
/// <summary>
/// Get/Create new Singleton for normal class
/// </summary>
/// <typeparam name="T">Type of class that contain PRIVATE CONSTRUCTOR</typeparam>
/// <returns></returns>
private static T NormalInstance <T>() where T : ISingleton
{
System.Type type = typeof(T);
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance);
if (constructors.Length == 0)
{
throw new System.Exception("Private constructor not found");
}
else
{
ISingleton value = (ISingleton)constructors[0].Invoke(new object[] { });
return((T)value);
}
}
/// <summary>
/// Main entry funciton
/// </summary>
/// <param name="args">command line args</param>
static void Main(string[] args)
{
// initial resolutions
ISingleton s = Program.GetContainer().Resolve <ISingleton>();
IMathFunc m = Program.GetContainer().Resolve <IMathFunc>();
s.SetVal(m.MathFunc(1.1, 2.2).ToString());
s = null;
// test singleton
s = Program.GetContainer().Resolve <ISingleton>();
Console.WriteLine(string.Format("Singleton value: {0} (should be 3.3)", s.GetVal()));
Console.ReadLine();
}
public Combined(ISingleton first, ITransient second)
{
if (first == null)
{
throw new ArgumentNullException("first");
}
if (second == null)
{
throw new ArgumentNullException("second");
}
Instances++;
}
public void MirandaGetSingletonTest()
{
ISingleton singleton = context.Get <ISingleton>();
Assert.AreEqual(SINGLETON_STRING, singleton.GetString());
string anotherString = "Change to this string.";
singleton.ChangeString(anotherString);
ISingleton anotherInstance = context.Get <ISingleton>();
Assert.AreNotEqual(SINGLETON_STRING, anotherInstance.GetString());
Assert.AreEqual(anotherString, anotherInstance.GetString());
}
static Repository()
{
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (Type type in assembly.GetExportedTypes())
{
if (type.GetInterface(typeof(ISingleton).FullName) != null)
{
ISingleton singleton = (ISingleton)Activator.CreateInstance(type);
_singletons.Add(singleton.Name, singleton);
}
}
}
}
public Glorp(IContainerManager containerManager, INormal normal1, INormal normal2, ISingleton singleton1, ISingleton singleton2)
{
IKeyed keyed1_1 = containerManager.GetInstance<IKeyed>("keyed-1");
IKeyed keyed1_2 = containerManager.GetInstance<IKeyed>("keyed-1");
IKeyed keyed2_1 = containerManager.GetInstance<IKeyed>("keyed-2");
IKeyed keyed2_2 = containerManager.GetInstance<IKeyed>("keyed-2");
string format = "{0} Name={1}, Key={2}";
Console.WriteLine(format, "normal1", normal1.Name, normal1.Key);
Console.WriteLine(format, "normal2", normal2.Name, normal2.Key);
Console.WriteLine(format, "singleton1", singleton1.Name, singleton1.Key);
Console.WriteLine(format, "singleton2", singleton2.Name, singleton2.Key);
Console.WriteLine(format, "keyed1_1", keyed1_1.Name, keyed1_1.Key);
Console.WriteLine(format, "keyed1_2", keyed1_2.Name, keyed1_2.Key);
Console.WriteLine(format, "keyed2_1", keyed2_1.Name, keyed2_1.Key);
Console.WriteLine(format, "keyed2_2", keyed2_2.Name, keyed2_2.Key);
}
public ScopedCombined(ITransient transient, ISingleton singleton)
{
if (transient == null)
{
throw new ArgumentNullException("transient");
}
if (singleton == null)
{
throw new ArgumentNullException("singleton");
}
if (!(transient is ScopedTransient))
{
throw new ArgumentException("transient should be of type ScopedTransient");
}
Instances++;
}
public SampleModuleWithSingletonDependency(ISingleton singleton)
{
Singleton = singleton;
}
public Thing(ITransient transient, ISingleton singleton)
{
_transient = transient;
_singleton = singleton;
}
