diff --git a/src/coreclr/binder/bindertracing.cpp b/src/coreclr/binder/bindertracing.cpp
index 66354d16b0197..5a0f1a9470a3e 100644
--- a/src/coreclr/binder/bindertracing.cpp
+++ b/src/coreclr/binder/bindertracing.cpp
@@ -88,7 +88,7 @@ namespace
         if (spec->GetName() != nullptr)
             spec->GetDisplayName(ASM_DISPLAYF_VERSION | ASM_DISPLAYF_CULTURE | ASM_DISPLAYF_PUBLIC_KEY_TOKEN, request.AssemblyName);
 
-        DomainAssembly *parentAssembly = spec->GetParentAssembly();
+        ::Assembly *parentAssembly = spec->GetParentAssembly();
         if (parentAssembly != nullptr)
         {
             PEAssembly *pPEAssembly = parentAssembly->GetPEAssembly();
diff --git a/src/coreclr/vm/appdomain.cpp b/src/coreclr/vm/appdomain.cpp
index 2b04bd530cf80..f8436aca04d5b 100644
--- a/src/coreclr/vm/appdomain.cpp
+++ b/src/coreclr/vm/appdomain.cpp
@@ -3946,7 +3946,7 @@ void AppDomain::ExceptionUnwind(Frame *pFrame)
 
 #ifndef DACCESS_COMPILE
 
-DomainAssembly* AppDomain::RaiseTypeResolveEventThrowing(DomainAssembly* pAssembly, LPCSTR szName, ASSEMBLYREF *pResultingAssemblyRef)
+Assembly* AppDomain::RaiseTypeResolveEventThrowing(Assembly* pAssembly, LPCSTR szName, ASSEMBLYREF *pResultingAssemblyRef)
 {
     CONTRACTL
     {
@@ -3959,7 +3959,7 @@ DomainAssembly* AppDomain::RaiseTypeResolveEventThrowing(DomainAssembly* pAssemb
 
     OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
 
-    DomainAssembly* pResolvedAssembly = NULL;
+    Assembly* pResolvedAssembly = NULL;
     _ASSERTE(strcmp(szName, g_AppDomainClassName));
 
     GCX_COOP();
@@ -3974,7 +3974,7 @@ DomainAssembly* AppDomain::RaiseTypeResolveEventThrowing(DomainAssembly* pAssemb
     GCPROTECT_BEGIN(gc);
 
     if (pAssembly != NULL)
-        gc.AssemblyRef = pAssembly->GetExposedAssemblyObject();
+        gc.AssemblyRef = pAssembly->GetExposedObject();
 
     MethodDescCallSite onTypeResolve(METHOD__ASSEMBLYLOADCONTEXT__ON_TYPE_RESOLVE);
 
@@ -3988,7 +3988,7 @@ DomainAssembly* AppDomain::RaiseTypeResolveEventThrowing(DomainAssembly* pAssemb
 
     if (ResultingAssemblyRef != NULL)
     {
-        pResolvedAssembly = ResultingAssemblyRef->GetDomainAssembly();
+        pResolvedAssembly = ResultingAssemblyRef->GetAssembly();
 
         if (pResultingAssemblyRef)
             *pResultingAssemblyRef = ResultingAssemblyRef;
@@ -4006,7 +4006,7 @@ DomainAssembly* AppDomain::RaiseTypeResolveEventThrowing(DomainAssembly* pAssemb
 }
 
 
-Assembly* AppDomain::RaiseResourceResolveEvent(DomainAssembly* pAssembly, LPCSTR szName)
+Assembly* AppDomain::RaiseResourceResolveEvent(Assembly* pAssembly, LPCSTR szName)
 {
     CONTRACT(Assembly*)
     {
@@ -4032,7 +4032,7 @@ Assembly* AppDomain::RaiseResourceResolveEvent(DomainAssembly* pAssembly, LPCSTR
     GCPROTECT_BEGIN(gc);
 
     if (pAssembly != NULL)
-        gc.AssemblyRef=pAssembly->GetExposedAssemblyObject();
+        gc.AssemblyRef=pAssembly->GetExposedObject();
 
     MethodDescCallSite onResourceResolve(METHOD__ASSEMBLYLOADCONTEXT__ON_RESOURCE_RESOLVE);
     gc.str = StringObject::NewString(szName);
@@ -4095,7 +4095,7 @@ AppDomain::RaiseAssemblyResolveEvent(
     {
         if (pSpec->GetParentAssembly() != NULL)
         {
-            gc.AssemblyRef=pSpec->GetParentAssembly()->GetExposedAssemblyObject();
+            gc.AssemblyRef=pSpec->GetParentAssembly()->GetExposedObject();
         }
 
         MethodDescCallSite onAssemblyResolve(METHOD__ASSEMBLYLOADCONTEXT__ON_ASSEMBLY_RESOLVE);
diff --git a/src/coreclr/vm/appdomain.hpp b/src/coreclr/vm/appdomain.hpp
index 5957aad24655e..7bf26952da867 100644
--- a/src/coreclr/vm/appdomain.hpp
+++ b/src/coreclr/vm/appdomain.hpp
@@ -1517,8 +1517,8 @@ class AppDomain : public BaseDomain
     }
 
     static void RaiseExitProcessEvent();
-    Assembly* RaiseResourceResolveEvent(DomainAssembly* pAssembly, LPCSTR szName);
-    DomainAssembly* RaiseTypeResolveEventThrowing(DomainAssembly* pAssembly, LPCSTR szName, ASSEMBLYREF *pResultingAssemblyRef);
+    Assembly* RaiseResourceResolveEvent(Assembly* pAssembly, LPCSTR szName);
+    Assembly* RaiseTypeResolveEventThrowing(Assembly* pAssembly, LPCSTR szName, ASSEMBLYREF *pResultingAssemblyRef);
     Assembly* RaiseAssemblyResolveEvent(AssemblySpec *pSpec);
 
 private:
diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp
index c7fb64b38158a..71482da1ed829 100644
--- a/src/coreclr/vm/assembly.cpp
+++ b/src/coreclr/vm/assembly.cpp
@@ -1590,9 +1590,8 @@ BOOL Assembly::FileNotFound(HRESULT hr)
 
 
 BOOL Assembly::GetResource(LPCSTR szName, DWORD *cbResource,
-                              PBYTE *pbInMemoryResource, Assembly** pAssemblyRef,
-                              LPCSTR *szFileName, DWORD *dwLocation,
-                              BOOL fSkipRaiseResolveEvent)
+                             PBYTE *pbInMemoryResource, Assembly** pAssemblyRef,
+                             LPCSTR *szFileName, DWORD *dwLocation)
 {
     CONTRACTL
     {
@@ -1602,13 +1601,10 @@ BOOL Assembly::GetResource(LPCSTR szName, DWORD *cbResource,
     }
     CONTRACTL_END;
 
-    DomainAssembly *pAssembly = NULL;
-    BOOL result = GetDomainAssembly()->GetResource(szName, cbResource,
-                                                   pbInMemoryResource, &pAssembly,
-                                                   szFileName, dwLocation,
-                                                   fSkipRaiseResolveEvent);
-    if (result && pAssemblyRef != NULL && pAssembly != NULL)
-        *pAssemblyRef = pAssembly->GetAssembly();
+    BOOL result = GetPEAssembly()->GetResource(szName, cbResource,
+                                                pbInMemoryResource, pAssemblyRef,
+                                                szFileName, dwLocation,
+                                                this);
 
     return result;
 }
diff --git a/src/coreclr/vm/assembly.hpp b/src/coreclr/vm/assembly.hpp
index 987b7231b0a40..617aa07676453 100644
--- a/src/coreclr/vm/assembly.hpp
+++ b/src/coreclr/vm/assembly.hpp
@@ -259,9 +259,8 @@ class Assembly
     ~Assembly();
 
     BOOL GetResource(LPCSTR szName, DWORD *cbResource,
-                     PBYTE *pbInMemoryResource, Assembly **pAssemblyRef,
-                     LPCSTR *szFileName, DWORD *dwLocation,
-                     BOOL fSkipRaiseResolveEvent = FALSE);
+                    PBYTE *pbInMemoryResource, Assembly **pAssemblyRef,
+                    LPCSTR *szFileName, DWORD *dwLocation);
 
     //****************************************************************************************
 #ifdef DACCESS_COMPILE
diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp
index ade4baf688f30..ca4820c405f61 100644
--- a/src/coreclr/vm/assemblynative.cpp
+++ b/src/coreclr/vm/assemblynative.cpp
@@ -63,10 +63,6 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* p
         {
             pRefAssembly = SystemDomain::GetCallersAssembly(stackMark);
         }
-        if (pRefAssembly)
-        {
-            pParentAssembly = pRefAssembly->GetDomainAssembly();
-        }
     }
 
     AssemblySpec spec;
@@ -93,8 +89,8 @@ extern "C" void QCALLTYPE AssemblyNative_InternalLoad(NativeAssemblyNameParts* p
     spec.Init(ssName.GetUTF8(), &asmInfo,
         pAssemblyNameParts->_pPublicKeyOrToken, pAssemblyNameParts->_cbPublicKeyOrToken, pAssemblyNameParts->_flags);
 
-    if (pParentAssembly != NULL)
-        spec.SetParentAssembly(pParentAssembly);
+    if (pRefAssembly != NULL)
+        spec.SetParentAssembly(pRefAssembly);
 
     // Have we been passed the reference to the binder against which this load should be triggered?
     // If so, then use it to set the fallback load context binder.
@@ -138,7 +134,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma
     ReleaseHolder<BINDER_SPACE::Assembly> pAssembly;
 
     // Set the caller's assembly to be CoreLib
-    DomainAssembly *pCallersAssembly = SystemDomain::System()->SystemAssembly()->GetDomainAssembly();
+    Assembly *pCallersAssembly = SystemDomain::System()->SystemAssembly();
 
     // Initialize the AssemblySpec
     AssemblySpec spec;
@@ -650,9 +646,9 @@ extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAs
     if (*pNameUTF8 == '\0')
         COMPlusThrow(kArgumentException, W("Format_StringZeroLength"));
 
-    pAssembly->GetResource(pNameUTF8, length,
+    pAssembly->GetPEAssembly()->GetResource(pNameUTF8, length,
                            &pbInMemoryResource, NULL, NULL,
-                           NULL, FALSE);
+                           NULL, pAssembly->GetAssembly());
 
     END_QCALL;
 
@@ -679,12 +675,12 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::Assembl
     if (*pNameUTF8 == '\0')
         COMPlusThrow(kArgumentException, W("Format_StringZeroLength"));
 
-    DomainAssembly * pReferencedAssembly = NULL;
+    Assembly * pReferencedAssembly = NULL;
     LPCSTR pFileName = NULL;
     DWORD dwLocation = 0;
 
-    if (pAssembly->GetResource(pNameUTF8, NULL, NULL, &pReferencedAssembly, &pFileName,
-                              &dwLocation, FALSE))
+    if (pAssembly->GetPEAssembly()->GetResource(pNameUTF8, NULL, NULL, &pReferencedAssembly, &pFileName,
+                              &dwLocation, pAssembly->GetAssembly()))
     {
         if (pFileName)
             retFileName.Set(pFileName);
@@ -692,7 +688,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::Assembl
         GCX_COOP();
 
         if (pReferencedAssembly)
-            retAssembly.Set(pReferencedAssembly->GetExposedAssemblyObject());
+            retAssembly.Set(pReferencedAssembly->GetExposedObject());
 
         rv = dwLocation;
     }
diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp
index a4872b732097b..11a394f665c46 100644
--- a/src/coreclr/vm/assemblyspec.cpp
+++ b/src/coreclr/vm/assemblyspec.cpp
@@ -148,7 +148,7 @@ AssemblySpecHash::~AssemblySpecHash()
 
 HRESULT AssemblySpec::InitializeSpecInternal(mdToken kAssemblyToken,
                                   IMDInternalImport *pImport,
-                                  DomainAssembly *pStaticParent)
+                                  Assembly *pStaticParent)
 {
     CONTRACTL
     {
@@ -325,12 +325,12 @@ AssemblyBinder* AssemblySpec::GetBinderFromParentAssembly(AppDomain *pDomain)
     CONTRACTL_END;
 
     AssemblyBinder *pParentAssemblyBinder = NULL;
-    DomainAssembly *pParentDomainAssembly = GetParentAssembly();
+    Assembly *pParentAssembly = GetParentAssembly();
 
-    if(pParentDomainAssembly != NULL)
+    if(pParentAssembly != NULL)
     {
         // Get the PEAssembly associated with the parent's domain assembly
-        PEAssembly *pParentPEAssembly = pParentDomainAssembly->GetPEAssembly();
+        PEAssembly *pParentPEAssembly = pParentAssembly->GetPEAssembly();
         pParentAssemblyBinder = pParentPEAssembly->GetAssemblyBinder();
     }
 
@@ -1121,7 +1121,7 @@ BOOL AssemblySpecBindingCache::CompareSpecs(UPTR u1, UPTR u2)
     return a1->CompareEx(a2);
 }
 
-DomainAssembly * AssemblySpec::GetParentAssembly()
+Assembly * AssemblySpec::GetParentAssembly()
 {
     LIMITED_METHOD_CONTRACT;
     return m_pParentAssembly;
diff --git a/src/coreclr/vm/assemblyspec.hpp b/src/coreclr/vm/assemblyspec.hpp
index 23a7c96e64756..96b8e409d1d99 100644
--- a/src/coreclr/vm/assemblyspec.hpp
+++ b/src/coreclr/vm/assemblyspec.hpp
@@ -28,7 +28,7 @@ class AssemblySpec  : public BaseAssemblySpec
 {
   private:
     AppDomain       *m_pAppDomain;
-    DomainAssembly  *m_pParentAssembly;
+    Assembly  *m_pParentAssembly;
 
     // Contains the reference to the fallback load context associated with RefEmitted assembly requesting the load of another assembly (static or dynamic)
     AssemblyBinder *m_pFallbackBinder;
@@ -38,7 +38,7 @@ class AssemblySpec  : public BaseAssemblySpec
 
     HRESULT InitializeSpecInternal(mdToken kAssemblyRefOrDef,
                                    IMDInternalImport *pImport,
-                                   DomainAssembly *pStaticParent);
+                                   Assembly *pStaticParent);
 
     // InitializeSpecInternal should be used very carefully so it's made private.
     // functions that take special care (and thus are allowed to use the function) are listed below
@@ -73,7 +73,7 @@ class AssemblySpec  : public BaseAssemblySpec
     }
 
 
-    DomainAssembly* GetParentAssembly();
+    Assembly* GetParentAssembly();
 
     AssemblyBinder* GetBinderFromParentAssembly(AppDomain *pDomain);
 
@@ -82,7 +82,7 @@ class AssemblySpec  : public BaseAssemblySpec
 
     void InitializeSpec(mdToken kAssemblyRefOrDef,
                         IMDInternalImport *pImport,
-                        DomainAssembly *pStaticParent = NULL)
+                        Assembly *pStaticParent = NULL)
     {
         CONTRACTL
         {
@@ -92,7 +92,7 @@ class AssemblySpec  : public BaseAssemblySpec
             MODE_ANY;
         }
         CONTRACTL_END;
-        HRESULT hr=InitializeSpecInternal(kAssemblyRefOrDef, pImport,pStaticParent);
+        HRESULT hr = InitializeSpecInternal(kAssemblyRefOrDef, pImport, pStaticParent);
         if(FAILED(hr))
             EEFileLoadException::Throw(this,hr);
     };
@@ -102,7 +102,7 @@ class AssemblySpec  : public BaseAssemblySpec
 
     void AssemblyNameInit(ASSEMBLYNAMEREF* pName); //[in,out]
 
-    void SetParentAssembly(DomainAssembly *pAssembly)
+    void SetParentAssembly(Assembly *pAssembly)
     {
         CONTRACTL
         {
diff --git a/src/coreclr/vm/callconvbuilder.cpp b/src/coreclr/vm/callconvbuilder.cpp
index af5d260afb082..d68ac7f023ec3 100644
--- a/src/coreclr/vm/callconvbuilder.cpp
+++ b/src/coreclr/vm/callconvbuilder.cpp
@@ -452,7 +452,7 @@ HRESULT CallConv::TryGetCallingConventionFromUnmanagedCallConv(
     callConvsArg.Init("CallConvs", SERIALIZATION_TYPE_SZARRAY, callConvsType);
 
     InlineFactory<SArray<CaValue>, 4> caValueArrayFactory;
-    DomainAssembly* domainAssembly = pMD->GetLoaderModule()->GetDomainAssembly();
+    Assembly* assembly = pMD->GetLoaderModule()->GetAssembly();
     IfFailThrow(CustomAttribute::ParseArgumentValues(
         pData,
         cData,
@@ -461,7 +461,7 @@ HRESULT CallConv::TryGetCallingConventionFromUnmanagedCallConv(
         0,
         &callConvsArg,
         1,
-        domainAssembly));
+        assembly ));
 
     // Value isn't defined
     if (callConvsArg.val.type.tag == SERIALIZATION_TYPE_UNDEFINED)
@@ -527,7 +527,7 @@ bool CallConv::TryGetCallingConventionFromUnmanagedCallersOnly(_In_ MethodDesc*
     namedArgs[1].Init("EntryPoint", SERIALIZATION_TYPE_STRING, caEntryPoint);
 
     InlineFactory<SArray<CaValue>, 4> caValueArrayFactory;
-    DomainAssembly* domainAssembly = pMD->GetLoaderModule()->GetDomainAssembly();
+    Assembly* assembly = pMD->GetLoaderModule()->GetAssembly();
     IfFailThrow(CustomAttribute::ParseArgumentValues(
         pData,
         cData,
@@ -536,7 +536,7 @@ bool CallConv::TryGetCallingConventionFromUnmanagedCallersOnly(_In_ MethodDesc*
         0,
         namedArgs,
         ARRAY_SIZE(namedArgs),
-        domainAssembly));
+        assembly));
 
     // If the value isn't defined, then return without setting anything.
     if (namedArgs[0].val.type.tag == SERIALIZATION_TYPE_UNDEFINED)
diff --git a/src/coreclr/vm/ceeload.cpp b/src/coreclr/vm/ceeload.cpp
index 81d6f2347cd1b..eb00a91abb433 100644
--- a/src/coreclr/vm/ceeload.cpp
+++ b/src/coreclr/vm/ceeload.cpp
@@ -2239,61 +2239,40 @@ Module::GetAssemblyIfLoaded(
         if ((pDomainAssembly == NULL) || !pDomainAssembly->IsLoaded())
             pAssembly = NULL;
     }
-#endif //!DACCESS_COMPILE
 
     if (pAssembly == NULL)
     {
-        do
-        {
-            AppDomain * pAppDomainExamine = AppDomain::GetCurrentDomain();
-
-            DomainAssembly * pCurAssemblyInExamineDomain = GetAssembly()->GetDomainAssembly();
-            if (pCurAssemblyInExamineDomain == NULL)
-            {
-                continue;
-            }
+        IMDInternalImport * pMDImport = (pMDImportOverride == NULL) ? (GetMDImport()) : (pMDImportOverride);
 
-#ifndef DACCESS_COMPILE
-            {
-                IMDInternalImport * pMDImport = (pMDImportOverride == NULL) ? (GetMDImport()) : (pMDImportOverride);
-
-                //we have to be very careful here.
-                //we are using InitializeSpecInternal so we need to make sure that under no condition
-                //the data we pass to it can outlive the assembly spec.
-                AssemblySpec spec;
-                if (FAILED(spec.InitializeSpecInternal(kAssemblyRef,
-                                                       pMDImport,
-                                                       pCurAssemblyInExamineDomain)))
-                {
-                    continue;
-                }
-
-                // If we have been passed the binding context for the loaded assembly that is being looked up in the
-                // cache, then set it up in the AssemblySpec for the cache lookup to use it below.
-                if (pBinderForLoadedAssembly != NULL)
-                {
-                    _ASSERTE(spec.GetBinder() == NULL);
-                    spec.SetBinder(pBinderForLoadedAssembly);
-                }
-                DomainAssembly * pDomainAssembly = nullptr;
+        //we have to be very careful here.
+        //we are using InitializeSpecInternal so we need to make sure that under no condition
+        //the data we pass to it can outlive the assembly spec.
+        AssemblySpec spec;
+        if (FAILED(spec.InitializeSpecInternal(kAssemblyRef,
+                                                pMDImport,
+                                                GetAssembly())))
+        {
+            return NULL;
+        }
 
-                {
-                    pDomainAssembly = pAppDomainExamine->FindCachedAssembly(&spec, FALSE /*fThrow*/);
-                }
+        // If we have been passed the binding context for the loaded assembly that is being looked up in the
+        // cache, then set it up in the AssemblySpec for the cache lookup to use it below.
+        if (pBinderForLoadedAssembly != NULL)
+        {
+            _ASSERTE(spec.GetBinder() == NULL);
+            spec.SetBinder(pBinderForLoadedAssembly);
+        }
 
-                if (pDomainAssembly && pDomainAssembly->IsLoaded())
-                    pAssembly = pDomainAssembly->GetAssembly();
+        DomainAssembly * pDomainAssembly = AppDomain::GetCurrentDomain()->FindCachedAssembly(&spec, FALSE /*fThrow*/);
 
-                // Only store in the rid map if working with the current AppDomain.
-                if (fCanUseRidMap && pAssembly)
-                    StoreAssemblyRef(kAssemblyRef, pAssembly);
+        if (pDomainAssembly && pDomainAssembly->IsLoaded())
+            pAssembly = pDomainAssembly->GetAssembly();
 
-                if (pAssembly != NULL)
-                    break;
-            }
-#endif //!DACCESS_COMPILE
-        } while (false);
+        // Only store in the rid map if working with the current AppDomain.
+        if (fCanUseRidMap && pAssembly)
+            StoreAssemblyRef(kAssemblyRef, pAssembly);
     }
+#endif //!DACCESS_COMPILE
 
     // When walking the stack or computing GC information this function should never fail.
     _ASSERTE((pAssembly != NULL) || !(IsStackWalkerThread() || IsGCThread()));
@@ -2372,9 +2351,9 @@ DomainAssembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef)
     }
 
     {
-        PEAssemblyHolder pPEAssembly = GetDomainAssembly()->GetPEAssembly()->LoadAssembly(kAssemblyRef);
+        PEAssemblyHolder pPEAssembly = GetPEAssembly()->LoadAssembly(kAssemblyRef);
         AssemblySpec spec;
-        spec.InitializeSpec(kAssemblyRef, GetMDImport(), GetDomainAssembly());
+        spec.InitializeSpec(kAssemblyRef, GetMDImport(), GetAssembly());
         // Set the binding context in the AssemblySpec if one is available. This can happen if the LoadAssembly ended up
         // invoking the custom AssemblyLoadContext implementation that returned a reference to an assembly bound to a different
         // AssemblyLoadContext implementation.
diff --git a/src/coreclr/vm/clsload.cpp b/src/coreclr/vm/clsload.cpp
index a85db9e3b96d1..f694bce1ade52 100644
--- a/src/coreclr/vm/clsload.cpp
+++ b/src/coreclr/vm/clsload.cpp
@@ -1615,12 +1615,6 @@ TypeHandle ClassLoader::LookupTypeDefOrRefInModule(ModuleBase *pModule, mdToken
     RETURN(typeHandle);
 }
 
-DomainAssembly *ClassLoader::GetDomainAssembly()
-{
-    WRAPPER_NO_CONTRACT;
-    return GetAssembly()->GetDomainAssembly();
-}
-
 #ifndef DACCESS_COMPILE
 
 //
@@ -1958,17 +1952,17 @@ TypeHandle ClassLoader::LoadTypeDefThrowing(Module *pModule,
                                                         className);
                         GCX_COOP();
                         ASSEMBLYREF asmRef = NULL;
-                        DomainAssembly *pDomainAssembly = NULL;
+                        Assembly* pAssembly = NULL;
                         GCPROTECT_BEGIN(asmRef);
 
-                        pDomainAssembly = pDomain->RaiseTypeResolveEventThrowing(
-                            pModule->GetAssembly()->GetDomainAssembly(),
+                        pAssembly = pDomain->RaiseTypeResolveEventThrowing(
+                            pModule->GetAssembly(),
                             pszFullName, &asmRef);
 
                         if (asmRef != NULL)
                         {
-                            _ASSERTE(pDomainAssembly != NULL);
-                            if (pDomainAssembly->GetAssembly()->GetLoaderAllocator()->IsCollectible())
+                            _ASSERTE(pAssembly != NULL);
+                            if (pAssembly->GetLoaderAllocator()->IsCollectible())
                             {
                                 if (!pModule->GetLoaderAllocator()->IsCollectible())
                                 {
@@ -1976,14 +1970,12 @@ TypeHandle ClassLoader::LoadTypeDefThrowing(Module *pModule,
                                     COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleBoundNonCollectible"));
                                 }
 
-                                pModule->GetLoaderAllocator()->EnsureReference(pDomainAssembly->GetAssembly()->GetLoaderAllocator());
+                                pModule->GetLoaderAllocator()->EnsureReference(pAssembly->GetLoaderAllocator());
                             }
                         }
                         GCPROTECT_END();
-                        if (pDomainAssembly != NULL)
+                        if (pAssembly != NULL)
                         {
-                            Assembly *pAssembly = pDomainAssembly->GetAssembly();
-
                             NameHandle name(nameSpace, className);
                             name.SetTypeToken(pModule, typeDef);
                             name.SetTokenNotToLoad(tdAllAssemblies);
diff --git a/src/coreclr/vm/clsload.hpp b/src/coreclr/vm/clsload.hpp
index fb79f0dfc810e..95afa2716ec9f 100644
--- a/src/coreclr/vm/clsload.hpp
+++ b/src/coreclr/vm/clsload.hpp
@@ -573,7 +573,6 @@ class ClassLoader
     void Init(AllocMemTracker *pamTracker);
 
     PTR_Assembly GetAssembly();
-    DomainAssembly* GetDomainAssembly();
 
     void    FreeModules();
 
diff --git a/src/coreclr/vm/customattribute.cpp b/src/coreclr/vm/customattribute.cpp
index 4386c74f1daae..e1bb562c5fe25 100644
--- a/src/coreclr/vm/customattribute.cpp
+++ b/src/coreclr/vm/customattribute.cpp
@@ -16,11 +16,11 @@
 #include "runtimehandles.h"
 #include "typestring.h"
 
-static TypeHandle GetTypeForEnum(LPCUTF8 szEnumName, COUNT_T cbEnumName, DomainAssembly* pDomainAssembly)
+static TypeHandle GetTypeForEnum(LPCUTF8 szEnumName, COUNT_T cbEnumName, Assembly* pAssembly)
 {
     CONTRACTL
     {
-        PRECONDITION(CheckPointer(pDomainAssembly));
+        PRECONDITION(CheckPointer(pAssembly));
         PRECONDITION(CheckPointer(szEnumName));
         PRECONDITION(cbEnumName);
         THROWS;
@@ -30,13 +30,13 @@ static TypeHandle GetTypeForEnum(LPCUTF8 szEnumName, COUNT_T cbEnumName, DomainA
     CONTRACTL_END;
 
     StackSString sszEnumName(SString::Utf8, szEnumName, cbEnumName);
-    return TypeName::GetTypeReferencedByCustomAttribute(sszEnumName.GetUnicode(), pDomainAssembly->GetAssembly());
+    return TypeName::GetTypeReferencedByCustomAttribute(sszEnumName.GetUnicode(), pAssembly);
 }
 
 static HRESULT ParseCaType(
     CustomAttributeParser &ca,
     CaType* pCaType,
-    DomainAssembly* pDomainAssembly,
+    Assembly* pAssembly,
     StackSString* ss = NULL)
 {
     WRAPPER_NO_CONTRACT;
@@ -48,7 +48,7 @@ static HRESULT ParseCaType(
     if (pCaType->tag == SERIALIZATION_TYPE_ENUM
         || (pCaType->tag == SERIALIZATION_TYPE_SZARRAY && pCaType->arrayType == SERIALIZATION_TYPE_ENUM ))
     {
-        TypeHandle th = GetTypeForEnum(pCaType->szEnumName, pCaType->cEnumName, pDomainAssembly);
+        TypeHandle th = GetTypeForEnum(pCaType->szEnumName, pCaType->cEnumName, pAssembly);
 
         if (!th.IsNull() && th.IsEnum())
         {
@@ -83,7 +83,7 @@ static HRESULT ParseCaValue(
     CaValue* pCaArg,
     CaType* pCaParam,
     CaValueArrayFactory* pCaValueArrayFactory,
-    DomainAssembly* pDomainAssembly)
+    Assembly* pAssembly)
 {
     CONTRACTL
     {
@@ -99,7 +99,7 @@ static HRESULT ParseCaValue(
     CaType elementType;
 
     if (pCaParam->tag == SERIALIZATION_TYPE_TAGGED_OBJECT)
-        IfFailGo(ParseCaType(ca, &pCaArg->type, pDomainAssembly));
+        IfFailGo(ParseCaType(ca, &pCaArg->type, pAssembly));
     else
         pCaArg->type = *pCaParam;
 
@@ -155,7 +155,7 @@ static HRESULT ParseCaValue(
         elementType.Init(pCaArg->type.arrayType, SERIALIZATION_TYPE_UNDEFINED,
             pCaArg->type.enumType, pCaArg->type.szEnumName, pCaArg->type.cEnumName);
         for (ULONG i = 0; i < pCaArg->arr.length; i++)
-            IfFailGo(ParseCaValue(ca, &*pCaArg->arr.pSArray->Append(), &elementType, pCaValueArrayFactory, pDomainAssembly));
+            IfFailGo(ParseCaValue(ca, &*pCaArg->arr.pSArray->Append(), &elementType, pCaValueArrayFactory, pAssembly));
 
         break;
 
@@ -174,7 +174,7 @@ static HRESULT ParseCaCtorArgs(
     CaArg* pArgs,
     ULONG cArgs,
     CaValueArrayFactory* pCaValueArrayFactory,
-    DomainAssembly* pDomainAssembly)
+    Assembly* pAssembly)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -191,7 +191,7 @@ static HRESULT ParseCaCtorArgs(
     for (ix=0; ix<cArgs; ++ix)
     {
         CaArg* pArg = &pArgs[ix];
-        IfFailGo(ParseCaValue(ca, &pArg->val, &pArg->type, pCaValueArrayFactory, pDomainAssembly));
+        IfFailGo(ParseCaValue(ca, &pArg->val, &pArg->type, pCaValueArrayFactory, pAssembly));
     }
 
 ErrExit:
@@ -210,11 +210,11 @@ static HRESULT ParseCaNamedArgs(
     CaNamedArg *pNamedParams,
     ULONG cNamedParams,
     CaValueArrayFactory* pCaValueArrayFactory,
-    DomainAssembly* pDomainAssembly)
+    Assembly* pAssembly)
 {
     CONTRACTL {
         PRECONDITION(CheckPointer(pCaValueArrayFactory));
-        PRECONDITION(CheckPointer(pDomainAssembly));
+        PRECONDITION(CheckPointer(pAssembly));
         THROWS;
     } CONTRACTL_END;
 
@@ -243,7 +243,7 @@ static HRESULT ParseCaNamedArgs(
         // Get argument type information
         CaType* pNamedArgType = &namedArg.type;
         StackSString ss;
-        IfFailGo(ParseCaType(ca, pNamedArgType, pDomainAssembly, &ss));
+        IfFailGo(ParseCaType(ca, pNamedArgType, pAssembly, &ss));
 
         LPCSTR szLoadedEnumName = NULL;
 
@@ -319,7 +319,7 @@ static HRESULT ParseCaNamedArgs(
             IfFailGo(PostError(META_E_CA_REPEATED_ARG, namedArg.cName, namedArg.szName));
         }
 
-        IfFailGo(ParseCaValue(ca, &pNamedParams[ixParam].val, &namedArg.type, pCaValueArrayFactory, pDomainAssembly));
+        IfFailGo(ParseCaValue(ca, &pNamedParams[ixParam].val, &namedArg.type, pCaValueArrayFactory, pAssembly));
     }
 
 ErrExit:
@@ -334,15 +334,15 @@ HRESULT CustomAttribute::ParseArgumentValues(
     COUNT_T cArgs,
     CaNamedArg* pCaNamedArgs,
     COUNT_T cNamedArgs,
-    DomainAssembly* pDomainAssembly)
+    Assembly* pAssembly)
 {
     WRAPPER_NO_CONTRACT;
 
     HRESULT hr = S_OK;
     CustomAttributeParser cap(pCa, cCa);
 
-    IfFailGo(ParseCaCtorArgs(cap, pCaArgs, cArgs, pCaValueArrayFactory, pDomainAssembly));
-    IfFailGo(ParseCaNamedArgs(cap, pCaNamedArgs, cNamedArgs, pCaValueArrayFactory, pDomainAssembly));
+    IfFailGo(ParseCaCtorArgs(cap, pCaArgs, cArgs, pCaValueArrayFactory, pAssembly));
+    IfFailGo(ParseCaNamedArgs(cap, pCaNamedArgs, cNamedArgs, pCaValueArrayFactory, pAssembly));
 
 ErrExit:
     return hr;
diff --git a/src/coreclr/vm/customattribute.h b/src/coreclr/vm/customattribute.h
index b5074872f736b..2cbc846bff8f1 100644
--- a/src/coreclr/vm/customattribute.h
+++ b/src/coreclr/vm/customattribute.h
@@ -20,7 +20,7 @@ namespace CustomAttribute
         COUNT_T cArgs,
         CaNamedArg* pCaNamedArgs,
         COUNT_T cNamedArgs,
-        DomainAssembly* pDomainAssembly);
+        Assembly* pAssembly);
 }
 
 extern "C" BOOL QCALLTYPE CustomAttribute_ParseAttributeUsageAttribute(
diff --git a/src/coreclr/vm/domainassembly.cpp b/src/coreclr/vm/domainassembly.cpp
index 3c6c68de688e9..30dbe9207e630 100644
--- a/src/coreclr/vm/domainassembly.cpp
+++ b/src/coreclr/vm/domainassembly.cpp
@@ -815,42 +815,6 @@ void DomainAssembly::DeliverSyncEvents()
 #endif // DEBUGGING_SUPPORTED
 }
 
-/*
-  // The enum for dwLocation from managed code:
-    public enum ResourceLocation
-    {
-        Embedded = 1,
-        ContainedInAnotherAssembly = 2,
-        ContainedInManifestFile = 4
-    }
-*/
-
-BOOL DomainAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
-                                 PBYTE *pbInMemoryResource, DomainAssembly** pAssemblyRef,
-                                 LPCSTR *szFileName, DWORD *dwLocation,
-                                 BOOL fSkipRaiseResolveEvent)
-{
-    CONTRACTL
-    {
-        INSTANCE_CHECK;
-        THROWS;
-        MODE_ANY;
-        INJECT_FAULT(COMPlusThrowOM(););
-    }
-    CONTRACTL_END;
-
-    return GetPEAssembly()->GetResource( szName,
-                                   cbResource,
-                                   pbInMemoryResource,
-                                   pAssemblyRef,
-                                   szFileName,
-                                   dwLocation,
-                                   fSkipRaiseResolveEvent,
-                                   this,
-                                   AppDomain::GetCurrentDomain() );
-}
-
-
 DWORD DomainAssembly::ComputeDebuggingConfig()
 {
     CONTRACTL
diff --git a/src/coreclr/vm/domainassembly.h b/src/coreclr/vm/domainassembly.h
index 40262412f4753..64b8c4a9fdf4e 100644
--- a/src/coreclr/vm/domainassembly.h
+++ b/src/coreclr/vm/domainassembly.h
@@ -290,15 +290,6 @@ class DomainAssembly final
         return m_pLoaderAllocator;
     }
 
-// ------------------------------------------------------------
-// Resource access
-// ------------------------------------------------------------
-
-    BOOL GetResource(LPCSTR szName, DWORD* cbResource,
-        PBYTE* pbInMemoryResource, DomainAssembly** pAssemblyRef,
-        LPCSTR* szFileName, DWORD* dwLocation,
-        BOOL fSkipRaiseResolveEvent);
-
  private:
     // ------------------------------------------------------------
     // Loader API
diff --git a/src/coreclr/vm/eventtrace.cpp b/src/coreclr/vm/eventtrace.cpp
index d2c515043a1ad..79c3043a24964 100644
--- a/src/coreclr/vm/eventtrace.cpp
+++ b/src/coreclr/vm/eventtrace.cpp
@@ -5517,7 +5517,7 @@ VOID ETW::EnumerationLog::IterateAssembly(Assembly *pAssembly, DWORD enumeration
         if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) ||
            (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart))
         {
-            Module* pModule = pAssembly->GetDomainAssembly()->GetModule();
+            Module* pModule = pAssembly->GetModule();
             ETW::LoaderLog::SendModuleEvent(pModule, enumerationOptions, TRUE);
         }
 
diff --git a/src/coreclr/vm/nativeimage.cpp b/src/coreclr/vm/nativeimage.cpp
index 49f797f896254..d68d031673f4e 100644
--- a/src/coreclr/vm/nativeimage.cpp
+++ b/src/coreclr/vm/nativeimage.cpp
@@ -261,7 +261,7 @@ NativeImage *NativeImage::Open(
 #endif
 
 #ifndef DACCESS_COMPILE
-Assembly *NativeImage::LoadManifestAssembly(uint32_t rowid, DomainAssembly *pParentAssembly)
+Assembly *NativeImage::LoadManifestAssembly(uint32_t rowid, Assembly *pParentAssembly)
 {
     STANDARD_VM_CONTRACT;
 
diff --git a/src/coreclr/vm/nativeimage.h b/src/coreclr/vm/nativeimage.h
index afbc1e32cd0ac..722a8f1aa6168 100644
--- a/src/coreclr/vm/nativeimage.h
+++ b/src/coreclr/vm/nativeimage.h
@@ -124,7 +124,7 @@ class NativeImage
     PTR_Assembly *GetManifestMetadataAssemblyRefMap() { return m_pNativeMetadataAssemblyRefMap; }
     AssemblyBinder *GetAssemblyBinder() const { return m_pAssemblyBinder; }
 
-    Assembly *LoadManifestAssembly(uint32_t rowid, DomainAssembly *pParentAssembly);
+    Assembly *LoadManifestAssembly(uint32_t rowid, Assembly *pParentAssembly);
     
     PTR_READYTORUN_CORE_HEADER GetComponentAssemblyHeader(LPCUTF8 assemblySimpleName);
 
diff --git a/src/coreclr/vm/peassembly.cpp b/src/coreclr/vm/peassembly.cpp
index d6b49ee14cff2..3f54dbff556af 100644
--- a/src/coreclr/vm/peassembly.cpp
+++ b/src/coreclr/vm/peassembly.cpp
@@ -497,16 +497,16 @@ PEAssembly* PEAssembly::LoadAssembly(mdAssemblyRef kAssemblyRef)
 
     AssemblySpec spec;
 
-    spec.InitializeSpec(kAssemblyRef, pImport, GetAppDomain()->FindAssembly(this));
+    spec.InitializeSpec(kAssemblyRef, pImport, GetAppDomain()->FindAssembly(this)->GetAssembly());
 
     RETURN GetAppDomain()->BindAssemblySpec(&spec, TRUE);
 }
 
-
+// dwLocation maps to System.Reflection.ResourceLocation
 BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
-                             PBYTE *pbInMemoryResource, DomainAssembly** pAssemblyRef,
+                             PBYTE *pbInMemoryResource, Assembly** pAssemblyRef,
                              LPCSTR *szFileName, DWORD *dwLocation,
-                             BOOL fSkipRaiseResolveEvent, DomainAssembly* pDomainAssembly, AppDomain* pAppDomain)
+                             Assembly* pAssembly)
 {
     CONTRACTL
     {
@@ -523,7 +523,6 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
     DWORD              dwResourceFlags;
     DWORD              dwOffset;
     mdManifestResource mdResource;
-    Assembly*          pAssembly = NULL;
     PEAssembly*        pPEAssembly = NULL;
     IMDInternalImport* pImport = GetMDImport();
     if (SUCCEEDED(pImport->FindManifestResourceByName(szName, &mdResource)))
@@ -538,16 +537,12 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
     }
     else
     {
-        if (fSkipRaiseResolveEvent || pAppDomain == NULL)
-            return FALSE;
-
-        DomainAssembly* pParentAssembly = GetAppDomain()->FindAssembly(this);
-        pAssembly = pAppDomain->RaiseResourceResolveEvent(pParentAssembly, szName);
+        AppDomain* pAppDomain = AppDomain::GetCurrentDomain();
+        DomainAssembly* pParentAssembly = pAppDomain->FindAssembly(this);
+        pAssembly = pAppDomain->RaiseResourceResolveEvent(pParentAssembly->GetAssembly(), szName);
         if (pAssembly == NULL)
             return FALSE;
-
-        pDomainAssembly = pAssembly->GetDomainAssembly();
-        pPEAssembly = pDomainAssembly->GetPEAssembly();
+        pPEAssembly = pAssembly->GetPEAssembly();
 
         if (FAILED(pAssembly->GetMDImport()->FindManifestResourceByName(
             szName,
@@ -559,11 +554,11 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
         if (dwLocation != 0)
         {
             if (pAssemblyRef != NULL)
-                *pAssemblyRef = pDomainAssembly;
+                *pAssemblyRef = pAssembly;
 
             *dwLocation = *dwLocation | 2; // ResourceLocation.containedInAnotherAssembly
         }
-        IfFailThrow(pPEAssembly->GetMDImport()->GetManifestResourceProps(
+        IfFailThrow(pAssembly->GetMDImport()->GetManifestResourceProps(
             mdResource,
             NULL,           //&szName,
             &mdLinkRef,
@@ -575,27 +570,27 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource,
     switch(TypeFromToken(mdLinkRef)) {
     case mdtAssemblyRef:
         {
-            if (pDomainAssembly == NULL)
+            if (pAssembly == NULL)
                 return FALSE;
 
             AssemblySpec spec;
-            spec.InitializeSpec(mdLinkRef, GetMDImport(), pDomainAssembly);
-            pDomainAssembly = spec.LoadDomainAssembly(FILE_LOADED);
+            spec.InitializeSpec(mdLinkRef, GetMDImport(), pAssembly);
+            DomainAssembly* pDomainAssembly = spec.LoadDomainAssembly(FILE_LOADED);
 
             if (dwLocation) {
                 if (pAssemblyRef)
-                    *pAssemblyRef = pDomainAssembly;
+                    *pAssemblyRef = pDomainAssembly->GetAssembly();
 
                 *dwLocation = *dwLocation | 2; // ResourceLocation.containedInAnotherAssembly
             }
 
-            return pDomainAssembly->GetResource(szName,
-                                                cbResource,
-                                                pbInMemoryResource,
-                                                pAssemblyRef,
-                                                szFileName,
-                                                dwLocation,
-                                                fSkipRaiseResolveEvent);
+            return GetResource(szName,
+                                cbResource,
+                                pbInMemoryResource,
+                                pAssemblyRef,
+                                szFileName,
+                                dwLocation,
+                                pDomainAssembly->GetAssembly());
         }
 
     case mdtFile:
diff --git a/src/coreclr/vm/peassembly.h b/src/coreclr/vm/peassembly.h
index f30ce986cb372..ae77b74943da1 100644
--- a/src/coreclr/vm/peassembly.h
+++ b/src/coreclr/vm/peassembly.h
@@ -204,10 +204,9 @@ class PEAssembly final
     void *GetVTable(RVA rva);
 
     BOOL GetResource(LPCSTR szName, DWORD *cbResource,
-                     PBYTE *pbInMemoryResource, DomainAssembly** pAssemblyRef,
+                     PBYTE *pbInMemoryResource, Assembly** pAssemblyRef,
                      LPCSTR *szFileName, DWORD *dwLocation,
-                     BOOL fSkipRaiseResolveEvent, DomainAssembly* pDomainAssembly,
-                     AppDomain* pAppDomain);
+                     Assembly* pAssembly);
 
 #ifndef DACCESS_COMPILE
     PTR_CVOID GetMetadata(COUNT_T *pSize);
diff --git a/src/coreclr/vm/typeparse.cpp b/src/coreclr/vm/typeparse.cpp
index 5a9947042928c..e66d3baef9d24 100644
--- a/src/coreclr/vm/typeparse.cpp
+++ b/src/coreclr/vm/typeparse.cpp
@@ -26,7 +26,7 @@ static TypeHandle GetTypeHelper(LPCWSTR szTypeName, Assembly* pRequestingAssembl
 
     if (pRequestingAssembly != NULL)
     {
-        objRequestingAssembly = pRequestingAssembly->GetDomainAssembly()->GetExposedAssemblyObject();
+        objRequestingAssembly = pRequestingAssembly->GetExposedObject();
     }
 
     OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED);
diff --git a/src/coreclr/vm/zapsig.cpp b/src/coreclr/vm/zapsig.cpp
index 28216cb27d1b8..87d679e34b4d0 100644
--- a/src/coreclr/vm/zapsig.cpp
+++ b/src/coreclr/vm/zapsig.cpp
@@ -599,7 +599,7 @@ ModuleBase *ZapSig::DecodeModuleFromIndex(Module *fromModule,
 
         if(pAssembly == NULL)
         {
-            DomainAssembly *pParentAssembly = fromModule->GetDomainAssembly();
+            Assembly *pParentAssembly = fromModule->GetAssembly();
             if (nativeImage != NULL)
             {
                 pAssembly = nativeImage->LoadManifestAssembly(index, pParentAssembly);