/// <summary>
		///   Generates the state slot metadata for the <paramref name="obj" />.
		/// </summary>
		/// <param name="obj">The object the state slot metadata should be generated for.</param>
		/// <param name="objectIdentifier">The identifier of the <paramref name="obj" />.</param>
		/// <param name="mode">The serialization mode that should be used to generate the metadata.</param>
		protected internal override IEnumerable<StateSlotMetadata> GetStateSlotMetadata(object obj, int objectIdentifier, SerializationMode mode)
		{
			Requires.That(((Array)obj).Rank == 1 && !obj.GetType().GetElementType().IsArray, "Multidimensional arrays are not supported.");

			var elementType = obj.GetType().GetElementType();
			var length = ((Array)obj).GetLength(0);

			if (elementType.IsStructType())
			{
				foreach (var metadataSlot in StateSlotMetadata.FromStruct(elementType, mode))
				{
					metadataSlot.Object = obj;
					metadataSlot.ObjectIdentifier = objectIdentifier;
					metadataSlot.ObjectType = obj.GetType();
					metadataSlot.ElementCount = length;

					yield return metadataSlot;
				}
			}
			else
			{
				yield return new StateSlotMetadata
				{
					Object = obj,
					ObjectIdentifier = objectIdentifier,
					ObjectType = obj.GetType(),
					DataType = obj.GetType().GetElementType(),
					ElementCount = length
				};
			}
		}

 internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
     : base(serializer, rootTypeDataContract, dataContractResolver)
 {
     _mode = SerializationMode.SharedContract;
     _preserveObjectReferences = serializer.PreserveObjectReferences;
     _serializationSurrogateProvider = serializer.SerializationSurrogateProvider;
 }

 internal XmlObjectSerializerReadContextComplex(DataContractSerializer serializer, DataContract rootTypeDataContract, DataContractResolver dataContractResolver)
     : base(serializer, rootTypeDataContract, dataContractResolver)
 {
     this.mode = SerializationMode.SharedContract;
     this.preserveObjectReferences = serializer.PreserveObjectReferences;
     this.dataContractSurrogate = serializer.DataContractSurrogate;
 }

        private static MvcHtmlString SerializeInternal(HtmlHelper htmlHelper, string name, object data, SerializationMode mode, bool useViewData, MvcSerializer serializer)
        {
            if (htmlHelper == null)
            {
                throw new ArgumentNullException("htmlHelper");
            }

            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }

            name = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            if (useViewData)
            {
                data = htmlHelper.ViewData.Eval(name);
            }

            string serializedData = (serializer ?? new MvcSerializer()).Serialize(data, mode);

            TagBuilder builder = new TagBuilder("input");
            builder.Attributes["type"] = "hidden";
            builder.Attributes["name"] = name;
            builder.Attributes["value"] = serializedData;
            return MvcHtmlString.Create(builder.ToString(TagRenderMode.SelfClosing));
        }

		/// <summary>
		///   Generates the state slot metadata for the <paramref name="obj" />.
		/// </summary>
		/// <param name="obj">The object the state slot metadata should be generated for.</param>
		/// <param name="objectIdentifier">The identifier of the <paramref name="obj" />.</param>
		/// <param name="mode">The serialization mode that should be used to generate the metadata.</param>
		protected internal override IEnumerable<StateSlotMetadata> GetStateSlotMetadata(object obj, int objectIdentifier, SerializationMode mode)
		{
			foreach (var field in GetFields(obj, mode))
			{
				if (field.FieldType.IsStructType())
				{
					foreach (var metadataSlot in StateSlotMetadata.FromStruct(field.FieldType, mode))
					{
						metadataSlot.Object = obj;
						metadataSlot.ObjectIdentifier = objectIdentifier;
						metadataSlot.ObjectType = obj.GetType();
						metadataSlot.ElementCount = 1;
						metadataSlot.Field = field;

						yield return metadataSlot;
					}
				}
				else
				{
					yield return new StateSlotMetadata
					{
						Object = obj,
						ObjectType = obj.GetType(),
						ObjectIdentifier = objectIdentifier,
						DataType = field.FieldType,
						Field = field,
						ElementCount = 1
					};
				}
			}
		}

        internal static object Deserialize(string serializedValue, SerializationMode mode, IMachineKey machineKey) {
            if (String.IsNullOrEmpty(serializedValue)) {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "serializedValue");
            }

            MachineKeyProtection protectionMode = GetMachineKeyProtectionMode(mode);

            try {
                // First, need to decrypt / verify data
                byte[] rawBytes = machineKey.Decode(serializedValue, protectionMode);

                // Next, verify magic header
                if (!ArrayContainsMagicHeader(rawBytes)) {
                    throw new SerializationException(MvcResources.MvcSerializer_MagicHeaderCheckFailed);
                }

                // Finally, deserialize the object graph
                using (MemoryStream ms = new MemoryStream(rawBytes, _magicHeader.Length, rawBytes.Length - _magicHeader.Length)) {
                    return DeserializeGraph(ms);
                }
            }
            catch (Exception ex) {
                throw CreateSerializationException(ex);
            }
        }

 internal XmlObjectSerializerReadContextComplex(NetDataContractSerializer serializer) : base(serializer)
 {
     this.mode = SerializationMode.SharedType;
     this.preserveObjectReferences = true;
     this.binder = serializer.Binder;
     this.surrogateSelector = serializer.SurrogateSelector;
     this.assemblyFormat = serializer.AssemblyFormat;
 }

        private static IStateFormatter GetFormatter(SerializationMode mode) {
            Func<IStateFormatter> formatterFactory;
            if (!_registeredFormatterFactories.TryGetValue(mode, out formatterFactory)) {
                throw new ArgumentOutOfRangeException("mode", MvcResources.MvcSerializer_InvalidSerializationMode);
            }

            return formatterFactory();
        }

		private static IStateFormatter GetFormatter(SerializationMode mode)
		{
			Func<IStateFormatter> formatterFactory;
			if (!_factories.TryGetValue(mode, out formatterFactory))
				throw Error.InvalidModelStateSerializationMode(mode);

			return formatterFactory();
		}

		/// <summary>
		///   Gets the fields declared by the <paramref name="obj" /> that should be serialized.
		/// </summary>
		/// <param name="obj">The object that should be serialized.</param>
		/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
		/// <param name="startType">
		///   The first type in <paramref name="obj" />'s inheritance hierarchy whose fields should be returned.
		///   If <c>null</c>, corresponds to <paramref name="obj" />'s actual type.
		/// </param>
		/// <param name="inheritanceRoot">
		///   The first base type of the <paramref name="obj" /> whose fields should be ignored. If
		///   <c>null</c>, <see cref="object" /> is the inheritance root.
		/// </param>
		/// <param name="discoveringObjects">Indicates whether objects are being discovered.</param>
		protected override IEnumerable<FieldInfo> GetFields(object obj, SerializationMode mode, Type startType = null, Type inheritanceRoot = null,
															bool discoveringObjects = false)
		{
			var fields = base.GetFields(obj, mode, startType, inheritanceRoot, discoveringObjects);

			if (mode == SerializationMode.Full || discoveringObjects)
				return fields;

			return fields.Where(field => field.Name == "_size");
		}

 internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts)
     : base(serializer)
 {
     this.mode = SerializationMode.SharedType;
     this.preserveObjectReferences = true;
     this.streamingContext = serializer.Context;
     this.binder = serializer.Binder;
     this.surrogateSelector = serializer.SurrogateSelector;
     this.surrogateDataContracts = surrogateDataContracts;
 }

 public ProfilePropertySettings(string name, bool readOnly, SerializationMode serializeAs, string providerName, string defaultValue, string profileType, bool allowAnonymous, string customProviderData)
 {
     this.Name = name;
     this.ReadOnly = readOnly;
     this.SerializeAs = serializeAs;
     this.Provider = providerName;
     this.DefaultValue = defaultValue;
     this.Type = profileType;
     this.AllowAnonymous = allowAnonymous;
     this.CustomProviderData = customProviderData;
 }

        private static MachineKeyProtection GetMachineKeyProtectionMode(SerializationMode mode) {
            switch (mode) {
                case SerializationMode.Signed:
                    return MachineKeyProtection.Validation;

                case SerializationMode.EncryptedAndSigned:
                    return MachineKeyProtection.All;

                default:
                    // bad
                    throw new ArgumentOutOfRangeException("mode", MvcResources.MvcSerializer_InvalidSerializationMode);
            }
        }

        public virtual object Deserialize(string serializedValue, SerializationMode mode) {
            if (String.IsNullOrEmpty(serializedValue)) {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "serializedValue");
            }

            IStateFormatter formatter = GetFormatter(mode);
            try {
                object deserializedValue = formatter.Deserialize(serializedValue);
                return deserializedValue;
            }
            catch (Exception ex) {
                throw CreateSerializationException(ex);
            }
        }

		public static ISerializer GetSerializer(SerializationMode mode)
		{
			switch(mode)
			{
				case SerializationMode.Xml:
					return Serializer.Xml;
                case SerializationMode.DataContractJson:
                    return Serializer.DataContractJson;
                case SerializationMode.NewtonsoftJson:
                    return Serializer.NewtonsoftJson;
				default:
					throw new NotSupportedException();
			}
		}

		/// <summary>
		///   Gets the fields declared by the <paramref name="obj" /> that should be serialized.
		/// </summary>
		/// <param name="obj">The object that should be serialized.</param>
		/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
		/// <param name="startType">
		///   The first type in <paramref name="obj" />'s inheritance hierarchy whose fields should be returned.
		///   If <c>null</c>, corresponds to <paramref name="obj" />'s actual type.
		/// </param>
		/// <param name="inheritanceRoot">
		///   The first base type of the <paramref name="obj" /> whose fields should be ignored. If
		///   <c>null</c>, <see cref="object" /> is the inheritance root.
		/// </param>
		/// <param name="discoveringObjects">Indicates whether objects are being discovered.</param>
		protected override IEnumerable<FieldInfo> GetFields(object obj, SerializationMode mode,
															Type startType = null,
															Type inheritanceRoot = null,
															bool discoveringObjects = false)
		{
			// Gets the fields declared by the obj that should be serialized. In full serialization mode, this only
			// includes the fields declared by <paramref name="obj" /> itself, not any of the fields declared by its base types. In
			// optimized mode, this includes all fields. The reason is that in optimized mode, fault effects are actually treated as
			// components, whereas in full mode, they only serve to serialize the delta to their base class.

			var type = ((Component)obj).FaultEffectType;
			return mode == SerializationMode.Optimized
				? base.GetFields(obj, mode)
				: base.GetFields(obj, mode, type, type.BaseType);
		}

        internal void Serialize(ClassMapping mapping, object instance, bool summary, SerializationMode mode = SerializationMode.AllMembers)
        {
            if (mapping == null) throw Error.ArgumentNull("mapping");

            _current.WriteStartComplexContent();

            // Emit members that need xml /attributes/ first (to facilitate stream writer API)
            foreach (var prop in mapping.PropertyMappings.Where(pm => pm.SerializationHint == XmlSerializationHint.Attribute))
                if(!summary || prop.InSummary) write(mapping, instance, summary, prop, mode);

            // Then emit the rest
            foreach (var prop in mapping.PropertyMappings.Where(pm => pm.SerializationHint != XmlSerializationHint.Attribute))
                if (!summary || prop.InSummary) write(mapping, instance, summary, prop, mode);

            _current.WriteEndComplexContent();
        }

		/// <summary>
		///   Gets all objects referenced by <paramref name="obj" /> potentially marked with the <paramref name="hidden" /> attribute.
		/// </summary>
		/// <param name="obj">The object the referenced objects should be returned for.</param>
		/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
		/// <param name="hidden">The <see cref="HiddenAttribute" /> instance, if any, the field storing <paramref name="obj" /> was marked with.</param>
		protected internal override IEnumerable<object> GetReferencedObjects(object obj, SerializationMode mode, HiddenAttribute hidden)
		{
			// Optimization: Skip enumerables with hidden elements
			if (mode == SerializationMode.Optimized && hidden?.HideElements == true)
			{
				// We have to make sure the objects referenced by the list are discovered nevertheless
				var enumerable = obj as IEnumerable;
				if (enumerable == null)
					yield break;

				foreach (var element in enumerable.Cast<object>().Where(item => item.GetType().IsReferenceType()))
					yield return element;
			}
			else
				yield return obj;
		}

		public static string Serialize(this HtmlHelper helper, 
			string name, object data, SerializationMode mode)
		{
			Precondition.Require(helper, () => Error.ArgumentNull("helper"));
			Precondition.Defined(name, () => Error.ArgumentNull("name"));

			ModelStateSerializer serializer = new ModelStateSerializer();
			string elementName = helper.Context.ViewData.Template.GetHtmlElementName(name);
			string value = serializer.Serialize(data ?? helper.Context.ViewData.Model, mode);

			HtmlElementBuilder builder = new HtmlElementBuilder("input");
			builder.Attributes["type"] = "hidden";
			builder.Attributes["name"] = elementName;
			builder.Attributes["value"] = value;

			return builder.ToString();
		}

		/// <summary>
		///   Gets all objects referenced by <paramref name="obj" />, excluding <paramref name="obj" /> itself.
		/// </summary>
		/// <param name="obj">The object the referenced objects should be returned for.</param>
		/// <param name="mode">The serialization mode that should be used to serialize the objects.</param>
		protected internal override IEnumerable<object> GetReferencedObjects(object obj, SerializationMode mode)
		{
			if (mode == SerializationMode.Optimized)
				yield break;

			var d = (Delegate)obj;
			var method = d.Method;

			yield return obj.GetType();
			yield return method.ReturnType;
			yield return method.DeclaringType;

			foreach (var parameter in method.GetParameters())
				yield return parameter.GetType();

			yield return new DelegateMetadata(d);
		}