diff --git a/encompass-cs/ComponentManager.cs b/encompass-cs/ComponentManager.cs
index efd4b63..8071864 100644
--- a/encompass-cs/ComponentManager.cs
+++ b/encompass-cs/ComponentManager.cs
@@ -70,57 +70,54 @@ namespace Encompass
 
         internal IEnumerable<Guid> GetComponentIDsByEntityID(Guid entityID)
         {
-            return entityIDToComponentIDs.ContainsKey(entityID) ?
-                entityIDToComponentIDs[entityID] :
-                Enumerable.Empty<Guid>();
+            HashSet<Guid> idSet;
+            if (entityIDToComponentIDs.TryGetValue(entityID, out idSet))
+            {
+                return idSet;
+            }
+            return Enumerable.Empty<Guid>();
         }
 
-        internal IEnumerable<ValueTuple<Guid, IComponent>> GetComponentsByEntity(Guid entityID)
+        internal IEnumerable<(Guid, TComponent)> GetComponentsByType<TComponent>() where TComponent : struct, IComponent
         {
-            return GetComponentIDsByEntityID(entityID).Select((id) => new ValueTuple<Guid, IComponent>(id, IDToComponent[id]));
-        }
-
-        internal IEnumerable<ValueTuple<Guid, Guid, TComponent>> GetComponentsByType<TComponent>() where TComponent : struct, IComponent
-        {
-            return typeToComponentIDs.ContainsKey(typeof(TComponent)) ?
-                typeToComponentIDs[typeof(TComponent)].Select((id) => new ValueTuple<Guid, Guid, TComponent>(GetEntityIDByComponentID(id), id, (TComponent)IDToComponent[id])) :
-                Enumerable.Empty<ValueTuple<Guid, Guid, TComponent>>();
-        }
-
-        internal IEnumerable<ValueTuple<Guid, IComponent>> GetComponentsByType(Type type)
-        {
-            return typeToComponentIDs.ContainsKey(type) ?
-                typeToComponentIDs[type].Select((id) => new ValueTuple<Guid, IComponent>(id, IDToComponent[id])) :
-                Enumerable.Empty<ValueTuple<Guid, IComponent>>();
+            HashSet<Guid> idSet;
+            if (typeToComponentIDs.TryGetValue(typeof(TComponent), out idSet))
+            {
+                return idSet.Select(id => (id, (TComponent)IDToComponent[id]));
+            }
+            return Enumerable.Empty<(Guid, TComponent)>();
         }
 
         internal IEnumerable<ValueTuple<Guid, TComponent>> GetComponentsByEntityAndType<TComponent>(Guid entityID) where TComponent : struct, IComponent
         {
-            return entityIDToComponentTypeToComponentIDs[entityID].ContainsKey(typeof(TComponent)) ?
-                entityIDToComponentTypeToComponentIDs[entityID][typeof(TComponent)].Select(id => (id, (TComponent)GetComponentByID(id))) :
-                Enumerable.Empty<(Guid, TComponent)>();
-        }
-
-        internal IEnumerable<ValueTuple<Guid, IComponent>> GetComponentsByEntityAndType(Guid entityID, Type type)
-        {
-            return entityIDToComponentTypeToComponentIDs[entityID].ContainsKey(type) ?
-                entityIDToComponentTypeToComponentIDs[entityID][type].Select(id => (id, GetComponentByID(id))) :
-                Enumerable.Empty<(Guid, IComponent)>();
-        }
-
-        internal IEnumerable<Type> GetAllComponentTypesOfEntity(Guid entityID)
-        {
-            return GetComponentIDsByEntityID(entityID).Select((id) => componentIDToType[id]);
+            HashSet<Guid> idSet;
+            if (entityIDToComponentTypeToComponentIDs.ContainsKey(entityID) && entityIDToComponentTypeToComponentIDs[entityID].TryGetValue(typeof(TComponent), out idSet))
+            {
+                return idSet.Select(id => (id, (TComponent)IDToComponent[id]));
+            }
+            return Enumerable.Empty<(Guid, TComponent)>();
         }
 
         internal bool EntityHasComponentOfType<TComponent>(Guid entityID) where TComponent : struct, IComponent
         {
-            return GetComponentsByEntityAndType<TComponent>(entityID).Any();
+            HashSet<Guid> idSet;
+            if (entityIDToComponentTypeToComponentIDs.ContainsKey(entityID) && entityIDToComponentTypeToComponentIDs[entityID].TryGetValue(typeof(TComponent), out idSet))
+            {
+                return idSet.Count > 0;
+            }
+
+            return false;
         }
 
-        internal bool EntityHasComponentOfType(Guid entityID, Type type)
+        internal bool ComponentOfTypeExists<TComponent>() where TComponent : struct, IComponent
         {
-            return GetComponentsByEntityAndType(entityID, type).Any();
+            HashSet<Guid> idSet;
+            if (typeToComponentIDs.TryGetValue(typeof(TComponent), out idSet))
+            {
+                return idSet.Count > 0;
+            }
+
+            return false;
         }
 
         internal IComponent GetComponentByID(Guid componentID)
@@ -183,7 +180,6 @@ namespace Encompass
 
         private void Remove(Guid componentID)
         {
-            var component = IDToComponent[componentID];
             var type = componentIDToType[componentID];
 
             var entityID = componentIDToEntityID[componentID];
diff --git a/encompass-cs/ComponentMessageManager.cs b/encompass-cs/ComponentMessageManager.cs
index 302ec14..2ecefdd 100644
--- a/encompass-cs/ComponentMessageManager.cs
+++ b/encompass-cs/ComponentMessageManager.cs
@@ -215,7 +215,7 @@ namespace Encompass
         internal IEnumerable<(Guid, TComponent)> ReadExistingAndPendingComponentsByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent
         {
             HashSet<Guid> idSet;
-            if (entityToTypeToComponentIDs.TryGetValue(entity, out _) && entityToTypeToComponentIDs[entity].TryGetValue(typeof(TComponent), out idSet))
+            if (entityToTypeToComponentIDs.ContainsKey(entity) && entityToTypeToComponentIDs[entity].TryGetValue(typeof(TComponent), out idSet))
             {
                 return idSet.Select(id => (id, (TComponent)componentIDToComponent[id]));
             }
@@ -226,7 +226,7 @@ namespace Encompass
         internal IEnumerable<(Guid, TComponent)> ReadExistingComponentsByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent
         {
             HashSet<Guid> idSet;
-            if (entityToTypeToExistingComponentIDs.TryGetValue(entity, out _) && entityToTypeToExistingComponentIDs[entity].TryGetValue(typeof(TComponent), out idSet))
+            if (entityToTypeToExistingComponentIDs.ContainsKey(entity) && entityToTypeToExistingComponentIDs[entity].TryGetValue(typeof(TComponent), out idSet))
             {
                 return idSet.Select(id => (id, (TComponent)componentIDToComponent[id]));
             }
@@ -237,7 +237,7 @@ namespace Encompass
         internal IEnumerable<(Guid, TComponent)> ReadPendingComponentsByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent
         {
             HashSet<Guid> idSet;
-            if (entityToTypeToPendingComponentIDs.TryGetValue(entity, out _) && entityToTypeToPendingComponentIDs[entity].TryGetValue(typeof(TComponent), out idSet))
+            if (entityToTypeToPendingComponentIDs.ContainsKey(entity) && entityToTypeToPendingComponentIDs[entity].TryGetValue(typeof(TComponent), out idSet))
             {
                 return idSet.Select(id => (id, (TComponent)componentIDToComponent[id]));
             }
diff --git a/encompass-cs/Engine.cs b/encompass-cs/Engine.cs
index 507f974..7da73df 100644
--- a/encompass-cs/Engine.cs
+++ b/encompass-cs/Engine.cs
@@ -112,9 +112,9 @@ namespace Encompass
             return (TComponent)componentManager.GetComponentByID(componentID);
         }
 
-        internal IEnumerable<ValueTuple<Entity, Guid, TComponent>> ReadComponentsFromWorld<TComponent>() where TComponent : struct, IComponent
+        internal IEnumerable<(Guid, TComponent)> ReadComponentsFromWorld<TComponent>() where TComponent : struct, IComponent
         {
-            return componentManager.GetComponentsByType<TComponent>().Select((triple) => (GetEntity(triple.Item1), triple.Item2, triple.Item3));
+            return componentManager.GetComponentsByType<TComponent>();
         }
 
         protected Guid AddComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
diff --git a/encompass-cs/Engines/ComponentMessageEmitter.cs b/encompass-cs/Engines/ComponentMessageEmitter.cs
index 4aa9e0a..0d124fa 100644
--- a/encompass-cs/Engines/ComponentMessageEmitter.cs
+++ b/encompass-cs/Engines/ComponentMessageEmitter.cs
@@ -11,10 +11,10 @@ namespace Encompass.Engines
 
         public override void Update(double dt)
         {
-            foreach (var (entity, componentID, component) in ReadComponentsFromWorld<TComponent>())
+            foreach (var (componentID, component) in ReadComponentsFromWorld<TComponent>())
             {
                 ComponentMessage<TComponent> componentMessage;
-                componentMessage.entity = entity;
+                componentMessage.entity = GetEntityByComponentID(componentID);
                 componentMessage.componentID = componentID;
                 componentMessage.component = component;
                 SendMessage(componentMessage);
diff --git a/encompass-cs/Renderer.cs b/encompass-cs/Renderer.cs
index dafc707..975a750 100644
--- a/encompass-cs/Renderer.cs
+++ b/encompass-cs/Renderer.cs
@@ -41,12 +41,12 @@ namespace Encompass
 
         protected IEnumerable<ValueTuple<Guid, TComponent>> ReadComponents<TComponent>() where TComponent : struct, IComponent
         {
-            return componentManager.GetComponentsByType<TComponent>().Select((triple) => (triple.Item2, triple.Item3));
+            return componentManager.GetComponentsByType<TComponent>();
         }
 
         protected ValueTuple<Guid, TComponent> ReadComponent<TComponent>() where TComponent : struct, IComponent
         {
-            return ReadComponents<TComponent>().Single();
+            return ReadComponents<TComponent>().First();
         }
 
         protected IEnumerable<ValueTuple<Guid, TComponent>> GetComponents<TComponent>(Entity entity) where TComponent : struct, IComponent
@@ -66,7 +66,7 @@ namespace Encompass
 
         protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
         {
-            return componentManager.GetComponentsByType<TComponent>().Any();
+            return componentManager.ComponentOfTypeExists<TComponent>();
         }
     }
 }