'App' does not contain a definition for 'InitializeComponent'

[samsunlu55atakum]

When I try to use winUI controls with xaml island in wpf (i will use the xaml code in uno platform later , anyway), i got issue like this
'App' does not contain a definition for 'InitializeComponent' and no accessible extension method 'InitializeComponent'

[DarranRowe]

Since you don't give much information on this "App", then this is going to be a complete and utter guess.
If you are writing a class which derives from Microsoft.UI.Xaml.Application to act as the metadata provider, then it doesn't work in the same way as a regular WinUI 3 "App" class. The InitializeComponent actually comes from the Xaml Compiler, which isn't really available here. It is possible to look at the generated code for a WinUI 3 application to see what it does. However, the Windows inbuilt Xaml Islands samples used a completely different application type.

The type that I use for "App" is defined as follows. It is C++ due to my working all of this out in C++. The namespace matches the root namespace of my application, but it isn't special. The class name, IslandApplication, is also not special. I just chose it to represent the fact that this is an application type for Xaml Islands.

//IslandApplication.idl
//This is what is seen by users of the class.
namespace XamlIslandTest3
{
	runtimeclass IslandApplication : Microsoft.UI.Xaml.Application, Microsoft.UI.Xaml.Markup.IXamlMetadataProvider, Windows.Foundation.IClosable
	{
		IslandApplication();
		IslandApplication(Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Markup.IXamlMetadataProvider> providers);

		Windows.Foundation.Collections.IVector<Microsoft.UI.Xaml.Markup.IXamlMetadataProvider> MetadataProviders{ get; };
		Windows.Foundation.IClosable WindowsXamlManager{ get; };
	}
}

//IslandApplication.h
#pragma once
#include "IslandApplication.g.h"

namespace winrt::XamlIslandTest3::implementation
{
	struct IslandApplication : IslandApplicationT<IslandApplication>
	{
	public:
		IslandApplication();
		IslandApplication(const winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider> &);
		~IslandApplication();

		void InitializeComponent();

		winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider> MetadataProviders();
		winrt::Windows::Foundation::IClosable WindowsXamlManager();
		winrt::Microsoft::UI::Xaml::Markup::IXamlType GetXamlType(winrt::Windows::UI::Xaml::Interop::TypeName const& type);
		winrt::Microsoft::UI::Xaml::Markup::IXamlType GetXamlType(hstring const& fullName);
		com_array<winrt::Microsoft::UI::Xaml::Markup::XmlnsDefinition> GetXmlnsDefinitions();
		void Close();
	private:
		winrt::Microsoft::UI::Xaml::Hosting::WindowsXamlManager m_windowsXamlManager = nullptr;
		winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::UI::Xaml::Markup::IXamlMetadataProvider> m_providers = nullptr;
		bool m_closed = false;
	};
}

namespace winrt::XamlIslandTest3::factory_implementation
{
	struct IslandApplication : IslandApplicationT<IslandApplication, implementation::IslandApplication>
	{
	};
}

There is a lot of C++ isms here. The important thing to note is that InitializeComponent is something that I defined myself.

This does mean that you can't rely on the application class itself initialising the metadata provider and Xaml resources. This has to be done manually.

int wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int)
{
    //Other initialisation stuff.
    //...

    //This is the WinUI 3 metadata provider.
    auto xcxmdp = winrt::Microsoft::UI::Xaml::XamlTypeInfo::XamlControlsXamlMetadataProvider();
    //Other custom control metadata providers.
    auto tcxmdp = winrt::TestComponent::XamlMetadataProvider();

    //Activate IslandApplication providing the metadata providers we just loaded.
    //IslandApplication.MetadataProviders can be used to do this too.
    auto island_app = winrt::XamlIslantTest3::IslandApplication({xcxmdp, tcxmdp});

    //This needs an instance of the metadata provider to exist before we activate the class.
    //This is why IslandApplication was initialised first.
    auto xcr = winrt::Microsoft::UI::Xaml::Controls::XamlControlsResources();
    island_app.Resources().MergedDictionaries().Append(xcr);

    //Other initialisation stuff.
    //...
}

As you can see, this code activates any metadata providers that you want to use. The second one is a custom control. It then activates an instance of IslandApplication, passing in all metadata providers. This is needed because the Xaml runtime will query this in certain circumstances to figure out type information. This code is generated by the Xaml compiler in a WinUI 3 application.

Next, an instance of XamlControlsResources is activated and added to the Application's resources. This is what normally happens in the Xaml compiler's generated InitializeComponent implementation.

For completion's sake, here is the source file for IslandApplication too.

#include "pch.h"
#include "IslandApplication.h"
#include "IslandApplication.g.cpp"

namespace winrt
{
    namespace wf = winrt::Windows::Foundation;
    namespace wfc = winrt::Windows::Foundation::Collections;

    namespace wuxi = winrt::Windows::UI::Xaml::Interop;

    namespace muxh = winrt::Microsoft::UI::Xaml::Hosting;
    namespace muxm = winrt::Microsoft::UI::Xaml::Markup;
}

namespace winrt::XamlIslandTest3::implementation
{
    IslandApplication::IslandApplication() : m_providers(winrt::single_threaded_vector<muxm::IXamlMetadataProvider>()) {}

    IslandApplication::IslandApplication(const wfc::IVector<muxm::IXamlMetadataProvider> &providers) : m_providers(winrt::single_threaded_vector<muxm::IXamlMetadataProvider>())
    {
        for (const auto &provider : providers)
        {
            m_providers.Append(provider);
        }
    }

    IslandApplication::~IslandApplication()
    {
        Close();
    }

    void IslandApplication::InitializeComponent()
    {
        m_windowsXamlManager = muxh::WindowsXamlManager::InitializeForCurrentThread();
    }

    wfc::IVector<muxm::IXamlMetadataProvider> IslandApplication::MetadataProviders()
    {
        return m_providers;
    }
    wf::IClosable IslandApplication::WindowsXamlManager()
    {
        return m_windowsXamlManager;
    }
    muxm::IXamlType IslandApplication::GetXamlType(wuxi::TypeName const& type)
    {
        for (const auto &provider : m_providers)
        {
            const auto xaml_type = provider.GetXamlType(type);
            if (xaml_type)
            {
                return xaml_type;
            }
        }

        return nullptr;
    }
    muxm::IXamlType IslandApplication::GetXamlType(hstring const& fullName)
    {
        for (const auto &provider : m_providers)
        {
            const auto xaml_type = provider.GetXamlType(fullName);
            if (xaml_type)
            {
                return xaml_type;
            }
        }

        return nullptr;
    }
    com_array<muxm::XmlnsDefinition> IslandApplication::GetXmlnsDefinitions()
    {
        std::vector<muxm::XmlnsDefinition> definitions;

        for (const auto &provider : m_providers)
        {
            auto defs = provider.GetXmlnsDefinitions();
            for (const auto &def : defs)
            {
                definitions.emplace_back(def);
            }
        }

        return winrt::com_array<muxm::XmlnsDefinition>(std::move(definitions));
    }
    void IslandApplication::Close()
    {
        if (m_closed)
        {
            return;
        }

        m_closed = true;
        m_windowsXamlManager.Close();
        m_providers.Clear();
        m_windowsXamlManager = nullptr;
    }
}

Hopefully this will help you adapt it to C#.