Params Keyword With IEnumerable In C# 6.0

static int Sum(params int[] values)
{
    // Method body goes here
}

using System;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int result = Addition(12, 22, 33);
            Console.WriteLine("The sum of num1, num2, and num3 is: " + result);
            Console.ReadLine();
        }
        public static int Addition(int num1, int num2, int num3)
        {
            return num1 + num2 + num3;
        }
    }
}

using System;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int result = Addition(1, 2, 3, 4, 5, 6, 7, 8, 9);
            Console.WriteLine("The sum of numbers from 1 to 9 is: " + result);
            Console.ReadLine();
        }
        public static int Addition(params int[] listNumbers)
        {
            int sum = 0;
            foreach (int i in listNumbers)
            {
                sum += i;
            }
            return sum;
        }
    }
}

The IEnumerable interface

ienumerable<T> works like an interface. Here, we can enumerate any type of instances that we want to enumerate. It is a generic interface generated using the query expression. The query expression is the ienumerable<T>. Here, T will be an int, float, or maybe anything. The ienumerable interface is found in the System. Collection namespace and has a single method in it. I think you will understand it with a simple example, so I will provide an example of ienumerable. Let's see it.

using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> names = new List<string>(); // This is the use of generics
            names.Add("Rizwan");
            names.Add("Shridhar");
            names.Add("Abhishek");
            names.Add("Nimit");
            names.Add("Gaurav");
            names.Add("Atul");
            IEnumerable<string> ienum = (IEnumerable<string>)names; // Use of IEnumerable
            foreach (string i in ienum)
            {
                Console.WriteLine(i);
            }
            Console.Read();
        }
    }
}

Output

That is an overview of params and ienumerable. I think now you can easily work with params and ienumerable. So we will proceed further to discuss the latest features of C# 6.0, that is, the params Ienumerable.

As I said above, you cannot use another keyword in a single method when you use the params keyword in a method. So before the new C# 6.0, you could not do this, but now C# 6.0 provides the ability to use ienumerable with the params keyword.

Now, it is not necessary to declare the params method as an array, so there are some changes in it. Params ienumerable provides the ability to use ienumerable<T> instead of T[ ] when we use a params method.

Before we use it like.

public void method(params int[] values)
{
    // Your method implementation here
}

Now, C# 6.0 provides us with a new technique to write this like.

public void method(params IEnumerable<T> values)
{
    // Your method implementation here
}

Now, I will provide an example of params with innumerable.

Example

using System;
using System.Collections.Generic;
namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> a = new List<string>(); // This is the use of generics
            a.Add("Rizwan");
            a.Add("shridhar");
            a.Add("Abhishek");
            IEnumerable<string> ienum = (IEnumerable<string>)a;

           foreach (string i in ienum)
            {
                Console.WriteLine(i);
            }
            Console.Read();
        }
        public static class uses<T>
        {
            public static IEnumerable<string> Chain(params IEnumerable<string>[] arguments)
            {
                foreach (IEnumerable<string> a in arguments)
                {
                    foreach (string value in a)
                    {
                        yield return value; // Yield is a keyword
                        Console.Read();
                    }
                }
            }
        }
    }
}

Output

Summary

So, in this article, I provided you information about the Params keyword with ienumerable. Before C# 6.0, we could not use ienumerable with the params keyword, but now we can use it. We write ienumerable<T> instead of int[ ] with params. So, we can say it reduces our code, and the main advantage of using params with ienumerable is that we can provide the parameters depending on our needs. If we did not use params with innumerable, then every time, we would need to provide the parameters depending on the method definition. So to overcome that problem we use it. I think this is a good feature provided by C# 6.0.