C#

public interface IMessage
{
  void ShowMesage();
}
public class MainDialog : IMessage
{
  public MainDialog() {}
  public void ShowMessage()
  {
    MessageBox.Show("Hello");
  }
}

public static class SingleObj
{
  public static void ShowMessage<T>() where T : IMessage, new()
  {
    T dialog = new T();
    dialog.ShowMessage();
  }
}

public class Tab1
{
  public void Function_InTab()
  {
    SingleObj.ShowMessage<MainDialog>();
  }
}

AmbiguousName wrote:

I have a class which is designed to have only one instance.

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

Eddy Vluggen wrote:

Why not simply use a static class?

AmbiguousName wrote:

I would love to but in my current environment, they are considered plague

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

AmbiguousName wrote:

But at the moment I want to do this without static.

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

BobJanova wrote:

Singletons are just static classes hidden behind a layer of obfuscation

singleton class MyClass {
 public static singleton Instance { create { return new MyClass() } };
 
 private int nextID = 100;
 public int NextValue() { return nextID++; }
}

static class MyClass {
 private static int nextID = 100; 
 public static int NextValue() { return nextID++; }
}

class Singleton<T> where T: new() {
 private static object lockObject = new object();

 private static T instance;
 public static T Instance {
  get {
   if(instance == null){
    lock(lockObject) {
     if(instance == null) instance = new T();
    }
   }
   return instance;
  }
}

public class Tab1
{
  public void Function_InTab()
  {
    Singleton<MainDlg>.Instance.ShowMessage();
  }
}

public sealed class Foo // must be sealed to prevent alternate instanciation
{
  #region Singleton
  private static readonly Lazy<Foo> _Instance = new Lazy<Foo>(() => new Foo());
  public static Foo Instance { get { return _Instance.Value; } }

  private Foo()
  {
    // the ONLY constructor MUST be private to prevent other ways of creating an instance of the class
  }
  #endregion
  public void Method()
  {
    // ...
  }
  // other class methods/properties/etc.
}

Foo.Instance.Method();

In fact invoking your Singleton implementation twice will create a new instance each time!