mcs/class/referencesource/System.Data.Entity/System/Data/Metadata/ObjectLayer/ObjectItemAssemblyLoader.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="ObjectItemAssemblyLoader.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner       Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 namespace System.Data.Metadata.Edm
  11 {
  12     using System.Collections.Generic;
  13     using System.Data.Entity;
  14     using System.Diagnostics;
  15     using System.Reflection;
  16
  17     internal abstract class ObjectItemAssemblyLoader
  18     {
  19         protected const BindingFlags PropertyReflectionBindingFlags = BindingFlags.DeclaredOnly |
  20                                                                      BindingFlags.Instance |
  21                                                                      BindingFlags.Public |
  22                                                                      BindingFlags.NonPublic;
  23
  24         private readonly ObjectItemLoadingSessionData _sessionData;
  25         private Assembly _assembly;
  26         private AssemblyCacheEntry _cacheEntry;
  27
  28         protected ObjectItemAssemblyLoader(Assembly assembly, AssemblyCacheEntry cacheEntry, ObjectItemLoadingSessionData sessionData)
  29         {
  30             _assembly = assembly;
  31             _cacheEntry = cacheEntry;
  32             _sessionData = sessionData;
  33         }
  34
  35         internal virtual void Load()
  36         {
  37             AddToAssembliesLoaded();
  38
  39             LoadTypesFromAssembly();
  40
  41             AddToKnownAssemblies();
  42
  43             LoadClosureAssemblies();
  44         }
  45
  46         protected abstract void AddToAssembliesLoaded();
  47         protected abstract void LoadTypesFromAssembly();
  48         protected virtual void LoadClosureAssemblies()
  49         {
  50             LoadAssemblies(CacheEntry.ClosureAssemblies, SessionData);
  51         }
  52
  53         internal virtual void OnLevel1SessionProcessing() { }
  54         internal virtual void OnLevel2SessionProcessing() { }
  55
  56         internal static ObjectItemAssemblyLoader CreateLoader(Assembly assembly, ObjectItemLoadingSessionData sessionData)
  57         {
  58             ImmutableAssemblyCacheEntry cacheEntry;
  59
  60             // KnownAssembly -> NoOp
  61             // Inside the LockedAssemblyCache means it is an attribute based assembly -> Cachedassembly
  62             // Inside the OcCache on EdmItemCollection -> cachedassembly
  63             // If none of above, setup the LoaderFactory based on the current assembly and EdmItemCollection
  64             if (sessionData.KnownAssemblies.Contains(assembly, sessionData.ObjectItemAssemblyLoaderFactory, sessionData.EdmItemCollection))
  65             {
  66                 return new ObjectItemNoOpAssemblyLoader(assembly, sessionData);
  67             }
  68             else if (sessionData.LockedAssemblyCache.TryGetValue(assembly, out cacheEntry))
  69             {
  70                 if (sessionData.ObjectItemAssemblyLoaderFactory == null)
  71                 {
  72                     if (cacheEntry.TypesInAssembly.Count != 0)
  73                     {
  74                         // we are loading based on attributes now
  75                         sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemAttributeAssemblyLoader.Create;
  76                     }
  77                     // if types in assembly are 0, don't commit to any loader yet
  78                 }
  79                 else if (sessionData.ObjectItemAssemblyLoaderFactory != ObjectItemAttributeAssemblyLoader.Create)
  80                 {
  81                     // we were loading in convention mode, and ran into an assembly that can't be loaded by convention
  82                     // we know this because all cached assemblies are attribute based at the moment.
  83                     sessionData.EdmItemErrors.Add(new EdmItemError(Strings.Validator_OSpace_Convention_AttributeAssemblyReferenced(assembly.FullName), null));
  84                 }
  85                 return new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData);
  86             }
  87             else if (sessionData.EdmItemCollection != null &&
  88                     sessionData.EdmItemCollection.ConventionalOcCache.TryGetConventionalOcCacheFromAssemblyCache(
  89                         assembly, out cacheEntry))
  90             {
  91                 sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemConventionAssemblyLoader.Create;
  92                 return new ObjectItemCachedAssemblyLoader(assembly, cacheEntry, sessionData);
  93             }
  94             else if (sessionData.ObjectItemAssemblyLoaderFactory == null)
  95             {
  96                 if (ObjectItemAttributeAssemblyLoader.IsSchemaAttributePresent(assembly))
  97                 {
  98                     sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemAttributeAssemblyLoader.Create;
  99                 }
 100                 else if (ObjectItemConventionAssemblyLoader.SessionContainsConventionParameters(sessionData))
 101                 {
 102                     sessionData.ObjectItemAssemblyLoaderFactory = ObjectItemConventionAssemblyLoader.Create;
 103                 }
 104             }
 105
 106             if (sessionData.ObjectItemAssemblyLoaderFactory != null)
 107             {
 108                 return sessionData.ObjectItemAssemblyLoaderFactory(assembly, sessionData);
 109             }
 110
 111             return new ObjectItemNoOpAssemblyLoader(assembly, sessionData);
 112
 113         }
 114
 115         internal static bool IsAttributeLoader(object loaderCookie)
 116         {
 117             Debug.Assert(loaderCookie == null || loaderCookie is Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>, "Non loader cookie passed in");
 118             return IsAttributeLoader(loaderCookie as Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader>);
 119         }
 120
 121         internal static bool IsAttributeLoader(Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader> loaderFactory)
 122         {
 123             if (loaderFactory == null)
 124             {
 125                 return false;
 126             }
 127
 128             return loaderFactory == ObjectItemAttributeAssemblyLoader.Create;
 129         }
 130
 131         internal static bool IsConventionLoader(Func<Assembly, ObjectItemLoadingSessionData, ObjectItemAssemblyLoader> loaderFactory)
 132         {
 133             if (loaderFactory == null)
 134             {
 135                 return false;
 136             }
 137
 138             return loaderFactory == ObjectItemConventionAssemblyLoader.Create;
 139         }
 140
 141         protected virtual void AddToKnownAssemblies()
 142         {
 143             Debug.Assert(!_sessionData.KnownAssemblies.Contains(_assembly, SessionData.ObjectItemAssemblyLoaderFactory, _sessionData.EdmItemCollection), "This assembly must not be present in the list of known assemblies");
 144             _sessionData.KnownAssemblies.Add(_assembly, new KnownAssemblyEntry(CacheEntry, SessionData.EdmItemCollection != null));
 145         }
 146
 147         protected static void LoadAssemblies(IEnumerable<Assembly> assemblies, ObjectItemLoadingSessionData sessionData)
 148         {
 149             foreach (Assembly assembly in assemblies)
 150             {
 151                 ObjectItemAssemblyLoader loader = ObjectItemAssemblyLoader.CreateLoader(assembly, sessionData);
 152                 loader.Load();
 153             }
 154         }
 155
 156         protected bool TryGetPrimitiveType(Type type, out PrimitiveType primitiveType)
 157         {
 158             return ClrProviderManifest.Instance.TryGetPrimitiveType(Nullable.GetUnderlyingType(type) ?? type, out primitiveType);
 159         }
 160
 161
 162
 163         protected ObjectItemLoadingSessionData SessionData { get { return _sessionData; } }
 164         protected Assembly SourceAssembly { get { return _assembly; } }
 165         protected AssemblyCacheEntry CacheEntry { get { return _cacheEntry; } }
 166
 167     }
 168 }