A Property or Indexer May Not Be Passed as an Out or Ref Parameter

A property or indexer may not be passed as an out or ref parameter

you cannot use

double.TryParse(objReader[i].ToString(), out bd.Budget); 

replace bd.Budget with some variable.

double k;
double.TryParse(objReader[i].ToString(), out k);

A property or indexer may not be passed as an out or ref parameter while Array Resize

use variable, but not property

var obj = Globals.NameList;
Array.Resize(ref obj , 0);
Globals.NameList=obj;

C# property and ref parameter, why no sugar?

Just for info, C# 4.0 will have something like this sugar, but only when calling interop methods - partly due to the sheer propensity of ref in this scenario. I haven't tested it much (in the CTP); we'll have to see how it pans out...

Why can't I pass a property or indexer as a ref parameter when .NET reflector shows that it's done in the .NET Framework?

I think it is some bad interpretation from Reflector. Actually if you write your code like this:

static void Main(string[] args)
{
DummyClass x = new DummyClass();
string username = x.ClassName;
DoSomething(ref username);
}

and compile it in Release mode you will see this in Reflector:

static void Main(string[] args)
{
DummyClass x = new DummyClass();
DoSomething(ref x.ClassName);
}

Remember that the C# compiler is not producing C# code but IL so what you see in Reflector is not always the reality. So to clearly understand what is going on under the hood you may look at the real code produced by the compiler:

L_000f: callvirt instance string System.Web.Security.MembershipUser::get_UserName()
L_0014: stloc.0
L_0015: ldloca.s str
L_0017: ldc.i4.1
L_0018: ldc.i4.1
L_0019: ldc.i4.1
L_001a: ldc.i4 0x100
L_001f: ldstr "UserName"
L_0024: call void System.Web.Util.SecUtility::CheckParameter(string&, bool, bool, bool, int32, string)

It is clear that a local variable is used.

A property or indexer may not be passed as an out or ref parameter Xamarin.Forms (C#)

The compiler produces an error because you made gimnasios a property instead of a field:

private ObservableCollection<Gimnasio> gimnasios { get; set; }

As the compiler says, you're not allowed to pass a property as a ref parameter.

You probably intended gimnasios to be a backing field for the Gimnasios property, so replace { get; set; } with a semicolon:

private ObservableCollection<Gimnasio> gimnasios;

Is it possible to pass a property as a ref parameter in a setter? c# (avoid a property or indexer may not be passed as an out or ref parameter .)

No, basically.

There is a potential loophole around mutable ref-returning get-only properties, but that probably won't help you because:

  1. you can't have any set logic in a mutable ref-returning get-only property
  2. this is an absurdly niche scenario that the majority of devs don't know exists, and will never need to use :)

A property or indexer may not be passed as an out or ref parameter error

Of course it won't work, because you are updating the local variable v and discarding it after the setter is executed.

You either have to check manually and then rise the property changed event yourself, or you assign v to _wcfObject.SomeProperty afterwards.

public string SomeProperty
{
get { return _wcfObject.SomeProperty; }
set {
var v = _wcfObject.SomeProperty;
Set(nameof(SomeProperty), ref v, value);
_wcfObject.SomeProperty = v;
}
}

That just looks pretty... "odd". Best may be to use proper backing fields, it's bad practice anyways to directly operate on models when wrapping them around, as you can't discard the changes.

private string someField;
public string SomeProperty
{
get { return someField; }
set {
Set(nameof(SomeProperty), ref someField, value);
}
}

public ICommand DoSomethingCommand
{
return new DelegateCommand(DoSomething);
}

private void DoSomething()
{
// apply your ViewModel state to the _wcfObject and do something with it
}

Then your _wcfObject is unaffected by the changes user do, until he initiates an action/command.

Why a property can not be passed as out parameter?

This is valid in VB, but not in C#... VB effectively creates a temporary local variable for you, calls the method passing in the local variable as the argument, and then sets the property with the value of the local variable. C# doesn't usually hide that sort of thing for you.

The method itself needs a variable as the out parameter. It's got to have a storage location it can just write values to. Not a property, not anything it needs to invoke: just a storage location. A property doesn't satisfy that requirement. So there's nothing that can be done by the compiler in the method to allow this.

So either the compiler has to fake it with a temporary variable, as per VB, or disallow it, as per C#. Personally I prefer the C# approach - otherwise it looks as if each time the method assigned a value to the out parameter, the property would be set - which certainly isn't the case.

Why can't I pass indexer as a ref parameter?

An indexer value is not classified as a variable; therefore, you cannot pass an indexer value as a ref or out parameter.

Refer msdn



Related Topics



Leave a reply



Submit