| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845 | 
							- <#@ template language="C#" debug="false" hostspecific="true"#>
 
- <#@ include file="EF.Utility.CS.ttinclude"#><#@ 
 
-  output extension=".cs"#><#
 
- const string inputFile = @"DataModel.edmx";
 
- var textTransform = DynamicTextTransformation.Create(this);
 
- var code = new CodeGenerationTools(this);
 
- var ef = new MetadataTools(this);
 
- var typeMapper = new TypeMapper(code, ef, textTransform.Errors);
 
- var	fileManager = EntityFrameworkTemplateFileManager.Create(this);
 
- var itemCollection = new EdmMetadataLoader(textTransform.Host, textTransform.Errors).CreateEdmItemCollection(inputFile);
 
- var codeStringGenerator = new CodeStringGenerator(code, typeMapper, ef);
 
- if (!typeMapper.VerifyCaseInsensitiveTypeUniqueness(typeMapper.GetAllGlobalItems(itemCollection), inputFile))
 
- {
 
-     return string.Empty;
 
- }
 
- WriteHeader(codeStringGenerator, fileManager);
 
- foreach (var entity in typeMapper.GetItemsToGenerate<EntityType>(itemCollection))
 
- {
 
-     fileManager.StartNewFile(entity.Name + ".cs");
 
-     BeginNamespace(code);
 
- #>
 
- <#=codeStringGenerator.UsingDirectives(inHeader: false)#>
 
- <#=codeStringGenerator.EntityClassOpening(entity)#>
 
- {
 
- <#
 
-     var propertiesWithDefaultValues = typeMapper.GetPropertiesWithDefaultValues(entity);
 
-     var collectionNavigationProperties = typeMapper.GetCollectionNavigationProperties(entity);
 
-     var complexProperties = typeMapper.GetComplexProperties(entity);
 
-     if (propertiesWithDefaultValues.Any() || collectionNavigationProperties.Any() || complexProperties.Any())
 
-     {
 
- #>
 
-     public <#=code.Escape(entity)#>()
 
-     {
 
- <#
 
-         foreach (var edmProperty in propertiesWithDefaultValues)
 
-         {
 
- #>
 
-         this.<#=code.Escape(edmProperty)#> = <#=typeMapper.CreateLiteral(edmProperty.DefaultValue)#>;
 
- <#
 
-         }
 
-         foreach (var navigationProperty in collectionNavigationProperties)
 
-         {
 
- #>
 
-         this.<#=code.Escape(navigationProperty)#> = new HashSet<<#=typeMapper.GetTypeName(navigationProperty.ToEndMember.GetEntityType())#>>();
 
- <#
 
-         }
 
-         foreach (var complexProperty in complexProperties)
 
-         {
 
- #>
 
-         this.<#=code.Escape(complexProperty)#> = new <#=typeMapper.GetTypeName(complexProperty.TypeUsage)#>();
 
- <#
 
-         }
 
- #>
 
-     }
 
- <#
 
-     }
 
-     var simpleProperties = typeMapper.GetSimpleProperties(entity);
 
-     if (simpleProperties.Any())
 
-     {
 
-         foreach (var edmProperty in simpleProperties)
 
-         {
 
- #>
 
-     <#=codeStringGenerator.Property(edmProperty)#>
 
- <#
 
-         }
 
-     }
 
-     if (complexProperties.Any())
 
-     {
 
- #>
 
- <#
 
-         foreach(var complexProperty in complexProperties)
 
-         {
 
- #>
 
-     <#=codeStringGenerator.Property(complexProperty)#>
 
- <#
 
-         }
 
-     }
 
-     var navigationProperties = typeMapper.GetNavigationProperties(entity);
 
-     if (navigationProperties.Any())
 
-     {
 
- #>
 
- <#
 
-         foreach (var navigationProperty in navigationProperties)
 
-         {
 
- #>
 
-     <#=codeStringGenerator.NavigationProperty(navigationProperty)#>
 
- <#
 
-         }
 
-     }
 
- #>
 
- }
 
- <#
 
-     EndNamespace(code);
 
- }
 
- foreach (var complex in typeMapper.GetItemsToGenerate<ComplexType>(itemCollection))
 
- {
 
-     fileManager.StartNewFile(complex.Name + ".cs");
 
-     BeginNamespace(code);
 
- #>
 
- <#=codeStringGenerator.UsingDirectives(inHeader: false, includeCollections: false)#>
 
- <#=Accessibility.ForType(complex)#> partial class <#=code.Escape(complex)#>
 
- {
 
- <#
 
-     var complexProperties = typeMapper.GetComplexProperties(complex);
 
-     var propertiesWithDefaultValues = typeMapper.GetPropertiesWithDefaultValues(complex);
 
-     if (propertiesWithDefaultValues.Any() || complexProperties.Any())
 
-     {
 
- #>
 
-     public <#=code.Escape(complex)#>()
 
-     {
 
- <#
 
-         foreach (var edmProperty in propertiesWithDefaultValues)
 
-         {
 
- #>
 
-         this.<#=code.Escape(edmProperty)#> = <#=typeMapper.CreateLiteral(edmProperty.DefaultValue)#>;
 
- <#
 
-         }
 
-         foreach (var complexProperty in complexProperties)
 
-         {
 
- #>
 
-         this.<#=code.Escape(complexProperty)#> = new <#=typeMapper.GetTypeName(complexProperty.TypeUsage)#>();
 
- <#
 
-         }
 
- #>
 
-     }
 
- <#
 
-     }
 
-     var simpleProperties = typeMapper.GetSimpleProperties(complex);
 
-     if (simpleProperties.Any())
 
-     {
 
-         foreach(var edmProperty in simpleProperties)
 
-         {
 
- #>
 
-     <#=codeStringGenerator.Property(edmProperty)#>
 
- <#
 
-         }
 
-     }
 
-     if (complexProperties.Any())
 
-     {
 
- #>
 
- <#
 
-         foreach(var edmProperty in complexProperties)
 
-         {
 
- #>
 
-     <#=codeStringGenerator.Property(edmProperty)#>
 
- <#
 
-         }
 
-     }
 
- #>
 
- }
 
- <#
 
-     EndNamespace(code);
 
- }
 
- foreach (var enumType in typeMapper.GetEnumItemsToGenerate(itemCollection))
 
- {
 
-     fileManager.StartNewFile(enumType.Name + ".cs");
 
-     BeginNamespace(code);
 
- #>
 
- <#=codeStringGenerator.UsingDirectives(inHeader: false, includeCollections: false)#>
 
- <#
 
-     if (typeMapper.EnumIsFlags(enumType))
 
-     {
 
- #>
 
- [Flags]
 
- <#
 
-     }
 
- #>
 
- <#=codeStringGenerator.EnumOpening(enumType)#>
 
- {
 
- <#
 
-     var foundOne = false;
 
-     
 
-     foreach (MetadataItem member in typeMapper.GetEnumMembers(enumType))
 
-     {
 
-         foundOne = true;
 
- #>
 
-     <#=code.Escape(typeMapper.GetEnumMemberName(member))#> = <#=typeMapper.GetEnumMemberValue(member)#>,
 
- <#
 
-     }
 
-     if (foundOne)
 
-     {
 
-         this.GenerationEnvironment.Remove(this.GenerationEnvironment.Length - 3, 1);
 
-     }
 
- #>
 
- }
 
- <#
 
-     EndNamespace(code);
 
- }
 
- fileManager.Process();
 
- #>
 
- <#+
 
- public void WriteHeader(CodeStringGenerator codeStringGenerator, EntityFrameworkTemplateFileManager fileManager)
 
- {
 
-     fileManager.StartHeader();
 
- #>
 
- //------------------------------------------------------------------------------
 
- // <auto-generated>
 
- // <#=GetResourceString("Template_GeneratedCodeCommentLine1")#>
 
- //
 
- // <#=GetResourceString("Template_GeneratedCodeCommentLine2")#>
 
- // <#=GetResourceString("Template_GeneratedCodeCommentLine3")#>
 
- // </auto-generated>
 
- //------------------------------------------------------------------------------
 
- <#=codeStringGenerator.UsingDirectives(inHeader: true)#>
 
- <#+
 
-     fileManager.EndBlock();
 
- }
 
- public void BeginNamespace(CodeGenerationTools code)
 
- {
 
-     var codeNamespace = code.VsNamespaceSuggestion();
 
-     if (!String.IsNullOrEmpty(codeNamespace))
 
-     {
 
- #>
 
- namespace <#=code.EscapeNamespace(codeNamespace)#>
 
- {
 
- <#+
 
-         PushIndent("    ");
 
-     }
 
- }
 
- public void EndNamespace(CodeGenerationTools code)
 
- {
 
-     if (!String.IsNullOrEmpty(code.VsNamespaceSuggestion()))
 
-     {
 
-         PopIndent();
 
- #>
 
- }
 
- <#+
 
-     }
 
- }
 
- public const string TemplateId = "CSharp_DbContext_Types_EF5";
 
- public class CodeStringGenerator
 
- {
 
-     private readonly CodeGenerationTools _code;
 
-     private readonly TypeMapper _typeMapper;
 
-     private readonly MetadataTools _ef;
 
-     public CodeStringGenerator(CodeGenerationTools code, TypeMapper typeMapper, MetadataTools ef)
 
-     {
 
-         ArgumentNotNull(code, "code");
 
-         ArgumentNotNull(typeMapper, "typeMapper");
 
-         ArgumentNotNull(ef, "ef");
 
-         _code = code;
 
-         _typeMapper = typeMapper;
 
-         _ef = ef;
 
-     }
 
-     public string Property(EdmProperty edmProperty)
 
-     {
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} {1} {2} {{ {3}get; {4}set; }}",
 
-             Accessibility.ForProperty(edmProperty),
 
-             _typeMapper.GetTypeName(edmProperty.TypeUsage),
 
-             _code.Escape(edmProperty),
 
-             _code.SpaceAfter(Accessibility.ForGetter(edmProperty)),
 
-             _code.SpaceAfter(Accessibility.ForSetter(edmProperty)));
 
-     }
 
-     public string NavigationProperty(NavigationProperty navigationProperty)
 
-     {
 
-         var endType = _typeMapper.GetTypeName(navigationProperty.ToEndMember.GetEntityType());
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} {1} {2} {{ {3}get; {4}set; }}",
 
-             AccessibilityAndVirtual(Accessibility.ForProperty(navigationProperty)),
 
-             navigationProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ICollection<" + endType + ">") : endType,
 
-             _code.Escape(navigationProperty),
 
-             _code.SpaceAfter(Accessibility.ForGetter(navigationProperty)),
 
-             _code.SpaceAfter(Accessibility.ForSetter(navigationProperty)));
 
-     }
 
-     
 
-     public string AccessibilityAndVirtual(string accessibility)
 
-     {
 
-         return accessibility + (accessibility != "private" ? " virtual" : "");
 
-     }
 
-     
 
-     public string EntityClassOpening(EntityType entity)
 
-     {
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} {1}partial class {2}{3}",
 
-             Accessibility.ForType(entity),
 
-             _code.SpaceAfter(_code.AbstractOption(entity)),
 
-             _code.Escape(entity),
 
-             _code.StringBefore(" : ", _typeMapper.GetTypeName(entity.BaseType)));
 
-     }
 
-     
 
-     public string EnumOpening(SimpleType enumType)
 
-     {
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} enum {1} : {2}",
 
-             Accessibility.ForType(enumType),
 
-             _code.Escape(enumType),
 
-             _code.Escape(_typeMapper.UnderlyingClrType(enumType)));
 
-         }
 
-     
 
-     public void WriteFunctionParameters(EdmFunction edmFunction, Action<string, string, string, string> writeParameter)
 
-     {
 
-         var parameters = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
 
-         foreach (var parameter in parameters.Where(p => p.NeedsLocalVariable))
 
-         {
 
-             var isNotNull = parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null";
 
-             var notNullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")";
 
-             var nullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", typeof(" + parameter.RawClrTypeName + "))";
 
-             writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit);
 
-         }
 
-     }
 
-     
 
-     public string ComposableFunctionMethod(EdmFunction edmFunction, string modelNamespace)
 
-     {
 
-         var parameters = _typeMapper.GetParameters(edmFunction);
 
-         
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} IQueryable<{1}> {2}({3})",
 
-             AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
 
-             _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
 
-             _code.Escape(edmFunction),
 
-             string.Join(", ", parameters.Select(p => p.FunctionParameterType + " " + p.FunctionParameterName).ToArray()));
 
-     }
 
-     
 
-     public string ComposableCreateQuery(EdmFunction edmFunction, string modelNamespace)
 
-     {
 
-         var parameters = _typeMapper.GetParameters(edmFunction);
 
-         
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{0}>(\"[{1}].[{2}]({3})\"{4});",
 
-             _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),
 
-             edmFunction.NamespaceName,
 
-             edmFunction.Name,
 
-             string.Join(", ", parameters.Select(p => "@" + p.EsqlParameterName).ToArray()),
 
-             _code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray())));
 
-     }
 
-     
 
-     public string FunctionMethod(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
 
-     {
 
-         var parameters = _typeMapper.GetParameters(edmFunction);
 
-         var returnType = _typeMapper.GetReturnType(edmFunction);
 
-         var paramList = String.Join(", ", parameters.Select(p => p.FunctionParameterType + " " + p.FunctionParameterName).ToArray());
 
-         if (includeMergeOption)
 
-         {
 
-             paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption";
 
-         }
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} {1} {2}({3})",
 
-             AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),
 
-             returnType == null ? "int" : "ObjectResult<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
 
-             _code.Escape(edmFunction),
 
-             paramList);
 
-     }
 
-     
 
-     public string ExecuteFunction(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)
 
-     {
 
-         var parameters = _typeMapper.GetParameters(edmFunction);
 
-         var returnType = _typeMapper.GetReturnType(edmFunction);
 
-         var callParams = _code.StringBefore(", ", String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()));
 
-         if (includeMergeOption)
 
-         {
 
-             callParams = ", mergeOption" + callParams;
 
-         }
 
-         
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction{0}(\"{1}\"{2});",
 
-             returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",
 
-             edmFunction.Name,
 
-             callParams);
 
-     }
 
-     
 
-     public string DbSet(EntitySet entitySet)
 
-     {
 
-         return string.Format(
 
-             CultureInfo.InvariantCulture,
 
-             "{0} DbSet<{1}> {2} {{ get; set; }}",
 
-             Accessibility.ForReadOnlyProperty(entitySet),
 
-             _typeMapper.GetTypeName(entitySet.ElementType),
 
-             _code.Escape(entitySet));
 
-     }
 
-     public string UsingDirectives(bool inHeader, bool includeCollections = true)
 
-     {
 
-         return inHeader == string.IsNullOrEmpty(_code.VsNamespaceSuggestion())
 
-             ? string.Format(
 
-                 CultureInfo.InvariantCulture,
 
-                 "{0}using System;{1}" +
 
-                 "{2}",
 
-                 inHeader ? Environment.NewLine : "",
 
-                 includeCollections ? (Environment.NewLine + "using System.Collections.Generic;") : "",
 
-                 inHeader ? "" : Environment.NewLine)
 
-             : "";
 
-     }
 
- }
 
- public class TypeMapper
 
- {
 
-     private const string ExternalTypeNameAttributeName = @"http://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName";
 
-     private readonly System.Collections.IList _errors;
 
-     private readonly CodeGenerationTools _code;
 
-     private readonly MetadataTools _ef;
 
-     public TypeMapper(CodeGenerationTools code, MetadataTools ef, System.Collections.IList errors)
 
-     {
 
-         ArgumentNotNull(code, "code");
 
-         ArgumentNotNull(ef, "ef");
 
-         ArgumentNotNull(errors, "errors");
 
-         _code = code;
 
-         _ef = ef;
 
-         _errors = errors;
 
-     }
 
-     public string GetTypeName(TypeUsage typeUsage)
 
-     {
 
-         return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace: null);
 
-     }
 
-     public string GetTypeName(EdmType edmType)
 
-     {
 
-         return GetTypeName(edmType, isNullable: null, modelNamespace: null);
 
-     }
 
-     public string GetTypeName(TypeUsage typeUsage, string modelNamespace)
 
-     {
 
-         return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace);
 
-     }
 
-     public string GetTypeName(EdmType edmType, string modelNamespace)
 
-     {
 
-         return GetTypeName(edmType, isNullable: null, modelNamespace: modelNamespace);
 
-     }
 
-     public string GetTypeName(EdmType edmType, bool? isNullable, string modelNamespace)
 
-     {
 
-         if (edmType == null)
 
-         {
 
-             return null;
 
-         }
 
-         var collectionType = edmType as CollectionType;
 
-         if (collectionType != null)
 
-         {
 
-             return String.Format(CultureInfo.InvariantCulture, "ICollection<{0}>", GetTypeName(collectionType.TypeUsage, modelNamespace));
 
-         }
 
-         var typeName = _code.Escape(edmType.MetadataProperties
 
-                                 .Where(p => p.Name == ExternalTypeNameAttributeName)
 
-                                 .Select(p => (string)p.Value)
 
-                                 .FirstOrDefault())
 
-             ?? (modelNamespace != null && edmType.NamespaceName != modelNamespace ?
 
-                 _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)) :
 
-                 _code.Escape(edmType));
 
-         if (edmType is StructuralType)
 
-         {
 
-             return typeName;
 
-         }
 
-         if (edmType is SimpleType)
 
-         {
 
-             var clrType = UnderlyingClrType(edmType);
 
-             if (!IsEnumType(edmType))
 
-             {
 
-                 typeName = _code.Escape(clrType);
 
-             }
 
-             return clrType.IsValueType && isNullable == true ?
 
-                 String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", typeName) :
 
-                 typeName;
 
-         }
 
-         throw new ArgumentException("edmType");
 
-     }
 
-     
 
-     public Type UnderlyingClrType(EdmType edmType)
 
-     {
 
-         ArgumentNotNull(edmType, "edmType");
 
-         var primitiveType = edmType as PrimitiveType;
 
-         if (primitiveType != null)
 
-         {
 
-             return primitiveType.ClrEquivalentType;
 
-         }
 
-         if (IsEnumType(edmType))
 
-         {
 
-             return GetEnumUnderlyingType(edmType).ClrEquivalentType;
 
-         }
 
-         return typeof(object);
 
-     }
 
-     
 
-     public object GetEnumMemberValue(MetadataItem enumMember)
 
-     {
 
-         ArgumentNotNull(enumMember, "enumMember");
 
-         
 
-         var valueProperty = enumMember.GetType().GetProperty("Value");
 
-         return valueProperty == null ? null : valueProperty.GetValue(enumMember, null);
 
-     }
 
-     
 
-     public string GetEnumMemberName(MetadataItem enumMember)
 
-     {
 
-         ArgumentNotNull(enumMember, "enumMember");
 
-         
 
-         var nameProperty = enumMember.GetType().GetProperty("Name");
 
-         return nameProperty == null ? null : (string)nameProperty.GetValue(enumMember, null);
 
-     }
 
-     public System.Collections.IEnumerable GetEnumMembers(EdmType enumType)
 
-     {
 
-         ArgumentNotNull(enumType, "enumType");
 
-         var membersProperty = enumType.GetType().GetProperty("Members");
 
-         return membersProperty != null 
 
-             ? (System.Collections.IEnumerable)membersProperty.GetValue(enumType, null)
 
-             : Enumerable.Empty<MetadataItem>();
 
-     }
 
-     
 
-     public bool EnumIsFlags(EdmType enumType)
 
-     {
 
-         ArgumentNotNull(enumType, "enumType");
 
-         
 
-         var isFlagsProperty = enumType.GetType().GetProperty("IsFlags");
 
-         return isFlagsProperty != null && (bool)isFlagsProperty.GetValue(enumType, null);
 
-     }
 
-     public bool IsEnumType(GlobalItem edmType)
 
-     {
 
-         ArgumentNotNull(edmType, "edmType");
 
-         return edmType.GetType().Name == "EnumType";
 
-     }
 
-     public PrimitiveType GetEnumUnderlyingType(EdmType enumType)
 
-     {
 
-         ArgumentNotNull(enumType, "enumType");
 
-         return (PrimitiveType)enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, null);
 
-     }
 
-     public string CreateLiteral(object value)
 
-     {
 
-         if (value == null || value.GetType() != typeof(TimeSpan))
 
-         {
 
-             return _code.CreateLiteral(value);
 
-         }
 
-         return string.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", ((TimeSpan)value).Ticks);
 
-     }
 
-     
 
-     public bool VerifyCaseInsensitiveTypeUniqueness(IEnumerable<string> types, string sourceFile)
 
-     {
 
-         ArgumentNotNull(types, "types");
 
-         ArgumentNotNull(sourceFile, "sourceFile");
 
-         
 
-         var hash = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase);
 
-         if (types.Any(item => !hash.Add(item)))
 
-         {
 
-             _errors.Add(
 
-                 new CompilerError(sourceFile, -1, -1, "6023",
 
-                     String.Format(CultureInfo.CurrentCulture, GetResourceString("Template_CaseInsensitiveTypeConflict"))));
 
-             return false;
 
-         }
 
-         return true;
 
-     }
 
-     
 
-     public IEnumerable<SimpleType> GetEnumItemsToGenerate(IEnumerable<GlobalItem> itemCollection)
 
-     {
 
-         return GetItemsToGenerate<SimpleType>(itemCollection)
 
-             .Where(e => IsEnumType(e));
 
-     }
 
-     
 
-     public IEnumerable<T> GetItemsToGenerate<T>(IEnumerable<GlobalItem> itemCollection) where T: EdmType
 
-     {
 
-         return itemCollection
 
-             .OfType<T>()
 
-             .Where(i => !i.MetadataProperties.Any(p => p.Name == ExternalTypeNameAttributeName))
 
-             .OrderBy(i => i.Name);
 
-     }
 
-     public IEnumerable<string> GetAllGlobalItems(IEnumerable<GlobalItem> itemCollection)
 
-     {
 
-         return itemCollection
 
-             .Where(i => i is EntityType || i is ComplexType || i is EntityContainer || IsEnumType(i))
 
-             .Select(g => GetGlobalItemName(g));
 
-     }
 
-     public string GetGlobalItemName(GlobalItem item)
 
-     {
 
-         if (item is EdmType)
 
-         {
 
-             return ((EdmType)item).Name;
 
-         }
 
-         else
 
-         {
 
-             return ((EntityContainer)item).Name;
 
-         }
 
-     }
 
-     public IEnumerable<EdmProperty> GetSimpleProperties(EntityType type)
 
-     {
 
-         return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
 
-     }
 
-     
 
-     public IEnumerable<EdmProperty> GetSimpleProperties(ComplexType type)
 
-     {
 
-         return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type);
 
-     }
 
-     
 
-     public IEnumerable<EdmProperty> GetComplexProperties(EntityType type)
 
-     {
 
-         return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
 
-     }
 
-     
 
-     public IEnumerable<EdmProperty> GetComplexProperties(ComplexType type)
 
-     {
 
-         return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type);
 
-     }
 
-     public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(EntityType type)
 
-     {
 
-         return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
 
-     }
 
-     
 
-     public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(ComplexType type)
 
-     {
 
-         return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null);
 
-     }
 
-     public IEnumerable<NavigationProperty> GetNavigationProperties(EntityType type)
 
-     {
 
-         return type.NavigationProperties.Where(np => np.DeclaringType == type);
 
-     }
 
-     
 
-     public IEnumerable<NavigationProperty> GetCollectionNavigationProperties(EntityType type)
 
-     {
 
-         return type.NavigationProperties.Where(np => np.DeclaringType == type && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many);
 
-     }
 
-     
 
-     public FunctionParameter GetReturnParameter(EdmFunction edmFunction)
 
-     {
 
-         ArgumentNotNull(edmFunction, "edmFunction");
 
-         var returnParamsProperty = edmFunction.GetType().GetProperty("ReturnParameters");
 
-         return returnParamsProperty == null
 
-             ? edmFunction.ReturnParameter
 
-             : ((IEnumerable<FunctionParameter>)returnParamsProperty.GetValue(edmFunction, null)).FirstOrDefault();
 
-     }
 
-     public bool IsComposable(EdmFunction edmFunction)
 
-     {
 
-         ArgumentNotNull(edmFunction, "edmFunction");
 
-         var isComposableProperty = edmFunction.GetType().GetProperty("IsComposableAttribute");
 
-         return isComposableProperty != null && (bool)isComposableProperty.GetValue(edmFunction, null);
 
-     }
 
-     public IEnumerable<FunctionImportParameter> GetParameters(EdmFunction edmFunction)
 
-     {
 
-         return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);
 
-     }
 
-     public TypeUsage GetReturnType(EdmFunction edmFunction)
 
-     {
 
-         var returnParam = GetReturnParameter(edmFunction);
 
-         return returnParam == null ? null : _ef.GetElementType(returnParam.TypeUsage);
 
-     }
 
-     
 
-     public bool GenerateMergeOptionFunction(EdmFunction edmFunction, bool includeMergeOption)
 
-     {
 
-         var returnType = GetReturnType(edmFunction);
 
-         return !includeMergeOption && returnType != null && returnType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType;
 
-     }
 
- }
 
- public class EdmMetadataLoader
 
- {
 
-     private readonly IDynamicHost _host;
 
-     private readonly System.Collections.IList _errors;
 
-     public EdmMetadataLoader(IDynamicHost host, System.Collections.IList errors)
 
-     {
 
-         ArgumentNotNull(host, "host");
 
-         ArgumentNotNull(errors, "errors");
 
-         _host = host;
 
-         _errors = errors;
 
-     }
 
-     public IEnumerable<GlobalItem> CreateEdmItemCollection(string sourcePath)
 
-     {
 
-         ArgumentNotNull(sourcePath, "sourcePath");
 
-         if (!ValidateInputPath(sourcePath))
 
-         {
 
-             return new EdmItemCollection();
 
-         }
 
-         var schemaElement = LoadRootElement(_host.ResolvePath(sourcePath));
 
-         if (schemaElement != null)
 
-         {
 
-             using (var reader = schemaElement.CreateReader())
 
-             {
 
-                 IList<EdmSchemaError> errors;
 
-                 var itemCollection = MetadataItemCollectionFactory.CreateEdmItemCollection(new[] { reader }, out errors);
 
-                 ProcessErrors(errors, sourcePath);
 
-                 return itemCollection;
 
-             }
 
-         }
 
-         return new EdmItemCollection();
 
-     }
 
-     public string GetModelNamespace(string sourcePath)
 
-     {
 
-         ArgumentNotNull(sourcePath, "sourcePath");
 
-         if (!ValidateInputPath(sourcePath))
 
-         {
 
-             return string.Empty;
 
-         }
 
-         var model = LoadRootElement(_host.ResolvePath(sourcePath));
 
-         if (model == null)
 
-         {
 
-             return string.Empty;
 
-         }
 
-         var attribute = model.Attribute("Namespace");
 
-         return attribute != null ? attribute.Value : "";
 
-     }
 
-     private bool ValidateInputPath(string sourcePath)
 
-     {
 
-         if (sourcePath == "$" + "edmxInputFile" + "$")
 
-         {
 
-             _errors.Add(
 
-                 new CompilerError(_host.TemplateFile ?? sourcePath, 0, 0, string.Empty,
 
-                     GetResourceString("Template_ReplaceVsItemTemplateToken")));
 
-             return false;
 
-         }
 
-         return true;
 
-     }
 
-     public XElement LoadRootElement(string sourcePath)
 
-     {
 
-         ArgumentNotNull(sourcePath, "sourcePath");
 
-         var root = XElement.Load(sourcePath, LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);
 
-         return root.Elements()
 
-             .Where(e => e.Name.LocalName == "Runtime")
 
-             .Elements()
 
-             .Where(e => e.Name.LocalName == "ConceptualModels")
 
-             .Elements()
 
-             .Where(e => e.Name.LocalName == "Schema")
 
-             .FirstOrDefault()
 
-                 ?? root;
 
-     }
 
-     private void ProcessErrors(IEnumerable<EdmSchemaError> errors, string sourceFilePath)
 
-     {
 
-         foreach (var error in errors)
 
-         {
 
-             _errors.Add(
 
-                 new CompilerError(
 
-                     error.SchemaLocation ?? sourceFilePath,
 
-                     error.Line,
 
-                     error.Column,
 
-                     error.ErrorCode.ToString(CultureInfo.InvariantCulture),
 
-                     error.Message)
 
-                 {
 
-                     IsWarning = error.Severity == EdmSchemaErrorSeverity.Warning
 
-                 });
 
-         }
 
-     }
 
-     
 
-     public bool IsLazyLoadingEnabled(EntityContainer container)
 
-     {
 
-         string lazyLoadingAttributeValue;
 
-         var lazyLoadingAttributeName = MetadataConstants.EDM_ANNOTATION_09_02 + ":LazyLoadingEnabled";
 
-         bool isLazyLoading;
 
-         return !MetadataTools.TryGetStringMetadataPropertySetting(container, lazyLoadingAttributeName, out lazyLoadingAttributeValue)
 
-             || !bool.TryParse(lazyLoadingAttributeValue, out isLazyLoading)
 
-             || isLazyLoading;
 
-     }
 
- }
 
- public static void ArgumentNotNull<T>(T arg, string name) where T : class
 
- {
 
-     if (arg == null)
 
-     {
 
-         throw new ArgumentNullException(name);
 
-     }
 
- }
 
-     
 
- private static readonly Lazy<System.Resources.ResourceManager> ResourceManager =
 
-     new Lazy<System.Resources.ResourceManager>(
 
-         () => new System.Resources.ResourceManager("System.Data.Entity.Design", typeof(MetadataItemCollectionFactory).Assembly), isThreadSafe: true);
 
- public static string GetResourceString(string resourceName)
 
- {
 
-     ArgumentNotNull(resourceName, "resourceName");
 
-     return ResourceManager.Value.GetString(resourceName, null);
 
- }
 
- #>
 
 
  |