Questione : Conservando e richiamando oggetto alla lima using XML in VS2005

Sto provando a generare un metodo generico per il salvataggio dell'oggetto fuori ad una lima ed il richiamo esso ancora.  Sto indovinando che XML è il senso andare, ma tutti esempi che trovo per richiedere un di più alto livello di .NET che ho accesso to.

What voglio sono qualcosa di simile: impiegato del codice categoria del

public {nome = "" riservati della stringa del
; ssn = "" riservati della stringa del
; nome pubblico pubblico della stringa del
degli impiegati del
() {
} {
ottiene {this.name di ritorno; } il
si è regolato {this.name = valore; } stringa pubblica SSN del
del
} {
ottiene {this.ssn di ritorno; } il
si è regolato {this.ssn = valore; } il

I del
del
}} vuole potere usarlo gradice questo: impiegato del

emp = nuovo impiegato ();
SaveObject (emp, @ " c:\temp\myemp ");

… ed allora impiegato del later
emp = RetrieveObject (@ " yemp di c:\temp\m "); il

Can questo be è fatto con VS2005?  Che cosa i metodi conterrebbero?
class= del

Risposta : Conservando e richiamando oggetto alla lima using XML in VS2005

È più complicato di sembra in modo da ho attaccato un certo codice che lo farà (vedere sotto) poichè un codice categoria del PHP. Ciò è soltanto un cestino molto semplice ma può essere estesa facilmente.

È usata come così

$b = nuovo myBasket (“basketName„);    // potete fare funzionare parecchi cestini, appena usate i nomi unici

$b->addItem ($productCode);  // aggiunge 1 articolo

$b->addItem ($productCode2, 10);   // aggiunge una quantità di 10 per productCode2


Per per visualizzare il cestino

$items = $b->fetchAllItems ();
$qty = $b->fetchAllQtys ();

foreach ($items come $index=> $aProductCode) {

     il codice di prodotto di eco “$aProductCode ha {$qty [$index]} articoli
“;
}
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:

sessName = $name. “_bskt„;
          $this->sessQty  = $name. “_qty„;

          $this->initialise ();
     }





     // ----- Metodi riservati -------------------------------------------------


     Deposito di // l'allineamento corrente in una variabile di sessione
     //
     updateBasket riservato di funzione () {
          $_SESSION [$this->sessName] = pubblicano ($this->basket);
          $_SESSION [$this->sessQty]  = pubblicano ($this->qty);
     }



     // inizializza il cestino
     //
     la funzione riservata inizializza () {

          Controllo di // se la sessione è in progresso ed in caso affermativo richiamare il cestino attuale
          //
          se (isset ($_SESSION [$this->sessName]) isset del && ($_SESSION [$this->sessQty])) {
               $this->basket = unserialize ($_SESSION [$this->sessName]);
               $this->qty    = unserialize ($_SESSION [$this->sessQty]);
          }
          altrimenti {
               $this->basket = allineamento ();
               $this->qty    = allineamento ();
               $this->updateBasket ();
          }

     }



     // ----- Metodi pubblici --------------------------------------------------


     // svuota il cestino fuori
     //
     radura di funzione () {

          unset ($_SESSION [$this->sessName]);
          unset ($_SESSION [$this->sessQty]);
          $this->initialise ();
     }



     // aggiunge un oggetto all'estremità della lista
     //
     Parametri di //: $item - un oggetto da immagazzinare
     //             $num - una quantità da immagazzinare, difetti a 1
     //
     addItem di funzione ($item, $num=1) {
          // assicura il soggiorno di indici al punto richiamando l'più alto
          indice attuale di // ed incrementarlo
          //
          $ctr = conteggio ($this->basket);

          se ($ctr > 0) {
               $lastKey = estremità (array_keys ($this->qty));
               $ctr = $lastKey + 1;
          }

          $this->basket [$ctr] = $item;
          $this->qty    [$ctr] = $num;

          $this->updateBasket ();
     }



     // rimuove un articolo dalla lista - identificare dal numero del cestino.
     la NOTA di // CHE RIMUOVERE UN ARTICOLO NON RIPRISTINA IL CESTINO NUMERA negli allineamenti.
     //
     Parametri di //: $basketNumber - l'indice dell'entrata di allineamento da rimuovere dall'allineamento
     //
     rmvItem di funzione ($basketNumber) {

          se (conteggio ($this->basket) > 0) {

               Controllo di // 001 che un articolo esiste prima di tentare la relativa rimozione
               //
               se (isset ($this->basket [$basketNumber]  )) {
                    unset ($this->basket [$basketNumber]);
                    unset ($this->qty [$basketNumber]);
                    $this->updateBasket ();
               }
          }
     }



     Ampiezza di // un articolo
     //
     Parametri di //: $basketNumber - l'indice dell'entrata di allineamento da richiamare dall'allineamento
     //
     fetchItem di funzione ($basketNumber) {
          se (conteggio ($this->basket) > 0) {
               $this->basket di ritorno [$basketNumber];
          }
     }



     Ampiezza di // un la quantità per un articolo
     //
     Parametri di //: $basketNumber - l'indice del qty da richiamare dall'allineamento
     //
     fetchItemQuantity di funzione ($basketNumber) {
          se (conteggio ($this->qty) > 0) {
               $this->qty di ritorno [$basketNumber];
          }
     }


     Cambiamento di // un articolo dato nella lista
     //
     Parametri di //: $basketNumber - l'indice dell'oggetto all'aggiornamento
     //             $anItem - un oggetto
     //
     chgItem di funzione ($basketNumber, $anItem) {
          se (conteggio del && del >= 0 di $basketNumber ($this->basket) > 0) {
               Controllo di // 001 che un articolo esiste prima di tentare la relativa rimozione
               //
               se (isset ($this->basket [$basketNumber]  )) {
                    $this->basket [$basketNumber] = $anItem;
                    $this->updateBasket ();
               }
          }
     }



     Cambiamento di // un la quantità data degli articoli nella lista
     //
     Parametri di //: $basketNumber - l'indice dell'oggetto all'aggiornamento
     //             $qty - Nuova quantità
     //
     funzione chgQty ($basketNumber, $qty) {
          se (conteggio del && del >= 0 di $basketNumber ($this->qty) > 0) {

               Controllo di // 001 che un articolo esiste prima di tentare la relativa rimozione
               //
               se (isset ($this->basket [$basketNumber]  )) {
                    $this->qty [$basketNumber] = $qty;
                    $this->updateBasket ();
               }
          }
     }



     // ottiene una lista di tutti gli articoli nel cestino
     //
     fetchAllItems di funzione () {
          $this->basket di ritorno;
     }



     // ottiene una lista di tutte le quantità dell'articolo immagazzinate nel cestino
     //
     fetchAllQtys di funzione () {
          $this->qty di ritorno;
     }



     // restituisce il conteggio del numero degli articoli nel cestino
     //
     countBasket di funzione () {
          array_sum di ritorno ($this->qty);
     }



} estremità di // del myBasket del codice categoria
Altre soluzioni  
 
programming4us programming4us