Créer de la classe héritée de la classe de base

public class Car 
{ 
    private string make;
    private string model;
    public Car(string make, string model)
    {
         this.make = make;
         this.model = model;
    }
    public virtual void Display()
    {
       Console.WriteLine("Make: {0}", make);
       Console.WriteLine("Model: {0}", model);
    }
    public string Make
    {
       get{return make;}
       set{make = value;}
    }
    public string Model
    {
       get{return model;}
       set{model = value;}
    }
}

public class SuperCar:Car
{
    private Car car;
    private int horsePower;
    public SuperCar(Car car)
    {
        this.car = car;
    }
    public int HorsePower
    {
       get{return horsePower;}
       set{horsepower = value;}
    }
    public override void Display()
    {
       base.Display();
       Console.WriteLine("I am a super car");
}

Quand je fais quelque chose comme

Car myCar = new Car("Porsche", "911");
SuperCar mySupcar = new SuperCar(myCar);
mySupcar.Display();

Je ne reçois que "je suis une supercar", mais pas les propriétés de ma classe de base. Dois-je affecter explicitement les propriétés de ma classe de base dans la SuperCar du constructeur? En fait, je suis en train Décorateur modèle où je veux qu'une classe pour ajouter un comportement à une classe de base.

Pour Supercar être un vrai décorateur, déléguer l'ensemble de la Voiture de méthodes pour votre enveloppé voiture. On peut se demander si Décorateur est le bon modèle ici, d'autant que vous traitez avec des classes concrètes.
Supposons que vous renommez Voiture de Conteneur et de la SuperCar de la Boîte. Vous dites "une Boîte est Une sorte de Récipient (car il hérite de Conteneur) et chaque Boîte contient un Conteneur (parce qu'il faut un conteneur dans son constructeur et l'enregistre dans un champ)". Est-ce réellement ce que vous voulez de modèle? Pourquoi une boîte contient un conteneur? Pourquoi une SuperCar contiennent tous les deux une Voiture et d'être un genre de Voiture?

OriginalL'auteur Raj | 2010-05-20

c#decorator design-patterns inheritance

8

sinon:
```
public class Car
{
    public Car(string make, string model)
    {
         this.make = make;
         this.model = model;
    }


    public Car (Car car):this(car.Make, Car.Model){}
}

public class SuperCar : Car
{
  SuperCar(Car car): base(car){}
}
```
De cette façon, vous pouvez hériter de toute la classe de voiture, et la voiture contenu remplir à partir de la condition d'objet. Les objets hérités n'avez pas besoin de savoir quelque chose au sujet de ce jeu. Qu'ils viennent passer la Voiture actuelle de l'objet à la classe de base et il fait le travail.

OriginalL'auteur kemiller2002
5

Je suis peut-être à venir dans un peu de retard ici, mais juste au cas où quelqu'un trouve cela utile:

Vous pouvez utiliser la réflexion. Elle nécessite un peu plus de code que ce que vous avez proposé, mais je pense qu'il offre toujours la brièveté vous êtes à la recherche pour.
```
public SuperCar(Car car)
{
    var props = typeof(Car).GetProperties().Where(p => !p.GetIndexParameters().Any());
    foreach (var prop in props)
    {
        if (prop.CanWrite)
            prop.SetValue(this, prop.GetValue(car));
    }

    //Set SuperCarcentric properties
    //.
    //.
    //.
}
```
J'ai écrit cette explicitement à partir de votre exemple pour illustrer clairement le concept, mais je pense que ce serait mieux fait d'une méthode générique qui peut être utilisé dans tous les cas similaires de votre solution.

Espère que cette aide.

OriginalL'auteur Josh Wheelock
1

En regardant ton code je ne suis pas sûr de savoir comment il compile. Votre constructeur sont mauvais parce que le constructeur de base ne savez pas comment faire pour exécuter un constructeur qui prend type de voiture. Il semble que vous essayez de mettre en oeuvre le décorateur motif, mais n'ont pas fait correctement. Vraiment ce que vous devez avoir est un ICar interface à la fois de mettre en œuvre et de Display() dans SuperCar vous devriez appeler car.Display() Vous aurez également à mettre en œuvre sur Super voiture et les faire revenir la voiture.Faire & voiture.De modèle pour mettre en oeuvre le décorateur modèle correctement.
```
public interface ICar
{
string Make {get; set;}
string Model {get; set;}
void Display();
}
public class Car :ICar
{ 
private string make;
private string model;
public Car(string make, string model)
{
this.make = make;
this.model = model;
}
public virtual void Display()
{
Console.WriteLine("Make: {0}", make);
Console.WriteLine("Model: {0}", model);
}
public string Make
{
get{return make;}
set{make = value;}
}
public string Model
{
get{return model;}
set{model = value;}
}
}
public class SuperCar:ICar
{
private ICar car;
private int horsePower;
public SuperCar(ICar car)
{
this.car = car;
}
public string Make
{
get{return car.Make;}
set{car.Make = value;}
}
public string Model
{
get{return car.Model;}
set{car.Model = value;}
}
public int HorsePower
{
get{return horsePower;}
set{horsepower = value;}
}
public override void Display()
{
car.Display();
Console.WriteLine("I am a super car");
}
```
J'ai accepté de Kevin répondre parce que dans mon cas, je n'ai pas une interface et je tiens à ajouter d'autres comportements d'une classe existante. Cependant, je vous remercie de votre explication complète du pattern décorateur.
C'est une question si vous voulez utiliser le décorateur modèle ou non. Vraiment on dirait que vous ne voulez pas que le pattern décorateur parce que vous voulez juste pour développer la voiture (qui est ce que l'héritage est pour) et pas de l'emballer et de changer la façon dont il fonctionne, dans ce cas de Kevin est la bonne solution.

OriginalL'auteur Craig Suchanec
0

Modifier les propriétés privées des biens protégés, privés ne sont pas accessibles par quiconque à l'exception de la classe qui crée entre eux, tout en étant protégé des variables peut être consulté par les classes héritées.

Est-ce à dire que je vais devoir affecter explicitement les variables protégés de la Voiture propriétés de l'objet que j'utilise pour créer la SuperCar de l'objet?

OriginalL'auteur jpabluz
0

yep pour obtenir que cela fonctionne comme vous le souhaitez, vous devez définir le constructeur de base comme ci-dessous:
```
public SuperCar(Car car):base(car.make,car.model)
{
this.car = car;
}
```
OriginalL'auteur Somedeveloper

Vous n'êtes pas assez mise en œuvre de la décorateur modèle

Vous avez besoin d'une classe de base abstraite pour tenir la décorées voiture

  public abstract class CarDecorator
{
protected Car DecoratedCar { get; private set; }
protected CarDecorator(Car decoratedCar)
{
DecoratedCar = decoratedCar;
}
}
public class SuperCar : CarDecorator
{
public SuperCar(Car car)
: base(car)
{
}
public int HorsePower
{
get { return horsePower; }
set { horsepower = value; }
}
public override void Display()
{
DecoratedCar.Display()
Console.WriteLine("Plus I'm a super car.");
}
}

Mais puis-je attribuer une SuperCar objet d'une Voiture de l'objet, de l'e.g ajouter une SuperCar à une Liste<Voiture> ?
Non, vous auriez besoin d'une liste de CarDecorators à la place.

OriginalL'auteur Daniel

@JoshWheelock réponse, j'ai écrit cette méthode que j'ai mis dans un fichier partagé de mon Xamarin projet

Elle clones de classes, de sorte que vous pouvez utiliser pour dupliquer une base de classe, l'héritière, vous pouvez ajuster la T param

//...
#if WINDOWS_UWP
using System.Reflection;
#endif
//...
public void CloneIn<T>(T src, T dest)
{
#if WINDOWS_UWP
var props = typeof(T).GetTypeInfo().DeclaredProperties.Where(p => !p.GetIndexParameters().Any());
#else
var props = typeof(T).GetProperties().Where(p => !p.GetIndexParameters().Any());
#endif
foreach (var prop in props)
{
if(prop.SetMethod!=null)
prop.SetValue(dest, prop.GetValue(src));
}
}

Pas encore testé sur Android et iOS, concernant Android, j'ai mon émulateur qui soddenly cessé de fonctionner correctement depuis une semaine ...

OriginalL'auteur Fabrice T

Vous devez vous connecter pour publier un commentaire.