class MyClass
{
    private MyClass()
    {
    }    

    public MyClass Create();
}

class MyClass()
{
    private void Initialize()
    {
    }

    public MyClass()
    {
        Initialize();
    }
}

public class MyClass
{
    public MyClass()
    {
    }    

    public MyClass Initialize(...);
}

public class MyClass
{
    public MyClass(...)
    {
    }
}

class MyClass
{
    private MyClass()
    {
    }    

    public static MyClass Create() {}
}

var myObj = new MyClass();
myObj.Initialize();

class A
{
  A(ISomething s)
  {
    if(s == null)
      throw new ArgumentNullException("s");
    this.s = s;
  }
}

A>>Срочно вынести в отдельный метод!

class Foo : IDisposable
{
  public Foo(...)
  {
    //проверка аргументов и примитивная логика инициализации вроде присвоения начальных значений полям.
  }

  public void Initialize()
  {
    //тяжелый код с выделением ресурсов
  }

  public void Dispose()
  {
    if(disposed)
      return;
    //проверяем, какие ресурсы были выделены и освобождаем их
  }
}

using (Foo foo = new Foo())
{
  //...
  foo.Initialize()
  //...
}

if(someresource != null)
  someresource.Dispose();

class Foo : IDisposable
{
  public Foo(...)
  {
    //проверка аргументов и примитивная логика инициализации вроде присвоения начальных значений полям.

    try
    {
      Initialize();
    }
    catch
    {
      Dispose();
      throw;
    }
  }

  private void Initialize()
  {
    //тяжелый код с выделением ресурсов
  }

  public void Dispose()
  {
    if(disposed)
      return;
    //проверяем, какие ресурсы были выделены и освобождаем их
  }
}

Есть ли у этого подхода преимущества перед обычной инициализацией через конструктор в C#?

        public static object CreateInstance(Type type, object[] arguments)
        {
            if (arguments == null || arguments.Length == 0)
            {
                Expression newExp = Expression.New(type);
                Func<object> activator = Expression.Lambda<Func<object>>(Expression.Convert(newExp, typeof(object))).Compile();
                return activator();
            }
            else
            {
                Type[] argTypes = arguments.Select(arg => arg.GetType()).ToArray();
                ConstructorInfo constructor = type.GetConstructor(argTypes);

                if (constructor == null)
                {
                    string msg = String.Format(
                        "Constructor on type {0} that takes in parameters of type [{1}] not found.",
                        type,
                        String.Join<Type>(",", argTypes));
                    throw new MissingMethodException(msg);
                }

                ParameterExpression param = Expression.Parameter(typeof(object[]), "args");
                List<Expression> argsExp = new List<Expression>();

                for (int i = 0; i < arguments.Length; i++)
                {
                    Expression paramAccessorExp = Expression.ArrayIndex(param, Expression.Constant(i));
                    Expression paramCastExp = Expression.Convert(paramAccessorExp, argTypes[i]);
                    argsExp.Add(paramCastExp);
                }

                Expression newExp = Expression.New(constructor, argsExp);
                Func<object[], object> activator = Expression.Lambda<Func<object[], object>>(newExp, param).Compile();

                return activator(arguments);
            }
        }

Foo foo = new Foo();
Thread instantiationThread = new Thread(() =>
{
    do
    {
        foo = new Foo();
    } while (true);
});

Thread checkInitializedThread = new Thread(() =>
{
    do
    {
        if (!foo._initialized1 | !foo._initialized2)
        {
            Console.WriteLine("Bingo!!!");
        }
    } while (true);
});

instantiationThread.Start();
checkInitializedThread.Start();

class Foo
{
    public bool _initialized1;
    public bool _initialized2;

    public Foo()
    {
        //Thread.Sleep(10);
        _initialized1 = true;
        Thread.Sleep(10);
        _initialized2 = true;
    }
}

            Foo foo = new Foo();
            int i = 0;

            Thread checkInitializedThread = new Thread(() =>
            {
                do
                {
                    if (!foo._initialized1 | !foo._initialized2)
                    {
                        Console.WriteLine("Bingo!!!");
                    }
                    Console.WriteLine(foo._i);
                } while (true);
            });

            checkInitializedThread.Start();

            do
            {
                foo = new Foo();
                foo._i = i;
                i++;
            } while (true);

class Foo
{
    public bool _initialized1;
    public bool _initialized2;
    public int _i;

    public Foo()
    {
        //Thread.Sleep(10);
        _initialized1 = true;
        Thread.Sleep(10);
        _initialized2 = true;
    }
}

public static object CreateInstance(Type type, object[] arguments)
{
   try
   {
      Activator.CreateInstance(t, args);
   }
   catch(TargetInvocationException ex)
   {
     throw ex.InnerException.PreserveStackTrace();
   }
}

public static class ExceptionHelper
{
    private static readonly Action<Exception> _preserveInternalException;

    static ExceptionHelper()
    {
        var preserveStackTrace = typeof( Exception ).GetMethod( "InternalPreserveStackTrace", BindingFlags.Instance | BindingFlags.NonPublic );
        _preserveInternalException = (Action<Exception>)Delegate.CreateDelegate( typeof( Action<Exception> ), preserveStackTrace );            
    }

    public static Exception PreserveStackTrace(this Exception ex )
    {
        _preserveInternalException( ex );
        return ex;
    }
}

public static class ExceptionHelper
{
    private static readonly Action<Exception> _preserveInternalException;

    static ExceptionHelper()
    {
        var preserveStackTrace = typeof(Exception).GetMethod("InternalPreserveStackTrace", BindingFlags.Instance | BindingFlags.NonPublic);
        _preserveInternalException = (Action<Exception>)Delegate.CreateDelegate(typeof(Action<Exception>), preserveStackTrace);
    }

    public static Exception PreserveStackTrace(this Exception ex)
    {
        _preserveInternalException(ex);
        return ex;
    }
}

public class A
{
    public A(int x, string s)
    {
        throw new ArgumentException("s");
    }
}

static class Program
{
    public static object CreateInstance(Type type, object[] arguments)
    {
        try
        {
            return Activator.CreateInstance(type, arguments);
        }
        catch (TargetInvocationException ex)
        {
            throw ex.InnerException.PreserveStackTrace();
        }
    }

    private static void Main()
    {
        try
        {
            //var a = new A(42, "Hi");
            var a = CreateInstance(typeof(A), new object[] { 42, "Hi" });
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}

System.ArgumentException: s
at ConsoleApplication46.A..ctor(Int32 x, String s) in d:\tmp\ConsoleApplication46\ConsoleApplication46\Program.cs:line 34
at ConsoleApplication46.Program.CreateInstance(Type type, Object[] arguments) in d:\tmp\ConsoleApplication46\ConsoleApplication46\Program.cs:line 56
at ConsoleApplication46.Program.Main() in d:\tmp\ConsoleApplication46\ConsoleApplication46\Program.cs:line 80

A>>И на каждый вызов делает компиляцию создаваемого Expression-а?

void F()
{
  new SomeClassWithUnmanagedResources();
}

A>hackability?

public void Foo(Something x)
try
{
    GiveMeAdminPrivileges();
    Process(x);
}
finally
{
    RevertToUserPrivileges();
}

    class Program
    {
        static Foo foo = new Foo(10000);
        static void Main(string[] args)
        {
            Thread instantiationThread = new Thread(() =>
            {
                do
                {
                    foo = new Foo(10000);
                } while (true);
            });

            Thread checkInitializedThread = new Thread(() =>
            {
                do
                {
                    var local = foo;
                    if (!local._initialized1 | !local._initialized2 | local._val == 0)
                    {
                        Console.WriteLine("Bingo!!!");
                    }
                } while (true);
            });

            instantiationThread.Start();
            checkInitializedThread.Start();
            Console.ReadKey();
        }
        
        class Foo
        {
            private static readonly Random rnd = new Random(0);

            public bool _initialized1;
            public bool _initialized2;
            public int _val;


            public Foo(int count)
            {
                //Thread.Sleep(10);
                _initialized1 = true;
                //Thread.Sleep(10);
                _initialized2 = true;

                _val = rnd.Next(count) + 1;
            }
        }
    }

                    foo = new Foo(10000); (конструктор заинлайнен)
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        esi  
00000004  mov         ecx,193488h 
00000009  call        FFCE1E14 
0000000e  mov         esi,eax 
00000010  mov         byte ptr [esi+8],1 
00000014  mov         byte ptr [esi+9],1 
00000018  mov         ecx,dword ptr ds:[035E1F0Ch] 
0000001e  mov         edx,2710h 
00000023  mov         eax,dword ptr [ecx] 
00000025  call        dword ptr [eax+44h] 
00000028  inc         eax  
00000029  mov         dword ptr [esi+4],eax
0000002c  lea         edx,ds:[035E1F00h] 
00000032  call        72232DD0 
00000037  jmp         00000004

                    var local = foo;
00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  mov         ecx,dword ptr ds:[035E1F00h]

var local = foo;
do
{
} while (local==foo);

Console.WriteLine("local != foo");

HL>class MyClass
HL>{
HL>    private MyClass()
HL>    {
HL>    }    

HL>    public MyClass Create(){};
HL>}
HL>

HL>class MyClass()
HL>{
HL>    private void Initialize()
HL>    {
HL>    }

HL>    public MyClass()
HL>    {
HL>        Initialize();
HL>    }
HL>}
HL>

class MyClass()
{
    private void Initialize(int IntParam,string Name)
    {
       /* 
         тут 100500 строк кода
       */
    }
    // а вот и конструкторы
    public MyClass()
    {
        Initialize(0,"Zero");
    }
    public MyClass(int IntParam)
    {
        Initialize(IntParam,"Int");
    }
    public MyClass(int IntParam,string Name)
    {
        Initialize(IntParam,Name)
    }

}

public class A
{
    public static int N;
    private int x;

    public A()
    {
        N = 42;

        GC.Collect();
        GC.WaitForPendingFinalizers();

        Console.WriteLine(N);
        //x = N; //uncomment me
    }

    ~A()
    {
        N = 666;
    }
}

static void Main()
{
    new A();

    Console.WriteLine("Done...");
    Console.ReadKey();

    return;
}