We just saw how we can write stand-alone generic methods

when we wrote the take method.

The cool thing about generic methods is that C#

can infer what the type perimeter is so we don't have to type it here.

That's one of my favorite things about generic methods, we can use this feature

to simplify instantiating the EnumerableCompositor Class.

So, let's go back to EnumerableCompositor.cs.

First, we'll create another class name, EnumerableCompositor, but

this time it won't be generic.

Will also make it a static class since it will only contain static methods.

So, say static class EnumerableCompositor one

common pattern is to write a method that takes care of the instantiation for us.

This is known as a factory method.

So, save public, static, and it will return and in EnumerableCompositor.

So, say in EnumerableCompositor the generic one T.

i will name the method create, since it will be used to

create an EnumerableCompositor.

We'll specify the type parameter here and it will accept and IEnumerable

of T, and will just have it, except an array of IEnumerables.

We'll call it collections and

it will return a new instance of EnumerableCompositor and

we'll just pass in collections here.

So, this create method is taking an array of collections and then

passing that array of collections to the constructor of a EnumerableComposite of T.

To create a new instance and then returning it.

Now, in main to get and EnumerableCompositor we can change this

to EnumerableComposite.Create and

we'll pass in our array of collections.

So, say new IEnumerable.

And I'll split this up on two lines we can see it easier.

And this is an array.

Because create is a generic method C# was able to infer what the type parameter is.

However, we lost the ability to use the collection initializer instead we have to

pass in array of collections we want the EnumerableCompositor to be composed of.

C# has another neat feature that allows passing

any number of parameters into a method.

Back in the create method,

we can add a params keyword here in front of the collections parameter.

Now we can go back to where we're calling create.

Notice that there are no red squiggly lines.

And we can still pass in an array.

However, because we added the params keyword,

we can also just list the collections here as if they're normal parameters.

The params keyword allows passing in any number of parameters that are of the type

in the array.

There's a caveat though, only the last parameter of the method

can have the params keyword In this case we only have a single

parameter in the create method and it's an array of a IEnumerable T.

So when calling create we can pass in as many IEnumerable of T,

as we want just as if there are normal parameters to the method.

They all get put in a single array which we can treat just like a regular rate.

In this case we're just passing the array to the constructor

of EnumerableCompositor.

With the static create method we can now create an instance of

innumerable compositor without specifying the type or using the new keyword word.

This is so streamlined that we can copy this right into the for each loop.

EnumerableCompositor dot create is still a lot to type just to wrap

a bunch of collections.

So that they can be enumerated as a single collection.

Let's make it, so that we don't have to type in EnumerableCompositor any more.

We do that with a using static directive at the top of the file.

So we can say, using static Generics Demo.EnumerableCompositor.

This means that we can call static methods in the EnumerableCompositor class

without prefixing them with the class name.

So, we can change this to just create.

But without the class name it's hard to tell what we're creating here.

Let's just change the name of the create method to EC.

In Visual Studio, I can do a rename by clicking on it and hitting control RR.

I'll type in EC here.

Notice that it also changed back in the method declaration.

Now, this is all we need to create and new EnumerableCompositor.

And because in EnumerableCompositor is IEnumerable we can use

any link method on it.

So, to count all of the odd integers contained in all of these collections

we can just do this down here.

By leveraging the power of IEnumerable, Yield and Generics,

we've been able to create a very elegant solution

to a common problem that can be used for any group of collections.

Now, instead of writing for foreach loops that all have duplicate code in them,

we've been able to reduce it to a single line of code that's very readable.

I like the core logic of my code to be as simple and readable as possible, so

I find myself making lots of methods in classes like these

to pull out anything that isn't part of the core logic.

These methods and classes, like the EnumerableCompositor class and

the EC method, can often be re-used.

They get added to my toolkit and

I often find myself using them again in later projects.

This often means writing custom data structures by implementing IEnumerable or

another generic interface such as ICollection, IList, ISet or IDictionary.

All of those interfaces inherit from IEnumerable.

So, you will use the same principles we've discussed here

when implementing those interfaces as well, we're not done yet.

No discussion of generics is complete without learning how to limit

what can be used as a generic parameter.

We'll learn about generic constraints in the next video.