Remplacer une propriété définie dans la classe de base

J'ai le cas où la hiérarchie de classe est quelque chose comme cela,

   +---------------+
   | UIElement     |
   |---------------|                            +----------------------+
   | ...           |                            | My Windows Application
   | SomePropert{} |                            |----------------------|
   |               |<---+                       |+--------------------+|
   |               |    |                       ||MyUserControl       ||
   +---------------+    |                       ||--------------------||
         +--------------+-----+                 ||                    ||
         |FrameWorkElement    |                 |+--------------------+|
         |--------------------|                 |//Want to use         |
         |    ...             |<-+              |//SomeProperty;      |
         +--------------------+  |              |                      |
                     +-----------+-+            |                      |
                     |Control      |            |                      |
                     |-------------|            +----------------------+
                     |  ...        |<---+
                     +-------------+    |
                            +-----------+---+
                            | UserControl   |
                            |---------------|<---+
                            |  ...          |    |
                            +---------------+    |
                                      +----------+-------+
                                      | MyUserControl    |
                                      |------------------|
                                      | SomeProperty{}   |
                                      | //Want to override
                                      |                  |
                                      +------------------+

Maintenant dans mon application (et toutes les autres applications où je peux exporter cette MyUserControl) puis-je régler le SomeProperty qui est géré par la MyUserControl classe plutôt que de UIElement?

Je suis maintenant en train de faire cela en créant un objet de MyUserControl et que l'attribution de la commande que j'ai ajouté dans mon xaml page.Donc, pour l'instant ressemble à ça,

MyUserControl newControl = new MyUserControl();
web = windowsPhoneControl11;  //windowsPhoneControll1 is the 
                              //one that I added from toolbox.
                              //i.e., mycustomecontrol added from toolbox.

Alors maintenant, depuis que je suis à l'aide de la "nouvelle" il devient surchargé. Mais lorsque j'exporte ce contrôle je ne peux pas attendre de l'utilisateur pour créer un nouvel objet et de l'affecter au contrôle que l'on utilise dans le code xaml de la page.

Donc, il y a un autre moyen que je pourrais remplacer ce un bien de manière à ce que la cession de ce bien est géré par MyUserControl classe, plutôt que la classe UIElement? Ce que je veux dire à propos de MyUserControl avoir le contrôle de définir cette propriété est que j'ai besoin de vérifier certaines de valeur avant de l'affecter. Si elle n'est pas au moins à la valeur attendue et puis j'ai besoin de donner une valeur par défaut.

Ps: je suis désolé pour cette longue question, mais je ne pouvais pas l'exprimer plus précise et je n'étais pas en mesure de trouver n'importe quelle autre question liée à la présente. Et c'est WindowsPhoneApp... Pas de l'ordinaire windowsapplication.

source d'informationauteur Ajai

  1. 10

    Pardonnez-moi si j'ai interprété cette incorrectement, mais serait la suite des travaux:

    public class BaseClass
{
    public int MyProperty
    {
       get; set;
    }
}
public class ChildClass : BaseClass
{
    public new int MyProperty
    {
       get
       {
           return base.MyProperty;
       }
       set
       {
           if(DoYourCheckingStuff(value))
           {
               base.MyProperty = value;
           }
       }
    }
}

    N'ai pas tester cette.

    Bien que cela se sent vraiment comme un hack-ish façon de faire. Ce bien êtes-vous en train d'essayer de 'contrôle'? Puisqu'il peut y avoir des moyens plus faciles de le faire.

    Un exemple: Changement d'un contrôle utilisateur, de sorte que c'est la largeur ne peut pas être réglée entre 100 et 200 (Bien que ce soit probablement une assez mauvaise façon de le faire), en le cachant à la Largeur de la propriété: 

    public class MyUserControl : UserControl
{
    public new double Width
    {
        get
        {
            return base.Width;
        }
        set
        {
             if(!(value > 100 && value < 200))
                 base.Width = value;
        }
    }
}
  2. -2

    vous pouvez modifier les propriétés comme des méthodes.

    public new int Age()
{
    get
    {
        return Age ?? 21;
    }
    set
    {
        Age = value;
    }
}