You're spoiled for choice: Dealing with dependencies in software development

				
					/// <summary>
        /// Searches for View models and views that match the name convention and adds them to the resource dictionary
        /// </summary>
        /// <param name="typeNamespace"> The namespace in which will be searched for the view models</param>
        /// <param name="res">Reference to Dictionary in which the template should be stored</param>
        /// <param name="relTypes">Array of types that contains among other types, the view model types and view types</param>
        /// <returns>List that contains the imported templates</returns>
        public static List<String> GenerateTemplateDictionary(String typeNamespace, ResourceDictionary res, Type[] relTypes)
        {
            // get names of namespaces for VMs and Views by convention
            String vmNs = $@"{typeNamespace}.ViewModels";
            String viewNs = vmNs.Replace("Model", String.Empty);

            // getting types of VMs and Views from that namespaces
            var viewModelQuery = from t in relTypes
                          where t != null && t.IsClass && !t.IsAbstract && t.Namespace != null && t.Namespace.StartsWith(vmNs)
                          select t;

            var viewModelTypeList = viewModelQuery.Where(t => t != null).GroupBy(t => t.Name).Select(g => g.First()).ToDictionary(t => t.Name, t => t);

            var viewQuery = from t in relTypes
                            where t != null && t.IsClass && !t.IsAbstract && t.Namespace != null && t.Namespace.StartsWith(viewNs)
                            select t;
            var viewTypeList = viewQuery.Where(t => t != null).GroupBy(t => t.Name).Select(g => g.First()).ToDictionary(t => t.Name, t => t);

            var foundItems = new List<String>();

            // link the VM types to View types by convention into a datatemplate and add the datatemplate to app.resources
            foreach (var vmt in viewModelTypeList)
            {
                var viewKey = vmt.Key.Replace("Model", String.Empty);
                if (viewTypeList.ContainsKey(viewKey))
                {
                    var viewType = viewTypeList[viewKey];
                    var template = CreateTemplate(vmt.Value, viewType);
                    if (!res.Contains(template.DataTemplateKey ?? throw new InvalidOperationException()))
                    {
                        res.Add(template.DataTemplateKey ?? throw new InvalidOperationException(), template);
                        foundItems.Add($@"Found and add VM -> View: {viewType.FullName} -> {vmt.Value.FullName}");
                    }
                    else
                        foundItems.Add($@"Pair is already known VM -> View: {viewType.FullName} -> {vmt.Value.FullName}");
                }
            }

            return foundItems;
        }
        
        private static DataTemplate CreateTemplate(Type viewModelType, Type viewType)
        {
            // The only way to get around some problems with binding later is this way of creating datatemplate objects
            // see www.ikriv.com/dev/wpf/DataTemplateCreation/ 

            const String xamlTemplate = "<DataTemplate DataType=\"{{x:Type vm:{0}}}\"><v:{1} /></DataTemplate>";
            var xaml = String.Format(xamlTemplate, viewModelType.Name, viewType.Name);

            var context = new ParserContext { XamlTypeMapper = new XamlTypeMapper(new String[0]) };

            context.XamlTypeMapper.AddMappingProcessingInstruction("vm", viewModelType.Namespace ?? throw new InvalidOperationException(), viewModelType.Assembly.FullName);
            context.XamlTypeMapper.AddMappingProcessingInstruction("v", viewType.Namespace ?? throw new InvalidOperationException(), viewType.Assembly.FullName);
caliburnmicro.com
            context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
            context.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");
            context.XmlnsDictionary.Add("vm", "vm");
            context.XmlnsDictionary.Add("v", "v");

            var template = (DataTemplate)XamlReader.Parse(xaml, context);
            return template;
        }