Singleton's stateless instance method thread safety (C#)

Question

Is it thread safe to make Converter a singleton?

public interface IConverter<TFoo, TBar>
    where TFoo : class, new()
    where TBar : class, new()
{
    TFoo ToFoo(TBar q);
    TBar ToBar(TFoo q);
}

public class Converter : IConverter<Foo, Bar>
{
    public Foo ToFoo(Bar b) {return new Foo(b);}
    public Bar ToBar(Foo f) {return new Bar(f);}
}

Answer 1

Yes, that's absolutely fine. There's no state, thus no thread safety issues - and there's no reason to have multiple instances. It's a fairly natural singleton.

Of course it's nice to use the interface where you can, for flexibility and testability - but when you know you want to use that specific implementation, a singleton instance is fine.

Answer 2

Yes, the implementation does nothing that depend on state.

Answer 3

Yes, as the class has no data members, you can make it a singleton.

As the class is so small, you can just create a static instance of it:

public class Converter : IConverter<Foo, Bar> {

  private static _instance = new Converter();

  public static Instance { get { return _instance; } }

  public Foo ToFoo(Bar b) {return new Foo(b);}
  public Bar ToBar(Foo f) {return new Bar(f);}

}