|
//---------------------------------------------------------------------
// <copyright file="Utils.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System.Collections.Generic;
using System.Data.Metadata.Edm;
using System.Diagnostics;
using System.Reflection;
namespace System.Data.EntityModel.Emitters
{
/// <summary>
/// Summary description for Utils
/// </summary>
internal static class Utils
{
#region Static Fields
public const string WebFrameworkNamespace = "System.Data.Services.Client";
public const string WebFrameworkCommonNamespace = "System.Data.Services.Common";
public const string AdoFrameworkNamespace = "System.Data.Objects";
public const string AdoFrameworkDataClassesNamespace = "System.Data.Objects.DataClasses";
public const string AdoFrameworkMetadataEdmNamespace = "System.Data.Metadata.Edm";
public const string AdoEntityClientNamespace = "System.Data.EntityClient";
public const string SetValidValueMethodName = "SetValidValue";
public const string ReportPropertyChangingMethodName = "ReportPropertyChanging";
public const string ReportPropertyChangedMethodName = "ReportPropertyChanged";
public const string GetValidValueMethodName = "GetValidValue";
public const string VerifyComplexObjectIsNotNullName = "VerifyComplexObjectIsNotNull";
// this is the list of keywords we check against for names.
// If a name matches this keyword we prefix it, this is only used when creating parameter names from property, etc. names(see FixKeyword)
private static string[] _keywords = new string[]
{
"class",
"event",
};
// to guarantee uniqueness these must all be unique, begin with and end with an underscore and not contain internal underscores
private static string[] _privateMemberPrefixes = new string[(int)PrivateMemberPrefixId.Count]
{
"_",
"_Initialize_",
"PropertyInfo",
"_pi",
};
// suffix that is added to field names to create a boolean field used to indicate whether or
// not a complex property has been explicitly initialized
private static string _complexPropertyInitializedSuffix = "Initialized";
private static List<KeyValuePair<string, Type>> _typeReservedNames = InitializeTypeReservedNames();
/// <summary>
/// Initialize some statics that cannot be initialized in member declaration...
/// </summary>
static List<KeyValuePair<string, Type>> InitializeTypeReservedNames()
{
Dictionary<string, Type> typeReservedNames = new Dictionary<string, Type>(StringComparer.Ordinal);
const BindingFlags bindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static;
foreach (MemberInfo member in typeof(object).GetMembers(bindingFlags))
{
if (ShouldReserveName(member))
{
if (!typeReservedNames.ContainsKey(member.Name))
{
typeReservedNames.Add(member.Name, null);
}
}
}
List<KeyValuePair<string, Type>> pairs = new List<KeyValuePair<string, Type>>();
foreach (KeyValuePair<string, Type> pair in typeReservedNames)
{
pairs.Add(pair);
}
return pairs;
}
private static bool ShouldReserveName(MemberInfo member)
{
if (member is EventInfo)
{
return ShouldReserveName((EventInfo)member);
}
else if (member is FieldInfo)
{
return ShouldReserveName((FieldInfo)member);
}
else if (member is MethodBase)
{
return ShouldReserveName((MethodBase)member);
}
else if (member is PropertyInfo)
{
return ShouldReserveName((PropertyInfo)member);
}
else
{
Debug.Assert(member is Type, "Did you add a new type of member?");
return ShouldReserveName((Type)member);
}
}
private static bool ShouldReserveName(EventInfo member)
{
bool hasNonPrivate = false;
MethodInfo miAdd = member.GetAddMethod();
if (miAdd != null)
{
hasNonPrivate |= ShouldReserveName(miAdd, false);
}
MethodInfo miRemove = member.GetRemoveMethod();
if (miRemove != null)
{
hasNonPrivate |= ShouldReserveName(miRemove, false);
}
return hasNonPrivate;
}
private static bool ShouldReserveName(PropertyInfo member)
{
bool hasNonPrivate = false;
MethodInfo miSet = member.GetSetMethod();
if (miSet != null)
{
hasNonPrivate |= ShouldReserveName(miSet, false);
}
MethodInfo miGet = member.GetGetMethod();
if (miGet != null)
{
hasNonPrivate |= ShouldReserveName(miGet, false);
}
return hasNonPrivate;
}
private static bool ShouldReserveName(FieldInfo member)
{
return !member.IsPrivate && !member.IsAssembly &&
!member.IsSpecialName;
}
private static bool ShouldReserveName(MethodBase member, bool checkForSpecial)
{
return !member.IsPrivate && !member.IsAssembly &&
(!checkForSpecial || !member.IsSpecialName);
}
private static bool ShouldReserveName(MethodBase member)
{
return ShouldReserveName(member, true);
}
private static bool ShouldReserveName(Type member)
{
// we don't want to keep types
return false;
}
#endregion
#region Public Methods
/// <summary>
///
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1308", Justification = "required for this feature")]
public static string CamelCase(string text)
{
if (string.IsNullOrEmpty(text))
return text;
if (text.Length == 1)
return text[0].ToString(System.Globalization.CultureInfo.InvariantCulture).ToLowerInvariant();
return text[0].ToString(System.Globalization.CultureInfo.InvariantCulture).ToLowerInvariant() + text.Substring(1);
}
/// <summary>
///
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string PascalCase(string text)
{
if (string.IsNullOrEmpty(text))
return text;
if (text.Length == 1)
return text[0].ToString(System.Globalization.CultureInfo.InvariantCulture).ToUpperInvariant();
return text[0].ToString(System.Globalization.CultureInfo.InvariantCulture).ToUpperInvariant() + text.Substring(1);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="prefix"></param>
/// <returns></returns>
private static string FixKeyword(string name, string prefix)
{
foreach (string keyword in _keywords)
{
if (name == keyword)
{
return prefix + PascalCase(name);
}
}
return name;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="prefix"></param>
/// <returns></returns>
public static string FixParameterName(string name, string prefix)
{
return CamelCase(FixKeyword(name, prefix));
}
/// <summary>
///
/// </summary>
/// <param name="propName"></param>
/// <returns></returns>
public static string FieldNameFromPropName(string propName)
{
return PrivateMemberPrefix(PrivateMemberPrefixId.Field) + propName;
}
/// <summary>
/// Generate the name of a field that is used to indicate whether a complex property has been explicitly initialized
/// </summary>
/// <param name="propName">Name of the property associated that with this field</param>
/// <returns>Generated field name</returns>
public static string ComplexPropertyInitializedNameFromPropName(string propName)
{
return FieldNameFromPropName(propName) + _complexPropertyInitializedSuffix;
}
/// <summary>
/// get the prefix ussed for a private member
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static string PrivateMemberPrefix(PrivateMemberPrefixId id)
{
return _privateMemberPrefixes[(int)id];
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <param name="modelType"></param>
/// <returns></returns>
public static bool TryGetPrimitiveTypeKind(EdmType type, out PrimitiveTypeKind modelType)
{
if (!Helper.IsPrimitiveType(type))
{
// set it to something bogus because I have to
modelType = PrimitiveTypeKind.Binary;
return false;
}
modelType = ((PrimitiveType)type).PrimitiveTypeKind;
return true;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static string[] SplitName(string name)
{
Debug.Assert(!string.IsNullOrEmpty(name), "name parameter is null or empty");
if (name.Length > 0 && name[0] == '.')
return name.Substring(1).Split('.');
return name.Split('.');
}
public static string GetFullyQualifiedCodeGenerationAttributeName(string attribute)
{
return XmlConstants.CodeGenerationSchemaNamespace + ":" + attribute;
}
/// <summary>
/// check if a name is reserved for a type
/// </summary>
/// <param name="type">the object representing the schema type being defined</param>
/// <param name="name">the member name</param>
/// <returns>true if the name is reserved by the type</returns>
public static bool DoesTypeReserveMemberName(StructuralType type, string name, StringComparison comparison)
{
Type reservingType = null;
if (!TryGetReservedName(name, comparison, out reservingType))
{
return false;
}
// if reserving types is null it means the name is reserved for all types.
if (reservingType == null)
{
return true;
}
return (reservingType == type.GetType());
}
public static bool TryGetReservedName(string name, StringComparison comparison, out Type applyToSpecificType)
{
applyToSpecificType = null;
foreach (KeyValuePair<string, Type> pair in _typeReservedNames)
{
if (pair.Key.Equals(name, comparison))
{
applyToSpecificType = pair.Value;
return true;
}
}
return false;
}
public static string SetSpecialCaseForFxCopOnPropertyName(string propertyName)
{
// FxCop consider 'iD' as violation, we will change any property that is 'id'(case insensitive) to 'ID'
if (StringComparer.OrdinalIgnoreCase.Equals(propertyName, "id"))
{
return "ID";
}
return propertyName;
}
#endregion
}
}
|