non possono definire statico proprietà stringa astratto

Question

ho incontrato un problema interessante e sono alla ricerca di alcuni suggerimenti sul modo migliore per gestire questo ...

devo una classe astratta che contiene un metodo statico che accetta una stringa statica che vorrei definire come una proprietà astratta. Il problema è che C# non non supporta le seguenti (vedi ConfigurationSectionName e attuali proprietà):

public abstract class ProviderConfiguration : ConfigurationSection 
    { 
     private const string _defaultProviderPropertyName = "defaultProvider"; 
     private const string _providersPropertyName = "providers"; 

     protected static string ConfigurationSectionName { get; } 

     public static Configuration Current 
     { 
      get { return Configuration)ConfigurationManager.GetSection(ConfigurationSectionName); } 
     } 
    } 

Suppongo un modo per gestire questa situazione sarebbe quello di rendere ConfigurationSectionName NON astratta e quindi creare una nuova definizione di ConfigurationSectionName nelle classi derivate, ma ciò sembra piuttosto logico. Qualsiasi suggerimento sarebbe il benvenuto.

Gratias !!!

Answer 1

I membri statici non hanno il polimorfismo, quindi non possono essere astratti. :(

Se questo è quello che vi serve, considerare la possibilità di un oggetto Singleton, e leggendo la proprietà fuori quell'oggetto.

Answer 2

Basta usare new per ignorare un metodo statico in una classe derivata. Nulla di ciò che rende new una cosa negativa da fare per i metodi e le proprietà virtuali si applica dal momento che il nome del tipo devono essere forniti:.

public class BaseClass 
{ 
    public static int Max { get { return 0; } } 
} 

public class InteriorClass : BaseClass 
{ 
} 

public class DerivedClass : InteriorClass 
{ 
    public new static int Max { get { return BaseClass.Max + 1; } } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Console.WriteLine("BaseClass.Max = {0}", BaseClass.Max); 
     Console.WriteLine("InteriorClass.Max = {0}", InteriorClass.Max); 
     Console.WriteLine("DerivedClass.Max = {0}", DerivedClass.Max); 
     Console.ReadKey(); 
    } 
} 

Answer 3

quello che stai cercando di fare è impossibile, come altri hanno detto

mi piacerebbe provare someth ing come questo

public abstract class ProviderConfiguration : ConfigurationSection 
{ 
    public string ConfigurationSectionName { get; set; } 

    public static ProviderConfiguration Provider { get; set; } 

    public static Configuration Current 
    { 
     get { return (Configuration)ConfigurationManager.GetSection(Provider.ConfigurationSectionName); } 
    } 
} 

Poi nella pratica:

public void DoStuff() 
{ 
    var provider = new DerivedProviderConfiguration(); 
    ProviderConfiguration.Provider = provider; 
} 

Answer 4

Ok, questo non è esattamente di creare una proprietà astratta statica, ma è possibile ottenere l'effetto desiderato.

È possibile ottenere questo utilizzando farmaci generici:

public abstract class MyAbstractClass<T> 
{ 
    public static string MyAbstractString{ get; set; } 
    public static string GetMyAbstracString() 
    { 

     return "Who are you? " + MyAbstractString; 

    } 
} 

public class MyDerivedClass : MyAbstractClass<MyDerivedClass> 
{ 
    public static new string MyAbstractString 
    { 
     get 
     { 
      return MyAbstractClass<MyDerivedClass>.MyAbstractString; 
     } 
     set 
     { 
      MyAbstractClass<MyDerivedClass>.MyAbstractString = value;    
     } 
    } 

} 


public class MyDerivedClassTwo : MyAbstractClass<MyDerivedClassTwo> 
{ 
    public static new string MyAbstractString 
    { 
     get 
     { 
      return MyAbstractClass<MyDerivedClassTwo>.MyAbstractString; 
     } 
     set 
     { 
      MyAbstractClass<MyDerivedClassTwo>.MyAbstractString = value; 
     } 
    } 

} 


public class Test 
{ 

    public void Test() 
    { 

     MyDerivedClass.MyAbstractString = "I am MyDerivedClass"; 
     MyDerivedClassTwo.MyAbstractString = "I am MyDerivedClassTwo"; 


     Debug.Print(MyDerivedClass.GetMyAbstracString()); 
     Debug.Print(MyDerivedClassTwo.GetMyAbstracString()); 


    } 

} 

Così, chiamando la classe di test si otterrà:?

"? Chi sei tu io sono MyDerivedClass" "Chi sei tu io sono MyDerivedClassTwo"

Quindi, si ha un metodo statico in una classe astratta, ma il valore astratto è diversa per ogni classe derivata, bella: D

Ok, quindi, cosa sta succedendo qui? Il trucco è il tag generico, il compilatore è che genera una classe astratta diversa per ciascun tipo derivato.

Come ho detto non è una proprietà astratta, ma si ottengono tutti i vantaggi delle proprietà statiche astratte, che sono la programmazione di funzioni statiche sulla classe astratta ma utilizzando diversi parametri statici per tipo.