Each function or method can only ever return a zunächstmal information. This is expressed by the return value or return parameters. What do you do but if you want to return in a way more information that maybe will even be optional? One possibility is of course a complex data type to define and designate these as the return type of the method. For convenience, but rather not make the man.
a most pragmatic approach is to provide the additional return values each out to define parameters. The out parameters are generally primitive data types such as string or int .
In. NET Framework, there are some methods which have a out parameters. A class is often used as the Dictionary .
Here's an example:
var dict = new
Dictionary \u0026lt;string , int> ();
dict.Add ( "A" , 1);
dict.Add ( "B" , 2);
We are now trying to pull values from the dictionary. Since it can not be guaranteed that the value sought is in the dictionary, we use the method TryGetValue . Since this is now a out parameters defined, we need before we can call this method a variable with the corresponding parameter type out and define the method with the return value of variable aufrufen.Der TryGetValue is a bool so that can be seen, whether the value in the Dictionary is available. Only if the value exists, also has the variable value. But be careful! Since int is a value type, he always has a default value, which is 0 For safety, one should therefore out variables to assign a value other than the default value at int example: -1 instead o.
int value = -1;
var success = dict.TryGetValue ( "A" , value);
if (success) {
Console WriteLine (value). ;
}
extent is likely to be clear and certainly have been made many times. For me, the above method, as TryParse a legitimate reason to use out parameters. All other reasons are of secondary importance since convenience is a priority. They want to halt any complex data types to create only one return parameter.
But there is another way: # F!
F # to the rescue
Because F # is a normal. NET is language, of course you can also call the classes of the framework. For example, the methods out define parameters such as as the Dictionary. How does F # with it?
In F # we can normally produce a dictionary.
open System.Collections.Generic
let dict = new Dictionary \u0026lt;string,int> ()
Now, we add values to the Dictionary
dict.Add ( "A" , 1)
dict.Add ( "B" , 2)
Finally, we want to read the values again.
let result = dict.TryGetValue ( "A" )
Now what type of result is now? And why do you not pass a out parameters?
F # Interactive is the answer.
val result: bool * int = (true, 1)
Result is of type bool * int
what is means in F # that this is a tuple. . NET 4.0 can describe this as Tuple \u0026lt;bool,int>
.
Now we can use this tuple to the functions fst and disassemble snd .
let success = fst result
val success: bool = true
let value = snd result
val value: int = 1
F # F # would not be if it could not even express simple. One can namely the tuple directly into its component parts.
let (success, value) = dict.TryGetValue ( "A" )
val value: int = 1
val success: bool = true
let (success, value) = dict.TryGetValue ( "C" )
val value: int = 0
val success: bool = false
Conclusion
to me that this is a good example of how expressive is F #. In the Vergangeneheit many errors in the programming language design have been made. Above all, C + +, but unfortunately, even with C #. Tuples are a Brilliant means to avoid out parameters. Since tuple. NET 4.0 is a "first class" data type, there is no reason to do so in C # to a hollowing out as an alternative to parameters. Ultimately, it makes more fun but with F #!
Over and out !
