C#

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!

Akshay_88 wrote:

How does these fonts work?

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Text;

namespace Barcodes.Code39
{
    [Serializable]
    public class Barcode : IEquatable<Barcode>
    {
        public static readonly Color DefaultBarColor = Color.Black;
        public const int DefaultNarrowWidth = MinNarrowWidth;
        public const int MinNarrowWidth = 1;

        public const int MinHeight = 1;

        private const int NormalRatio = 2;
        private const int LargeRatio = 3;

        internal static readonly char StartStopCharacter = '*';
        public static readonly IList<char> ValidCharacters = 
            new ReadOnlyCollection<char>(new char[]{
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
                'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
                '-', '.', ' ',
                '$', '/', '+', '%'
        });
        private static readonly Dictionary<char, short> CharacterValuesDictionary =
            new Dictionary<char, short>()
        {
            // b or w = 0, B or W = 1
            // bwbWBwBwb
            {'0', 0x0034},
            // BwbWbwbwB
            {'1', 0x0121},
            // bwBWbwbwB
            {'2', 0x0061},
            // BwBWbwbwb
            {'3', 0x0160},
            // bwbWBwbwB
            {'4', 0x0031},
            // BwbWBwbwb
            {'5', 0x0130},
            // bwBWBwbwb
            {'6', 0x0070},
            // bwbWbwBwB
            {'7', 0x0025},
            // BwbWbwBwb
            {'8', 0x0124},
            // bwBWbwBwb
            {'9', 0x0064},

            // ToDo: Add A-Z and special characters

            // bWbwBwBwb
            {'*', 0x0094}
        };

        private string value;

        public Barcode(string value)
        {
            if (value != null)
            {
                value = value.ToUpperInvariant();
                StringBuilder stringBuilder = new StringBuilder(value.Length);
                foreach (char c in value)
                    if (ValidCharacters.Contains(c))
                        stringBuilder.Append(c);
                if (stringBuilder.Length > 0)
                    this.value = stringBuilder.ToString();
            }
        }

        public static implicit operator string(Barcode barcode)
        {
            return barcode.value;
        }
        public static explicit operator Barcode(string value)
        {
            return new Barcode(value);
        }
        public static bool operator ==(Barcode first, Barcode other)
        {
            if (object.ReferenceEquals(first, other))
                return true;
            if (object.ReferenceEquals(null, first) || object.ReferenceEquals(null, other))
                return false;
            return first.value == other.value;
        }
        public static bool operator !=(Barcode first, Barcode other)
        {
            return !(first == other);
        }

        public Image Draw(int height)
        {
            return Draw(DefaultBarColor, DefaultNarrowWidth, height, false);
        }
        public Image Draw(Color barColor, int height)
        {
            return Draw(barColor, DefaultNarrowWidth, height, false);
        }
        public Image Draw(int narrowWidth, int height)
        {
            return Draw(DefaultBarColor, narrowWidth, height, false);
        }
        public Image Draw(int height, bool largeRatio)
        {
            return Draw(DefaultBarColor, DefaultNarrowWidth, height, largeRatio);
        }
        public Image Draw(Color barColor, int height, bool largeRatio)
        {
            return Draw(barColor, DefaultNarrowWidth, height, largeRatio);
        }
        public Image Draw(int narrowWidth, int height, bool largeRatio)
        {
            return Draw(DefaultBarColor, narrowWidth, height, largeRatio);
        }
        public Image Draw(Color barColor, int narrowWidth, int height, bool largeRatio)
        {
            if (narrowWidth < MinNarrowWidth)
                narrowWidth = MinNarrowWidth;
            if (height < MinHeight)
                height = MinHeight;
            if (value != null)
            {
                int ratio = largeRatio ? LargeRatio : NormalRatio;
                int charactersCount = value.Length + 2;
                // narrows + wides + separators + 1 pixel
                int width = 
                    (charactersCount * (narrowWidth * 6)) + 
                    (charactersCount * ((narrowWidth * ratio)* 3)) + 
                    ((charactersCount-1) * narrowWidth) + 
                    1;
                Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
                bitmap.MakeTransparent(Color.Transparent);
                using (Graphics g = Graphics.FromImage(bitmap))
                using (Brush brush = new SolidBrush(barColor))
                {
                    g.Clear(Color.Transparent);
                    int x = 0;
                    DrawCharacter(StartStopCharacter, g, brush, ref x, narrowWidth, height, ratio);
                    foreach (char c in value)
                    {
                        x += narrowWidth; // separator
                        DrawCharacter(c, g, brush, ref x, narrowWidth, height, ratio);
                    }
                    x += narrowWidth; // separator
                    DrawCharacter(StartStopCharacter, g, brush, ref x, narrowWidth, height, ratio);
                }
                return bitmap;
            }
            else
                return null;
        }
        private void DrawCharacter(char c, Graphics g, Brush brush, ref int x, int narrowWidth, int height, int ratio)
        {
            short characterValue = CharacterValuesDictionary[c];
            for (int bitIndex = 8; bitIndex >= 0; bitIndex--)
            {
                int bit = (characterValue >> bitIndex) & 1;
                int width = bit == 1 ? narrowWidth * ratio : narrowWidth;
                if ((bitIndex % 2) == 0) // bar
                    g.FillRectangle(brush, x, 0, width, height);
                x += width;
            }
        }
        public override bool Equals(object obj)
        {
            if (obj is Barcode)
                return Equals(obj as Barcode);
            return base.Equals(obj);
        }
        public bool Equals(Barcode other)
        {
            return this == other;
        }
        public override int GetHashCode()
        {
            if (value == null)
                return 0;
            return value.GetHashCode();
        }
        public override string ToString()
        {
            return value;
        }
    }
}