There is a way to declare a method with a collection of anonymous type as parameter?
for example somethings like this pseudo syntax :
private void dosomething ( List<class with { string Name, string Lastname, int Age }> persons) {
...
}
To avoid creating a single use class.
UPDATE What I want is to avoid the definition of a class that I will use only for passing data to this method.
update
Your question is a bit confusing.
According to your first part of the question I think you need a generic method.
private void dosomething<T>(List<T> items) {
...
}
but after looking at the code you wrote you just need an interface IPerson
public interface IPerson
{
Name { get; set; }
LastName { get; set; }
Age { get; set; }
}
private void dosomething(List<IPerson> persons) {
...
}
Name, Lastname or Age in the method, though.
T is restricted further to an interface that includes the respective attributes, it comes close. (And certainly much closer than using the dynamic keyword.)
You should make a class for this anonymous type because an anonymous type cannot be passed in a strong manner outside the scope of an individual method, because there is no way to represent it outside the method's scope. But if you really don't want to, you could use dynamics:
public void DoSomething (IEnumerable<dynamic> list)
{
foreach (dynamic item in list)
{
string name = item.Name;
string lastName = item.LastName;
int age = item.Age;
}
}
Note that this is not strongly typed, so if, for example, Name changes to EmployeeName, you won't know there's a problem until runtime.
ideal solution would be to create a class. And as per OP question he want's to pass an anonymous types as parameter for which i suggested can be done using dynamic.
You can do this with a dynamic keyword, although you will lose strongly typed properties.
private void doSomething (List<dynamic> persons)
{
var name = persons.FirstOrDefault().Name;
}
string Name, string Lastname, int Age *, not just any anonymous types. And in fact, I have upvoted the answer that suggests generics.dynamic keyword won't work. The solution with a generic type avoids the requirement of defining a new class, but - as C# doesn't allow to restrict arguments by attribute lists - the eligible types have to implement an interface, which is as close as we can get to what the OP asked.
private void dosomething<T> (List<T> ...