Asp.Net MVC 3 Custom Variable Object Model Binding

My objects: (PersonModel must have an address type of AddressOne or AddressTwo (and possibly others), so PersonModel has an object type for the address field.)

public class Person
{
    public int PersonId { get; set; }
    public string Name { get; set; }
    public string Surname { get; set; }
    public object Address { get; set; }
}

public class AddressOne
{
    public string Street { get; set; }
    public string City { get; set; }
}

public class AddressTwo
{
    public string Province { get; set; }
    public string State { get; set; }
}

models: (I pass the hidden field to typeOfAddress to match the correct address after submitting the form)

public class PersonModel
{
    private System.Type _typeOfAddress;
    private object _address;

    [Required]
    public int PersonId { get; set; }
    [Required]
    public string Name { get; set; }
    [Required]
    public string Surname { get; set; }

    public System.Type typeOfAddress
    {
        get { return _typeOfAddress; }
        set { _typeOfAddress = value; }
    }

    public object Address
    { 
        get {
            return _address;
        } 
        set {
            _address = value;
            _typeOfAddress = _address.GetType(); 
        } 
    }
}

public class AddressOneModel
{
    [Required]
    public string Street { get; set; }
    [Required]
    public string City { get; set; }
}

public class AddressTwoModel
{
    [Required]
    public string Province { get; set; }
    [Required]
    public string State { get; set; }
}

My view (for the address field I have an ad editor template that is not specified in this code):

@using (Html.BeginForm()) {

<ul>
<li> 
    PersonId: @Html.EditorFor(model => model.PersonId)
</li>
<li>
    Name: @Html.EditorFor(model => model.Name)
</li>
<li>
    Surname: @Html.EditorFor(model => model.Surname)
</li>
<li>
    Address:
</li>
<li>
    @Html.HiddenFor(model => model.typeOfAddress)
    @Html.EditorFor(model => model.Address)
</li>
</ul>
<button type="submit">Submit</button>

}

and then my controller: (in this example, I am loading AddressOne into the model, but there must be one or two depending on the execution time ...)

    [HttpGet]
    public ActionResult Index()
    {
        PersonModel myPerson = new PersonModel();

        myPerson.PersonId = 1;
        myPerson.Name = "Michael";
        myPerson.Surname = "Douglas";

        AddressOneModel Address = new AddressOneModel();
        Address.Street = "5th Avenue";
        Address.City = "New York";

        myPerson.Address = Address;

        return View(myPerson);
    }

    [HttpPost]
    public ActionResult Index([ModelBinder(typeof(PersonModelBinder))]PersonModel myPerson)
    {
        if (ModelState.IsValid) { 
            // some things here
        }
        return View();
    }

then there is a Model Binder for PersonModel:

public class PersonModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        PersonModel bindedModel = new PersonModel();

        foreach (var Property in typeof(PersonModel).GetProperties())
        {
            PropertyInfo info = bindedModel.GetType().GetProperty(Property.Name); 
            object castedInfo = new object();

            var uType = info.PropertyType;
            if (uType == typeof(string))
            {
                castedInfo = bindingContext.ValueProvider.GetValue(Property.Name).AttemptedValue.ToString();
            }
            else if (uType == typeof(Type))
            {
                castedInfo = Type.GetType(bindingContext.ValueProvider.GetValue(Property.Name).AttemptedValue.ToString());
            }
            else if (uType == typeof(object))
            {
                string objType = bindingContext.ValueProvider.GetValue("typeOfAddress").AttemptedValue; 
                object address = (object)Activator.CreateInstance(Type.GetType(objType));

                // another foreach as previous
            }
            else
            {
                object uCasted = (object)Activator.CreateInstance(info.PropertyType);
                uCasted = Convert.ChangeType(bindingContext.ValueProvider.GetValue(Property.Name).AttemptedValue, Property.PropertyType);
                castedInfo = uCasted;
            }
            info.SetValue(bindedModel, castedInfo, null);
        }
        return bindedModel;
    }

Is this the right way to implement PersonModel bindings? What about checking in the [Post] controller?

I also saw a way to use DefaultBinder in a way like this:

[ModelBinderType(typeof(PersonModel))]
public class PersonModelBinder : DefaultModelBinder
{
     //...
}

ModelBinderType MVC3!! ?