Classe d'interface ou abstraite pour répondre à l'exigence

Question

Je souhaite avoir une vue abstraite pour tout type d'interface utilisateur (Web ou fenêtre). Pour ce faire, je dois utiliser Interface (IView) dans lequel je ne peux appliquer que des règles sur la vue. En fait, je veux définir une fonction de base pour fournir à ses héritages.

Donc, de cette façon, je dois utiliser la classe abstraite. Le problème est

1) Interface ont seulement des règles 2) La vue (formulaire Web ou sous forme de fenêtre) ne peut hériter plus puisque c'est déjà hérité de la forme de la fenêtre ou sur le Web

Comment puis-je faire cela? Un grand merci

Answer 1

Les fonctions que vous ajoutez vont-elles changer la définition de ce qu'est la classe, ou créerez-vous simplement des fonctions pour manipuler des données qui font déjà partie de la classe?

Si vous devez redéfinir des aspects de la classe de base de ces deux classes, alors oui, vous devrez modifier votre structure d'héritage. Mais si les fonctions vont simplement manipuler des données qui font déjà partie de la classe maintenant, je vous suggère d'utiliser l'interface et de créer des fonctions utilitaires.

Voici un exemple maladroit de ce que je veux dire:

using System; 

abstract class Pet { } 

class Dog : Pet, IPet 
{ 
    public String Name { get; set; } 
    public Int32 Age { get; set; } 
} 

class Cat : Pet, IPet 
{ 
    public String Name { get; set; } 
    public Int32 Age { get; set; } 
} 

interface IPet 
{ 
    String Name { get; set; } 
    Int32 Age { get; set; } 
} 

static class PetUtils 
{ 
    public static void Print(this IPet pet) 
    { 
     Console.WriteLine(pet.Name + " is " + pet.Age); 
    } 
} 

Vos deux classes de l'interface utilisateur sont liées peut-être de cette façon. J'imagine que ce que vous devez faire d'une manière transversale serait résolu par une méthode utilitaire comme celle que j'ai créée. J'ai créé la méthode PetUtils.Print en tant que méthode d'extension car cela créera l'illusion expressive d'une méthode d'instance. Si vous n'utilisez pas C# 3, supprimez simplement "this" de public static void Print(this IPet pet).

Answer 2

Vous pouvez hériter d'une classe concrète (formulaire Web/formulaire de fenêtre), déclarer votre classe abstraite et implémenter une interface.

exemple System.Web.UI.Page:

public interface IView 
{ 
    void Foo(); 
} 

public abstract class BasePage : Page, IView 
{ 
    //honor the interface 
    //but pass implementation responsibility to inheriting classes 
    public abstract void Foo(); 

    //concrete method 
    public void Bar() 
    { 
     //do concrete work 
    } 
} 

public class ConcretePage : BasePage 
{ 
    //implement Foo 
    public override void Foo() { } 
} 

Cela vous donne l'avantage de l'interface et la méthode du béton Bar();

Answer 3

ce que je veux faire est quelque chose comme ça

MustInherit publique Classe ControllerBase (M Comme {ModelBase, Nouveau}, V Comme {IView})

Inherits BaseController 

Dim model As M 
Dim view As V 
Public Sub New() 
    model = New M 
    view.Controller = Me 
    model.Controller = Me 
End Sub 
Public Overridable Function GetModel() As M 
    Return model 
End Function 
Public Overridable Function GetView() As V 
    Return view 
End Function 

End Class

classe publique BaseWindow

Inherits System.Windows.Forms.Form 
Implements IView 
Dim c As BaseController 

Public Function GetController() As BaseController 
    Return c 
End Function 

Friend WriteOnly Property Controller() As BaseController Implements IView.Controller 
    Set(ByVal value As BaseController) 
     c = value 
    End Set 
End Property 

End Class

Public Class BaseWeb 
Inherits System.Web.UI.Page 
Implements IView 

Dim c As BaseController 

Public Function GetController() As BaseController 
    Return c 
End Function 

Friend WriteOnly Property Controller() As BaseController Implements IView.Controller 
    Set(ByVal value As BaseController) 
     c = value 
    End Set 
End Property 

End Class

Interface publique IView

WriteOnly Property Controller() As BaseController 

Fin Interface