|
//---------------------------------------------------------------------
// <copyright file="Utils.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//
// @owner Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------
using System;
using System.Collections.Specialized;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.Metadata.Edm;
using System.Data.EntityModel.SchemaObjectModel;
using System.Data.Entity.Design.Common;
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 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";
// 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);
BindingFlags bindingFlags = BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static;
foreach (MemberInfo member in TypeReference.ComplexTypeBaseClassType.GetMembers(bindingFlags))
{
if (ShouldReserveName(member))
{
if (!typeReservedNames.ContainsKey(member.Name))
{
typeReservedNames.Add(member.Name, typeof(ComplexType));
}
}
}
foreach (MemberInfo member in TypeReference.EntityTypeBaseClassType.GetMembers(bindingFlags))
{
if (ShouldReserveName(member))
{
if (typeReservedNames.ContainsKey(member.Name))
{
if (typeReservedNames[member.Name] == typeof(ComplexType))
{
// apply to all types
typeReservedNames[member.Name] = null;
}
}
else
{
typeReservedNames.Add(member.Name, typeof(EntityType));
}
}
}
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:NormalizeStringsToUppercase")]
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);
}
public static string FixParameterName(string name)
{
// FxCop consider 'iD' as violation, we will change any property that is 'id'(case insensitive) to 'ID'
if (StringComparer.OrdinalIgnoreCase.Equals(name, "id"))
{
// it is an abreviation not an acronym so it should be all lower case
return "id";
}
return CamelCase(name);
}
/// <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="name"></param>
/// <returns></returns>
public static string FQAdoFrameworkName( string name )
{
return AdoFrameworkNamespace + "." + name;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static string FQAdoFrameworkDataClassesName( string name )
{
return AdoFrameworkDataClassesNamespace + "." + name;
}
/// <summary>
///
/// </summary>
/// <param name="name">unqualifed name of the type</param>
/// <returns></returns>
public static string FQAdoFrameworkMetadataEdmName(string name)
{
return AdoFrameworkMetadataEdmNamespace + "." + name;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static string FQAdoEntityClientName(string name)
{
return AdoEntityClientNamespace + "." + name;
}
/// <summary>
///
/// </summary>
/// <param name="element"></param>
/// <param name="modelType"></param>
/// <returns></returns>
public static bool TryGetPrimitiveTypeKind(EdmType type, out PrimitiveTypeKind modelType )
{
if (!MetadataUtil.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;
}
#endregion
}
}
|