Chaînage de méthode en C #

Je n’ai aucune idée de ce que cela s’appelle en C #. Mais je veux append la fonctionnalité à ma classe pour append plusieurs éléments en même temps.

myObj.AddItem(mItem).AddItem(mItem2).AddItem(mItem3); 

La technique que vous mentionnez s’appelle les méthodes chaînables. Il est couramment utilisé lors de la création de DSL ou d’ interfaces fluides en C #.

Le modèle type consiste à faire en sorte que votre méthode AddItem () renvoie une instance de la classe (ou de l’interface) dont elle fait partie. Cela permet les appels suivants à être enchaînés à elle.

 public MyCollection AddItem( MyItem item ) { // internal logic... return this; } 

Certaines alternatives au chaînage de méthodes, pour append des éléments à une collection, incluent:

Utiliser la syntaxe params pour permettre à plusieurs éléments d’être transmis à votre méthode en tant que tableau. Utile lorsque vous souhaitez masquer la création du tableau et fournir une syntaxe d’argument variable à vos méthodes:

 public void AddItems( params MyItem[] items ) { foreach( var item in items ) m_innerCollection.Add( item ); } // can be called with any number of arguments... coll.AddItems( first, second, third ); coll.AddItems( first, second, third, fourth, fifth ); 

Fournir une surcharge de type IEnumerable ou IEnumerable afin que plusieurs éléments puissent être transmis ensemble à votre classe de collecte.

 public void AddItems( IEnumerable items ) { foreach( var item in items ) m_innerCollection.Add( item ); } 

Utilisez la syntaxe de l’initialiseur de collection .NET 3.5. Votre classe doit fournir une méthode Add( item ) un seul paramètre, implémenter IEnumerable et avoir un constructeur par défaut (ou vous devez appeler un constructeur spécifique dans l’instruction d’initialisation). Ensuite, vous pouvez écrire:

 var myColl = new MyCollection { first, second, third, ... }; 

Utilisez cette astuce:

 public class MyClass { private List _Items = new List (); public MyClass AddItem (MyItem item) { // Add the object if (item != null) _Items.Add (item) return this; } } 

Il renvoie l’instance actuelle qui vous permettra de chaîner les appels de méthode (ajoutant ainsi plusieurs objects “en même temps”).

“Je n’ai aucune idée de ce que cela s’appelle en c #”

Une API fluide; SsortingngBuilder est l’exemple le plus courant de .NET:

 var sb = new SsortingngBuilder(); ssortingng s = sb.Append("this").Append(' ').Append("is a ").Append("silly way to") .AppendLine("append ssortingngs").ToSsortingng(); 

D’autres ont répondu en termes de chaînage de méthode directe, mais si vous utilisez C # 3.0, vous pourriez être intéressé par les initialiseurs de collection … ils ne sont disponibles que lorsque vous effectuez un appel constructeur, et seulement si vos méthodes et méthodes sont appropriées. implémente IEnumerable , mais alors vous pouvez faire:

 MyClass myClass = new MyClass { item1, item2, item3 }; 

Pourquoi n’utilisez-vous pas le mot clé params ?

 public void AddItem (params MyClass[] object) { // Add the multiple items } 

Que diriez-vous

 AddItem(ICollection items); 

ou

 AddItem(params Item[] items); 

Vous pouvez les utiliser comme ça

 myObj.AddItem(new Item[] { item1, item2, item3 }); myObj.AddItem(item1, item2, item3); 

Ce n’est pas un chaînage de méthode, mais il ajoute plusieurs éléments à votre object en un seul appel.

Vous pouvez append une méthode d’extension pour prendre en charge cela, à condition que votre classe hérite d’ICollection:

 [TestClass] public class UnitTest1 { [TestMethod] public void CanChainSsortingngs() { ICollection ssortingngs = new List(); ssortingngs.AddItem("Another").AddItem("Ssortingng"); Assert.AreEqual(2, ssortingngs.Count); } } 
 public static class ChainAdd { public static ICollection AddItem(this ICollection collection, T item) { collection.Add(item); return collection; } } 

Si votre élément agit comme une liste, vous souhaiterez peut-être implémenter une interface telle que iList ou iEnumerable / iEnumerable.

Quoi qu’il en soit, la clé pour enchaîner les appels comme vous le souhaitez est de renvoyer l’object souhaité.

 public Class Foo { public Foo AddItem(Foo object) { //Add object to your collection internally return this; } } 

Quelque chose comme ça?

 class MyCollection { public MyCollection AddItem(Object item) { // do stuff return this; } }