Implementing a PlayerPrefs Manager with Reflection in Unity
Reflection Knowledge Primer
Determining if one type can be assigned to another (inheritance relationships):
public class ParentClass
{
}
public class ChildClass : ParentClass
{
}
...
Type parentType = typeof(ParentClass);
Type childType = typeof(ChildClass);
// Check if the specified type can be assigned to this type
if(parentType.IsAssignabl ...
Posted on Mon, 02 Nov 2026 16:48:51 +0000 by 4rxsid
Singleton and Builder Design Patterns Implementation
Singleton Pattern
Ensures a class has only one instance while providing a global access point.
Eager Enitialization
public class EagerSingleton {
private EagerSingleton() {}
private static final EagerSingleton INSTANCE = new EagerSingleton();
public static EagerSingleton getInstance() {
return INSTANCE;
}
}
La ...
Posted on Fri, 30 Oct 2026 16:45:58 +0000 by unibroue
Singleton Pattern: Five Implementation Approaches
Overview
The Singleton pattern ensures a class has exact one instance and provides a global point of access to it.
The core challenge is: how to bypass traditional constructors and guarantee a single instance? Clients calling a class should not concern themselves with instance count restrictions—this responsibility falls on the class designer, ...
Posted on Tue, 27 Oct 2026 16:30:40 +0000 by ntohky14
Core Components of Spring Bean Management
The foundation of Spring's bean management system revolves around several key components that work together to define, instantiate, and manage beans. Below is a simplified implemantation illustrating these core concepts.
BeanDefinition: Metadata Container for Beans
BeanDefinition acts as a metadata holder for a bean, storing information such as ...
Posted on Fri, 09 Oct 2026 16:05:25 +0000 by flashback
Singleton Pattern Implementation Strategies and Security Considerations
The Singleton pattern represents one of the most fundamental design patterns in software engineering, providing an efficient mechanism for ensuring that exact one instance of a class exists throughout the application lifecycle.
Core Principles of Singleton Implementation
There are two primary approaches to implementing the Singleton pattern:
E ...
Posted on Thu, 17 Sep 2026 16:19:48 +0000 by flashpipe
Spring Source Analysis: Bean Lifecycle (Part 3)
In previous articles, we've covered the foundational steps for bean preparation, including bean definition processing and FactoryBean identification. Building upon this knowledge, we can now dive deeper into the implementation logic of the getBean method and gain better insights into how the createBean method works.
Usage of getBean
Before divi ...
Posted on Fri, 11 Sep 2026 16:31:00 +0000 by nihal
Thread Safety of Beans in Spring Framework
Thread safety in Spring beans depends on their scope. Spring supports multiple bean scopes, with Singleton and Prototype being the most commonly used.
By default, Spring beans are singletons, meaning a single instance exists per Spring IoC container. In contrast, prototype-scoped beans create a new instance each time they are requested from the ...
Posted on Fri, 11 Sep 2026 16:01:38 +0000 by SuperTini
Thread-Safe Singleton Pattern Implementation Strategies in Java
The Singleton pattern restricts a class to a single instance and provides a global point of access to that instance. This pattern is characterized by a private constructor, a private static reference to the single instance, and a public static method (often named getInstance) that returns the instance.
Eager Initialization
In the eager initia ...
Posted on Mon, 07 Sep 2026 16:56:23 +0000 by jasonok6
Understanding the Singleton Design Pattern in Java
Overview
The Singleton pattern ensures that a class has only one instance throughout an application while providing a global access point to that instance. This is particularly useful for resource-intensive objects that should be shared, such as database connection pools, configuration managers, or logging utilities.
For example, SessionFactory ...
Posted on Tue, 01 Sep 2026 16:08:28 +0000 by erfg1
GoF Design Patterns Explained
============================================================
Creational Patterns
Singleton Pattern
Ensures a class has only one instance, and provides a global point of access to it.
/**
* Eager initialization
*/
public class Singleton {
private static final Singleton INSTANCE = new Singleton();
private Singleton() {}
public sta ...
Posted on Mon, 31 Aug 2026 16:17:25 +0000 by dr.maju