Builder.cz - Informacni server o programovani

Odběr fotomagazínu

Fotografický magazín "iZIN IDIF" každý týden ve Vašem e-mailu.
Co nového ve světě fotografie!

 

Zadejte Vaši e-mailovou adresu:

Kamarád fotí rád?

Přihlas ho k odběru fotomagazínu!

 

Zadejte e-mailovou adresu kamaráda:

Soutěž

Sponzorem soutěže je:

IDIF – vaše škola fotografie

 

Kdo lektoruje pražský letní workshop v ZOO a Botanické zahradě?

V dnešní soutěži hrajeme o:

Dárkový certifikát v hodnotě 1000 Kč



Generovani kolekce objektu (recordu)

Seznam témat     Nová odpověď

Přihlásit se     Registrace     Zapomenuté heslo

Re: Generovani kolekce objektu (recordu)

Autor: algida

0:46:03 25.05.2011

Zdravim,
pri hledani vhodne literatury ke studiu sem narazil na Release It!
Design and Deploy Production-Ready Software od Michael T. Nygard
ISBN-10: 0-9787392-1-3 .
Neni to uplne nejnovejsi kousek, ale je to pomerne zajimava knizka.

Pokud nekdo ma zkusenost pripadne nazor, rad si poslechnu co si o knize
myslite :-)
A.
Dne 24.5.2011 11:40, algida napsal(a):
>
> Dekuji,
> na zdroje informaci se podivam a kod pouziju ne copy paste, ale opravdu
> diky moc za nakopnuti spravnym smerem.
>
> Preju alespon tak hezky den, jako mam ja :-)
> A.
> Dne 24.5.2011 11:35, RSTEIN napsal(a):
>> Rado se stalo, jen to také berte jako rychle reseni, které si mate sam
>> upravit a které se hlavne snazilo dodrzovat strukturu vaseho původního kodu.
>> Stahente si ten kod opravdu radeji z gistu, ještě jsem ho drobne upravoval
>>
>> K tem best practices:
>> Jako uplny zaklad bych videl, ze vsichni vyvojari umi rafaktorizovat a
>> nepisou třeba ty silene metody, co zminujete nize:
>>
>> http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/02014856
>> 72
>>
>> A také je pro zacatek vhodna velmi dobra kniha Clean Code od Roberta C.
>> Martina
>> http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/01323508
>> 82/ref=pd_sim_b_3
>>
>>
>> Zdravim
>> Rene Stein
>> http://blog.renestein.net
>> twitter: http://twitter.com/renestein
>>
>> Příspěvek zaslán emailem
>
> Příspěvek zaslán emailem


Příspěvek zaslán emailem

Citovat příspěvek

 

Re: Generovani kolekce objektu (recordu)

Autor: algida

11:40:44 24.05.2011

Dekuji,
na zdroje informaci se podivam a kod pouziju ne copy paste, ale opravdu
diky moc za nakopnuti spravnym smerem.

Preju alespon tak hezky den, jako mam ja :-)
A.
Dne 24.5.2011 11:35, RSTEIN napsal(a):
>
> Rado se stalo, jen to také berte jako rychle reseni, které si mate sam
> upravit a které se hlavne snazilo dodrzovat strukturu vaseho původního kodu.
> Stahente si ten kod opravdu radeji z gistu, ještě jsem ho drobne upravoval
>
> K tem best practices:
> Jako uplny zaklad bych videl, ze vsichni vyvojari umi rafaktorizovat a
> nepisou třeba ty silene metody, co zminujete nize:
>
> http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/02014856
> 72
>
> A také je pro zacatek vhodna velmi dobra kniha Clean Code od Roberta C.
> Martina
> http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/01323508
> 82/ref=pd_sim_b_3
>
>
> Zdravim
> Rene Stein
> http://blog.renestein.net
> twitter: http://twitter.com/renestein
>
> Příspěvek zaslán emailem


Příspěvek zaslán emailem

Citovat příspěvek

 

RE: Generovani kolekce objektu (recordu)

Autor: RSTEIN

11:35:26 24.05.2011

Rado se stalo, jen to také berte jako rychle reseni, které si mate sam
upravit a které se hlavne snazilo dodrzovat strukturu vaseho původního kodu.
Stahente si ten kod opravdu radeji z gistu, ještě jsem ho drobne upravoval

K tem best practices:
Jako uplny zaklad bych videl, ze vsichni vyvojari umi rafaktorizovat a
nepisou třeba ty silene metody, co zminujete nize:

http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/02014856
72

A také je pro zacatek vhodna velmi dobra kniha Clean Code od Roberta C.
Martina
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/01323508
82/ref=pd_sim_b_3


Zdravim
Rene Stein
http://blog.renestein.net
twitter: http://twitter.com/renestein

Příspěvek zaslán emailem

Citovat příspěvek

 

Re: Generovani kolekce objektu (recordu)

Autor: algida

11:21:32 24.05.2011

Uhhhh,
dekuju mooc, uz sem aplikoval reseni s tim ze menim primo vlastnosti
row, nelibilo se mi to, konecne dneska budu mit z prace taky radost.
Hned si to nastuduju a zatepla upravim svuj kod.

Zacal sem totiz tak nejak hledat jake jsou overene praktiky pri
programovani a z hruzou sem zjistil, ze delame 90% tak jak by se nemelo :-)

Drive sem Unit Testy povazoval za pomerne peknou moznost testovani kodu,
bohuzel se u nas ve firme na podobne veci nahlizi jako na ztratu casu,
tak sem si zacal psat svoje testy bokem pouze z duvodu uceni se. No a
musim rict ze prozatim vice nez otestovani casti aplikace se mi zamlouva
to, ze me to nuti psat pruhlednej a citelnej kod, coz pri pohledu do
nasich zdrojovych kodu je opravdu rozdil. Nejsou vyjimkou tridy ktere
maji 1000+ radek pricemc 80% tridy tvori 2-3 metody :-)




Jeste jednou dekuju mnohokrat. a kdyby bylo mozne Vas poprosit o nejaky
zdroj best practices budu velmi vdecny.

Ales.

Dne 24.5.2011 10:50, RSTEIN napsal(a):
>
> Dobry den,
> ten popis je trochu zmateny;), ale pokusil jsem se vyjit z toho, co jste mi
> naznačil a také jsem viděl, že používáte asi C#.
>
> Kod jsem dal i na GitHub (gisty), protože Builder emailové příspěvky sám
> neformátuje.
> http://jdem.cz/nzzx4
>
> Jednoducha trida Row, která se ale tvari jako imutabilni, což znamená, že
> všechny metody pro změnu instance vrací novou instanci (podobně se v .Net
> chová třída string), což mi umožní zachytit všechny změny na konkrétní
> instanci.
>
> using System;
> using System.Collections.Generic;
> using System.Linq;
> using System.Text;
>
> namespace Builder_Algida_Row_Generator
> {
> class Row
> {
>
> public Row(int value1, decimal a, decimal b, decimal c, decimal d,
> decimal e, decimal f)
> {
> Value1 = value1;
> A = a;
> B = b;
> C = c;
> D = d;
> E = e;
> F = f;
> }
>
> public Row() : this(0, 0m, 0m, 0m, 0m, 0m, 0m)
> {
>
> }
>
> public int Value1
> {
> get;
> private set;
> }
>
> public decimal A
> {
> get;
> private set;
> }
>
> public decimal B
> {
> get;
> private set;
> }
>
> public decimal C
> {
> get;
> private set;
> }
>
> public decimal D
> {
> get;
> private set;
> }
>
> public decimal E
> {
> get;
> private set;
> }
>
> public decimal F
> {
> get;
> set;
> }
>
> public Row ChangeValue1(int value1)
> {
> return new Row(value1, A, B, C, D, E, F);
> }
>
> public Row ChangeA(decimal a)
> {
> return new Row(Value1, a, B, C, D, E, F);
> }
>
> public Row ChangeB(decimal b)
> {
> return new Row(Value1, A, b, C, D, E, F);
> }
>
>
> public Row ChangeC(decimal c)
> {
> return new Row(Value1, A, B, c, D, E, F);
> }
>
> public Row ChangeD(decimal d)
> {
> return new Row(Value1, A, B, C, d, E, F);
> }
>
> public Row ChangeE(decimal e)
> {
> return new Row(Value1, A, B, C, D, e, F);
> }
>
> public Row ChangeF(decimal f)
> {
> return new Row(Value1, A, B, C, D, E, f);
> }
>
>
> }
> }
>
>
> Třída RowGenerator generuje řádky a může být parametrizována libovolným
> množstvím delegátů (argument params Func[] rowGenerators).
> Pokud žádnou funkci nepředáte, vygenerují se řádky pomocí výchozího
> konstruktoru a nijak modifikovány nebudou.
>
> Další možná rozšíření:
>
> 1) Můžete do metody Generate vložit výchozí inicializaci objektů row, která
> bude složitější a hlavně je při každé inicializaci stejná. V tomto případě
> pak nemusíte metode Generate v argumentu rowGenerators předat při každém
> volání znovu a znovu delegáta, který dělá vždy to samé.
>
> 2) Podívejte se do komentářů v kódu. Nejen že dostanete řádky s výslednými
> hodnotami, ale pokud chcete, tak v samopopisné kolekci rowsWithHistory
> naleznete pro každý řádek LinkedList, který vám dovolí sledovat všechny
> změny, které na řádku proběhly. Pokud s nimi pracovat nechcete, nemusíte, do
> proměnné m_rows je uložena poslední verze řádků.
>
> using System;
> using System.Collections.Generic;
> using System.Linq;
> using System.Text;
>
> namespace Builder_Algida_Row_Generator
> {
> class RowGenerator
> {
> public RowGenerator()
> {
> m_rows = new List();
> }
>
> private List m_rows;
>
> public Row GetRow(int index)
> {
> return m_rows[index];
> }
>
> public void Generate (int numberOfRows, params Func[]
> rowGenerators)
> {
>
>
> var innerRowGenerator = rowGenerators ?? new Func[]
> {(index, row) => new Row()};
> var generatorExtensions = new GeneratorExtensions(); //I tato třída
> může být skryta za rozhraním a injektována do objektu
>
>
> var rowsWithHistory = Enumerable.Range(0, numberOfRows)
> .Select(index => new {Row = new Row(), Index =
> index})
> .Aggregate(new List>(),
> (result, rowData) =>
> {
> var rowHistory =
> generatorExtensions.ApplyFunctionsWithHistory(rowData.Row, rowData.Index,
> innerRowGenerator);
> result.Add(rowHistory);
> return result;
> }
> );
>
> //V rowsWithHistory mám historii změn na objektu, pokud ji
> nepotřebuju, vyzvednu poslední objekt v každém listu
> m_rows = rowsWithHistory.Select(linkedList =>
> linkedList.Last.Value).ToList();
>
>
> }
> }
> }
>
> Pomocná metoda ApplyfunctionsWithHistory používaná v generátoru (var
> rowHistory = generatorExtensions.ApplyFunctionsWithHistory(rowData.Row,
> rowData.Index, innerRowGenerator);
>
> using System;
> using System.Collections.Generic;
> using System.Linq;
> using System.Text;
>
> namespace Builder_Algida_Row_Generator
> {
> class GeneratorExtensions
> {
> public LinkedList ApplyFunctionsWithHistory> TReturn>(TReturn arg1, TA1 arg2,
>
> params Func[] innerFunctions)
> {
> var linkedList = new LinkedList();
> linkedList.AddFirst(arg1);
>
> if (innerFunctions == null)
> {
>
> return linkedList;
> }
>
> innerFunctions.Aggregate(new {List = linkedList, LastValue =
> linkedList.Last.Value},
> (currentValues, func) =>
> {
> var lastValue = currentValues.LastValue;
> var newValue = func(lastValue, arg2);
> if (!newValue.Equals(lastValue))
> {
> currentValues.List.AddLast(newValue);
> }
>
> return new {List = currentValues.List,
> LastValue = newValue};
> },
>
> lastValues => lastValues.LastValue
>
> );
>
>
> return linkedList;
>
> }
> }
> }
>
> Zde je ukázka generování. Vygeneruju 200 řádků a vypíšu jejich vlastnost C.
> Metodě Generate předávám lambda výrazy, nebo když potřebuji, tak mohu
> samozřejmě dodat i složitější běžné instanční i staické funkce (ukázkou je v
> kódu metoda new SpecialGeneratorFunctions().ChangeDValue));. Další proměnné,
> které mohu chtít při generování používat jsou zachyceny v lambda výrazech -
> u vás metoda Generate měla argumenty x a y, což ji rovnou svazovalo s
> určitým algoritmem, jehož kroky právě na těchto proměnných závisí.
>
> using System;
> using System.Collections.Generic;
> using System.Linq;
> using System.Text;
>
> namespace Builder_Algida_Row_Generator
> {
> class Program
> {
> static void Main(string[] args)
> {
> const int TESTROWS = 200;
> var rowGenerator = new RowGenerator();
> //Zachycení proměnných pro generování řádku v lambdách
> decimal x = 10;
> decimal y = 20;
> rowGenerator.Generate(TESTROWS, (row, index) => row.ChangeA(x / y),
> (row, index) => row.ChangeB(x * y /
> (index + 1)),
> (row, index) => row.ChangeC(index +
> 1),
> new
> SpecialGeneratorFunctions().ChangeDValue);
>
>
> Enumerable.Range(0, TESTROWS).Select(index =>
> rowGenerator.GetRow(index))
> .ToList().ForEach(row =>
> Console.WriteLine(row.C));
>
> Console.ReadLine();
> //
>
> //for (int i=0; i> //{
> // Radka r = new Radka();
> // radky.Add(r);
> // r.a = x/y;
> // r.b = x*y/(i+1)
> // r.c = i+1
> // if (r.b > r.a)
> // r.= r.b-r.a;
> // .........
> }
>
>
> }
> }
>
> SpecialGeneratorFunctions().ChangeDValue
> using System;
> using System.Collections.Generic;
> using System.Linq;
> using System.Text;
>
> namespace Builder_Algida_Row_Generator
> {
> class SpecialGeneratorFunctions
> {
> public SpecialGeneratorFunctions()
> {
>
> }
>
> public Row ChangeDValue(Row row, int index)
> {
> if (row == null)
> {
> throw new ArgumentNullException("row");
> }
>
> var returnRow = row;
>
> if (row.B > row.A)
> {
> returnRow = row.ChangeD(row.B - row.A);
> }
>
> return returnRow;
>
> }
> }
> }
>
>
> Zdravim
> Rene Stein
> http://blog.renestein.net
> twitter: http://twitter.com/renestein
> Příspěvek zaslán emailem


Příspěvek zaslán emailem

Citovat příspěvek

 

RE: Generovani kolekce objektu (recordu)

Autor: RSTEIN

10:50:48 24.05.2011

Dobry den,
ten popis je trochu zmateny;), ale pokusil jsem se vyjit z toho, co jste mi
naznačil a také jsem viděl, že používáte asi C#.

Kod jsem dal i na GitHub (gisty), protože Builder emailové příspěvky sám
neformátuje.
http://jdem.cz/nzzx4

Jednoducha trida Row, která se ale tvari jako imutabilni, což znamená, že
všechny metody pro změnu instance vrací novou instanci (podobně se v .Net
chová třída string), což mi umožní zachytit všechny změny na konkrétní
instanci.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Builder_Algida_Row_Generator
{
class Row
{

public Row(int value1, decimal a, decimal b, decimal c, decimal d,
decimal e, decimal f)
{
Value1 = value1;
A = a;
B = b;
C = c;
D = d;
E = e;
F = f;
}

public Row() : this(0, 0m, 0m, 0m, 0m, 0m, 0m)
{

}

public int Value1
{
get;
private set;
}

public decimal A
{
get;
private set;
}

public decimal B
{
get;
private set;
}

public decimal C
{
get;
private set;
}

public decimal D
{
get;
private set;
}

public decimal E
{
get;
private set;
}

public decimal F
{
get;
set;
}

public Row ChangeValue1(int value1)
{
return new Row(value1, A, B, C, D, E, F);
}

public Row ChangeA(decimal a)
{
return new Row(Value1, a, B, C, D, E, F);
}

public Row ChangeB(decimal b)
{
return new Row(Value1, A, b, C, D, E, F);
}


public Row ChangeC(decimal c)
{
return new Row(Value1, A, B, c, D, E, F);
}

public Row ChangeD(decimal d)
{
return new Row(Value1, A, B, C, d, E, F);
}

public Row ChangeE(decimal e)
{
return new Row(Value1, A, B, C, D, e, F);
}

public Row ChangeF(decimal f)
{
return new Row(Value1, A, B, C, D, E, f);
}


}
}


Třída RowGenerator generuje řádky a může být parametrizována libovolným
množstvím delegátů (argument params Func[] rowGenerators).
Pokud žádnou funkci nepředáte, vygenerují se řádky pomocí výchozího
konstruktoru a nijak modifikovány nebudou.

Další možná rozšíření:

1) Můžete do metody Generate vložit výchozí inicializaci objektů row, která
bude složitější a hlavně je při každé inicializaci stejná. V tomto případě
pak nemusíte metode Generate v argumentu rowGenerators předat při každém
volání znovu a znovu delegáta, který dělá vždy to samé.

2) Podívejte se do komentářů v kódu. Nejen že dostanete řádky s výslednými
hodnotami, ale pokud chcete, tak v samopopisné kolekci rowsWithHistory
naleznete pro každý řádek LinkedList, který vám dovolí sledovat všechny
změny, které na řádku proběhly. Pokud s nimi pracovat nechcete, nemusíte, do
proměnné m_rows je uložena poslední verze řádků.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Builder_Algida_Row_Generator
{
class RowGenerator
{
public RowGenerator()
{
m_rows = new List();
}

private List m_rows;

public Row GetRow(int index)
{
return m_rows[index];
}

public void Generate (int numberOfRows, params Func[]
rowGenerators)
{


var innerRowGenerator = rowGenerators ?? new Func[]
{(index, row) => new Row()};
var generatorExtensions = new GeneratorExtensions(); //I tato třída
může být skryta za rozhraním a injektována do objektu


var rowsWithHistory = Enumerable.Range(0, numberOfRows)
.Select(index => new {Row = new Row(), Index =
index})
.Aggregate(new List>(),
(result, rowData) =>
{
var rowHistory =
generatorExtensions.ApplyFunctionsWithHistory(rowData.Row, rowData.Index,
innerRowGenerator);
result.Add(rowHistory);
return result;
}
);

//V rowsWithHistory mám historii změn na objektu, pokud ji
nepotřebuju, vyzvednu poslední objekt v každém listu
m_rows = rowsWithHistory.Select(linkedList =>
linkedList.Last.Value).ToList();


}
}
}

Pomocná metoda ApplyfunctionsWithHistory používaná v generátoru (var
rowHistory = generatorExtensions.ApplyFunctionsWithHistory(rowData.Row,
rowData.Index, innerRowGenerator);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Builder_Algida_Row_Generator
{
class GeneratorExtensions
{
public LinkedList ApplyFunctionsWithHistoryTReturn>(TReturn arg1, TA1 arg2,

params Func[] innerFunctions)
{
var linkedList = new LinkedList();
linkedList.AddFirst(arg1);

if (innerFunctions == null)
{

return linkedList;
}

innerFunctions.Aggregate(new {List = linkedList, LastValue =
linkedList.Last.Value},
(currentValues, func) =>
{
var lastValue = currentValues.LastValue;
var newValue = func(lastValue, arg2);
if (!newValue.Equals(lastValue))
{
currentValues.List.AddLast(newValue);
}

return new {List = currentValues.List,
LastValue = newValue};
},

lastValues => lastValues.LastValue

);


return linkedList;

}
}
}

Zde je ukázka generování. Vygeneruju 200 řádků a vypíšu jejich vlastnost C.
Metodě Generate předávám lambda výrazy, nebo když potřebuji, tak mohu
samozřejmě dodat i složitější běžné instanční i staické funkce (ukázkou je v
kódu metoda new SpecialGeneratorFunctions().ChangeDValue));. Další proměnné,
které mohu chtít při generování používat jsou zachyceny v lambda výrazech -
u vás metoda Generate měla argumenty x a y, což ji rovnou svazovalo s
určitým algoritmem, jehož kroky právě na těchto proměnných závisí.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Builder_Algida_Row_Generator
{
class Program
{
static void Main(string[] args)
{
const int TESTROWS = 200;
var rowGenerator = new RowGenerator();
//Zachycení proměnných pro generování řádku v lambdách
decimal x = 10;
decimal y = 20;
rowGenerator.Generate(TESTROWS, (row, index) => row.ChangeA(x / y),
(row, index) => row.ChangeB(x * y /
(index + 1)),
(row, index) => row.ChangeC(index +
1),
new
SpecialGeneratorFunctions().ChangeDValue);


Enumerable.Range(0, TESTROWS).Select(index =>
rowGenerator.GetRow(index))
.ToList().ForEach(row =>
Console.WriteLine(row.C));

Console.ReadLine();
//

//for (int i=0; i //{
// Radka r = new Radka();
// radky.Add(r);
// r.a = x/y;
// r.b = x*y/(i+1)
// r.c = i+1
// if (r.b > r.a)
// r.= r.b-r.a;
// .........
}


}
}

SpecialGeneratorFunctions().ChangeDValue
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Builder_Algida_Row_Generator
{
class SpecialGeneratorFunctions
{
public SpecialGeneratorFunctions()
{

}

public Row ChangeDValue(Row row, int index)
{
if (row == null)
{
throw new ArgumentNullException("row");
}

var returnRow = row;

if (row.B > row.A)
{
returnRow = row.ChangeD(row.B - row.A);
}

return returnRow;

}
}
}


Zdravim
Rene Stein
http://blog.renestein.net
twitter: http://twitter.com/renestein
Příspěvek zaslán emailem

Citovat příspěvek

 

Re: Generovani kolekce objektu (recordu)

Autor: algida

16:26:20 23.05.2011

Dne 23.5.2011 14:46, algida napsal(a):
>
> Zdravim,
> rad bych Vas poprosil o nazor, pripadne doporuceni jak se nejlepe poprat
> s nasledujicim problemem.
>
> Potrebuji vygenerovat kolekci radek, kde znam vstupni hodnoty jako pocet
> radek a zakladni informace pro plneni radek.
>
> Nicmene plneni jednotlivych sloupcu v radccich muze zaviset jak na
> hodnotach, ktere byly vlozeny do predchozich radek kolekce, tak na tom,
> jaka hodnota v aktualne plnenem radu je v urcitem sloupci.
>
> Cela metoda plneni radku je pomerne hodne neprehledna.
>
> Problem by se dal vyresit nekolika zpusoby.
> 1. nekolikanasobny pruchod kolekci, pricemz by se vzdy spocetlo cast
> udaju radky. I kdyz nic jineho, tak to alespon zprehledni vypocet.
> Nicmene me trapi predstava, ze vypocetni trida modifikuje
> nekontrolovatelne kolekci radek a tudiz si mohou jednotlive tridy
> zodpovedne za urcitou cast vypoctu menit sloupce. Takze po case by mohlo
> dojit k tomu, ze z neznamych duvodu nekdo upravy cast vypoctu a tim
> rozbije jinou cast vypoctu.
>
> 2. Jeden pruchod kolekci a volani metod zaregistrovanych instanci
> objektu pro jednotlive casti vypoctu. Toto se mi libi, nicmene moc se mi
> nelibi ze by jednotlive instance dostavaly referenci na poctiany radek a
> hodnoty v tomto radku primo menily. Tim by se snadno mohlo stat, ze
> vysledek po case bude o5 strasne neprehledny v tom smyslu, ze Vypocetni
> tridy si budou modifikovat sloupce po svem a nikde neni jistota, ze
> vstupni hodnoty potrebnych sloupcu nektera z predchozich trid nezmenila,
> tak ze vypocet jiz nebude fungovat.
>
> Nevim jestli jsem se dokazal vyjadrit alespon trochu pochopitelne.
> Nicmene obe reseni se mi nelibi z pohledu toho, ze sice zezacatku bude
> krasne citelny vypocet (ktery bude rozdelen na ruzne tridy po logickych
> castech vypoctu), ale casem se vypocet muze nekontrolovane zmenit a muze
> dochazet k nepredpokladatelnym chybam, jelikoz nekdo upravi cast, ktera
> rozbije jinou cast.
>
> Mozna by bylo resenim posilat do jednotlivych casti vypoctu Clony
> kolekce radek a pri navratu se postarat o modifikaci kmenove kolekce.
> Ale toto reseni mi prijde prehnane slozite.
>
> Rad bych Vas poprosil, jestli tedy existuje, o nejake osvedcene reseni,
> ktere by mohlo nastinit jakou cestou se dat.
>
>
> Dekuji mnohokrat A.
>
> Příspěvek zaslán emailem
Aha, tak jak to tak po sobe ctu tak to moc zrejme neni.

public Radka
{
public int podari;
public decimal a, b, c, d, e, f;
}

public Generator
{
private List radky = new ..... ;
public Radka GetRadka (int i)
{
return radky[i];
}
public void Generuj (int pocet, int x, int y)
{
for (i=0;i {
Radka r = new Radka();
radky.Add(r);
r.a = x/y;
r.b = x*y/(i+1)
r.c = i+1
if (r.b > r.a)
r.= r.b-r.a;
.........
}
}
}

Tridy na hore jsou pouze jako jednoduchy priklad.
Nicmene jedna se o prepsani tridy Generuj, tak aby jednotlive hodnoty
(nebo mnoziny hodnot) mohly pocitat samostatne tridy, tak aby se vypocet
rozdelil na logicke celky a pripadne se dalo modifikovat generovani
radek tim, ze se zaregistruji a pouziji ruzne tridy samostatnych vypoctu.

Vypocetni tridy by mohly vypadata takto

public VypocetniTrida
{
SetupParm _parm;
VypocetniTrida (SetupParm p)
{
_parm = p;
}
void Pocitej (Radka r)
{
r.a = _parm.x/parm.y;
}
}
Pripadne nejake kontroly a navratova hodnota podle toho jak dopadl vypocet.
Co se mi na tomto reseni nelibi je ze se bude menit primo predavana radka.
Bohuzel me nenapada nejake pekne reseni jak to udelat jinak.
Krom snad toho, ze kazda vypocetni trida bude mit ruzne navratove
hodnoty (nebo pole navratovych hodnot) ktere se potom nastavi v Generuj
do prislusnych sloupcu Radky.
Toto se mi prilis nelibi, protoze co vypocet ( a vypocetnich trid muze
byt pomerne mnoho) to ruzna navratova kolekce a to by zase pomerne
zneprehlednilo aplikaci VypocetniTrida.Pocitej.

Doufam, ze nyni je problem trochu vic zrejmy.

Dekuji A.

Příspěvek zaslán emailem

Citovat příspěvek

 

Generovani kolekce objektu (recordu)

Autor: algida

14:46:53 23.05.2011

Zdravim,
rad bych Vas poprosil o nazor, pripadne doporuceni jak se nejlepe poprat
s nasledujicim problemem.

Potrebuji vygenerovat kolekci radek, kde znam vstupni hodnoty jako pocet
radek a zakladni informace pro plneni radek.

Nicmene plneni jednotlivych sloupcu v radccich muze zaviset jak na
hodnotach, ktere byly vlozeny do predchozich radek kolekce, tak na tom,
jaka hodnota v aktualne plnenem radu je v urcitem sloupci.

Cela metoda plneni radku je pomerne hodne neprehledna.

Problem by se dal vyresit nekolika zpusoby.
1. nekolikanasobny pruchod kolekci, pricemz by se vzdy spocetlo cast
udaju radky. I kdyz nic jineho, tak to alespon zprehledni vypocet.
Nicmene me trapi predstava, ze vypocetni trida modifikuje
nekontrolovatelne kolekci radek a tudiz si mohou jednotlive tridy
zodpovedne za urcitou cast vypoctu menit sloupce. Takze po case by mohlo
dojit k tomu, ze z neznamych duvodu nekdo upravy cast vypoctu a tim
rozbije jinou cast vypoctu.

2. Jeden pruchod kolekci a volani metod zaregistrovanych instanci
objektu pro jednotlive casti vypoctu. Toto se mi libi, nicmene moc se mi
nelibi ze by jednotlive instance dostavaly referenci na poctiany radek a
hodnoty v tomto radku primo menily. Tim by se snadno mohlo stat, ze
vysledek po case bude o5 strasne neprehledny v tom smyslu, ze Vypocetni
tridy si budou modifikovat sloupce po svem a nikde neni jistota, ze
vstupni hodnoty potrebnych sloupcu nektera z predchozich trid nezmenila,
tak ze vypocet jiz nebude fungovat.

Nevim jestli jsem se dokazal vyjadrit alespon trochu pochopitelne.
Nicmene obe reseni se mi nelibi z pohledu toho, ze sice zezacatku bude
krasne citelny vypocet (ktery bude rozdelen na ruzne tridy po logickych
castech vypoctu), ale casem se vypocet muze nekontrolovane zmenit a muze
dochazet k nepredpokladatelnym chybam, jelikoz nekdo upravi cast, ktera
rozbije jinou cast.

Mozna by bylo resenim posilat do jednotlivych casti vypoctu Clony
kolekce radek a pri navratu se postarat o modifikaci kmenove kolekce.
Ale toto reseni mi prijde prehnane slozite.

Rad bych Vas poprosil, jestli tedy existuje, o nejake osvedcene reseni,
ktere by mohlo nastinit jakou cestou se dat.


Dekuji mnohokrat A.

Příspěvek zaslán emailem

Citovat příspěvek

 

 

 

Přihlášení k mému účtu

Uživatelské jméno:

Heslo: