Je sais qu'il y a eu beaucoup de posts sur ce sujet, mais il confond encore moi pourquoi devriez-vous passer dans une interface comme IList et retourner une interface comme IList dos plutôt que sur le béton de la liste.
J'ai lu beaucoup de posts pour dire à quel point cela rend plus facile de changer la mise en œuvre plus tard, mais je n'ai pas du bien voir comment cela fonctionne.
Dire que si j'ai cette méthode
public class SomeClass
{
public bool IsChecked { get; set; }
}
public void LogAllChecked(IList<SomeClass> someClasses)
{
foreach (var s in someClasses)
{
if (s.IsChecked)
{
// log
}
}
}
Je ne suis pas sûr de savoir comment, dans l'avenir, grâce à des IList va m'aider.
Comment savoir si je suis déjà dans la méthode? Dois-je continuer à l'aide de IList?
public void LogAllChecked(IList<SomeClass> someClasses)
{
//why not List<string> myStrings = new List<string>()
IList<string> myStrings = new List<string>();
foreach (var s in someClasses)
{
if (s.IsChecked)
{
myStrings.Add(s.IsChecked.ToString());
}
}
}
Que dois-je obtenir de l'aide IList maintenant?
public IList<int> onlySomeInts(IList<int> myInts)
{
IList<int> store = new List<int>();
foreach (var i in myInts)
{
if (i % 2 == 0)
{
store.Add(i);
}
}
return store;
}
comment est-il maintenant? Est-il une nouvelle mise en œuvre d'une liste de int est que j'ai besoin de changement?
Donc en gros, j'ai besoin de voir quelques exemples de code de façon si je où à l'aide de IList aurait résolu un problème plus juste de prendre la Liste de tout.
De ma lecture, je pense que je pourrais avoir utilisé IEnumberable au lieu de IList depuis que je suis seulement en boucle à travers des choses.
Modifier Donc j'ai été jouer avec certains de mes méthodes sur la façon de le faire. Je suis toujours pas sûr de savoir le type de retour(si je doit le rendre plus concret ou une interface)
public class CardFrmVm
{
public IList<TravelFeaturesVm> TravelFeaturesVm { get; set; }
public IList<WarrantyFeaturesVm> WarrantyFeaturesVm { get; set; }
public CardFrmVm()
{
WarrantyFeaturesVm = new List<WarrantyFeaturesVm>();
TravelFeaturesVm = new List<TravelFeaturesVm>();
}
}
public class WarrantyFeaturesVm : AvailableFeatureVm
{
}
public class TravelFeaturesVm : AvailableFeatureVm
{
}
public class AvailableFeatureVm
{
public Guid FeatureId { get; set; }
public bool HasFeature { get; set; }
public string Name { get; set; }
}
private IList<AvailableFeature> FillAvailableFeatures(IEnumerable<AvailableFeatureVm> avaliableFeaturesVm)
{
List<AvailableFeature> availableFeatures = new List<AvailableFeature>();
foreach (var f in avaliableFeaturesVm)
{
if (f.HasFeature)
{
// nhibernate call to Load<>()
AvailableFeature availableFeature = featureService.LoadAvaliableFeatureById(f.FeatureId);
availableFeatures.Add(availableFeature);
}
}
return availableFeatures;
}
Donc, je suis maintenant de retour IList pour le simple fait que je vais l'ajouter à mon modèle de domaine de ce qui a une propriété comme cela
public virtual IList<AvailableFeature> AvailableFeatures { get; set; }
le ci-dessus est un IList lui-même que c'est ce qui semble être la norme à utiliser avec nhibernate. Sinon j'ai peut-être retourné IEnumberable en arrière, mais pas sûr. Ne peut toujours pas comprendre ce que l'utilisateur serait 100% besoin(c'est là que le retour de béton a un avantage sur).
Edit 2
Je pensais aussi qu'advient-il si je veux faire passer par référence dans ma méthode?
private void FillAvailableFeatures(IEnumerable<AvailableFeatureVm> avaliableFeaturesVm, IList<AvailableFeature> toFill)
{
foreach (var f in avaliableFeaturesVm)
{
if (f.HasFeature)
{
// nhibernate call to Load<>()
AvailableFeature availableFeature = featureService.LoadAvaliableFeatureById(f.FeatureId);
toFill.Add(availableFeature);
}
}
}
aurais-je des problèmes avec ça? Depuis que pourraient-ils ne pas passer un tableau(qui a une taille fixe)? Serait-il mieux peut-être pour une Liste concrète?
