C＃中的条件变量范围

Question

So this is kind of an odd question, is there any way to modify a variable's visibility depending on a certain condition (eg via some attribute)?

This may be more of a design pattern question, so allow me to explain my situation:

I have a class which has many user configurable values (9 total, 4 of which are conditional). However, some of these variables only apply if certain conditions are met. Right now, they are all visible to the user. I'm looking for a way I can restrict the visibility of certain variables at compile time in a per-scope context. I want to avoid getting the user confused and having them potentially set certain values that will just get ignored.

Example:

Property B only applies if property A is true . If the user sets A to false , the current scope will lose visibility of B .

var settings = new Settings() {
    A = true,
    B = ... //Everything is fine since A is true
}


var settings = new Settings() {
    A = false,
    B = ... //Compile Error, Settings does not contain definition for "B"
}

//Somewhere that uses the settings variable...
if(A) { useB(B); } else { useDefault(); }

Is there a better solution to this than "good documentation?"

Answer 1

You can't do exactly what you're asking, but you can get something close chaining fluent APIs with the builder pattern...

public interface ISettings
{
    string SomePropertyOnlyForTrue { get; }
    int B { get; }
}

public interface IBuilderFoo
{
    IBuilderFooTrue BuildFooTrue();
    IBuilderFooFalse BuildFooFalse();
}

public interface IBuilderFooTrue
{
    IBuilderFooTrue WithSomePropertyOnlyForTrue(string value);
    ISettings Build();
}

public interface IBuilderFooFalse
{
    IBuilderFooFalse WithB(int value);
    ISettings Build();
}

public void Whatever()
{
    var theThingTrue = new BuilderFoo().BuildFooTrue()
        .WithSomePropertyOnlyForTrue("face").Build();
    var theThingTrueCompilerError = new BuilderFoo().BuildFooTrue()
        .WithB(5).Build(); // compiler error

    var theThingFalse = new BuilderFoo().BuildFooFalse()
        .WithB(5).Build();
    var theThingFalseCompilerError = new BuilderFoo().BuildFooFalse()
        .WithSomePropertyOnlyForTrue("face").Build(); // compiler error
}

Note the getters are only defined in the ISettings , you'd be best to make the class immutable to not allow changing after being Build() . I did not provide impls for the builders, but should be easy enough to figure out. Let me know if you do need something aside from the builder samples like at https://www.dofactory.com/net/builder-design-pattern .

Here's a quick example: https://dotnetfiddle.net/DtEidh

Answer 2

No, this is not possible. If it's some kind of security question, note if you want to go crazy, you can even call internal things via reflection

The closest thing I can imagine is with interfaces:

public interface IA
{
    public bool A { get; set; }
}

public interface IB
{
    public bool B { get; set; }
}

public class Settings: IA, IB
{
    public bool A { get; set; }
    public bool B { get; set; }
}

Usage for example:

IA config = new Settings();
config.A = true; //fine
config.B = true; //error

That said, if this is a problem, your Model probably contains to much data. Maybe A and B could be seperate classes, which are properties of your model?

public class Settings
{
    public A A {get; set;}
    public B B {get; set;}
}

Or you could create a factory class

public class SettingsFactory
{
    public Settings CreateA(...)
    {
        return new Settings { ... };
    }

    public Settings CreateB(...)
    {
        return new Settings { ... };
    }
}

Anyway, you should trust your user, that he is reading your documentation.