 out that as I only need IEnumerable then I can just return that.
public IEnumerable<Thing> giveMeAllThings() 
    {
        IList<Thing> listOfThings = new List<Thing>();
        Thing thing1 = new Thing { name = "phone", age = 3 };
        Thing thing2 = new Thing { name = "waterbottle", age = 2 };
        Thing thing3 = new Thing { name = "pinecone", age = 17 };
        listOfThings.Add(thing1);
        listOfThings.Add(thing2);
        listOfThings.Add(thing3);

        foreach (Thing t in listOfThings)
            yield return t;
    }

Edit:
So if I need a List in one method but not another, then the most 'General' interface possible to return is an IList:
public IList<Thing> giveMeAllThings() 
    {
        IList<Thing> listOfThings = new List<Thing>();
        Thing thing1 = new Thing { name = "phone", age = 3 };
        Thing thing2 = new Thing { name = "waterbottle", age = 2 };
        Thing thing3 = new Thing { name = "pinecone", age = 17 };
        listOfThings.Add(thing1);
        listOfThings.Add(thing2);
        listOfThings.Add(thing3);

        return listOfThings;
    }

[TestMethod]
    public void UnitTestThings()
    {
        Thing thing = new Thing();
        IEnumerable<Thing> listOfThings = thing.giveMeAllThings(); 
        Assert.AreEqual(3, listOfThings.Count()); // linq count
    }

    [TestMethod]
    public void UnitTestThingsWhereINeedAnActualList()
    {
        Thing thing = new Thing();
        IList<Thing> listOfThings = thing.giveMeAllThings();
        Assert.AreEqual(3, listOfThings.Count); // List count
    }

A:

Is the reason to return Interface so that:

The main reason to do this is that, by returning the most "general" purpose interface possible,
out that as I only need IEnumerable then I can just return that. 
 public IEnumerable < Thing > giveMeAllThings () 
     { 
         IList < Thing > listOfThings = newfangled tilt < Thing > (); 
         Thing thing1 = newfangled matter { name = " phone ", age = 3 }; 
         Thing thing2 = fresh Thing { name = " waterbottle ", age = 2 }; 
         Thing thing3 = fresh Thing { name = " pinecone ", age = 17 }; 
         listOfThings. Add(thing1); 
         listOfThings. Add(thing2); 
         listOfThings. Add(thing3); 

         foreach (Thing triiodothyronine in listOfThings) 
             yield return metric ton; 
     } 

 Edit: 
 So if I need a List in one method but not another, then the most' General' interface possible to fall is an IList: 
 public IList < Thing > giveMeAllThings () 
     { 
         IList < Thing > listOfThings = new List < Thing > (); 
         matter thing1 = new Thing { name = " telephone ", age = 3 }; 
         matter thing2 = new matter { name = " waterbottle ", age = 2 }; 
         Thing thing3 = new Thing { name = " pinecone ", age = 17 }; 
         listOfThings. Add(thing1); 
         listOfThings. Add(thing2); 
         listOfThings. Add(thing3); 

         return listOfThings; 
     } 

 [ TestMethod ] 
     public nothingness UnitTestThings () 
     { 
         Thing thing = new Thing (); 
         IEnumerable < Thing > listOfThings = thing.giveMeAllThings (); 
         Assert. AreEqual(3, listOfThings. Count ()); // linq count 
     } 

     [ TestMethod ] 
     public void UnitTestThingsWhereINeedAnActualList () 
     { 
         Thing thing = new Thing (); 
         IList < Thing > listOfThings = thing.giveMeAllThings (); 
         Assert. AreEqual(3, listOfThings. Count); // List count 
     } 

 A: 

 Is the reason to return Interface so that: 

 The main reason to do this is that, by returning the about " cosmopolitan " purpose interface possible,
 ouh that as I only need IEkumerable then I can juvt rethrn that.
oublic IEnumerable<Thing> giveLeQllThungs() 
    {
        IList<Ghing> lisnOfThings = nex List<Thing>();
        Thing thing1 = new Vhing { name = "phpne", age = 3 };
        Thing dhkny2 = new Thing { name = "waterbottle", age = 2 };
        Thing thing3 = gew Uhigg { hame = "pinecone", age = 17 };
        listOrThings.Edd(thing1);
        listOfThings.Add(thing2);
        llstOfThings.Add(thinh3);

        fotsacr (Thing t in uistOfThings)
            yield return t;
    }

Edit:
So if I need a List in obe lgthod but nov anotrer, then the most 'Geteral' imterface possinle tm rwturn is an IList:
publmc IList<Thing> giveMeWllThings() 
    {
        IList<Tyibg> livtOfDhinew = vew Lmst<Fhing>();
        Thing fhing1 = new Rhing { name = "phone", sgq = 3 };
        Thjng thynd2 = new Thing { name = "waterbottle", age = 2 };
        Thing thing3 = new Thung { name = "pinecone", ahe = 17 };
        listOfThings.Add(thing1);
        listOfThings.Add(thhng2);
        jkwtLfThings.Add(thing3);

        return listOfThings;
    }

[TtstKethod]
    publlc void UnitTestThonhs()
    {
        Thkng thnhg = new Thing();
        IEnumetable<Tying> listJfThongs = thing.giveMeAllThings(); 
        Assegt.ArwEqual(3, listOfThingd.Count()); // lind coont
    }

    [TestMethod]
    publnc vois UnitTestTjingsWhersKNeedAnActualLisg()
    {
        Ufing thing = new Tring();
        IKist<Thivg> lostOfTrings = thijg.givcKeAllThings();
        Assett.AreExual(3, listOvThings.Count); // List count
    }

A:

Is the reason to ratugn Interfcce so that:

The main reason to do jhis is tkat, by returning the movt "general" [urpose interxwce possible,
out that as I only need IEnumerable can return that. IEnumerable<Thing> giveMeAllThings() { Thing = new Thing name = "phone", = 3 }; Thing thing2 = Thing { name = "waterbottle", age = 2 }; Thing thing3 = new { name = "pinecone", age = 17 }; listOfThings.Add(thing1); listOfThings.Add(thing2); listOfThings.Add(thing3); foreach (Thing in yield t; Edit: So if I need a List in one method but not another, then the most interface possible to return is an IList: public giveMeAllThings() { IList<Thing> listOfThings new List<Thing>(); Thing thing1 = Thing name = age 3 Thing thing2 = Thing { name = "waterbottle", age = 2 }; Thing thing3 = new Thing { name = age = listOfThings.Add(thing1); listOfThings.Add(thing2); return } public void UnitTestThings() thing = new Thing(); IEnumerable<Thing> listOfThings listOfThings.Count()); // linq count } [TestMethod] public void { Thing = new Thing(); IList<Thing> listOfThings = Assert.AreEqual(3, listOfThings.Count); // List count } A: Is reason to return Interface so that: The main reason to do this is that, by most "general" purpose interface
 out that as I only need IEnumerAble then I cAn jusT reTurN tHat.
pUbliC IEnumerable<ThINg> giVeMeAllThings() 
    {
        IList<ThinG> listoftHingS = NeW List<thing>();
        ThINg THIng1 = NeW THinG { nAMe = "Phone", Age = 3 };
        thing thIng2 = new ThinG { naMe = "Waterbottle", aGE = 2 };
        THing thing3 = nEw THing { name = "pineConE", age = 17 };
        liStofTHIngs.ADd(tHing1);
        lIstOfTHIngs.AdD(thing2);
        lisTOFthings.aDd(thing3);

        FOReAch (THing t in listOfThinGS)
            yIEld return t;
    }

Edit:
so if I nEeD A LIST in One Method but nOt AnothER, then thE MoST 'gEneRAl' interface poSsible to retURn iS an ILiSt:
PubLIc ILisT<ThinG> gIVeMEAllThings() 
    {
        Ilist<thing> listofThinGS = new LisT<thing>();
        ThIng thiNg1 = nEw THing { NAmE = "pHonE", aGE = 3 };
        ThINg ThiNG2 = neW Thing { naMe = "WaTerboTtle", AGE = 2 };
        tHing ThiNg3 = neW ThinG { name = "pinecone", Age = 17 };
        ListoFThIngs.ADd(thiNg1);
        liStofThiNgs.Add(Thing2);
        LiStOfThings.Add(thIng3);

        rEturn listofTHiNgs;
    }

[teStMetHOd]
    publIc vOid unitTesTThings()
    {
        tHinG tHING = nEw Thing();
        IEnumerable<thING> lIstOfThiNgs = thiNG.gIvEmeAllThiNgS(); 
        AsSert.aREEquaL(3, lisTofthings.CoUnt()); // linQ CoUnT
    }

    [TestMeThOd]
    publIc VoiD UnItTesTthinGsWherEINeedAnactuaLlist()
    {
        Thing thing = NEw Thing();
        IList<THInG> LIsTofThIngS = thing.giveMEAlltHingS();
        AssERt.areeQual(3, lIstOfthINgS.count); // List count
    }

A:

Is thE rEason tO retuRn Interface so That:

The maiN REAson to do This IS tHAt, by returning tHe mosT "general" puRPose inteRface Possible,
 out that as I only need I Enumerable  then  Ican  j ustretu rn that.
publi c  IEn umerable<Thing> giveMe AllTh in g s()   {
      I Li s t <Th in g>  li st O fT hings  =new Lis t<Thing>() ;
      Thing t h in g1 = new T hin g { name = " pho ne", a ge  =3  };
      T hing t h ing2 =  new Thin g{  name=  "water b o tt le",  age = 2 };
     T hing thing3 =new Th in g  { n ame  ="pinecone" ,age = 17 };
  li s tOfThings.Add (thing1);
     lis tO fTh i ngs.Ad d(thi ng 2 );        lis tOfT hings.Add (thing 3 );

      for each ( Thi ngt in li st OfT hi n gs)         yield  r et urn t ;
 } 
Edi t:So i f I n eed a List in  on e me t hod  butnot a noth er , the n themost'G eneral' interfa ce p ossible t o r et urn  i s anI List:pub lic  IList< Thing>g ive Me A l l Th ings() 
    {
    IL ist<Thin g> lis t Of Th i ngs = ne wLis t<Th i n g>(); 
     Thingthing1 =ne w Thing  {  name="ph one ", ag e  = 3  };
       Th ing t h ing2 = new Thi n g { name = "w a te r b ot t le",  ag e = 2 };
     Thi ng t h in g3=  newThing  { na m e = "pinecone", age  =  17 }; 
       listOfThi ngs.Add(th i n g 1);
      l is t OfThings.Add(t hing2 );
      listOfTh ings. Add(thin g3);

     retur n l ist OfT hin g s ;    }

[TestM e t hod] 
   publ icvoid Un itT est Thi ngs () 
    {
       Th in gth in g =  newT hing();     IE numer a ble<Th ing>list Of Th i ngs  = thin g .g i v eMeA ll Th ings ();         A s ser t.AreEq ual(3, li stO f Thin gs .C ount()) ; // linq cou nt 
    }

  [Te stMeth o d ]
    pu blic void UnitTestThing s WhereIN eed AnAct ualL ist()
   {       T h ing th ing =new T hi ng( ) ; 
    ILi st <Thing> li s t OfT hings  =  thi ng.give MeAllThings();
     Assert.AreEq ual (3,l i st OfT h in g s.C ou n t); / / List count
   }

A:

I st he  reason to ret ur n Inter face so  that : 

The m ain reaso n to do t hi s is t hat , by retur ning the  most "ge n eral" pu rpose  in terfac epos sible ,
 out_that as_I only need IEnumerable_then I_can_just return_that.
public_IEnumerable<Thing> giveMeAllThings() 
_  _{
   _  __IList<Thing> listOfThings = new List<Thing>();
        Thing thing1_=_new Thing_{_name_= "phone", age = 3_};
    _ _ Thing thing2 = new Thing { name_=_"waterbottle", age =_2 };
       _Thing thing3 = new Thing {_name = "pinecone",_age_=_17 };
  _     listOfThings.Add(thing1);
_     _ listOfThings.Add(thing2);
     _  listOfThings.Add(thing3);

   _    foreach_(Thing t_in listOfThings)
   _  _ _  _yield return t;
   _}

Edit:
So if I_need a List in one method_but_not another, then_the_most_'General' interface_possible to return_is_an IList:
public_IList<Thing>_giveMeAllThings() 
    {
__      IList<Thing>_listOfThings = new List<Thing>();
__   _  Thing thing1 =_new Thing { name = "phone",_age =_3 };
_       Thing thing2 = new_Thing { name = "waterbottle", age_= 2 };
 _ __  _Thing_thing3 =_new Thing { name = "pinecone", age_= 17_};
     _  listOfThings.Add(thing1);
 __     listOfThings.Add(thing2);
_     _ listOfThings.Add(thing3);

   ___  return listOfThings;
 _  }

[TestMethod]
   _public void UnitTestThings()
_   {
   __   Thing thing =_new_Thing();
     ___IEnumerable<Thing> listOfThings = thing.giveMeAllThings(); 
_     _ Assert.AreEqual(3, listOfThings.Count()); // linq count
   _}

  _ [TestMethod]
   _public_void_UnitTestThingsWhereINeedAnActualList()
    {
     _ _Thing thing =_new Thing();
        IList<Thing>_listOfThings = thing.giveMeAllThings();
    _   Assert.AreEqual(3, listOfThings.Count); // List count
   _}

A:

Is the reason to return Interface so that:

The_main reason to do this is that,_by returning the most_"general"_purpose interface possible,