C# Calling-Base-Methode von der Schnittstellenmethode

Question

Ich fange an, C# zu lernen und kann nicht herausfinden, wie die Basisklassenmethode innerhalb der Interface-Methode aufgerufen wird. In diesem speziellen Fall muss ich irgendwie sendData von innerhalb onRecieve Methode anrufen.

WebSocketBase.cs

using WebSocketSharp; 
using System; 
using System.Collections.Generic; 
using System.Threading; 

class WebSocketBase 
{ 
    private WebSocket webSocketClient = null; 
    private WebSocketService webService = null; 
    private string url = null; 

    public WebSocketBase(string url, WebSocketService webService) 
    { 
     this.webService = webService; 
     this.url = url; 
    } 

    public void start() 
    { 
     webSocketClient = new WebSocket(url); 
     webSocketClient.OnError += new EventHandler<WebSocketSharp.ErrorEventArgs>(webSocketClient_Error); 
     webSocketClient.OnOpen += new EventHandler(webSocketClient_Opened); 
     webSocketClient.OnClose += new EventHandler<WebSocketSharp.CloseEventArgs>(webSocketClient_Closed); 
     webSocketClient.OnMessage += new EventHandler<MessageEventArgs>(webSocketClient_MessageReceived); 
     webSocketClient.ConnectAsync(); 
    } 

    private void webSocketClient_MessageReceived(object sender, MessageEventArgs e) 
    { 
     webService.onReceive(e.Data); 
    } 

    public void send(string channel) 
    { 
     webSocketClient.Send(channel); 
    } 

    public void sendData(string data) 
    { 
     send("data"); 
    } 

} 

interface WebSocketService 
{ 
    void onReceive(String msg); 
} 

Logic.cs

class Logic : WebSocketService 
{ 
    public void onReceive(string msg) 
    { 
     Console.WriteLine("Received message") 
    } 
} 

Answer 1

So sieht es aus wie Ihre WebSocketBase eine Abhängigkeit von der Service. Warum sollte der Dienst nicht wissen, was WebSocketBase ihm Nachrichten schickt?

interface WebSocketService 
{ 
    void onReceive(WebSocketBase sender, String msg); 
} 

class Logic : WebSocketService 
{ 
    public void onReceive(WebSocketBase sender, string msg) 
    { 
     sender.send("blah"); 
    } 
} 

class WebSocketBase 
{ 
    ... 

    private void webSocketClient_MessageReceived(object sender, MessageEventArgs e) 
    { 
     webService.onReceive(this, e.Data); 
    } 

    public void send(string channel) 
    { 
     webSocketClient.Send(channel); 
    } 

    ...  
} 

Answer 2

Vielleicht war dies nicht Ihre Absicht (Kommentar und ich bearbeiten), aber ich würde die einfachste Sache zu verlängern sein der Basistyp UND implementieren Sie Ihre Schnittstelle.

class Logic : WebSocketBase, WebSocketService 
{ 
    public void onReceive(string msg) 
    { 
     Console.WriteLine("Received message") 

     // Call method defined in base 
     sendData(msg); 
    } 
} 

Answer 3

Wie schon in anderen Kommentaren angezeigt, tun Sie nicht mit der WebSocketBase Klasse nichts.

Einige andere stilistische Punkte:
a) WebSocketService sollte „IWebSocketService“ vereinbarungs
b) Falls alleinigen Zweck der WebSocketBase ist eine Basisklasse sein, Sie es Ihre abstrakten
c) Stellen Sie sicher machen sollte markieren auch Klassen und sich Schnittstellen mit Zugriffsmodifikatoren (nicht nur die Methoden in ihnen)

public interface IWebSocketService 
{ 
    void onReceive(String msg); 
} 

public abstract class WebSocketBase : IWebSocketService 
{ 

... 


private void webSocketClient_MessageReceived(object sender, MessageEventArgs e) 
{ 
    webService.onReceive(e.Data); 
} 

    public void sendData(string data) 
    { 
     send("data"); 
    } 

} 

public class Logic : WebSocketBase 
{ 
    public void onReceive(string msg) 
    { 
     Console.WriteLine("Received message") 
    } 
}