Custom namespace vs internal interface

[kakenbok]

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

public function get value() : Number; 

- internal, protected oder custom_namespace setter

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

public function get value() : Number; 

- custom_namespace setValue() Methoden

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:

value++; // failed 
 

Konzept 3 (klappt)
----------------------------------------------------
- Interface für die getter

interface IInterface
...
function get value() : Number; 

- Spezialisiertes "internes" Interface für die setter, welches Library-intern verwendet wird.

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]

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.

[blue]

Hi, also das hier geht problemlos (Compiler / Runtime ):

			private var _i:int;
			
			private function set i( value:int):void
			{
				_i = value;
			}
			
			public function get i():int
			{
				return _i;
			}

[kakenbok]

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;

[blue]

Stimmt, im lfd. Projekt soll man so etwas auch nicht testen

aber probier mal dies:

    		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;
		}

[kakenbok]

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.