Pergunta : Conservando e recuperando o objeto à lima using XML em VS2005

Eu estou tentando criar um método genérico para conservar um objeto para fora a uma lima e recuperá-lo outra vez.  Eu estou supor que XML é a maneira de ir, mas todo o exemplo que eu encontro para exigir um de mais alto nível de .NET do que eu tenho o acesso to.

What eu quero sou qualquer outra coisa semelhante: empregado da classe do

public {nome = "" confidenciais da corda do
; ssn = "" confidenciais da corda do
; nome público público da corda do
do empregado do
() {
} {o
começ {this.name do retorno; } o
ajustou-se {this.name = valor; } corda pública SSN do
do
} {o
começ {this.ssn do retorno; } o
ajustou-se {this.ssn = valor; } o

I do
do
}} quer poder usá-lo gosta disto: empregado do

emp = empregado novo ();
SaveObject (emp, @ " c:\temp\myemp ");

… e então empregado do later
emp = RetrieveObject (@ de " yemp c:\temp\m "); o

Can isto seja feito com VS2005?  Que os métodos conteriam?
class= do

Resposta : Conservando e recuperando o objeto à lima using XML em VS2005

É mais complicado do que parece assim que eu uni algum código que o fará (ver abaixo) porque uma classe do PHP. Esta é somente uma cesta muito simples mas pode facilmente ser estendido.

É usado como assim

$b = myBasket novo (“basketName”);    // você pode funcionar diversas cestas, apenas usa nomes originais

$b->addItem ($productCode);  // adiciona 1 artigo

$b->addItem ($productCode2, 10);   // adiciona uma quantidade de 10 para productCode2


Para indicar a cesta

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

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

     o código produto $aProductCode do eco de “tem {$qty [$index]} artigos
“;
}
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 ();
     }





     // ----- Métodos confidenciais -------------------------------------------------


     Loja de // a disposição atual em uma variável da sessão
     //
     updateBasket confidencial da função () {
          $_SESSION [$this->sessName] = fabricam ($this->basket);
          $_SESSION [$this->sessQty]  = fabricam ($this->qty);
     }



     // inicializa a cesta
     //
     a função confidencial inicializa () {

          Verificação de // se a sessão é em andamento e se recuperar assim a cesta existente
          //
          se (isset ($_SESSION [$this->sessName]) isset do && ($_SESSION [$this->sessQty])) {
               $this->basket = unserialize ($_SESSION [$this->sessName]);
               $this->qty    = unserialize ($_SESSION [$this->sessQty]);
          }
          mais {
               $this->basket = disposição ();
               $this->qty    = disposição ();
               $this->updateBasket ();
          }

     }



     // ----- Métodos públicos --------------------------------------------------


     // esvazia a cesta para fora
     //
     espaço livre da função () {

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



     // adiciona um objeto à extremidade da lista
     //
     Parâmetros de //: $item - um objeto a ser armazenado
     //             $num - uma quantidade a ser armazenada, defeitos a 1
     //
     addItem da função ($item, $num=1) {
          // assegura a estada dos índices na etapa recuperando o mais elevado
          índice existente de // e incremento dele
          //
          $ctr = contagem ($this->basket);

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

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

          $this->updateBasket ();
     }



     // remove um artigo da lista - identificar pelo número da cesta.
     a NOTA de // QUE REMOVER UM ARTIGO NÃO RESTAURA A CESTA NUMERA nas disposições.
     //
     Parâmetros de //: $basketNumber - o índice da entrada da disposição a remover da disposição
     //
     rmvItem da função ($basketNumber) {

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

               Verificação de // 001 que um artigo existe antes de tentar sua remoção
               //
               se (isset ($this->basket [$basketNumber]  )) {
                    unset ($this->basket [$basketNumber]);
                    unset ($this->qty [$basketNumber]);
                    $this->updateBasket ();
               }
          }
     }



     Esforço de // um artigo
     //
     Parâmetros de //: $basketNumber - o índice da entrada da disposição a recuperar da disposição
     //
     fetchItem da função ($basketNumber) {
          se (contagem ($this->basket) > 0) {
               $this->basket do retorno [$basketNumber];
          }
     }



     Esforço de // um a quantidade para um artigo
     //
     Parâmetros de //: $basketNumber - o índice do qty a recuperar da disposição
     //
     fetchItemQuantity da função ($basketNumber) {
          se (contagem ($this->qty) > 0) {
               $this->qty do retorno [$basketNumber];
          }
     }


     Mudança de // um artigo dado na lista
     //
     Parâmetros de //: $basketNumber - o índice do objeto à atualização
     //             $anItem - um objeto
     //
     chgItem da função ($basketNumber, $anItem) {
          se (contagem do && do >= 0 de $basketNumber ($this->basket) > 0) {
               Verificação de // 001 que um artigo existe antes de tentar sua remoção
               //
               se (isset ($this->basket [$basketNumber]  )) {
                    $this->basket [$basketNumber] = $anItem;
                    $this->updateBasket ();
               }
          }
     }



     Mudança de // um a quantidade dada dos artigos na lista
     //
     Parâmetros de //: $basketNumber - o índice do objeto à atualização
     //             $qty - A quantidade nova
     //
     função chgQty ($basketNumber, $qty) {
          se (contagem do && do >= 0 de $basketNumber ($this->qty) > 0) {

               Verificação de // 001 que um artigo existe antes de tentar sua remoção
               //
               se (isset ($this->basket [$basketNumber]  )) {
                    $this->qty [$basketNumber] = $qty;
                    $this->updateBasket ();
               }
          }
     }



     // começ uma lista de todos os artigos na cesta
     //
     fetchAllItems da função () {
          $this->basket do retorno;
     }



     // começ uma lista de todas as quantidades do artigo armazenadas na cesta
     //
     fetchAllQtys da função () {
          $this->qty do retorno;
     }



     // retorna a contagem do número de artigos na cesta
     //
     countBasket da função () {
          array_sum do retorno ($this->qty);
     }



} extremidade de // do myBasket da classe
Outras soluções  
 
programming4us programming4us