Eu sei que houve muitas postagens sobre isso, mas ainda me confunde por que você deve passar em uma interface como IList e retornar uma interface como IList de volta em vez da lista concret

Li várias postagens dizendo como isso facilita a alteração da implementação mais tarde, mas simplesmente não vejo completamente como isso funcion

Dizer se eu tenho esse método

  public class SomeClass
    {
        public bool IsChecked { get; set; }
    }

 public void LogAllChecked(IList<SomeClass> someClasses)
    {
        foreach (var s in someClasses)
        {
            if (s.IsChecked)
            {
                // log 
            }

        }
    }

Não sei ao certo como no futuro, usando o IList, me ajudar

E se eu já estiver no método? Ainda devo usar o 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());
            }

        }
    }

O que eu ganho por usar o IList agora?

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;
    }

que tal agora? Existe alguma nova implementação de uma lista de int que eu precise mudar?

Então, basicamente, eu preciso ver alguns exemplos de código reais de como se eu, usando o IList, tivesse resolvido algum problema ao simplesmente levar a Lista para tud

De minha leitura, acho que poderia ter usado IEnumberable em vez de IList, já que estou apenas analisando as coisa

Edita Então, eu estou brincando com alguns dos meus métodos sobre como fazer isso. Ainda não tenho certeza sobre o tipo de retorno (se devo torná-lo mais concreto ou uma 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;
        }

Então, agora estou retornando o IList pelo simples fato de adicioná-lo ao meu modelo de domínio que possui uma propriedade como esta

public virtual IList<AvailableFeature> AvailableFeatures { get; set; }

acima é uma IList propriamente dita, pois esse é o padrão que parece ser usado com o nhibernate. Caso contrário, eu poderia ter retornado IEnumberable de volta, mas não tenho certeza. Ainda não é possível descobrir o que o usuário precisaria 100% (é aí que o retorno de um concreto tem uma vantagem sobre

Edit 2

Eu também estava pensando o que acontece se eu quiser passar por referência no meu métod

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);
                    }
                }
            }

Eu teria problemas com isso? Desde que eles não poderiam passar em uma matriz (que tem um tamanho fixo)? Seria melhor, talvez, para uma lista concreta?