Por que o mundo .Net parece adotar seqüências de caracteres mágicas em vez de alternativas com tipagem estática?

Então, eu trabalho no .Net. Eu faço projetos de código aberto no .net. Um dos meus maiores problemas com isso não é necessariamente com o .net, mas com a comunidade e os frameworks em torno dele. Parece em todos os lugares que esquemas mágicos de nomeação e strings são tratados como a melhor maneira de fazer tudo. Declaração ousada, mas olhe para ela:

ASP.Net MVC:

Olá rota mundial:

        routes.MapRoute(
            "Default",                                              // Route name
            "{controller}/{action}/{id}",                           // URL with parameters
            new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
        );

O que isto significa é que o ASP.Net MVC irá de alguma forma procurar HomeController em seu código. De alguma forma, crie uma nova instância e, em seguida, chame a função Index aparentemente com um parâmetro id de algum tipo. E depois há outras coisas como:

RenderView("Categories", categories);
...or..
ViewData["Foobar"]="meh";

E também há coisas semelhantes com o XAML. DataContext é tratado como um objeto e você tem que esperar e orar para que ele seja resolvido com o tipo desejado. DependencyProperties deve usar strings mágicas e convenções de nomenclatura mágica. E coisas assim:

  MyData myDataObject = new MyData(DateTime.Now);      
  Binding myBinding = new Binding("MyDataProperty");
  myBinding.Source = myDataObject;

Embora se baseie mais em fundição e vários suportes de tempo de execução mágicos.

Enfim, eu digo tudo isso para acabar aqui: Por que isso é tão bem tolerado no mundo do .net? Não estamos usando linguagens com tipagem estática para quase sempre saber quais são os tipos de coisas? Por que a reflexão e o tipo / método / propriedade / quaisquer nomes (como cadeias de caracteres) preferiam tanto em comparação com genéricos e delegados ou até geração de código?

Existem motivos herdados pelos quais eu não sei por que a sintaxe de roteamento do ASP.Net depende quase exclusivamente da reflexão para realmente resolver como lidar com uma rota? Eu odeio quando eu mudo o nome de um método ou propriedade e de repente as coisas quebram, mas não parece haver nenhuma referência a esse método ou propriedade e obviamente não há erros no compilador. Por que a aparente conveniência das cordas mágicas era considerada "valiosa"?

Eu sei que existem também alternativas geralmente tipadas estaticamente para algumas coisas, mas elas geralmente ficam em segundo plano e parecem nunca estar em tutoriais ou outro material para iniciantes.