[c#] classi, sottoclassi e visibilita'

[_AnDrEa_1483]

ciao, premetto che si tratta di un inf piu che altro didattica, cioe' una cosa ke potrebbe essermi utile ma nn indispensabile

ho una definizione del genere

public class A
{
static A io;
static A Associa()
{if(io == null) io = new A();
return io;}
private A()
{....}
...
public class B
{...}
....
}

la calsse A alla fine e' un array di oggetti B
A possiede un costruttore privato e un metodo statico per istanziare la classe...
A possiede dei metodi per elaborazione e la ricerca degli oggetti B
le funzioni di ricerca ritornano il puntatore all'oggeto B trovato

premesso che B deve essere obbligatoriamente una classe xke eredita da altre

vorrei fare in modo ke solo funzioni interne ad A possano creare un oggetto B o accedere ai suoi metodi;

le classi che usano A e a cui vengono ritornati gli oggetti B devono solo poter accedere alle propieta' readonly

spero di essere stato chiaro...

grazie mille in anticipo

[U235]

 public class c
    {
        public void metodo()
        {

        }
    }

    public class a
    {
        List[b] bList;

        private a()
        {
            this.bList = new List[b]();
        }

        public static a createA()
        {
            return new a();
        }

        private class b : c
        {
            readonly string data;

            public b(int para)
            {
                this.data = System.DateTime.Now.ToString();
            }
            public void metodoB()
            {

            }

            public string Data
            {
                get { return this.data; }
            }
        }

        public int createb(int para)
        {
            this.bList.Add(new b(para));
            return this.bList.Count - 1;
        }

        public void metodoB(int index)
        {
            this.bList[index].metodoB();
        }

        public void metodo(int index)
        {
            this.bList[index].metodo();
        }

        public string Data(int index)
        {
            return this.bList[index].Data;
        }
    }

    public class d
    {
        a a;
        public d()
        {
            this.a = a.createA();
            this.a.createb(0);
            this.a.metodo(0);
            this.a.metodoB(0);
            string data = this.a.Data(0);
        }
    }

non so se ho capito, l'ho buttata giu' cosi senza testarla.

[_AnDrEa_1483]

Originariamente inviato da U235
non so se ho capito, l'ho buttata giu' cosi senza testarla.

ciao, grazie della risp... purtroppo nn e' quello ke intendevo, scusa ma mi devo essere estresso male...

01 public class A
02 {
03    static A io;
04    static A Associa()
05    {
06       if(io == null) io = new A();
07       return io;
08    }
09    private A()
10    {....}
11    ...
12    public class B
13    { 
14       public B ()
15       {...}
16       ...
17    }
18    ....
19    public B Aggiungi(....)
20    {
21       ...
22       B _nuovo = new B(...);
23       ...
24       return _nuovo;
25    }
26 }
27 
28 class C
29 {
30    public C
31    {
32       //questa parte deve funzionare
33       A prova = new A();
34       B prova 2 = A.Aggiungi(...);
35       //questa voglio ke dia errore
36       B prova3 = new B();
37    }
38 }

io ho questa struttura... lascia stare tutto quello ke ho detto prima..prob confonde solo le idee

vorrei ke l'istruzione 36 nn sia permessa... ma se dichiaro private il costruttore B anke la riga 22 da errore e invece voglio che vada...

se invece dichiaro privata l'intera classe B da' errore la riga 34

[U235]

scusa ma non riesco a capire l'esigenza di questo :

public B Aggiungi(....)
20    {
21       ...
22       B _nuvo = new B(...);
23       ...
24       return _nuovo;
25    }

se puoi/devi usare b solo con a? a che ti serve che sia public b?

[_AnDrEa_1483]

ho semplificato parekkio il problema...

il concetto e' ke B ha vari membri

di questici sono proprieta' e un costruttore che a deve poter usare...in lettura e scrittura

B inoltre viene restituito da alcune funzioni di A quindi B deve essere public

ora tutto questo finira' in una DLL che nn usero' io quindi volevo imporre ke chiunque nn sia A possa solo leggere le proprieta' delle istanze B restituite altrimenti se vengono scritte esce un macello

per ora nei rami "set" delle propireta' controllo l'istanza ke tenta la modifica e se non e' A nn la consento... ma cercavo qualcosa di piu performante e soprattutto visto ke sono un sacco ste prorieta' mi si rende illeggibile il codice

[U235]

Originariamente inviato da _AnDrEa_1483
ho semplificato parekkio il problema...

il concetto e' ke B ha vari membri

di questici sono proprieta' e un costruttore che a deve poter usare...in lettura e scrittura

B inoltre viene restituito da alcune funzioni di A quindi B deve essere public

ora tutto questo finira' in una DLL che nn usero' io quindi volevo imporre ke chiunque nn sia A possa solo leggere le proprieta' delle istanze B restituite altrimenti se vengono scritte esce un macello

non mi sembra una aproccio corretto, ma per dirlo bisognerebbe sapere le tue effettive esigenze...

se di b non vuoi che si modifichi nulla se non attraverso a perchè dovresti restituire una istanza (che a quel punto quella istanza di b diventa modificabile al di fuori di a) da a?

non è meglio esporre in lettura le proprieta di b dentro a e modificarle solo da a con i metodi di a?

[U235]

per ora nei rami "set" delle propireta' controllo l'istanza ke tenta la modifica e se non e' A nn la consento... ma cercavo qualcosa di piu performante e soprattutto visto ke sono un sacco ste prorieta' mi si rende illeggibile il codice

questo l'ho letto dopo...

aspetta lo devo analizzare

prova a farmi un esempio pratico di cosa devi fare e sopratutto perchè! magari si risolve cambiando qualche modificatore nelle altre classi...

[U235]

buongiorno ,

se il tuo problema è il numero di proprietà da scrivere allora è sufficiente che aggiungi una cosa del genere :

public object B_Property(string propertyName, int index)
        {
            return this.bList[index].GetType().GetProperty(propertyName).GetValue(this.bList[index], null);
        }

in a, e puoi usarle cosi nelle classi che istanziano a :

string data = (string)this.a.B_Property("Data", 1)

dove "Data" è il nome della proprietà e 1 (oppure quello che ti pare, l'importante e che ci sia!) è l'indice dell'oggetto b di cui vuoi leggerne la proprietà public.
ovviamente il casting lo fai sul tipo restituito dalla proprietà.

se poi sia piu' performante di quello che gia fai non lo so (chiedo consiglio ai grandi del forum) sicuramente diverso, ma se la tua reale esigenza è che b deve necessariamente essere public (ma a quel punto non capisco perche il perchè di a!)...