One-branch ternary and/or keep-value initiailization

[Wallby]

I tried searching the discussions, but I don't have time to go through 10 pages of them. So if this is a duplicate, well, that is just how it is.

I was wondering if there is a way to do something like this:

void StartProcessAndMore(string path, string workingDirectory? workingDirectory)
{
	var info = new ProcessStartInfo(){
		WorkingDirectory = workingDirectory ? workingDirectory : value // value keyword the same as in property accessors
	};
	Process.Start(path, info);
}

That doesn't seem like a helpful way to implement this, as that would make this functionality unusable in property accessors.

The keyword default I assume always uses the default for the type, not the default value in a signature of a type or function (overload)?

So for example like this, keeping the default value of the signature, not the type's default constructor:

Process.Start(path, info ? info : default);

Something like this for example, was also a way of solving what I was trying to solve (making specific properties inaccessible to avoid confusion due to accidental duplication, as above with workingDirectory):

class ProcessStartAndMoreInfo : ProcessStartInfo
{
	// Ignored, so don't allow setting (like if "C++ = delete", would be possible on inherited types, properties and methods)
	private override bool RedirectStandardOutput;
}

In C++ (20 or later), this can be done using a template constraint I expect?

Any way to solve this problem in C#?

[CyrusNajmabadi]

	var info = new ProcessStartInfo(){
		WorkingDirectory = workingDirectory ? workingDirectory : value // value keyword the same as in property accessors
	};

Do:

var info = new ProcessStartInfo();
if (workingDirectory != null) info.WorkingDirectory = workingDirectory;

[Wallby]

I mixed up your comment with someone else's. Or misread it. What you wrote is what I already have. As I said, what I'd want is a way to reduce the redundant copy of the variable name workingDirectory (once in the if statement's expression, and once in the assignment's rhs expression).

[Wallby]

Oh no you did actually write that. But it's your other reply, not this one. The one with info ? info : default.

[CyrusNajmabadi]

s I said, what I'd want is a way to reduce the redundant copy of the variable name workingDirectory

Got it. But i don't understand why this isn't suitable:

new ProcessStartInfo()
{
  WorkingDirectory = workingDirectory,
}

[Wallby]

I meant the case of

new ProcessStartInfo() {
	WorkingDirectory = workingDirectory ? workingDirectory : null
}

If this assumed ProcessStartInfo.WorkingDirectory defaults to null. If the definition of ProcessStartInfo ever changes, let's say WorkingDirectory is currently null, and in the future it becomes an empty string (whether or not that is realistic doesn't matter for the example). And this function I implemented assumes that it is still null, that can lead to confusing behaviour given that I am using this case for an extension method for the Process class. So a developer would expect it to be consistent with the standard functions, using the same default value.

[GeeLaw]

what I'd want is a way to reduce the redundant copy of the variable name workingDirectory (once in the if statement's expression, and once in the assignment's rhs expression).

If your question is "how to set obj.Prop to v if and only if v is not null" (removing any specific propositions satisfied by ProcessStartInfo from deduction), then there's currently no way to do that without writing v twice in C#. If you're setting a property in such a way multiple times in your code base, you can define a helper method to do that. For example,

Console.WriteLine(new C { PropIfNotNull = null }.Prop);
// 1

public class C
{
  public int Prop { get; set; } = 1;
}

public static class CExtensions
{
  extension(C c)
  {
    public int? PropIfNotNull
    {
      set { if (value is not null) c.Prop = value.GetValueOrDefault(); }
    }
  }
}

[CyrusNajmabadi]

Process.Start(path, info ? info : default);

This is already legal code. But not really sensible. since info is before ?, it needs to be a boolean (ignoring the odd case of a type that overloads operators true/false). Which means it is either true, and passes true along. Or it is false and passes 'default' (which is false). So that's teh same as: Process.Start(path, info).

[GeeLaw]

It appears you misunderstood default(T) in C#. The "default" (value) for a type doesn't involve constructor, and the default(T) never runs a constructor. For a reference type T, it means null typed as T. It's also not clear what you mean by "default initializer".

[Wallby]

I assumed that all default values are derived from a default constructor for a type, as they are in other object oriented languages. Pretty sure that is what happens? As otherwise = default is the exact same as = null, which I am sure is not what happens.

[Wallby]

Most languages call the parameterless constructor the default constructor.
https://en.wikipedia.org/wiki/Default_constructor

It seems C# calls this the primary constructor?

[GeeLaw]

What you assumed is not true in C#. Why don't you try it in the compiler?

As otherwise = default is the exact same as = null, which I am sure is not what happens.

The construct default(T) (and default in C# 7.1) was introduced in C# 2.0 for generics, because the code being written has no idea whether T is reference type or non-nullable value type or nullable value type. It provides a consistent way to obtain the zeroed value for T. (For non-nullable value types, T a = null fails but T a = default compiles.)

If default(T) were just new T(), it wouldn't have been introduced.

[Wallby]

I would like for the pace of replies to my post here to slow down. Given that it is going far off course of what my question was actually about.

[CyrusNajmabadi]

private override bool RedirectStandardOutput;

I don't really get what this is trying to do.

[franchyd]

I think he wants to prevent calling that property (override with no public get/set)

[Wallby]

It is about extending the Process.Start method, providing an interface that is less generic than the default ones.

See this for an explanation as to why not having this is a problem: #10263 (reply in thread)

[CyrusNajmabadi]

I don't understand your explanation.

[GeeLaw]

In case of ProcessStartInfo, you can simply do new ProcessStartInfo { WorkingDirectory = workingDirectory }. The current behavior is as follows and highly unlikely to change.

• The setter accepts null.
• The getter returns the empty string if the property was last set to null.

---

The keyword default I assume always uses the default for the type, not the default value in a signature of a type or function (overload)?

Yes. default always boils down to default(T) for receiver type T.

---

Process.Start(path, info ? info : default);

Process.Start has no overload taking string and ProcessStartInfo, and no overload has an optional parameter (so "default value in signature of function" won't apply).

---

class ProcessStartAndMoreInfo : ProcessStartInfo

This is impossible because ProcessStartInfo is sealed.

For the general question (disallow setting a property), there are many cases:

• Almost always a bad idea.
  • If the property is on interface, you can reimplement it.
  • If the property is virtual and non-sealed on class, you can override it to make it non-functional.
• Likely a bad idea, yet with less probability than the previous case.
  • If you want to disallow setting the property when, and only when, the static type of the variable is your derived class, then you can use new to shadow the base property with void-returning method.

The last "solution" has the side effect of disallowing further overrides in case the property is virtual and non-sealed. Example:

var d = new D();
// d.Prop = 1;
((B)d).Prop = 1;

public class B
{
  public int Prop { get; set; }
}
public class D : B
{
  public new void Prop() { }
}

[Wallby]

You do need to explain why it's a good thing though. I find teh argument about why this is not a good idea compelling.

I do not have to do any such thing.

[CyrusNajmabadi]

I do not have to do any such thing.

We decide which features to add to the language. Definitionally, we only do that for things that have good arguments made for why it would be beneficial. If that is not provided, then the features def won't happen. :)

[CyrusNajmabadi]

I have a static extension method for System.Diagnostics.Process, where a different set of parameters is passed than any of the standard ones provide.

I don't undertand why that is not just:

var info = new ProcessStartInfo(path) { WorkingDirectory = workingDirectory }

[Wallby]

This post was not placed in the feature request category. It is placed in the Q&A category.

[CyrusNajmabadi]

Then no. There is no way to get this exact set of semantics. That said, this exact set seems highly questionable. So i think of that as a good thing.

[Wallby]

After further thinking about this, this is actually what monads in functional programming can do. Right? Though using only fmap from Functor, no Applicative functionality, but Monad to allowed for side effects, even though in actual Haskell there is no assignment monad (as far as I know), so (lhs=) is not valid.

In Haskell-like psuedo code:

example :: Maybe m => m workingDirectory
example Maybe workingDirectory
	fmap (info.WorkingDirectory=) workingDirectory

[Wallby]

In F#, this would be closest to computation expressions?