Part 79 Sort a list of complex types using Comparison delegate Video Lecture | C sharp: Enhance your Skills (English) - Back-End Programming

this is part 79 of c-sharp tutorial in
this video we'll discuss sorting a list
of complex types using comparison
delegate this is continuation to part 78
so please watch about 78 from the scene
shop tutorial before proceeding with
this video one of the old loads of the
sort method in list class expects a
comparison delegate to be passed as an
argument so at the moment if we look at
this list customers this is a list of
type customer objects and if you look at
this sort method there are several
overloaded versions of this method and
in the previous session of this video
series we have discussed using this
overloaded version which doesn't take
any parameters we also discussed using
this overloaded version which expects an
object of type I compare in this video
we're going to discuss this overloaded
version which expects an instance of
this comparison delegate so what's the
delegate in c-sharp a delegate is
nothing but a function pointer meaning a
delegate will be pointing to a function
and then when you invoke that delegate
it's going to automatically invoke the
function to which it is pointing to and
if you want a delegate to point to a
function then the signature of that
function must match with the signature
of the delegate which it is pointing to
so that's the reason why these delegates
are called type save function pointers
and now if I have to use this overloaded
version first of all I have to create a
function to which this delegate will be
pointing to and the signature of that
function has to match with the signature
of this delegate so first of all let's
look at the signature of that delegate
so comparison of type customer let's
right-click on that and go to the
definition and if we look at this
delegate it is returning an integer and
then it expects two objects of type T
okay so let's copy the signature and
then within our class let's include a
method so this is going to be a static
method and it's going to return an
integer and then
we are going to pass two instances of
our customer object okay and basically
let's give this method a meaningful name
maybe let's call this compare customer
okay so basically let's say we want the
list of customers to be sorted you know
based on their ID okay so we have to
tell that to the customer class and how
do we do that basically using this
method okay so return so we have two
instances of customer class here x and y
so return X dot ID and ID is an integer
property and this integer type has
already provided the implementation for
compareto method so we're going to make
use of that implementation so compare
the ID of this customer object X with
the ID of customer object Y and what is
this method returning it is returning an
integer back and our function is also
returning an integer back so basically
this is the method which will tell how
we want these customer objects to be
sorted now the next step is to create an
instance of comparison delegate so maybe
let's call this customer compare and to
the constructor of this delegate we need
to pass the name of the function to
which we want this delegate to point to
so basically we want the Stila gate to
point to this function look at this this
delegate expects you know a function to
have an integer
I mean return type as integer and that
function should have two customer
objects as parameters so here
the signature of this method matches
with the signature of this delegate so
we can pass the name of this function to
this constructor
okay so the next step is to basically
pass this instance to our sort method so
list customers dot sort and then we are
going to use this overloaded version
which expects an instance of comparison
delegate and we have an instance here so
let's pass that and then let's print the
customer list using a for each loop so
for each customer let's call it say in
our list of customers let's print their
IDs so C dot ID and basically this is
before we have sorted so let's say
before sorting and let's copy these
lines of code and then print the
customer list once again after sorting
okay so let's go ahead and run this now
look at that that's before sorting and
this is after sorting okay basically we
want to change this text after sorting
alright so basically what we have done
so far three steps we create a function
and the signature of that function has
to match the signature of the delegate
the comparison delegate basically and
then we created an instances of the
instance of the delegate and that
instance is pointing to that function
and then we passed that instance as an
argument to the sort method on the list
instance okay now there's a lot of you
know steps there do we really have to do
all these steps not really we can
achieve that using delegate keyword in
just you know one line like this so
let's look at that in action so instead
of you know creating a private function
here and then creating an instance of a
delegate and then passing that instance
to the sort method instead of doing all
that basically I can get rid of this
function altogether
and I can also get rid of creating an
instance of the delegate here and all
I'm going to do he is you know what is
this method expecting it is expecting a
delegate so I'm going to pass a delegate
here and then this delegate expects to
customer objects maybe let's call it c1
and another customer object c2
okay and then let's include the body for
this delegate and what should this
delegate do this delegate basically
should return an integer using this
delegate we have to tell the sort method
how to sort our list of customer objects
so we want to sort of a list of
customers using their ID and we have two
customer objects here so we are going to
tell the sort method how we want them to
be compared so return C 1 dot ID dot
compare to with C 2 dot ID so it's as
simple as that so let's run this control
f5 and look at this we have the same
output but again there's a quite a bit
of code and it's a little bit confusing
okay
usage of this delegate keyword now
instead of that I can still simplify
this by using a lambda expression like
this okay so let's look at using lambda
expression so instead of that so
obviously what we need here we need to
customer objects so you can give it any
meaningful name you want maybe c1 c2 or
X comma Y give it any meaningful name
you want so I have two customer objects
such that X dot ID dot compare that with
y dot ID so it's as simple as that as
simple lambda expression so now we run
it and look at that we have the same
output
that's it for today thank you for
listening have a great day