Getting list items

Well, you could receive a delegate for getting the elements - that is, to make the action that is different:

public List<Item> GetItems(Func<Item, Repository> getOtherItems) { if( getOtherItems == null ) { throw new ArgumentException(); } var result = new List<Item>(); foreach(var item in repo.GetItems2()) { var x = getOtherItems(); if (x.Value > 5) result.Add(x); } return result; } 

And then you could call it like so:

// In class A this.GetItems( repo => repo.GetOtherItems1(item.Id, "param1", param2) ); // In class B this.GetItems( repo => repo.GetOtherItems2(param1, param2, item.Id) ); 

But I notice that you also use repo.GetItems1() in A and repo.GetItems2() in B.
So the difference you pointed out is not the only one.

With this in mind, I would advise rethinking your class structure. These two could inherit from the same base class, and merely extend it. (Or it could be polymorphism, or...)

Maybe:

public interface IMyList<Item> { List<int> GetItems(); // If it returns a single item, the name should NOT be pluralized!! Item GetOtherItems(); } 

Or maybe an abstract class?

edit: read @JoeGeeky 's comment on the performance impact of using delegates; this may become relevant if the delegate is used on a very intensive cycle or under high loads.

I would make a couple suggestions:

• Consider making the return type of your GetItems methods IEnumerable<Item>, ICollection<Item>, or IList<Item>, depending on how you intend to use the result of your function. This will make refactoring later easier.
• Consider renaming your repo.GetOtherItemsN methods. Their names suggest that multiple items are being returned rather than a single item, but they appear to be returning single items. (ANeves mentions this in the comments for his interface)
• Consider updating the signature of both your repo.GetOtherItemsN methods to take in parameters in a similar order. It seems strange that one takes in Id, then param1 (as a string), then param2, while the other takes in param1 (unknown type), then param2, then Id. Id should probably come first.
• Consider using a constant/enum value in place of 5 within your if (x.Value > 5) statements. If both classes A and B have a common base class (suggested, given the other answers), I would put it there.
• Building on ANeves answer, I would also pass in an IEnumerable<Item> parameter to the GetItems function, since you use repo.GetItems1 versus repo.GetItems2 in the two classes and you do not do anything more involved than enumerating the collection.

If you are a LINQ-fan, you could also transform this to a LINQ statement:

public IEnumerable<Item> GetItems(IEnumerable<Items> source, Func<Item, Repository> getOtherItems) { if (getOtherItems == null) { throw new ArgumentException(); } var result = from item in source let x = getOtherItems() where x.Value > MIN_VAL select x; } 

If you need it evaluated early rather than lazy-loaded, you just need to toss on a .ToList () or .ToArray() before returning.

After taking Dan and the others suggestions for cleaning up the repository interface, you could also have some benefit from using a common expression for a Linq where statement.

[TestMethod] public void CanUseCommonWhereExpression() { var repo = SetupRepo(); Assert.AreEqual(1, GetItems1(repo).Where(ValueMoreThan(5)).Count()); Assert.AreEqual(2, GetItems2(repo).Where(ValueMoreThan(5)).Count()); Assert.AreEqual( 2, GetItems2(repo).AsQueryable().Where(QueryableValueMoreThan(5)).Count()); } // Fine for in-memory linq private Func<Item, bool> ValueMoreThan(int value) { return i => i.Value > value; } // Also fine for database query translation private Expression<Func<Item, bool>> QueryableValueMoreThan(int value) { return i => i.Value > value; } private static IEnumerable<Item> GetItems2(IRepository repo) { return repo.GetItems2().SelectMany(i => repo.GetOtherItems2(i.Id, 0)); } private static IEnumerable<Item> GetItems1(IRepository repo) { return repo.GetItems1().SelectMany(i => repo.GetOtherItems1(0, i.Id)); } private static IRepository SetupRepo() { var repo = MockRepository.GenerateMock<IRepository>(); repo.Stub(r => r.GetItems1()).Return(new[] { new Item { Id = 1, Value = 3 } }); repo.Stub( r => r.GetOtherItems1(0, 1)).Return(new[] { new Item { Id = 2, Value = 3 }, new Item { Id = 3, Value = 6 } }); repo.Stub(r => r.GetItems2()).Return(new[] { new Item { Id = 4, Value = 3 } }); repo.Stub( r => r.GetOtherItems2(4, 0)).Return(new[] { new Item { Id = 5, Value = 6 }, new Item { Id = 6, Value = 7 } }); return repo; } public interface IRepository { IEnumerable<Item> GetItems1(); IEnumerable<Item> GetOtherItems1(int foo, int id); IEnumerable<Item> GetItems2(); IEnumerable<Item> GetOtherItems2(int id, int bar); } public class Item { public int Id { get; set; } public int Value { get; set; } } 

Create a class that holds your parameters and instead of passing individual parameters, pass in the class object. something like:

class MyClass { public MyClass(){} public int ItemId { get; set;} public string ItemParam1 {get; set;} .... }