method parameters: when to use "out" with a List parameter...

  • Thread starter Thread starter Ojas
  • Start date Start date
O

Ojas

I'm wondering if there is a best practice for when you have a C#
method parameter that is a List object that is loaded by the method.
It basically is an "out" parameter. Normally I would have the caller
allocate the List object and pass it in such as example 1. However,
if I use example 2, where I declare it an "out" then that has its own
advantages.

EXAMPLE 1:

void mymethod(List<string> abc)
{
If (abc == null)
{
// throw error
}

abc.Clear();

abc.Add("hello");
abc.Add("world");
}

====

versus

=====

EXAMPLE 2:

void mymethod(out List<string> abc)
{
abc = new List<string>();

abc.Add("hello");
abc.Add("world");
}
 
Ojas said:
I'm wondering if there is a best practice for when you have a C#
method parameter that is a List object that is loaded by the method.
It basically is an "out" parameter. Normally I would have the caller
allocate the List object and pass it in such as example 1. However,
if I use example 2, where I declare it an "out" then that has its own
advantages.

EXAMPLE 1:

void mymethod(List<string> abc)
{
If (abc == null)
{
// throw error
}

abc.Clear();

abc.Add("hello");
abc.Add("world");
}

====

versus

=====

EXAMPLE 2:

void mymethod(out List<string> abc)
{
abc = new List<string>();

abc.Add("hello");
abc.Add("world");
}
Click to expand...

Generally avoid ref and out parameters if you can.

The obvious choise here would be to use the return value:

List<string> mymethod() {
abc = new List<string>();

abc.Add("hello");
abc.Add("world");

return abc;
}
 
Ojas said:
I'm wondering if there is a best practice for when you have a C#
method parameter that is a List object that is loaded by the method.
It basically is an "out" parameter. Normally I would have the caller
allocate the List object and pass it in such as example 1. However,
if I use example 2, where I declare it an "out" then that has its own
advantages.

EXAMPLE 1:

void mymethod(List<string> abc)
{
If (abc == null)
{
// throw error
}

abc.Clear();

abc.Add("hello");
abc.Add("world");
}

====

versus

=====

EXAMPLE 2:

void mymethod(out List<string> abc)
{
abc = new List<string>();

abc.Add("hello");
abc.Add("world");
}
Click to expand...

Generally avoid ref and out parameters if you can.

The obvious choise here would be to use the return value:

List<string> mymethod() {
abc = new List<string>();

abc.Add("hello");
abc.Add("world");

return abc;
}
 
Göran,

For this example, the real world usage I'm working on has multiple
"out" List objects for one method, something like...

void mymethod(out List<string> greatProducts, out List<string>
goodProducts, out List<string> okProducts, out List<string>
failingProducts);

if the method had just one list then I would likely return it rather
than use a ref/out parameter :)
 
Göran,

For this example, the real world usage I'm working on has multiple
"out" List objects for one method, something like...

void mymethod(out List<string> greatProducts, out List<string>
goodProducts, out List<string> okProducts, out List<string>
failingProducts);

if the method had just one list then I would likely return it rather
than use a ref/out parameter :)
 
Simply return a List<List<string>> object

List<List<string>> mymethod()
{
...
}


List<List<string>> _lists = mymethod();
List<string> greatProducts = _lists[0];
List<string> goodProducts = _lists[1];
List<string> okProducts = _lists[2];
List<string> failingProducts = _lists[3];


Göran,

For this example, the real world usage I'm working on has multiple
"out" List objects for one method, something like...

void mymethod(out List<string> greatProducts, out List<string>
goodProducts, out List<string> okProducts, out List<string>
failingProducts);

if the method had just one list then I would likely return it rather
than use a ref/out parameter :)
 
Simply return a List<List<string>> object

List<List<string>> mymethod()
{
...
}


List<List<string>> _lists = mymethod();
List<string> greatProducts = _lists[0];
List<string> goodProducts = _lists[1];
List<string> okProducts = _lists[2];
List<string> failingProducts = _lists[3];


Göran,

For this example, the real world usage I'm working on has multiple
"out" List objects for one method, something like...

void mymethod(out List<string> greatProducts, out List<string>
goodProducts, out List<string> okProducts, out List<string>
failingProducts);

if the method had just one list then I would likely return it rather
than use a ref/out parameter :)
 
Ojas said:
Göran,

For this example, the real world usage I'm working on has multiple
"out" List objects for one method, something like...

void mymethod(out List<string> greatProducts, out List<string>
goodProducts, out List<string> okProducts, out List<string>
failingProducts);

if the method had just one list then I would likely return it rather
than use a ref/out parameter :)
Click to expand...

Simply create a class to handle a return value with multiple values:

public class ProductsLists {

public List<string> GreatProducts { get; set; }
public List<string> GoodProducts { get; set; }
public List<string> OkProducts { get; set; }
public List<string> FailingProducts { get; set; }

}
 
Ojas said:
Göran,

For this example, the real world usage I'm working on has multiple
"out" List objects for one method, something like...

void mymethod(out List<string> greatProducts, out List<string>
goodProducts, out List<string> okProducts, out List<string>
failingProducts);

if the method had just one list then I would likely return it rather
than use a ref/out parameter :)
Click to expand...

Simply create a class to handle a return value with multiple values:

public class ProductsLists {

public List<string> GreatProducts { get; set; }
public List<string> GoodProducts { get; set; }
public List<string> OkProducts { get; set; }
public List<string> FailingProducts { get; set; }

}
 
Back
Top