diff --git a/cppwinrt/code_writers.h b/cppwinrt/code_writers.h
index b44516d60..d4885c94a 100644
--- a/cppwinrt/code_writers.h
+++ b/cppwinrt/code_writers.h
@@ -1327,6 +1327,12 @@ namespace cppwinrt
                 return result;
             }
         }
+
+        template <typename T>
+        auto LookupAs(param_type<K> const& key) const;
+
+        template <typename T>
+        auto TryLookupAs(param_type<K> const& key) const;
 )");
         }
         else if (type_name == "Windows.Foundation.Collections.IMap`2")
@@ -1358,6 +1364,12 @@ namespace cppwinrt
         {
             return 0 == impl::check_hresult_allow_bounds(WINRT_IMPL_SHIM(Windows::Foundation::Collections::IMap<K, V>)->Remove(get_abi(key)));
         }
+
+        template <typename T>
+        auto LookupAs(param_type<K> const& key) const;
+
+        template <typename T>
+        auto TryLookupAs(param_type<K> const& key) const;
 )");
         }
         else if (type_name == "Windows.Foundation.IAsyncAction")
diff --git a/strings/base_collections_map.h b/strings/base_collections_map.h
index 877b5bf30..dc3ff6bdc 100644
--- a/strings/base_collections_map.h
+++ b/strings/base_collections_map.h
@@ -26,6 +26,34 @@ namespace winrt::impl
 
         Container m_values;
     };
+
+    template <typename D, typename K, typename V> template <typename T>
+    auto consume_Windows_Foundation_Collections_IMap<D, K, V>::LookupAs(param_type<K> const& key) const
+    {
+        static_assert(std::is_same_v<V, Windows::Foundation::IInspectable>);
+        return unbox_value<T>(static_cast<D const&>(*this).Lookup(key));
+    }
+
+    template <typename D, typename K, typename V> template <typename T>
+    auto consume_Windows_Foundation_Collections_IMap<D, K, V>::TryLookupAs(param_type<K> const& key) const
+    {
+        static_assert(std::is_same_v<V, Windows::Foundation::IInspectable>);
+        return try_unbox_value<T>(static_cast<D const&>(*this).TryLookup(key));
+    }
+
+    template <typename D, typename K, typename V> template <typename T>
+    auto consume_Windows_Foundation_Collections_IMapView<D, K, V>::LookupAs(param_type<K> const& key) const
+    {
+        static_assert(std::is_same_v<V, Windows::Foundation::IInspectable>);
+        return unbox_value<T>(static_cast<D const&>(*this).Lookup(key));
+    }
+
+    template <typename D, typename K, typename V> template <typename T>
+    auto consume_Windows_Foundation_Collections_IMapView<D, K, V>::TryLookupAs(param_type<K> const& key) const
+    {
+        static_assert(std::is_same_v<V, Windows::Foundation::IInspectable>);
+        return try_unbox_value<T>(static_cast<D const&>(*this).TryLookup(key));
+    }
 }
 
 WINRT_EXPORT namespace winrt
diff --git a/strings/base_reference_produce.h b/strings/base_reference_produce.h
index 4ad39c5b9..fd8858e8f 100644
--- a/strings/base_reference_produce.h
+++ b/strings/base_reference_produce.h
@@ -377,6 +377,56 @@ WINRT_EXPORT namespace winrt
         return default_value;
     }
 
+    template <typename T>
+    auto try_unbox_value(Windows::Foundation::IInspectable const& value)
+    {
+        if constexpr (std::is_base_of_v<Windows::Foundation::IInspectable, T>)
+        {
+            return value.try_as<T>();
+        }
+        else
+        {
+            if (!value)
+            {
+                return std::optional<T>();
+            }
+
+            if constexpr (std::is_enum_v<T>)
+            {
+                if (auto temp = value.try_as<Windows::Foundation::IReference<T>>())
+                {
+                    return std::optional<T>(temp.Value());
+                }
+
+                if (auto temp = value.try_as<Windows::Foundation::IReference<std::underlying_type_t<T>>>())
+                {
+                    return std::optional<T>(static_cast<T>(temp.Value()));
+                }
+
+                return std::optional<T>();
+            }
+#ifdef WINRT_IMPL_IUNKNOWN_DEFINED
+            else if constexpr (std::is_same_v<T, GUID>)
+            {
+                if (auto temp = value.try_as<Windows::Foundation::IReference<guid>>())
+                {
+                    return std::optional<T>(temp.Value());
+                }
+
+                return std::optional<T>();
+            }
+#endif
+            else if (auto temp = value.try_as<Windows::Foundation::IReference<T>>())
+            {
+                return std::optional<T>(temp.Value());
+            }
+            else
+            {
+                return std::optional<T>();
+            }
+        }
+    }
+
     template <typename T>
     using optional = Windows::Foundation::IReference<T>;
 }
diff --git a/test/test/lookup_as.cpp b/test/test/lookup_as.cpp
new file mode 100644
index 000000000..c7add7fb8
--- /dev/null
+++ b/test/test/lookup_as.cpp
@@ -0,0 +1,82 @@
+#include "pch.h"
+
+using namespace winrt;
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+
+namespace
+{
+    template <typename M>
+    void test(M const& m)
+    {
+        // Good LookupAs
+
+        REQUIRE(m.LookupAs<Uri>(L"uri").Domain() == L"kennykerr.ca");
+        REQUIRE(m.LookupAs<IStringable>(L"uri").ToString() == L"http://kennykerr.ca/");
+        REQUIRE(m.LookupAs<AsyncStatus>(L"enum") == AsyncStatus::Completed);
+        REQUIRE(m.LookupAs<AsyncStatus>(L"underlying_type") == AsyncStatus::Error);
+        REQUIRE(m.LookupAs<guid>(L"guid") == guid_of<Uri>());
+        REQUIRE(m.LookupAs<GUID>(L"guid") == static_cast<GUID>(guid_of<Uri>()));
+        REQUIRE(m.LookupAs<hstring>(L"hstring") == L"Test");
+
+        // LookupAs edge cases
+
+        REQUIRE_THROWS_AS(m.LookupAs<bool>(L"INVALID"), hresult_out_of_bounds);
+        REQUIRE(m.LookupAs<Uri>(L"nullptr") == nullptr);
+        REQUIRE_THROWS_AS(m.LookupAs<bool>(L"nullptr"), hresult_no_interface);
+
+        // Bad LookupAs
+
+        REQUIRE_THROWS_AS(m.LookupAs<bool>(L"uri"), hresult_no_interface);
+        REQUIRE_THROWS_AS(m.LookupAs<IClosable>(L"uri"), hresult_no_interface);
+        REQUIRE_THROWS_AS(m.LookupAs<AsyncStatus>(L"uri"), hresult_no_interface);
+        REQUIRE_THROWS_AS(m.LookupAs<guid>(L"uri"), hresult_no_interface);
+        REQUIRE_THROWS_AS(m.LookupAs<GUID>(L"uri"), hresult_no_interface);
+
+        // Good TryLookupAs (these tests don't need `.value()` for comparison but it
+        // helps to assert that those variants return std::optional)
+
+        REQUIRE(m.TryLookupAs<Uri>(L"uri").Domain() == L"kennykerr.ca");
+        REQUIRE(m.TryLookupAs<IStringable>(L"uri").ToString() == L"http://kennykerr.ca/");
+        REQUIRE(m.TryLookupAs<AsyncStatus>(L"enum").value() == AsyncStatus::Completed);
+        REQUIRE(m.TryLookupAs<AsyncStatus>(L"underlying_type").value() == AsyncStatus::Error);
+        REQUIRE(m.TryLookupAs<guid>(L"guid").value() == guid_of<Uri>());
+        REQUIRE(m.TryLookupAs<GUID>(L"guid").value() == static_cast<GUID>(guid_of<Uri>()));
+        REQUIRE(m.TryLookupAs<hstring>(L"hstring").value() == L"Test");
+
+        // TryLookupAs edge cases
+
+        REQUIRE_FALSE(m.TryLookupAs<bool>(L"INVALID").has_value());
+        REQUIRE(m.TryLookupAs<Uri>(L"nullptr") == nullptr);
+        REQUIRE_FALSE(m.TryLookupAs<bool>(L"nullptr").has_value());
+
+        // Bad TryLookupAs
+
+        REQUIRE(m.TryLookupAs<IClosable>(L"uri") == nullptr);
+        REQUIRE_FALSE(m.TryLookupAs<bool>(L"uri").has_value());
+        REQUIRE_FALSE(m.TryLookupAs<AsyncStatus>(L"uri").has_value());
+        REQUIRE_FALSE(m.TryLookupAs<guid>(L"uri").has_value());
+        REQUIRE_FALSE(m.TryLookupAs<GUID>(L"uri").has_value());
+        REQUIRE_FALSE(m.TryLookupAs<hstring>(L"uri").has_value());
+    }
+}
+
+TEST_CASE("LookupAs")
+{
+    auto map = single_threaded_map<hstring, Windows::Foundation::IInspectable>();
+    map.Insert(L"uri", Uri(L"http://kennykerr.ca"));
+    map.Insert(L"enum", box_value(AsyncStatus::Completed));
+    map.Insert(L"underlying_type", box_value(static_cast<int32_t>(AsyncStatus::Error)));
+    map.Insert(L"guid", box_value(guid_of<Uri>()));
+    map.Insert(L"hstring", box_value(L"Test"));
+    map.Insert(L"nullptr", nullptr);
+
+    test(map);
+    test(map.GetView());
+
+    // Just making these helpers work inherited
+    ValueSet vs;
+    vs.Insert(L"key", box_value(L"value"));
+    REQUIRE(vs.LookupAs<hstring>(L"key") == L"value");
+    REQUIRE(vs.TryLookupAs<hstring>(L"key") == L"value");
+}
diff --git a/test/test/test.vcxproj b/test/test/test.vcxproj
index f29835de6..e84498fb0 100644
--- a/test/test/test.vcxproj
+++ b/test/test/test.vcxproj
@@ -433,6 +433,7 @@
     <ClCompile Include="struct_delegate.cpp" />
     <ClCompile Include="tearoff.cpp" />
     <ClCompile Include="thread_pool.cpp" />
+    <ClCompile Include="lookup_as.cpp" />
     <ClCompile Include="uniform_in_params.cpp" />
     <ClCompile Include="variadic_delegate.cpp" />
     <ClCompile Include="velocity.cpp" />