<p>There is some magic going on with WCF deserialization.  How does it instantiate an instance of the data contract type without calling its constructor?</p>

<p>For example, consider this data contract:</p>

<pre><code>[DataContract]
public sealed class CreateMe
{
   [DataMember] private readonly string _name;
   [DataMember] private readonly int _age;
   private readonly bool _wasConstructorCalled;

   public CreateMe()
   {
      _wasConstructorCalled = true;
   }

   // ... other members here
}
</code></pre>

<p>When obtaining an instance of this object via <code>DataContractSerializer</code> you will see that the field <code>_wasConstructorCalled</code> is <code>false</code>.</p>

<p>So, how does WCF do this?  Is this a technique that others can use too, or is it hidden away from us?</p>

```
FormatterServices.GetUninitializedObject()
```
will create an instance without calling a constructor.  I found this class by using
Reflector
and digging through some of the core .Net serialization classes.
I tested it using the sample code below and it looks like it works great:
```
```
using System;
using System.Reflection;
using System.Runtime.Serialization;

namespace NoConstructorThingy
{
    class Program
    {
        static void Main()
        {
            // does not call ctor
            var myClass = (MyClass)FormatterServices.GetUninitializedObject(typeof(MyClass));

            Console.WriteLine(myClass.One); // writes "0", constructor not called
            Console.WriteLine(myClass.Two); // writes "0", field initializer not called
        }
    }

    public class MyClass
    {
        public MyClass()
        {
            Console.WriteLine("MyClass ctor called.");
            One = 1;
        }

        public int One { get; private set; }
        public readonly int Two = 2;
    }
}
```
```
http://d3j5vwomefv46c.cloudfront.net/photos/large/687556261.png