Ich weiß, dass es viele Beiträge dazu gegeben hat, aber es verwirrt mich immer noch, warum Sie eine Schnittstelle wie IList übergeben und eine Schnittstelle wie IList anstelle der konkreten Liste zurückgeben sollten.
Ich habe viele Beiträge gelesen, in denen es darum geht, die Implementierung später einfacher zu ändern, aber ich sehe einfach nicht ganz, wie das funktioniert.
Sagen Sie, ob ich diese Methode habe
public class SomeClass
{
public bool IsChecked { get; set; }
}
public void LogAllChecked(IList<SomeClass> someClasses)
{
foreach (var s in someClasses)
{
if (s.IsChecked)
{
// log
}
}
}
Ich bin mir nicht sicher, wie mir die Verwendung von IList in Zukunft helfen wird.
Wie wäre es, wenn ich bereits in der Methode bin? Sollte ich IList weiterhin verwenden?
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());
}
}
}
Was bekomme ich jetzt für die Verwendung von IList?
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;
}
Wie wäre es jetzt? Gibt es eine neue Implementierung einer Liste von Ints, die ich ändern muss?
Grundsätzlich muss ich einige aktuelle Codebeispiele sehen, wie die Verwendung von IList ein Problem gelöst hätte, wenn nur List in alles aufgenommen worden wäre.
Nach meiner Lektüre hätte ich IEnumberable anstelle von IList verwenden können, da ich mich nur durch die Dinge schlage.
Bearbeiten Also habe ich mit einigen meiner Methoden herumgespielt, wie das geht. Ich bin mir immer noch nicht sicher über den Rückgabetyp (ob ich ihn konkreter oder eine Schnittstelle machen soll).
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;
}
Jetzt gebe ich IList zurück, weil ich dies dann meinem Domain-Modell hinzufügen werde, was eine Eigenschaft wie diese hat:
public virtual IList<AvailableFeature> AvailableFeatures { get; set; }
Das Obige ist eine IList selbst, da dies der Standard zu sein scheint, der mit nhibernate verwendet wird. Andernfalls hätte ich IEnumberable möglicherweise zurückgegeben, bin mir aber nicht sicher. Trotzdem kann ich nicht herausfinden, was der Benutzer zu 100% benötigen würde (hier hat die Rückgabe eines Betons einen Vorteil gegenüber).
Bearbeiten 2
Ich habe auch darüber nachgedacht, was passiert, wenn ich in meiner Methode als Referenz übergeben möchte.
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);
}
}
}
würde ich damit auf Probleme stoßen? Da konnten sie nicht in einem Array (das eine feste Größe hat) übergeben? Wäre es vielleicht besser für eine konkrete Liste?