创建自定义 属性 class 以便在 class 中多次重复使用
Creating a custom property class for multiple re-use within a class
假设我有一个 C# class,它有多个属性,看起来都像这样:
private bool _var1Dirty = true;
private Double? _var1;
public Double? Var1
{
get
{
if (_var1Dirty)
{
_var1 = Method_Var1();
_var1Dirty = false;
}
return _var1;
}
}
这些属性之间的唯一区别是:
- return var 的类型(在本例中为
Double?
,但也可以是 int
、string
等)
- 方法调用 -
Method_Var1()
(每个 属性 都会有一个不同的)
有什么方法可以将其写成自定义 class?
大致如下:
public class Prop
{
public delegate T Func();
private bool _dirty = true;
private T _val;
public T Val
{
get
{
if (_dirty)
{
_val = Func;
_dirty = false;
}
return _val;
}
}
}
然后我可以传递给它:
- Return 输入
T
- 方法
Func
(PS - 我 知道 这不会编译/是完全错误的,但我想说明我在寻找什么)
非常感谢任何帮助/指导。
谢谢!!!
你很接近。您可以按照以下方式做一些事情:
public class Dirty<T>
{
public Dirty(Func<T> valueFactory)
{
this.valueFactory = valueFactory;
dirty = true;
}
private Func<T> valueFactory;
private bool dirty;
private T value;
public T Value
{
get
{
if (dirty)
{
value = valueFactory();
dirty = false;
}
return value;
}
}
}
然后你这样消费它:
Dirty<double?> dirtyDouble = new Dirty<double?>(() => SomethingThatReturnsADouble());
double? value = dirtyDouble.Value;
我不确定脏检查实际上做了什么,但是如果你需要比 bool
更复杂的东西,你总是可以把它变成一些 Func<T>
脏检查。
编辑:
根据@mikez 的评论和您的回答,您可以使用内置的 Lazy<T>
来节省 Dirty<T>
class 的创建,这也保证了线程安全:
public class F
{
private Lazy<double?> lazyDouble = new Lazy<double?>(() =>
MethodThatReturnsNullableDouble(), true);
public double? Value
{
get
{
return lazyDouble.Value;
}
}
}
假设我有一个 C# class,它有多个属性,看起来都像这样:
private bool _var1Dirty = true;
private Double? _var1;
public Double? Var1
{
get
{
if (_var1Dirty)
{
_var1 = Method_Var1();
_var1Dirty = false;
}
return _var1;
}
}
这些属性之间的唯一区别是:
- return var 的类型(在本例中为
Double?
,但也可以是int
、string
等) - 方法调用 -
Method_Var1()
(每个 属性 都会有一个不同的)
有什么方法可以将其写成自定义 class?
大致如下:
public class Prop
{
public delegate T Func();
private bool _dirty = true;
private T _val;
public T Val
{
get
{
if (_dirty)
{
_val = Func;
_dirty = false;
}
return _val;
}
}
}
然后我可以传递给它:
- Return 输入
T
- 方法
Func
(PS - 我 知道 这不会编译/是完全错误的,但我想说明我在寻找什么)
非常感谢任何帮助/指导。
谢谢!!!
你很接近。您可以按照以下方式做一些事情:
public class Dirty<T>
{
public Dirty(Func<T> valueFactory)
{
this.valueFactory = valueFactory;
dirty = true;
}
private Func<T> valueFactory;
private bool dirty;
private T value;
public T Value
{
get
{
if (dirty)
{
value = valueFactory();
dirty = false;
}
return value;
}
}
}
然后你这样消费它:
Dirty<double?> dirtyDouble = new Dirty<double?>(() => SomethingThatReturnsADouble());
double? value = dirtyDouble.Value;
我不确定脏检查实际上做了什么,但是如果你需要比 bool
更复杂的东西,你总是可以把它变成一些 Func<T>
脏检查。
编辑:
根据@mikez 的评论和您的回答,您可以使用内置的 Lazy<T>
来节省 Dirty<T>
class 的创建,这也保证了线程安全:
public class F
{
private Lazy<double?> lazyDouble = new Lazy<double?>(() =>
MethodThatReturnsNullableDouble(), true);
public double? Value
{
get
{
return lazyDouble.Value;
}
}
}