How to pass an arbitrary number of parameters in C#

Question

OK I need to design a way to keep track of how many of each item exists. There are approximately 26 items. I also need a way to find out if a certain combination of items exist.

For example, This is an engine for a card game. Each card has a different type and each card can have card attached to it. There need to be a certain combination of cards attached to a card for the player to do certain things in the game. To make this program streamlined, I would like to do something like

if (meetsCrit(2, water, 4, ground))
{
    do this()
}
else
{
    displayerror()
}

EDIT: SOLVED!

I used a combination of techniques described in a few post below. Special mention to:

Jon Skeet, Rinat Abdullin, Frank,

Anyway here is what I did I made a class called pair which stores the type I'm looking for, and the number of that type. Then I used a Predicate Delegate to find all of that type and count how many there are, Then I compared it to number I was searching for and returned true or false respectively.

This is the code for it

public bool meetsCrit(params Pair[] specs)
{
    foreach (Pair i in specs)
    {
        if (!(attached.FindAll(delegate(Card c) { return c.type == i.type; }).Count >= i.value))
        {
            return false;
        }

    }
    return true;
}

Solution 1

I would take a Predicate which can be evaluated against your data source and then evaluate that, returning the result from the Predicate.

Solution 2

Use params:

The params keyword lets you specify a method parameter that takes an argument where the number of arguments is variable.

No additional parameters are permitted after the params keyword in a method declaration, and only one params keyword is permitted in a method declaration...

Solution 3

Use the params keyword to pass a variable number of arguments:

   private static void HowMayItems<T>(params T[] values) {
        foreach (T val in values) { 
            //Query how many items here..
        }
    }

Also you can create a Predicate and pass it a params filter. In the method you could return the union of all results. Somthing like this:

public class Item { 
    public string Name { get; set; }
}
public class ItemFilter {
    public string Name { get; set; }
    public ItemFilter(string name) {
        Name = name;
    }
    public bool FilterByName(Item i) {
        return i.Name.Equals(Name);
    }
}

public class ItemsTest {
    private static List<Item> HowMayItems(List<Item> l,params ItemFilter[] values)
    {
        List<Item> results= new List<Item>();
        foreach(ItemFilter f in values){
            Predicate<Item> p = new Predicate<Item>(f.FilterByName);
            List<Item> subList = l.FindAll(p);
            results.Concat(subList);
        }
        return results;
    }
}

EDIT:

OK, how about my mixed nuts version :):

public enum ItemTypes{
    Balloon,
    Cupcake,
    WaterMelon
    //Add the rest of the 26 items here...
}

public class ItemFilter {
    private ItemTypes Type { get; set; }
    public ItemFilter(ItemTypes type) {
        Type = type;
    }
    public bool FilterByType(ItemTypes type) {
        return this.Type == type;
    }
}

public class PicnicTable {
    private List<ItemTypes> Items;

    public PicnicTable() {
        Items = new List<ItemTypes>();
    }

    public void AddItem(ItemTypes item) {
        Items.Add(item);
    }

    public int HowMayItems(ItemTypes item)
    {
        ItemFilter filter = new ItemFilter(item);
        Predicate<ItemTypes> p = new Predicate<ItemTypes>(filter.FilterByType);
        List<ItemTypes> result = Items.FindAll(p);
        return result.Count;
    }
}

public class ItemsTest {
    public static void main(string[] args) {
        PicnicTable table = new PicnicTable();
        table.AddItem(ItemTypes.Balloon);
        table.AddItem(ItemTypes.Cupcake);
        table.AddItem(ItemTypes.Balloon);
        table.AddItem(ItemTypes.WaterMelon);
        Console.Out.WriteLine("How Many Cupcakes?: {0}", table.HowMayItems(ItemTypes.Cupcake));
    }
}

Solution 4

A params array is the obvious answer. An alternative is to create a class to represent the criteria. You could then use collection initializers, something like:

bool result = myCollection.Contains(new Criteria {
                 { 2, Item.Balloon },
                 { 4, Item.Cupcake }
              });

But if that's not useful either, we definitely need more information in the question.

If you could provide an example the syntax that you'd like to call the method with, that would certainly help us.

Solution 5

The params keyword allows you to pass an arbitrary number of parameters in non-array form. They will, however, be converted to an array inside the function. I don't know of any programming construct that's going to be different from that in any language.

View more solutions

Comments

[David Morton]

params forces the user to use an array. His post was asking if he could do it in a way without using an array.

[scwagner]

No, params allows you to keep adding parameters to the call, it does NOT require you to use an array.

[David Morton]

May I ask you... what does the data type look like within the method? Isn't it an array?

[Jon Skeet]

+1 to David's comments. If you try to declare a params parameter without it being an array type, you get: error CS0225: The params parameter must be a single dimensional array

[David Morton]

msdn.microsoft.com/en-us/library/aa645765(VS.71).aspx "Parameter arrays", courtesy of the C# language specification.

[Jon Skeet]

scwagner: Please show a legal declaration of the method which doesn't use an array as the parameter type...

[Timothy Carter]

The method would need to be a Method(params T[] arr) declaration, but the caller of the method would not need to create the array. The caller could do Method(t1, t2)

[Jon Skeet]

The caller wouldn't be explicitly creating the array, but I think it's fair to say that the call is still using an array.

[Alan]

It depends how you slice the OP questions. He asks how do you pass an arbitrary number of variables to a method, without using an array. So the caller doesn't have to use an array with the params keyword. So scwagner is right. The implementation will have to use an array, so David is correct too.

[Jon Skeet]

Where did David say the user would know they're using an array? "params" involves using an array. The question asks for a solution which doesn't use an array. Seems pretty straightforward to me.

[Jon Skeet]

The caller uses an array - just implicitly. Furthermore, I'd point out that the question just asks for "a good way to do this other than an array". Where did the "the user doesn't see the array" part come from?

[arkon]

-1 Why don't you at least attempt to answer the question yourself, instead of providing a link that may or may not be dead tomorrow?