Hello and welcome.

I'm Jeremy, in this workshop,

we'll see how to use generics to create our own types of data structures.

Data structures are classes that help to organize and use data efficiently.

For example, lists and dictionary are data structures provided by the .Net Framework.

The .Net Framework refers to these data structures as collections

because they're used to organize collections of things.

List and dictionary are also examples of generic classes.

You probably remember from previous courses that we can specify

what type of object we want a list to contain by putting the name of the type

between these two angle brackets when we instantiate the list.

This is called the generic type parameter.

And it's what makes list a generic class.

We use generic classes like list all the time, but in order to really understand

how generics and collections work, it's best to implement our own.

In fact, writing your own data structures to help you work with

data can help keep your code clean and readable.

You'll find that data structures you write to help you solve one problem

can often be reused the next time you run into a similar problem.

Coding them as generic classes makes them even more usable.

Let's start writing our own generic data structure.

I'll be writing the code for this workshop using Visual Studio.

If you're new to Visual Studio, you can get familiar with it by

following the link to the tree house workshop in the teacher's notes.

Of course, you don't have to use Visual Studio to code in C-sharp.

You can use any editor you want or

even open a Treehouse workspace by clicking on the button on this page.

Let's get going.

I'm in Visual Studio and I've created a console application project.

I've named this project GenericsDemo.

In program.cs, I've created four different collections of integers,

two lists, a HashSet and an array.

Let's say we wanted to count all of the odd

numbers contained in these four collections.

How could we do that?

I've already written a method to determine if a value is odd or not.

Now for each collection, we can loop through each value in the array and

check if it's odd.

We'll increment a counter for each odd number we find.

Let's see what the code for this looks like.

So I'll start by making an integer variable and

I'll name it numOdd, I'll set it equal to 0.

This will help us keep track of how many odd numbers we've encountered.

Now I'll say, foreach var value in list1.

If, and then we'll call the IsOdd method and pass in value.

So if it's odd, we'll increment numOdd, so I'll say numOdd ++.

Now we just need to do this with the other three collections.

So I'll copy this code, And

I'll paste it and each time, I'll change it to the next collection name.

So this one will be list2.

I'm going to do this two more times.

So this one is for set1.

And the last one is for array1.

There we go.

So this code loops through each collection and

increments numOdd for each odd number that it finds.

We could do anything we wanted with each value in these collections.

But we'd have to repeat it inside of each loop.

There's got to be a better way.

We could shorten the substantially using LINQ.

If you're unfamiliar with LINQ,

you'll find a link to a great course about it in the teacher's notes.

So to use LINQ, I'll first have to go up here and add a using directive.

So I'll say using System.LINQ.

This allows us access to all of the extension methods defined in LINQ.

Now it's write our LINQ expression.

Our LINQ expression will replace all of these foreach loops.

So I'll just say numOdd equals list1.Count.

So here I'll write a lambda expression where x is the value.

So say x, for each x call IsOdd and pass an x.

We'll call Count on each collection and add up the results.

So this is for list2.

And set1,

And array1.

That's certainly less code, but

we're still repeating the calls to count and IsOdd four times.

What we'd really like to be able to do is loop through these collections

as if they're all one collection.

It's not unreasonable to think that this is something that would be useful for

more than just this case.

So we should write some code that does this in a reusable way.

To do this, we'll write our own data structure that takes a bunch of

collections and makes them behave like a single collection.

We can make it a generic collection so that it can be used for

not just integers, but any type of object that a collection can contain.

We'll call this new collection type and an enumerable composite.

And we'll start coding it in the next video.

While we make this new collection type, we'll also be learning the ins and

outs of generics as well as how to implement the IEnumerable interface.

IEnumerable is the interface that every collection type implements.