Zurück   Flashforum > Flash > ActionScript > Softwarearchitektur und Entwurfsmuster

Antwort
 
LinkBack Themen-Optionen Ansicht
Alt 30-04-2009, 08:25   #1 (permalink)
Neuer User
 
Registriert seit: Feb 2004
Ort: Dresden
Beiträge: 105
Custom namespace vs internal interface

Ich habe eine AS-Library. Die Library enthält Klassen. Die Klassen besitzen
getter und setter Methoden. Der Anwender der Library soll nur die getter-
Methoden aufrufen dürfen. Intern müssen aber die setter Methoden verfügbar
sein.


Konzept 1 (klappt nicht)
----------------------------------------------------
- public getter
Code:
    public function get value() : Number;
- internal, protected oder custom_namespace setter
Code:
    internal function set value(theValue : Number) : void; custom_namespace function set value(theValue : Number) : void;
Getter-Setter-Paare dürfen laut Compiler und Doc nicht in verschiedenen namespaces liegen.


Konzept 2 (klappt)
----------------------------------------------------
- public getter
Code:
    public function get value() : Number;
- custom_namespace setValue() Methoden
Code:
    custom_namespace function setValue(theValue : Number) : void;
Vorteil: Ohne den custom namespace explizit zu deklarieren ist kein Zugriff auf dessen Methoden möglich.
Nachteil: Man schreibt sich einen Ast und kann außerdem die Vorteile der setter nicht verwenden:
Code:
    value++; // failed


Konzept 3 (klappt)
----------------------------------------------------
- Interface für die getter
Code:
    interface IInterface ... function get value() : Number;
- Spezialisiertes "internes" Interface für die setter, welches Library-intern verwendet wird.
Code:
    interface IInterfaceInternal extends IInterface ... function setValue(theValue : Number) : void; ... public class MyValue implements IInterfaceInternal { ...
Vorteil: Man kann die Getter-Setter-Vorzüge genießen und schreibt sich keinen Ast.
Nachteil: Der Anwender kann stets auch das interne Interface ansprechen. Man hat eine Reihe an zusätzlichen Interfaces.


Konzept 4 (klappt)
----------------------------------------------------
Alle getter und setter in einem Interface und genaue Dokumenentation, wann welche Methode erlaubt ist.
Vorteil: Kein Ast, keine doppelten Interfaces.
Nachteil: Ja.


Wie würden Sie entscheiden ...
kakenbok ist offline   Mit Zitat antworten
Alt 30-04-2009, 08:39   #2 (permalink)
Neuer User
 
Registriert seit: Feb 2004
Ort: Dresden
Beiträge: 105
Edit: Nachteil von namespaces ist auch, dass man intern gegen die Implementierung
programmieren muss.

Nachteil von "internen" Interfaces ist definitiv, dass die IDE die internen Interfaces
als Vorschlag der Code-completion ausspuckt. Hier kann man evtl. ein anderes Naming-
Schema anwenden. Statt IValueInternal extends IValue z.B. IInternalValue
extends IValue. Der Nutzer kann auch immer seine Instanz mit der Implementierung
typisieren und erhält Zugriff auch auf die "internen" Methoden.

Geändert von kakenbok (30-04-2009 um 09:23 Uhr) Grund: Neuer Nachteil
kakenbok ist offline   Mit Zitat antworten
Alt 30-04-2009, 09:07   #3 (permalink)
random
 
Registriert seit: Jun 2001
Beiträge: 844
Hi, also das hier geht problemlos (Compiler / Runtime ):
Code:
			private var _i:int;
			
			private function set i( value:int):void
			{
				_i = value;
			}
			
			public function get i():int
			{
				return _i;
			}
__________________
-------------------


ciao, blue
blue ist offline   Mit Zitat antworten
Alt 30-04-2009, 09:14   #4 (permalink)
Neuer User
 
Registriert seit: Feb 2004
Ort: Dresden
Beiträge: 105
Code:
    package {     import flash.display.Sprite;         public class B extends Sprite {                 private var _i : int;                 public function B() {             i = 10;         }                 private function set i(value : int) : void {             _i = value;         }         public function get i() : int {             return _i;         }             } }

Compiler: src\B.as(9): col: 4 Error: Unklarer Verweis auf i.

>>>> i = 10;
kakenbok ist offline   Mit Zitat antworten
Alt 30-04-2009, 09:46   #5 (permalink)
random
 
Registriert seit: Jun 2001
Beiträge: 844
Stimmt, im lfd. Projekt soll man so etwas auch nicht testen

aber probier mal dies:
Code:
    		private var __i : int;
			
		public function booking( val:int = 10 ):void 
		{
			_i = val;
			trace( 'i: ' + i );
		}               
		
		public function get i():int 
		{            
			return _i;
		}        
		
		private function set _i( value:int ) : void 
		{            
			__i = value;
		}        
		
		private function get _i():int 
		{
			return __i;
		}
__________________
-------------------


ciao, blue
blue ist offline   Mit Zitat antworten
Alt 30-04-2009, 10:03   #6 (permalink)
Neuer User
 
Registriert seit: Feb 2004
Ort: Dresden
Beiträge: 105
Das zähle ich also als Stimme für "custom namespace".

Die setter im ganz oben geschilderten Problem sollen übrigens wenigstens im
namespace internal verfügbar sein, wenn nicht gar besser paketübergreifend.

Den getter zu duplizieren ist natürlich nicht schick, wenn es auch _i++ möglich macht.
kakenbok ist offline   Mit Zitat antworten
Antwort

Lesezeichen

Themen-Optionen
Ansicht

Forumregeln
Es ist Ihnen nicht erlaubt, neue Themen zu verfassen.
Es ist Ihnen nicht erlaubt, auf Beiträge zu antworten.
Es ist Ihnen nicht erlaubt, Anhänge hochzuladen.
Es ist Ihnen nicht erlaubt, Ihre Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks sind an
Pingbacks sind an
Refbacks sind an



Alle Zeitangaben in WEZ +1. Es ist jetzt 16:51 Uhr.

Domains, Webhosting & Vserver von Host Europe
Unterstützt das Flashforum!
Adobe User Group


Copyright ©1999 – 2014 Marc Thiele