// private methods /// <summary> /// Creates a convention pack from the ConventionProfile. /// </summary> /// <returns></returns> private IEnumerable <IConvention> GetNewConventions() { var pack = new ConventionPack(); // need to process defaults... pack.Append(DefaultConventionPack.Instance); // class mapping conventions if (MemberFinderConvention != null) { pack.Add(new MemberFinderConventionAdapter(MemberFinderConvention)); } if (IdMemberConvention != null) { pack.Add(new IdMemberConventionAdapter(IdMemberConvention)); } if (IdGeneratorConvention != null) { pack.Add(new IdGeneratorConventionAdapter(IdGeneratorConvention)); } if (ExtraElementsMemberConvention != null) { pack.Add(new ExtraElementsConventionAdapter(ExtraElementsMemberConvention)); } if (IgnoreExtraElementsConvention != null) { pack.Add(new IgnoreExtraElementsConventionAdapter(IgnoreExtraElementsConvention)); } // member mapping conventions if (DefaultValueConvention != null) { pack.Add(new DefaultValueConventionAdapter(DefaultValueConvention)); } if (SerializeDefaultValueConvention != null) { pack.Add(new SerializeDefaultValueConventionAdapter(SerializeDefaultValueConvention)); } if (IgnoreIfDefaultConvention != null) { pack.Add(new IgnoreIfDefaultConventionAdapter(IgnoreIfDefaultConvention)); } if (IgnoreIfNullConvention != null) { pack.Add(new IgnoreIfNullConventionAdapter(IgnoreIfNullConvention)); } if (SerializationOptionsConvention != null) { pack.Add(new SerializationOptionsConventionAdapter(SerializationOptionsConvention)); } if (ElementNameConvention != null) { pack.Add(new ElementNameConventionAdapter(ElementNameConvention)); } // still need to process attributes pack.Append(AttributeConventionPack.Instance); return(pack.Conventions); }
// public static methods /// <summary> /// Looks up the effective set of conventions that apply to a type. /// </summary> /// <param name="type">The type.</param> /// <returns>The conventions for that type.</returns> public static IConventionPack Lookup(Type type) { if (type == null) { throw new ArgumentNullException("type"); } lock (__lock) { var pack = new ConventionPack(); // append any attribute packs (usually just one) at the end so attributes are processed last var attributePacks = new List <IConventionPack>(); #pragma warning disable 618 //obsoleted by ConventionProfile ConventionProfile conventionProfile = null; #pragma warning restore 618 foreach (var container in __conventionPacks) { if (container.Filter(type)) { #pragma warning disable 618 //obsoleted by ConventionProfile if (container.Pack is ConventionProfile) { conventionProfile = container.Pack as ConventionProfile; } #pragma warning restore 618 if (container.Name == "__attributes__") { attributePacks.Add(container.Pack); } else { pack.Append(container.Pack); } } } if (conventionProfile != null) { // already includes the default attribute convention pack return(conventionProfile); } foreach (var attributePack in attributePacks) { pack.Append(attributePack); } return(pack); } }
// public static methods /// <summary> /// Looks up the effective set of conventions that apply to a type. /// </summary> /// <param name="type">The type.</param> /// <returns>The conventions for that type.</returns> public static IConventionPack Lookup(Type type) { if (type == null) { throw new ArgumentNullException("type"); } lock (__lock) { var pack = new ConventionPack(); // append any attribute packs (usually just one) at the end so attributes are processed last var attributePacks = new List <IConventionPack>(); foreach (var container in __conventionPacks) { if (container.Filter(type)) { if (container.Name == "__attributes__") { attributePacks.Add(container.Pack); } else { pack.Append(container.Pack); } } } foreach (var attributePack in attributePacks) { pack.Append(attributePack); } return(pack); } }