Sorry, für den etwas länglichen Text, aber ich weiss nicht wie ich es anders
Beschreiben soll.
Meine Kenntnisse in Python sind sehr rudimentär und was objektorientierte
Programmierung angeht, habe ich wenig Wissen. Bisher programmierte ich
in Perl oder Bash.
Meine Python Klassen soll eine Verbindung zu einem Programm auf einem oder
mehreren Rechnern mittels eines Socket herstellen, dorthin Befehle senden
und das Ergebnis holen. Die Befehle sind als Methoden in einer Klasse
definiert.
Soweit funktioniert alles auch, aber jetzt sollen Methoden mit eventuell
gleichem Namen aber anderen Argumenten und anderen Inhalt für ein anderes
Zielprogramm hinzukommen.
Wenn also eine Verbindung zu einem Rechner mit Zielprogramm A aufgebaut werden soll,
sollen die Methoden in der Datei "a_methoden.py" benutzt werden, bei Zielprogramm B
die Methoden in der Datei "b_methoden.py".
Aus Sicht des Anwenders soll das aber nicht sichtbar sein. Er soll etwas
Initialisieren und dann die Methode benutzen können. Zu welchem Zielprogramm (A/B)
eine Verbindung aufgebaut werden soll, kann aus Angaben, die bei der Initialisierung
gemacht werden, ermittelt werden.
Wie mache ich so etwas ?
Beispiel:
Anwendersicht:
# So soll ein Anwender vereinfacht den Code benutzen.
Code: Alles auswählen
from testanwendung import *
aObj = Testanwendung("A", a, b) # Initialisierung für Prg A
resultA = aObj.Befehl1(para1, para2)
bObj = Testanwendung("B", c, d) # Initialisierung für Prg B
resultB = bObj.Befehl1(para1)
testanwendung.py In dieser Datei befindet sich der nächste Code.
Code: Alles auswählen
class TestanwendungClinet:
# Klasse, für zentrale Funktionen
def __init__(self, p1, p2):
# Initialisiere alle später benutzten Variablen
def connect(self, ipAddr):
# Verbinde zu benötigtem Rechner und merke die Verbindungsdaten
def send(self, command, args):
# Sende den Befehl mit argumenten
def receive(self, ...):
# Lese was von der Verbindung kommt und gebe es an den Anwender zurück
class Testanwendung:
# In dieser Class sind alle Befehle für Prg A definiert und ein paar
# 'common' Methoden, die auch später für beide Prg gelten werden
def __init__(self, name, p1, p2):
# 'name' wird noch nicht ausgewertet
self.std = TestanwendungClinet(p1, p2)
def Befehl1(self, para1)
# Baue aus para1 ein Kommando und sende es
command = "befehl1"
result = self.std.send(command, args)
def Befehl2(...)
------------------------------
erweiterten Funktonalität:
Da die aktuelle Implementierung schon von vielen Leuten benutzt wird,
sollen die notwendigen Änderungen möglichst keine Änderung für die Leute bedeuten.
Deren Programme sollen gleich bleiben. Alle notwendigen Daten aus denen
A oder B ermitteln werden kann, werden jetzt schon bei der Initialisierung
übergeben.
testanwendung.py Hier sollen alle gemeinsamm genutzten Methoden verbleiben
a_methods.py Hier sollen nur die für A gültigen Methoden enthalten sein
Sie müssen also von testanwendung.py dorthin verschoben werden.
b_methods.py Hier sollen nur die für B gültigen Methoden enthalten sein
Die Aufteilung auf 2 Files ist notwendig, weil "b_methoden.py" von einer
anderen Person in einem anderen Land gepflegt wird und ich will keine
Änderungsprobleme.
Ist folgendes möglich ?
Wie genau ?
Code: Alles auswählen
class Testanwendung:
def __init__(self, name, p1, p2):
# Jetzt 'name' wird ausgewertet
if name == "A":
# Lade oder initialisiere Methoden für A
# was muss ich hier machen, dass später über aObj die Methoden für A benutzen kann ?
if name == "B":
# Lade oder initialisiere Methoden für B
# was muss ich hier machen, dass später über bObj die Methoden für B benutzen kann ?
self.std = TestanwendungClinet(p1, p2) # Initialisieren muss ich auch noch
# Hier oder im IF Block ?
Wie in dem Anwendercode ganz oben zu sehen ist, muss es möglich sein Methoden für A und B gleichzeitig zu verwenden.
Geht das über:
- für A: TestanwendungA(Testanwendung):
- für B: TestanwendungB(Testanwendung):
Oder geht das überhaupt nicht wie ich mir das Vorstelle.
herzlichen Danke für's Lesen und für einen Tipp
Werner
