基本クラス静的プロパティを派生クラスと正しく共有する方法

Question

httpリクエストを実行するための基本ロジックを含む基本クラスがあります。しかし、ユーザーが設定した設定に依存しているため、URLのドメインが変更されるため、何らかのスイッチが必要です。

これに基づいて、必要な基本値を与える責任がある列挙型を保持する静的プロパティを作成しました。さらに、基本クラスはnugetパッケージを介して配布されるため、ユーザーには幾分かの密封があり、必要なフィールドを実装するだけでよく、親に定義されたロジックを使用できます。

基本的に私はこれまでこの解決策を考え出しました。

public abstract class Base{ 
    protected static Environment Environment { get; set; } 
    public static Init(Environment NewEnvironment){ 
     Environment = NewEnvironment; 
    } 
    public void UseEnvironment(){ 
     //use the selected environment on the method 
    } 
} 

public A : Base{ 
    public void UseAEnvironment(){ 
     UseEnvironment(); //using the environment defined with A.init() call 
    } 
} 
public B : Base{ 
    public void UseBEnvironment(){ 
     UseEnvironment(); //using the environment defined with B.init() call 
    } 

は、私はあなたがクラスの値に設定したときにこのように、Bが同じ値を使用して終了します、メモリ内の静的プロパティのコピーが1つだけであることを知っています。

私はプログラムを実行すると、クラスBがリリース値を持つことになりますしながら、だから、クラスAで定義されたすべてのメソッドは、デバッグ値で実行されます

A.Init(Environment.Debug); 
B.Init(Environment.Release); 

を行うことができるようにする必要があります。

私のソリューションは、私が必要としていることをしません、それを動作させる方法はありますか、この状況を回避して同様の結果を達成するために、

Answer 1

お持ちの場合：

public abstract class Base<T> where T : Base<T> 
{ 
    protected static Environment Environment { get; private set; } 

    public static void Init(Environment newEnvironment) 
    { 
    Environment = newEnvironment; 
    } 
} 

そして：

public class A : Base<A> 
{ 
    ... 
} 

public class B : Base<B> 
{ 
    ... 
} 

を、あなたはただ行うことができます：Base<T>でTのための何かの各置換は持っているので

Base<A>.Init(Environment.Debug); 
Base<B>.Init(Environment.Release); 

それは動作しますそれ自身の静的メンバー。つまり、それぞれジェネリックタイプ（「クローズド」ジェネリックタイプ）は、別々の静的フィールドを持っています。

またとしてそれを書くことができます：

A.Init(Environment.Debug); 
B.Init(Environment.Debug); 

が、私はそれがよりコンパクトな構文であったとしても、その少し混乱検討します。

Answer 2

ちょっと変わったデザインのようです。おそらく、コンパイラ指令（#if DEBUG）やApp.configなどの設定などの方が適切でしょうか？

とにかく、そうでない場合は...以下のようなものが

public abstract class Base<T> where T : Base<T> 
{ 
    private static readonly IDictionary<Type, Environment> _Environments = new Dictionary<Type, Environment>(); 

    public static void Init(Environment NewEnvironment) 
    { 
     _Environments[typeof(T)] = NewEnvironment; 
    } 

    protected Environment GetEnvironment() 
    { 
     if (!_Environments.ContainsKey(typeof(T))) 
      return default(Environment); 

     return _Environments[typeof(T)]; 
    } 

} 

public class A : Base<A> { 
    // ... 
} 
public class B : Base<B> { 
    // ... 
} 

Answer 3

私は以下の提案のコードを好きではないが動作するはずですが、それは私はあなたがやろうとしていると思うものを提供するために、コード激動の最小量を表し。抽象基本クラスの静的宣言の削除に注意してください。

public abstract class Base { 
    protected Environment Environment { get; set; } 

    public Init(Environment NewEnvironment) { 
     Environment = NewEnvironment; 
    } 
} 

public A : Base{ 
    public void UseEnvironment() { 
    } 
} 
public B : Base{ 
    public void UseEnvironment() { 
    } 
} 

次に初期化します。

static A DebugHttpAccess; 
static B RealeaseHttpAccess; 

DebugHttpAccess = new A(); 
DebugHttpAccess.Init(Environment.Debug); 
RealeaseHttpAccess= new B(); 
RealeaseHttpAccess.Init(Environment.Release); 

他のより高いレベルのロジックによって決定されるように最後に使用します。

if (needDebugHttpTracing) 
    DebugHttpAccess.UseEnvironment(); 
else 
    ReleaseHttpAccess.UseEnvironment(); 

私はあなたの条件に適切な解決策は、制御の反転ととして、あなたのHTTPアクセスの寿命を管理することができ、コンテナを必要とする疑いがありますシングルトンクラス。コンテナは、他のプロセス全体の構成設定で定義されている適切なHttpアクセスインスタンスを注入します。

IOCコンテナの例については、autofac.orgを参照してください。