Is there a way to create and return new variables from a method in C#?

Question

Basically like using the out keyword. But the problem is with the out keyword, you still have to declare a variable outside the method call, like:

double result;
Double.TryParse ( "76", out result );

where as I want something like:

Double.TryParse ( "76", out result );

and there I get a new variable called result.

Is there a way to do this (by using out or not)?

Answer 1

No, you have to declare the variable first because you are passing it to the method, the only difference is that you are explicitly requiring the method to fill it out before returning.

Answer 2

What's the problem with declaring it before the call?

Answer 3

Why are you trying to do this? There's no reason not to declare it before the method call, save the few keystrokes.

Answer 4

Is there any case with a sence for your szenario?

In order to use the variable after the call to your function, you have to know the type of the variable. Otherwise you would ignore the type-safety of the compiler and could easily run into runtime-errors.

Answer 5

Also, you can "rethrow" it, that is, you pass it up the stack as an out again. For example:

public void MyMethod(out int MyParam)
{
    SomeMethod(out MyParam);
}

Answer 6

variables live on the stack, not the heap, so the notion of calling a function to create new variables - while an interesting idea and not impossible in other languages - implies that you don't understand the difference between a variable and an object in C#.

• a variable's storage is allocated on the stack, and the variable only exists for the duration of the execution of the function that declares the variable

this is distinct from a 'member variable' which is a field belonging to an object.

the 'out' keyword in C# means that a variable will be passed into the function 'by reference', and the function is expected to (required to) set the variable's value.

in general, 'out' parameters should be avoided; if you need to pass several values out of a function, they probably belong to a missing object!

EDIT: in C# an 'out' parameter is similar to a 'ref' parameter in that they are both call-by-reference parameters, as opposed to the more typical call-by-value parameter.

Answer 7

No, you have to wrap it in another method that declares a local variable and then returns it.

With the specific example you gave, you can just use:

Double d = Double.Parse( "76" );

Answer 8

You can use C# tuples to compose multiple variables into one.

Answer 9

A variable must be declared before it is used and a method with more than a few parameters gets smelly quick. Output parameters especially.

I think what you want to do is declare a class that contains your five or six variables and pass that as the argument to the method:

class Args
{
  public int One { get; set; }
  public int Two { get; set; }
  public int Three { get; set; }
  public int Four { get; set; }
  public int Five { get; set; }
}

Then a method taking it as an argument:

public void Foo(Args args)
{
  // Modify members of args here.
}

And use it like this:

Args args = new Args();

Foo(args);

// Do stuff with results in args.