La lenteur est la Réflexion

Dans la plupart des cas: plus que assez rapide. Par exemple, si vous utilisez cette fonction pour créer un DAL objet wrapper, le temps pris pour créer l'objet par la réflexion sera minuscule par rapport au temps qu'il faut pour se connecter à un réseau. Ainsi, l'optimisation, ce serait une perte de temps.

Si vous êtes en utilisant la réflexion dans une boucle serrée, il y a des astuces pour l'améliorer:

• génériques (à l'aide d'un wrapper where T : new() et MakeGenericType)
• Delegate.CreateDelegate (à typé délégué; ne fonctionne pas pour les constructeurs)
• Reflection.Emit - hardcore
• Expression (comme Delegate.CreateDelegate, mais plus souple, et travaille pour les constructeurs)

Mais pour vos besoins, CreateInstance est parfaitement bien. S'en tenir à cela, et de garder les choses simples.

---

Edit: alors que le point sur la performance relative reste, et bien que la chose la plus importante, "mesurer", reste, je me dois de préciser certains. Parfois... il ne question. Mesurez d'abord. Toutefois, si vous trouvez qu'il est trop lent, vous pouvez jeter un oeil à quelque chose comme FastMember, qui fait tout le Reflection.Emit code tranquillement dans le fond, pour vous donner une bonne API; par exemple:

var accessor = TypeAccessor.Create(type);
List<object> results = new List<object>();
foreach(var row in rows) {
    object obj = accessor.CreateNew();
    foreach(var col in cols) {
        accessor[obj, col.Name] = col.Value;
    }
    results.Add(obj);
}

qui est simple, mais sera très rapide. Dans l'exemple particulier-je mentionner à propos d'un DAL wrapper—si vous faites cela beaucoup, pensez à quelque chose comme dapper, ce qui fait tout le Reflection.Emit code en arrière-plan pour vous donner le plus rapidement possible, mais facile à utiliser l'API:

int id = 12345;
var orders = connection.Query<Order>(
    "select top 10 * from Orders where CustomerId = @id order by Id desc",
    new { id }).ToList();

Voici quelques liens qui pourraient vous aider:

• Ce mec a fait quelques tests et fournit quelques métriques
• Article MSDN "Dodge Communes de la Performance des Pièges à l'Artisanat Rapide d'Applications"

J'ai pensé que je ferais un petit test pour démontrer la lenteur de la réflexion est par rapport à sans.

Avec La Réflexion

• L'instanciation de 58 objets en parcourant chacun de leurs Attributs et de l'appariement des

• Temps Total: 52254 nanosecondes

  while (reader.Read()) {
      string[] columns = reader.CurrentRecord;
      CdsRawPayfileEntry toAdd = new CdsRawPayfileEntry();
      IEnumerable<PropertyInfo> rawPayFileAttributes = typeof(CdsRawPayfileEntry).GetProperties().Where(prop => Attribute.IsDefined(prop, typeof(CustomIndexAttribute)));
      foreach (var property in rawPayFileAttributes) {
          int propertyIndex = ((CustomIndexAttribute)property.GetCustomAttribute(typeof(CustomIndexAttribute))).Index;
          if (propertyIndex < columns.Length)
              property.SetValue(toReturn, columns[propertyIndex]);
          else
              break;
      }
  }

Sans Réflexion

• L'instanciation de 58 Objets par la création d'un nouvel objet

• Temps Total: 868 nanosecondes

      while (reader2.Read()) {
          string[] columns = reader2.CurrentRecord;
          CdsRawPayfileEntry toAdd = new CdsRawPayfileEntry() {
              ColumnZero = columns[0],
              ColumnOne = columns[1],
              ColumnTwo = columns[2],
              ColumnThree = columns[3],
              ColumnFour = columns[4],
              ColumnFive = columns[5],
              ColumnSix = columns[6],
              ColumnSeven = columns[7],
              ColumnEight = columns[8],
              ColumnNine = columns[9],
              ColumnTen = columns[10],
              ColumnEleven = columns[11],
              ColumnTwelve = columns[12],
              ColumnThirteen = columns[13],
              ColumnFourteen = columns[14],
              ColumnFifteen = columns[15],
              ColumnSixteen = columns[16],
              ColumnSeventeen = columns[17]
          };
      }

Quoique, pas tout à fait juste puisque la réflexion a également pour récupérer un attribut spécifique de chaque propriété à 58*18 fois au sommet de la création d'un nouvel objet par la réflexion, mais c'est au moins fournit un certain point de vue.

Je faisais somethign similaires, jusqu'à ce que j'ai commencé à jouer avec le Cio. Je voudrais utiliser un Printemps définition de l'objet de spécifier le fournisseur de données - SQL, XML, ou se moque de!