Autofixture: Diccionario concurrente

Si alguien más se encuentra con el mismo problema, he escrito un generador de muestras para esto:

public class ConcurrentDictionaryGenerator : ISpecimenBuilder
{
    public object Create(object request, ISpecimenContext context)
    {
        Type type = request as Type;
        if (type == null)
        {
            return new NoSpecimen();
        }

        Type[] typeArguments = type.GetTypeInfo().GetGenericArguments();
        if (typeArguments.Length != 2 || typeof(ConcurrentDictionary<,>).MakeGenericType(typeArguments) != type)
        {
            return new NoSpecimen();
        }

        Type nonConcurrentDictionaryType = typeof(Dictionary<,>).MakeGenericType(typeArguments);
        IDictionary nonConcurrentDictionary = (IDictionary) context.Resolve(nonConcurrentDictionaryType);

        IDictionary concurrentDictionary = (IDictionary) Activator.CreateInstance(type);

        foreach (object key in nonConcurrentDictionary.Keys)
        {
            object value = nonConcurrentDictionary[key];
            concurrentDictionary.Add(key, value);
        }

        return concurrentDictionary;
    }
}

Hola,
No puedo decir las razones detrás de esto, pero mirando el código fuente, las colecciones admitidas están codificadas.
Por lo tanto, no es algo así como "el tipo implementa IDictionary", es "es tipo Dictionary<,>". Por lo tanto, ConcurrentDictionary no funciona.
No necesita crear su propio generador de especímenes, puede usar lo que ya está allí:

      var fixture = new Fixture();

      var query = new ModestConstructorQuery();
      var methodInvoker = new MethodInvoker(query);
      var dictionaryFiller = new DictionaryFiller();
      var postProcessor = new Postprocessor(methodInvoker, dictionaryFiller);
      var exactTypeSpecification = new ExactTypeSpecification(typeof(ConcurrentDictionary<,>));
      var specimenBuilder = new FilteringSpecimenBuilder(postProcessor, exactTypeSpecification);

      fixture.Customizations.Add(specimenBuilder);

Cuanto más aprendo sobre el funcionamiento interno de esta biblioteca, más me encanta.

¡Es interesante saber que actualmente solo está disponible en Dictionary<,> y gracias por la forma integrada de hacerlo!

Supongo que la única pregunta que le queda a alguien sería: ¿sería una buena característica para agregar? ¿Quizás no para ConcurrentDictionary<,> específicamente, sino para todas las implementaciones IDictionary<,> ?

Solo que no difundo información incorrecta, no es solo Dictionary<,>. Solo quería señalar que la lista de tipos se puede encontrar directamente en Fixture.cs. Por ejemplo, también es SortedDictionary<,>, pero como ya se dio cuenta, no es ConcurrentDictionary<,>.
Por supuesto, diría que una implementación futura debería verificar la interfaz.

En realidad, lo que está codificado no es el soporte, sino el hecho de que las interfaces se transmiten a algún tipo concreto. Al igual que IDictionary y IReadOnlyDictionary, se transmiten a Dictionary, y así sucesivamente.