ref

I wonder what the difference is between the following methods with regards to how the object parameter is referenced: public void DoSomething(object parameter){} and public void DoSomething(ref object parameter){} Should I use ref object parameter in cases where I want to change the reference to the object not override the object in the same reference? public void DoSomething(object parameter) { parameter = new Object(); // original object from the callee would be unaffected. } public void DoSomething(ref object parameter) { parameter = new Object(); // original object would be a new object }

So this works.. public MyClass(ref Apple apple) { apple = new Apple("Macintosh"); // Works fine } But is it possible to do something like this? private Apple myApple; public MyClass(ref Apple apple) { myApple = apple; } public void ModifyApple() { myApple = new Apple("Macintosh"); // does not change the input variable like the first example did } When the ref variable is copied to the member variable myApple it appears to lose it's 'ref-ness' and re-assigning it no longer changes the input variable. Is there a way around this? Not really, no. By the time your code is next invoked, the original

After some playing around F# member constraints feature and writing function like this: let inline parse< ^a when ^a : (static member Parse: string -> ^a) > s = (^a: (static member Parse: string -> ^a) s) That works perfectly fine: let xs = [ "123"; "456"; "999" ] |> List.map parse<int> I'm trying to write other func tryParse , that uses static method TryParse and wraps the parse result into 'a option type for better support in F#. Something like this doesn't compiles: let inline tryParse s = let mutable x = Unchecked.defaultof< ^a> if (^a: (static member TryParse: string * ^a byref -> bool)

This question already has an answer here: What is the use of “ref” for reference-type variables in C#? 10 answers someone in my team stumbled upon a peculiar use of the ref keyword on a reference type class A { /* ... */ } class B { public void DoSomething(ref A myObject) { // ... } } Is there any reason someone sane would do such a thing? I can't find a use for this in C# Let class A { public string Blah { get; set; } } void Do (ref A a) { a = new A { Blah = "Bar" }; } then A a = new A { Blah = "Foo" }; Console.WriteLine(a.Blah); // Foo Do (ref a); Console.WriteLine(a.Blah); // Bar But if

I'm trying to create a function that can create an Action that increments whatever integer is passed in. However my first attempt is giving me an error "cannot use ref or out parameter inside an anonymous method body". public static class IntEx { public static Action CreateIncrementer(ref int reference) { return () => { reference += 1; }; } } I understand why the compiler doesn't like this, but nonetheless I'd like to have a graceful way to provide a nice incrementer factory that can point to any integer. The only way I'm seeing to do this is something like the following: public static class