diff --git a/Core/Code/Common/mitkCoreServices.cpp b/Core/Code/Common/mitkCoreServices.cpp
index 870f74185a..06c9d2c44c 100644
--- a/Core/Code/Common/mitkCoreServices.cpp
+++ b/Core/Code/Common/mitkCoreServices.cpp
@@ -1,123 +1,127 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkCoreServices.h"
 
 #include <mitkIMimeTypeProvider.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
 #include <mitkIPropertyExtensions.h>
 #include <mitkIPropertyFilters.h>
 #include <mitkIShaderRepository.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usServiceReference.h>
 #include <usServiceTracker.h>
 
 #include <itkSimpleFastMutexLock.h>
 #include <itkMutexLockHolder.h>
 
 namespace mitk {
 
 itk::SimpleFastMutexLock& s_ContextToServicesMapMutex()
 {
   static itk::SimpleFastMutexLock mutex;
   return mutex;
 }
 
 std::map<us::ModuleContext*, std::map<void*,us::ServiceReferenceU> >& s_ContextToServicesMap()
 {
   static std::map<us::ModuleContext*, std::map<void*,us::ServiceReferenceU> > serviceMap;
   return serviceMap;
 }
 
 template<class S>
 static S* GetCoreService(us::ModuleContext* context)
 {
-  itk::MutexLockHolder<itk::SimpleFastMutexLock> l(s_ContextToServicesMapMutex());
+  if (context == NULL) context = us::GetModuleContext();
+
   S* coreService = NULL;
   us::ServiceReference<S> serviceRef = context->GetServiceReference<S>();
   if (serviceRef)
   {
     coreService = context->GetService(serviceRef);
   }
 
   assert(coreService && "Asserting non-NULL MITK core service");
-  s_ContextToServicesMap()[context].insert(std::make_pair(coreService,serviceRef));
+  {
+    itk::MutexLockHolder<itk::SimpleFastMutexLock> l(s_ContextToServicesMapMutex());
+    s_ContextToServicesMap()[context].insert(std::make_pair(coreService,serviceRef));
+  }
 
   return coreService;
 }
 
 IShaderRepository* CoreServices::GetShaderRepository()
 {
   static us::ServiceTracker<IShaderRepository> tracker(us::GetModuleContext());
   tracker.Open();
   return tracker.GetService();
 }
 
 IPropertyAliases* CoreServices::GetPropertyAliases(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyAliases>(context);
 }
 
 IPropertyDescriptions* CoreServices::GetPropertyDescriptions(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyDescriptions>(context);
 }
 
 IPropertyExtensions* CoreServices::GetPropertyExtensions(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyExtensions>(context);
 }
 
 IPropertyFilters* CoreServices::GetPropertyFilters(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyFilters>(context);
 }
 
 IMimeTypeProvider* CoreServices::GetMimeTypeProvider(us::ModuleContext* context)
 {
   return GetCoreService<IMimeTypeProvider>(context);
 }
 
 bool CoreServices::Unget(us::ModuleContext* context, const std::string& /*interfaceId*/, void* service)
 {
   bool success = false;
 
   itk::MutexLockHolder<itk::SimpleFastMutexLock> l(s_ContextToServicesMapMutex());
   std::map<us::ModuleContext*, std::map<void*,us::ServiceReferenceU> >::iterator iter = s_ContextToServicesMap().find(context);
   if (iter != s_ContextToServicesMap().end())
   {
     std::map<void*,us::ServiceReferenceU>::iterator iter2 = iter->second.find(service);
     if (iter2 != iter->second.end())
     {
       us::ServiceReferenceU serviceRef = iter2->second;
       if (serviceRef)
       {
         success = context->UngetService(serviceRef);
         if (success)
         {
           iter->second.erase(iter2);
         }
       }
     }
   }
 
   return success;
 }
 
 }
diff --git a/Core/Code/IO/mitkFileReaderRegistry.cpp b/Core/Code/IO/mitkFileReaderRegistry.cpp
index 11805052d7..7fa59a8669 100644
--- a/Core/Code/IO/mitkFileReaderRegistry.cpp
+++ b/Core/Code/IO/mitkFileReaderRegistry.cpp
@@ -1,114 +1,120 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkFileReaderRegistry.h"
 
 #include "mitkIMimeTypeProvider.h"
 #include "mitkCoreServices.h"
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 #include <usLDAPProp.h>
 
 #include "itksys/SystemTools.hxx"
 
 mitk::FileReaderRegistry::FileReaderRegistry()
 {
 }
 
 mitk::FileReaderRegistry::~FileReaderRegistry()
 {
   for (std::map<mitk::IFileReader*, us::ServiceObjects<mitk::IFileReader> >::iterator iter = m_ServiceObjects.begin(),
     end = m_ServiceObjects.end(); iter != end; ++iter)
   {
     iter->second.UngetService(iter->first);
   }
 }
 
 mitk::MimeType mitk::FileReaderRegistry::GetMimeTypeForFile(const std::string& path, us::ModuleContext* context)
 {
   mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider(context));
   std::vector<MimeType> mimeTypes = mimeTypeProvider->GetMimeTypesForFile(path);
   if (mimeTypes.empty())
   {
     return MimeType();
   }
   else
   {
     return mimeTypes.front();
   }
 }
 
 std::vector<mitk::FileReaderRegistry::ReaderReference> mitk::FileReaderRegistry::GetReferences(const MimeType& mimeType, us::ModuleContext* context)
 {
+  if (context == NULL) context = us::GetModuleContext();
+
   std::string filter = us::LDAPProp(us::ServiceConstants::OBJECTCLASS()) == us_service_interface_iid<IFileReader>() &&
                        us::LDAPProp(IFileReader::PROP_MIMETYPE()) == mimeType.GetName();
   return context->GetServiceReferences<IFileReader>(filter);
 }
 
 mitk::IFileReader* mitk::FileReaderRegistry::GetReader(const mitk::FileReaderRegistry::ReaderReference& ref, us::ModuleContext* context)
 {
+  if (context == NULL) context = us::GetModuleContext();
+
   us::ServiceObjects<mitk::IFileReader> serviceObjects = context->GetServiceObjects(ref);
   mitk::IFileReader* reader = serviceObjects.GetService();
   m_ServiceObjects.insert(std::make_pair(reader, serviceObjects));
   return reader;
 }
 
 std::vector <mitk::IFileReader*> mitk::FileReaderRegistry::GetReaders(const MimeType& mimeType, us::ModuleContext* context )
 {
+  if (context == NULL) context = us::GetModuleContext();
+
   std::vector <mitk::IFileReader*> result;
 
   if (!mimeType.IsValid()) return result;
 
   std::vector <us::ServiceReference<IFileReader> > refs = GetReferences(mimeType, context);
   std::sort(refs.begin(), refs.end());
 
   result.reserve(refs.size());
 
   // Translate List of ServiceRefs to List of Pointers
   for (std::vector<us::ServiceReference<IFileReader> >::const_reverse_iterator iter = refs.rbegin(), end = refs.rend();
        iter != end; ++iter)
   {
     us::ServiceObjects<mitk::IFileReader> serviceObjects = context->GetServiceObjects(*iter);
     mitk::IFileReader* reader = serviceObjects.GetService();
     m_ServiceObjects.insert(std::make_pair(reader, serviceObjects));
     result.push_back(reader);
   }
 
   return result;
 }
 
 void mitk::FileReaderRegistry::UngetReader(mitk::IFileReader* reader)
 {
   std::map<mitk::IFileReader*, us::ServiceObjects<mitk::IFileReader> >::iterator readerIter =
     m_ServiceObjects.find(reader);
   if (readerIter != m_ServiceObjects.end())
   {
     readerIter->second.UngetService(reader);
     m_ServiceObjects.erase(readerIter);
   }
 }
 
 void mitk::FileReaderRegistry::UngetReaders(const std::vector<mitk::IFileReader*>& readers)
 {
   for (std::vector<mitk::IFileReader*>::const_iterator iter = readers.begin(), end = readers.end();
     iter != end; ++iter)
   {
     this->UngetReader(*iter);
   }
 }
diff --git a/Core/Code/IO/mitkFileWriterRegistry.cpp b/Core/Code/IO/mitkFileWriterRegistry.cpp
index 3ee36fdf3d..cae1eeb6f8 100644
--- a/Core/Code/IO/mitkFileWriterRegistry.cpp
+++ b/Core/Code/IO/mitkFileWriterRegistry.cpp
@@ -1,126 +1,132 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkFileWriterRegistry.h"
 
 // MITK
 #include "mitkIMimeTypeProvider.h"
 #include "mitkCoreServices.h"
 #include "mitkBaseData.h"
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 #include <usLDAPProp.h>
 
 mitk::FileWriterRegistry::FileWriterRegistry()
 {
 }
 
 mitk::FileWriterRegistry::~FileWriterRegistry()
 {
   for (std::map<mitk::IFileWriter*, us::ServiceObjects<mitk::IFileWriter> >::iterator iter = m_ServiceObjects.begin(),
        end = m_ServiceObjects.end(); iter != end; ++iter)
   {
     iter->second.UngetService(iter->first);
   }
 }
 
 std::vector<mitk::FileWriterRegistry::WriterReference> mitk::FileWriterRegistry::GetReferences(const mitk::BaseData* baseData, us::ModuleContext* context)
 {
   return GetReferences(baseData, std::string(), context);
 }
 
 std::vector<mitk::FileWriterRegistry::WriterReference> mitk::FileWriterRegistry::GetReferences(const mitk::BaseData* baseData, const std::string& mimeType, us::ModuleContext* context)
 {
+  if (context == NULL) context = us::GetModuleContext();
+
   std::vector<WriterReference> result;
 
   // loop over the class hierarchy of baseData and get all writers
   // claiming the support the actual baseData class or any of its super classes
   std::vector<std::string> classHierarchy = baseData->GetClassHierarchy();
   for (std::vector<std::string>::const_iterator clIter = classHierarchy.begin(),
        clIterEnd = classHierarchy.end(); clIter != clIterEnd; ++clIter)
   {
     std::string filter = us::LDAPProp(us::ServiceConstants::OBJECTCLASS()) == us_service_interface_iid<IFileWriter>() &&
                          us::LDAPProp(IFileWriter::PROP_BASEDATA_TYPE()) == *clIter &&
                          (mimeType.empty() ? us::LDAPPropExpr(std::string()) : us::LDAPProp(IFileWriter::PROP_MIMETYPE()) == mimeType);
     std::vector<WriterReference> refs = context->GetServiceReferences<IFileWriter>(filter);
     result.insert(result.end(), refs.begin(), refs.end());
   }
   return result;
 }
 
 mitk::IFileWriter* mitk::FileWriterRegistry::GetWriter(const mitk::FileWriterRegistry::WriterReference& ref, us::ModuleContext* context)
 {
   if (!ref) return NULL;
 
+  if (context == NULL) context = us::GetModuleContext();
+
   us::ServiceObjects<mitk::IFileWriter> serviceObjects = context->GetServiceObjects(ref);
   mitk::IFileWriter* writer = serviceObjects.GetService();
   m_ServiceObjects.insert(std::make_pair(writer, serviceObjects));
   return writer;
 }
 
 std::vector<mitk::IFileWriter*> mitk::FileWriterRegistry::GetWriters(const mitk::BaseData* baseData, const std::string& mimeType, us::ModuleContext* context)
 {
+  if (context == NULL) context = us::GetModuleContext();
+
   std::vector <mitk::IFileWriter*> result;
 
   std::vector <us::ServiceReference<IFileWriter> > refs;
   if (mimeType.empty())
   {
     refs = GetReferences(baseData, context);
   }
   else
   {
     refs = GetReferences(baseData, mimeType, context);
   }
   std::sort(refs.begin(), refs.end());
 
   result.reserve(refs.size());
 
   // Translate List of ServiceRefs to List of Pointers
   for (std::vector<us::ServiceReference<IFileWriter> >::const_reverse_iterator iter = refs.rbegin(), end = refs.rend();
        iter != end; ++iter)
   {
     us::ServiceObjects<mitk::IFileWriter> serviceObjects = context->GetServiceObjects(*iter);
     mitk::IFileWriter* writer = serviceObjects.GetService();
     m_ServiceObjects.insert(std::make_pair(writer, serviceObjects));
     result.push_back(writer);
   }
 
   return result;
 }
 
 void mitk::FileWriterRegistry::UngetWriter(mitk::IFileWriter* writer)
 {
   std::map<mitk::IFileWriter*, us::ServiceObjects<mitk::IFileWriter> >::iterator writerIter =
       m_ServiceObjects.find(writer);
   if (writerIter != m_ServiceObjects.end())
   {
     writerIter->second.UngetService(writer);
     m_ServiceObjects.erase(writerIter);
   }
 }
 
 void mitk::FileWriterRegistry::UngetWriters(const std::vector<mitk::IFileWriter*>& writers)
 {
   for (std::vector<mitk::IFileWriter*>::const_iterator iter = writers.begin(), end = writers.end();
     iter != end; ++iter)
   {
     this->UngetWriter(*iter);
   }
 }
diff --git a/Core/CppMicroServices/core/include/usGetModuleContext.h b/Core/CppMicroServices/core/include/usGetModuleContext.h
index 83e7f72a09..aeabb1679d 100644
--- a/Core/CppMicroServices/core/include/usGetModuleContext.h
+++ b/Core/CppMicroServices/core/include/usGetModuleContext.h
@@ -1,56 +1,65 @@
 /*=============================================================================
 
   Library: CppMicroServices
 
   Copyright (c) German Cancer Research Center,
     Division of Medical and Biological Informatics
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 
 =============================================================================*/
 
 
 #ifndef USGETMODULECONTEXT_H
 #define USGETMODULECONTEXT_H
 
 #ifndef US_MODULE_NAME
 #error Missing preprocessor define US_MODULE_NAME
 #endif
 
 #include <usGlobalConfig.h>
 #include <usModuleRegistry.h>
 #include <usModule.h>
+#include <usLog_p.h>
 #include <usModuleUtils_p.h>
 
 US_BEGIN_NAMESPACE
 
 class ModuleContext;
 
 /**
  * \ingroup MicroServices
  *
  * \brief Returns the module context of the calling module.
  *
  * This function allows easy access to the ModuleContext instance from
  * inside a C++ Micro Services module.
  *
  * \return The ModuleContext of the calling module.
  */
 static inline ModuleContext* GetModuleContext()
 {
-  return ModuleRegistry::GetModule(US_STR(US_MODULE_NAME))->GetModuleContext();
+  Module* module = ModuleRegistry::GetModule(US_STR(US_MODULE_NAME));
+  if (module)
+  {
+    return module->GetModuleContext();
+  }
+  US_WARN << "Module '" << US_STR(US_MODULE_NAME) << "' unknown. "
+             "The calling module probably misses a US_MODULE_NAME compile definition "
+             "and/or a call to US_INITIALIZE_MODULE in one of its source files.";
+  return 0;
 }
 
 US_END_NAMESPACE
 
 #endif // USGETMODULECONTEXT_H