\n
![\"\"](\"http:\/\/mariusbancila.ro\/blog\/wp-content\/uploads\/2017\/03\/sorefout.png\")
<\/a><\/p>\nC# 7 has extended the way these modifiers can be used:<\/p>\n
- \n
- out<\/tt> variables can be declared inline and used in the outer scope<\/li>\n
- ref<\/tt> can be used for locals and return values from functions<\/li>\n<\/ul>\n
out variables<\/h2>\n
Prior to C#7, arguments passed to out<\/tt> parameters had to be declared before they are used. The following is a typical example:<\/p>\n
var text = \"42\";\r\nint value;\r\nint.TryParse(text, out value);\r\nConsole.WriteLine(value);<\/pre>\n
The new change allows the declaration of the out variable inline where it is actually used.<\/p>\n
var text = \"42\";\r\nint.TryParse(text, out var value);\r\nConsole.WriteLine(value);<\/pre>\n
You can either specify an explicit type, or use the var<\/tt> keyword and let the compiler infer the type.
\nThe scope of the variable declared in this manner is leaked into the output scope of the statement where it appears.<\/p>\nref locals and returns<\/h2>\n
The ref<\/tt> modifier has been extended to be used with local variables and return values.<\/p>\n
Local variables can be declared with the ref<\/tt> modifier, in which case the variable is a reference to another storage. Local references must be initialized upon declaration, and cannot be assigned values (i.e. ref var i = 42;<\/tt>).<\/p>\n
var i = 42;\r\nref var ri = ref i; \/\/ reference to i\r\nri = 43;\r\nConsole.WriteLine(i); \/\/ prints 43<\/pre>\n
On the other hand, functions can return references to variables. In this case the ref<\/tt> modifier needs to be used both on the return type declaration and on every return statement.<\/p>\n
In the following example Container<\/tt> is an implementation of a container that internally stores an array of elements of type T<\/tt>. Method at()<\/tt> takes an argument that represents the index of an element and returns a reference to that element, or throws an exception if the index is out of bounds. The return type is declared as ref T<\/tt> and the return statement is return ref<\/tt>.<\/p>\n
class Container<T>\r\n{\r\n private T[] data;\r\n\r\n public Container(int size = 16)\r\n {\r\n data = new T[16];\r\n }\r\n\r\n public ref T at(int index)\r\n {\r\n if(index >= 0 && index < data.Length)\r\n return ref data[index];\r\n\r\n throw new IndexOutOfRangeException();\r\n }\r\n}\r\n<\/pre>\nHaving an instance of this Container<\/tt> class we can gain access to its elements in order to read or write them using the at()<\/tt> method. Elements can be assigned new values directly (c.at(0) = 42;<\/tt>) or could be bound to local variables. <\/p>\n
\r\nvar c = new Container<int>();\r\nc.at(0) = 42;\r\nConsole.WriteLine(c.at(0)); \/\/ prints 42\r\n\r\nvar r1 = c.at(1);\r\nr1 = 42;\r\nConsole.WriteLine(c.at(1)); \/\/ prints 0\r\n\r\nref var r2 = ref c.at(2);\r\nr2 = 42;\r\nConsole.WriteLine(c.at(2)); \/\/ prints 42<\/pre>\n
There is an important difference between the last two examples:<\/p>\n
- \n
- var r1 = c.at(1);<\/tt> the value of the second element in the container is copied to the local variable r1<\/tt>, even though the function returned a reference. Modifying this local variable will not affect the element in the container.<\/li>\n
- ref var r2 = ref c.at(2);<\/tt> defines r2<\/tt> as a reference to the third element in the container, and therefore modifying the local variable will actually modify the element in the container.<\/li>\n<\/ul>\n
Returning a references to a local variable is not allowed (as its scope ends when the function returns, which would make the reference point to a storage that no longer exists).<\/p>\n
public ref int func()\r\n{\r\n var i = 42;\r\n return ref i; \/\/ error\r\n}<\/pre>\nYou can read more about these changes in this article, What’s new in C# 7<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
In C#, function parameters can be declared with the ref or out modifier, the former indicating that a value is already set and the function can read and write it, and the later that the value is not set and the function must do so before returning. As a side note, there is a good … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[11],"tags":[509,451,510,511],"class_list":["post-2422","post","type-post","status-publish","format-standard","hentry","category-csharp","tag-c7","tag-c","tag-out","tag-ref"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t
- ref var r2 = ref c.at(2);<\/tt> defines r2<\/tt> as a reference to the third element in the container, and therefore modifying the local variable will actually modify the element in the container.<\/li>\n<\/ul>\n
- ref<\/tt> can be used for locals and return values from functions<\/li>\n<\/ul>\n