- Motorola Edge 50 Neo - az egyensúly gyengesége
- Fenntartható, tartós kiegészítőket mutatott be a Fairphone
- Xiaomi 14T Pro - teljes a család?
- Zeiss triplakamera az új Vivo V60-ban
- Erős hardverrel érkezik a Honor 10 000 mAh-s mobilja
- Samsung Galaxy S24 Ultra - ha működik, ne változtass!
- Samsung Galaxy Z Fold7 - ezt vártuk, de…
- Samsung Galaxy Watch7 - kötelező kör
- Honor Magic V5 - méret a kamera mögött
- Jimmy Choo felel a Magic V Flip 2 dizájnjáért
Hirdetés
Új hozzászólás Aktív témák
-
Karma
félisten
using Ionic.Zip;
namespace ZipTest
{
class Program
{
static void Main(string[] args)
{
using (var zip = new ZipFile())
{
zip.AddEntry("doge.txt", "much zip very programming wow");
zip.Save(@"D:\test.zip");
}
}
}
}Ez bizony a D: meghajtóm gyökerében hozta létre a fájlt. (DotNetZip)
-
Karma
félisten
válasz
pigster
#5765
üzenetére
Mi mindent akarsz a UserControlba rakni? Ha csak egy TextBlockot, aminek a propertyjei felét kitöltöd előre, akkor bele se fogj, írj inkább egy Style resource-ot hozzá.
Nem árt az se, ha kihasználod azt, hogy a TextBlock több Runt tartalmazhat, amik külön-külön formázhatóak.
Ha kicsit több minden is van, akkor javaslom inkább a saját Control osztályt, aminek egyrészt annyi Dependency Propertyt írsz, amennyit nem szégyellsz (aztán ezeket annyi helyre bindolod, amennyire akarod), másrészt még akár logikát is írhatsz bele, ha nagyon muszáj.
Szóval mit is szeretnél kihozni ebből?
-
Karma
félisten
A greedy kifejezés a lehető legtöbb karaktert próbálja illeszteni, azaz ha több lehetőség is van, a leghosszabbat fogja választani. A lazy ezzel szemben a rövidebbet.
Mutatok egy példát, mert magyarázni nem igazán tudok ezen a héten:
Bemenet Regex Eredmény
almabeka kecskebeka ==> (.*)beka ==> 1 match: "almabeka kecskebeka"
almabeka kecskebeka ==> (.*?)beka ==> 2 match: "almabeka" és " kecskebeka"Az első a greedy, a második a lazy kifejezés. Aláhúzással jelöltem, hogy a zárójel mit fogott be a zárójel groupba. Fontos, hogy a kecske előtti szóköz is benne van! Csak azt nem tudom megformázni valamiért.
Látszik, hogy mivel a bemeneten a "beka" szöveg kétszer is szerepel, a greedy a végét vette figyelembe, az összes többi köztes karaktert (benne az első békát) behajította a zárójelbe. A lazy meg szétvágta és különvette a két illeszkedő mintát.
Egyébként a RegexPal a barátod, ha regexekkel foglalkozol: egy kísérletezésre alkalmas terület és még egy mini összefoglaló is a szintaxisról.
-
-
Karma
félisten
válasz
K_Gabor
#5722
üzenetére
1) Menübe tudtommal nem lehet csak úgy bármit belepakolni. Bejelölt menüelemeket ez az MSDN link alapján a MenuItem Checked propertyjével tudsz csinálni, némi lábbal hajtással.
2) Erről sajnos nem tudok nyilatkozni.
(#5725) Ticituc: Mármint XML-t szeretnél generálni? Szerintem a LINQ2XML (XDocument és társai) elég praktikus olvasáshoz és íráshoz is, ami nem mellesleg működik mindenhol - beleértve a WP, WinRT és PCL projekteket is.
-
Karma
félisten
Intraneten vagy interneten keresztül? Sima internetelérés van kifelé a két helyen?
Mert akkor egy köztes szerverrel meg lehet oldani. Például ha mindez realtime kell, a Pusher egy elég jó megoldás már az ingyenes sandbox módban is; ha meg nem muszáj, akkor ott van például az email.
-
Karma
félisten
"Hibával elszáll a program" - ilyet már kérdezni is teljesen felesleges. Konkrétan melyik sor, és ami még fontosabb, milyen exceptiont dob?
Egyébként egy dolgot kapásból látok. A következő sor 10-nél kisebb számoknál feldolgozhatatlan eredményt ad:
String.Format("{0}:{1}", udHours.Value, udMinutes.Value)Helyette formázd két számjegyre az értékeket:
String.Format("{0:00}:{1:00}", udHours.Value, udMinutes.Value)Így már csinál valamit korábbi időpontra, de az elég messze van a helyestől. Lásd itt.
Szerintem úgy kellene megoldani, hogy a TimeSpan számítás előtt megnézed < operátorral, hogy melyik dátum a nagyobb, és ennek megfelelően elvégzed a korrekciót.
-
Karma
félisten
Ahhoz képest, hogy az előző kódot metrón zötykölődve, telefonon írtam, csak egy dolgot hibáztam el benne: a Color.Blacket nem lehet default paraméternek használni, mert nem konstans. (Meg is szerkesztem a kódot.)
Ezt leszámítva működik, most próbáltam ki egy Forms projektben.
Ide feltettem az egész solutiont. -
Karma
félisten
Pedig csak szintaktika innen, ha a példa működött.
public static class RichTextBoxExtensions
{
public static void AppendWithColor(this RichTextBox rtb, string text, Color color)
{
var length = rtb.TextLength;
rtb.AppendText(text);
rtb.Select(length, text.Length);
rtb.SelectionColor = color;
rtb.SelectionLength = 0;
}
}Szerk.: a harmadik sorból kivettem egy default paramétert.
-
Karma
félisten
Ha ilyet akarsz, nem nagyon tudod megúszni, hogy számon tartsd, mi volt az Append előtti utolsó hossz, és az Append után ezt felhasználva a jó pozíciót jelöld ki. Én írnék egy extension methodot a RichTextBox osztályra (pl. AppendWithColor) néven, ami ezt intézi, és mindenhol ezt használnám.
-
-
Karma
félisten
Uh, az kemény. Nézd meg ezt a kódot - a Main függvényt mindenképp, a többi onnantól logikus.
Ezen az úton felül tudod bírálni, hogy mi történjen az el nem kapott exceptionnel. Ha beiktatsz egy Console.WriteLine-t is és parancssorból futtatod a programod, meglesz a stacktrace.
-
Karma
félisten
válasz
sztanozs
#5647
üzenetére
C# topikban, C# specifikus jelölésekkel gyanús, hogy C#-ot kérdezne.
KREE: Milyen jellegű segítségre gondolsz? Valaki írja meg ezt a feladatot, hogy lásd a megoldást? Jó lesz az neked? Eléggé lebetűzi a feladat, hogy mit kell csinálni, épp csak magyar mondatok helyett félangol-félzárójelre kell átfordítanod.
hcl: VS-ben nem látszik a bezáráskor eldobott exception? Esetleg a Debug menü Exceptions alatt pipáld be a Common Language Runtime hibáknál az automatikus breakpointot, hátha jobban el tudod kapni.
-
#5634
Karma
félisten
trisztan94
#5632
Karma
félisten
válasz
trisztan94
#5632
üzenetére
Programok telepítése és törlése - Visual Studio 2013 - Módosítás.
Csak a biztonság kedvéért nézz rá.Ha nem vezet eredményre, akkor próbáld meg kézzel feltelepíteni a dev.windowsphone.comról, SDK8.0 alatt.
-
#5631
Karma
félisten
trisztan94
#5630
Karma
félisten
válasz
trisztan94
#5630
üzenetére
Nem ártana a WP8 SDK-t is telepítened, expressnél úgy tűnik az külön téma.
-
Karma
félisten
válasz
tototos
#5623
üzenetére
Íme:
class LDF_akarmi
{
private DataTable _signals = new DataTable("Signals");
private DataTable _frames = new DataTable("Frames");
public LDF_akarmi()
{
InitTable(_signals, SignalTableColumns);
InitTable(_frames, FrameTableColumns);
}
private static readonly IList<Tuple<string, Type>> SignalTableColumns = new[]
{
new Tuple<string, Type>("Name", typeof(string)),
new Tuple<string, Type>("Size", typeof(byte)),
new Tuple<string, Type>("Initval", typeof(UInt16)),
new Tuple<string, Type>("TypeID", typeof(string)),
};
private static readonly IList<Tuple<string, Type>> FrameTableColumns = new Tuple<string, Type>[]
{
new Tuple<string, Type>("Name", typeof(string)),
new Tuple<string, Type>("ID", typeof(UInt16)),
new Tuple<string, Type>("Size", typeof(byte)),
new Tuple<string, Type>("SlotTime", typeof(Single)),
new Tuple<string, Type>("Transmit", typeof(byte))
};
private void InitTable(DataTable table, IEnumerable<Tuple<string, Type>> columns)
{
table.Columns.AddRange(columns.Select(col => new DataColumn(col.Item1, col.Item2)).ToArray());
}
}Szerintem elég drasztikus a különbség. A DataColumn[] tagváltozóid egyébként meg teljesen feleslegesek, így tömörítve meg még csak létre se jönnek külön. Ja és for ciklus se kellett, hiszen van AddRange metódusa a Columnsnek
Amúgy miért használsz DataSetet meg DataTable-t? Megjelenítésnél kihasználod ezeket az osztályokat? Mert ha nem, akkor valószínűleg jobban járnál, ha a Signalnak és a Frame-nek külön osztályt vezetnél be az ilyet táblás zsonglőrködés helyett.
-
Karma
félisten
válasz
tototos
#5621
üzenetére
Három dolog vágott szembe elsőre:
1) A System.Type.GetType(string) egy törékeny, és teljesen felesleges mellélövés, használd inkább a typeof operátort. Így biztos, hogy nem írod el a névteret, és azt a típust jelenti, amit szeretnél.
Például System.Type.GetType("System.String") helyett typeof(String).
2) Másrészt a kódod rettenetesen redundáns.
a) Például a két konstruktort (filename paraméteres és paraméter nélküli) simán össze tudnád vonni egybe, opcionális paraméterrel vagy a this konstruktor láncolással.
b) Magában a konstruktorban jön ki nagyon, hogy ismételed önmagad: ugyanaz a szerkezet ismétlődik újra meg újra meg újra, copy-paste-tel gondolom egyszerű volt megírni, de ez is nagyon törékeny és karbantarthatatlan. Az oszlopok definícióit ki kéne szervezned egy static readonly tömbbe (benne pl. string+Type Tuple-ökkel), és for ciklussal helyettesíteni az ismétlődő részeket.3) Túl hosszú és monolitikus. A 600 soros blob helyett szét kéne szedni – felelősség szerint – 100-150 soros darabokra.
-
#5609
Karma
félisten
trisztan94
#5608
Karma
félisten
válasz
trisztan94
#5608
üzenetére
Iratkozz fel a MediaElement többi eseményére is, biztos lesz jelzés hogy hiba van. A MediaOpenedre Play felesleges, ha az AutoPlayt true-ra állítod.
-
#5607
Karma
félisten
trisztan94
#5606
Karma
félisten
válasz
trisztan94
#5606
üzenetére
xmlns:controls="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Toolkit"
Ennek jónak kell lennie, de csak ebben a formában.
-
#5604
Karma
félisten
trisztan94
#5603
Karma
félisten
válasz
trisztan94
#5603
üzenetére
Ott kezdődik, hogy a feltöltés után 24 óra, amíg elérhetővé válik a csomag a linken.
-
#5602
Karma
félisten
trisztan94
#5601
Karma
félisten
válasz
trisztan94
#5601
üzenetére
A Store-ban feltöltésnél lehetőséged van arra, hogy Betaként töltsd fel az alkalmazást, amit csak megadott felhasználók érhetnek el (a Microsoft accountjaikat fel kell sorolnod feltöltéskor), és ők is csak úgy, hogy neked kell elküldened a linket hozzá.
A folyamat kb. magától értetődő, de nagyon lassú.
Illetve egy próbát megérhet a Windows Phone Power Tools különálló csomag. De ezt sose próbáltam így.
-
Karma
félisten
válasz
Pttypang
#5599
üzenetére
Úgy, hogy bár én nagyon kényelmesnek találom az IoC konténert, a kitalálása előtt is volt élet. Nevezz ki egy objektumot a viewmodelek létrehozásáért felelősnek fejben - például a ViewModelLocator elég kézenfekvő -, csinálj tagváltozókat a VM-eknek, és példányosítsd őket kézzel.
A példányokat meg propertyken át add oda a Page-eknek, mint általában szokás.
-
#5598
Karma
félisten
trisztan94
#5592
Karma
félisten
válasz
trisztan94
#5592
üzenetére
Kinyomoztam, a CustomMessageBox alap sablonjában be van égetve a 480-as szélesség a belső tartalomhoz. Ha veszed ezt a XAML-t és berakod az App.xaml-ödbe, és átírod a Width="480"-at (például kiveszed), akkor teljes szélességű belsőt csinálhatsz.
-
#5595
Karma
félisten
trisztan94
#5592
Karma
félisten
válasz
trisztan94
#5592
üzenetére
Próbálkoztam egy kicsit vele, szerintem ezt nem fogod tudni a CustomMessageBox gyári állapotában így. A forráskódjában le lehetne ellenőrizni, de szerintem be van égetve, hogy milyen széles legyen a content fekvő állásban, és emiatt borul a történet.
Egyébként is az Auto szélességgel csínján kell bánni.
Szerintem azt megpróbálhatnád, hogy a Gridet lecseréled egy függőleges StackPanelre, és abba rakod a gombokat. De még jobb lenne, ha nem erőltetnéd a MessageBoxot - ami a screenshotból ítélve a mentalitást nem igazán járható út
-
#5594
Karma
félisten
trisztan94
#5593
Karma
félisten
válasz
trisztan94
#5593
üzenetére
Ebben az esetben valamit nagyon durván elbarkácsoltál, mert a ListPicker csak előrenavigációt csinál, semmi nem indokolja hogy a meglévő beállításoldalad újra létrejöjjön. Nem csináltál valami csúnyaságot az OnNavigatedFrom/Toban?
-
#5591
Karma
félisten
trisztan94
#5590
Karma
félisten
válasz
trisztan94
#5590
üzenetére
Screenshotot csinálj róla kérlek.
-
#5589
Karma
félisten
trisztan94
#5588
Karma
félisten
válasz
trisztan94
#5588
üzenetére
using System.Linq; a fájlod tetejére, és jó lesz.
A Select egy extension method, ami abból a névtérből jön. -
#5587
Karma
félisten
trisztan94
#5579
Karma
félisten
válasz
trisztan94
#5579
üzenetére
Gondoltam segítek még egy lépéssel, mert odáig szép és jó, hogy összeraksz egy Gridet, azt is kezelni kéne, hogy melyik gombot nyomtad meg.
Lásd a következő kódot. A foreach ciklusban van a UI létrehozás, a körülötte egy async wrapper, illetve a legvégén másik metódusban példa, hogy hogyan lehet ezt használni.
public Task<int> ShowMultiButtonMessageBox(string caption, string message, IList<string> buttonContent)
{
var i = 0;
var tcs = new TaskCompletionSource<int>();
var grid = new Grid { Margin = new Thickness(0,24,12,0)};
var msgBox = new CustomMessageBox
{
Caption = caption,
Message = message,
Content = grid
};
foreach (var button in buttonContent.Select(content => new Button {Content = content}))
{
var index = i;
grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star)});
grid.Children.Add(button);
Grid.SetColumn(button, i);
button.Click += (sender, args) =>
{
tcs.TrySetResult(index);
msgBox.Dismiss();
};
i++;
}
msgBox.Dismissed += (sender, args) => tcs.TrySetResult(-1);
msgBox.Show();
return tcs.Task;
}
private async void OnTestButtonClicked(object sender, RoutedEventArgs e)
{
var i = await ShowMultiButtonMessageBox("Test", "Press a button!", new[] {"Hello", "Szia", "Mizu"});
MessageBox.Show(string.Format("Valasz: {0}", i));
} -
#5586
Karma
félisten
trisztan94
#5585
Karma
félisten
válasz
trisztan94
#5585
üzenetére
A Pivot template-jét talán át tudod szerkeszteni Blenddel annyira, hogy hasonlítson erre a valamire. De elég rossz ötlet egy-az-egyben Wp-re átlapátolni szerintem.
-
#5578
Karma
félisten
trisztan94
#5577
Karma
félisten
válasz
trisztan94
#5577
üzenetére
Nem kellene egy olyan Gridet megadni Contentnek, aminek van már szülője a hierarchiában.
Más szóval így nem lehet használni a CustomMessageBoxot; vagy csinálj egy UserControlt, amit kódban példányosítasz, vagy építsd össze a Gridet kézzel, és ezt az új példányt add meg Contentnek.
-
#5564
Karma
félisten
trisztan94
#5563
Karma
félisten
válasz
trisztan94
#5563
üzenetére
Nagyon durván ronda. Miért nem használsz IsolatedStorageSettingset?
-
#5562
Karma
félisten
trisztan94
#5561
Karma
félisten
válasz
trisztan94
#5561
üzenetére
Jól feltételezed, a back key visszaléptet magától, ha nem állítod az e.Cancel property-t true-ra.
Így kéne kinéznie, a sorrend se mindegy:
protected override void OnBackKeyPress(System.ComponentModel.CancelEventArgs e)
{
MessageBoxResult result = MessageBox.Show("Biztosan visszalép mentés nélkül?", string.Empty, MessageBoxButton.OKCancel);
e.Cancel = result != MessageBoxResult.OK;
base.OnBackKeyPress(e);
} -
#5556
Karma
félisten
trisztan94
#5555
Karma
félisten
válasz
trisztan94
#5555
üzenetére
Ha letiltod a UI-t (például a PhoneApplicationPage-et, ami a képernyőn van, IsEnabled = false-ba rakod) és a státuszsáv beépített progress barját használod, az nem elég?
Mert ha nem az, akkor nincs mit tenni, mint kézzel építeni egyet. Mondjuk ha dialógus, én biztos a WPToolkit CustomMessageBoxából indulnék ki.
-
Karma
félisten
válasz
zsambek
#5550
üzenetére
A Dictionaryk [] operátora mindkét irányba működik. Ha az értékadás jobb oldalán van, akkor kiveszi az adott kulcshoz tartozó értéket; ha meg a bal oldalán, akkor az adott kulcs alá berakja az eredményt. Ez így megválaszolja a kérdést?
A másodiknál sem teljesen értem a kérdést. Pont az a lényege, hogy kulcs-érték párokat tárol, és gyorsan meg lehet találni, hogy melyik kulcshoz milyen érték tartozik.
-
Karma
félisten
válasz
Jester01
#5548
üzenetére
Dehát wrapperből indult ki az egész feladat, semmi értelme átrakni egy másikba...
zsambek:
A Dictionarynek van egy ContainsKey metódusa, ami true-t ad vissza, ha van benne ilyen kulcs.
Például így, ami nem a legszebb, de szerintem érthető mit csinál:
if (eredmenyek.ContainsKey(teszt))
{
eredmenyek[teszt] ++;
}
else
{
eredmenyek[teszt] = 1; -
Karma
félisten
válasz
Jester01
#5544
üzenetére
A konkrét feladat ismeretében szerintem nincs gond a stringgel, hiszen egészen addig a pontig két intről van szó egy structban, amiket csoportosítási feltételnek kell felhasználni meg formázottan kiírni.
Ehhez még vegyük hozzá, hogy a Tuple megint egy új típus lenne, amit zsambeknak meg kéne ismernie két nappal az érettségi előtt.
Egyébként meg LINQ-kel egy sorban meg lehetne írni az egész feladatot, de nem ez volt a kérdés.
-
Karma
félisten
válasz
zsambek
#5540
üzenetére
Miért olyan különleges a 100-as szám?
Egyébként meg pont ilyet kellett már csinálnod, és akkor is azt mondtam, hogy a Dictionary a barátod. Most még egyszerűbb is a helyzet, mert elég egy Dictionary<string, int>, azaz a formázott eredményhez rendeled hozzá, hogy hányszor fordult elő.
Ennek felépítéséhez egy for ciklusra van szükséged, ami:
1) az eredményt a megfelelő formátumra alakítja, például 2 és 4 számokból "4-2" string;
2) megnézi, hogy ilyen string szerepel-e már a dictionary kulcsai között:
a) ha nem, akkor elhelyez egy 1-est ez a kulcs alá
b) ha igen, akkor kiveszi az értéket, és eggyel megnövelve rakja vissza
3) egy foreach ciklussal végigszaladsz a dictionary.Keys-en, és kiírod fájlba ahogy kell. -
Karma
félisten
válasz
zsambek
#5521
üzenetére
Az ötödik feladatban azt csinálhattad volna, hogy az érvényes címleteket csökkenő sorrendben elrakod egy konstans tömbbe (vagy listába, mindegy most), és egy while ciklussal végzed el az osztás-kivonásokat addig, amíg a maradványösszeg 0 nem lesz.
Az utolsó feladatban a tabulátorral elválasztáshoz annyit kell tenned, hogy a {0} után a sok szóköz helyett azt kell beírnod, hogy \t.
A kiírás meg azért nem működik, mert a feltételeid teljesen el vannak szúrva. Próbáld meg visszaolvasni, amit írtál az ifekbe - sok köze most nincs ahhoz, hogy "a hetes rekeszben a csokoládé száma nagyobb vagy egyenlő mint a vásárlás", illetve "a bedobott pénz nagyobb vagy egyenlő, mint a vásárlás összege". Emellett a rekesz aktuális darabszámát a ciklus során karban kéne tartanod.
Sajnos voltam olyan balga, hogy a tabletem töltőjét bennhagytam a munkahelyemen, így kóddal nem sokat tudok segíteni. De az biztos, hogy az előző bekezdést követve például "vasarlasok[i ].rekesz == 6"-ot akartál írni a hetes rekesz darabszáma helyett.
-
#5533
Karma
félisten
trisztan94
#5532
Karma
félisten
válasz
trisztan94
#5532
üzenetére
Valamit akkor elbarmoltál a GetData metódusban, hiszen már most is Task-alapú és awaiteled - ez nagyon távolról olyan, mint a then, épp csak sokkal jobb - és ha ez csak akkor térne vissza, amikor megvan az adat, pont az történne mint amit leírtál.
-
Karma
félisten
válasz
zsambek
#5516
üzenetére
A kódodat most nem tudom megnézni, de a számításod biztosan nem kóser - ott az a "kivonom az 5600/3600-at" félremegy. Ha kivonogatsz, akkor 5600/3600*3600-at vonj ki, ez ugyanolyan, mint az én cseleztem a tízzel.
De használhatod helyette a % operátort is, tisztább lesz a vége.
SPOILER
int sec = 5600;
int hours = sec / 3600;
sec = sec % 3600;
int min = sec / 60;
sec = sec % 60;Előáll: hours, min, sec
-
Karma
félisten
válasz
zsambek
#5514
üzenetére
1) double-ről intre alakításnál alapvetően ugyanaz a cast és a Convert. Stringnél például már más a helyzet, a sima cast érvénytelen lenne.
2)-3) Összekevertél két dolgot, de akkor inkább végigmegyek a műveleteken.A maradékos osztás (jele: / ), egész számok között működik. Tehát ha egy osztás mindkét oldalán egész számok vannak, az eredmény is egy egész szám lesz.
Például:
25 / 5 = 5, 20 / 5 = 4, viszont 19 / 3 = 6 (elveszett az 1 maradék!), és így logikusan 5 / 10 = 0.Ha az osztás bármelyik fele valós szám, akkor valós osztásra vált a nyelv.
25 / 5.0 = 5.0, 20.0 / 5 = 4.0, 19.0 / 3 = 6.333333, 5 / 10.0 = 0.5A maradékképzés operátor (%) egészek között működik, és a második osztályos osztásból a maradékot adja vissza.
25 % 5 = 0, 20 % 5 = 0, 19 % 3 = 1, 5 % 10 = 5Ennek az egésznek semmi köze a Math.Ceilinghez.
Az egy felső egészrész függvény, és pont úgy viselkedik, mint ahogy eredetileg leírtam. Sajnos a fórumon nem tudok ilyen félszögletes zárójeleket írni.4) Az egész számokat jól vezetted végig, ez a lényeg.
50.5-öt akkor kapsz, ha az osztó vagy az osztandó valós. Ezt elérheted a 10.0-val is, meg akkor is, ha egy double változóba teszed az osztandót előtte. És akkor nyilván nem működik a kitalált gondolatmenetem, hiszen amint visszaszorzód tízzel, megint 505 az érték
Az integer természetesen nem tud tizedesjegyeket kezelni, hiszen definíció szerint egész szám
-
Karma
félisten
válasz
zsambek
#5511
üzenetére
Üdv újra. Már készültem rákérdezni, hogy mi újság a gyakorlással.
1) Túlkomplikáltad ezt az árszámítást matek és C# oldalon is. C# oldalon azért, mert a Convert.ToDouble hívás felesleges, matek oldalon meg azért, mert ha jó képletet választasz a kerekítés előtti árhoz, nem kell ifelned meg kézzel +71-et hozzáadni.
Van a Math.Ceiling függvény, ami visszaadja a double számhoz legközelebbi, annál nem kisebb egészt. Azaz például 4 -> 4, 4.1 -> 5, 4.9 -> 5, stb.
Ezt kihasználva az árszámítás (57-68. sorod) ennyire alakul át:
jegyek[j].fizetnivalo = (int)(Math.Ceiling((jegyek[j].le - jegyek[j].fel) / 10.0) * 71);A 10.0 nagyon fontos, mert enélkül maradékos osztást csinál a fordító!
A magyar ötforintos kerekítésre sajnos nem alkalmas a Math.Round. De még egy teljesen naív switches megoldás is teljesen kielégítő:
int diff = 0;
switch (fizetendo % 10) {
case 0:
case 1:
case 2:
diff = 0;
break;
case 3:
case 4:
case 5:
case 6:
case 7:
diff = 5;
break;
case 8:
case 9:
diff = 10;
break;
}
fizetendo = fizetendo / 10 * 10 + diff;A /10*10 maradékos osztással levágja az utolsó számjegyet, a diff meg az a szám, amit a kerekítés miatt hozzá kellett csapni.
2) Ez a megközelítés nem biztos, hogy jó eredményre vezet, ha az első megállónál senki se szállt fel, vagy mindenki leszállt már az utolsó előtt. Biztonságosabb, ha a vizsgáló ciklusodat úgy futtatod, hogy a másodiktól az utolsó előtti megállóig fusson (így a szélsőkkel nem foglalkozol).
3) Úgy látom két hiba biztosan van a hetedik feladatodban: egyrészt 48 ülés helyett 49-cel operálsz (a félreindexelés halálfejes hiba); másrészt a 183. sorban lévő belső ciklus teljesen felesleges. Nem is használod a ciklusváltozóját.
De egyébként az elvben nem látok hibát.
A futás közbeni állapotot úgy tudod követni, hogy egy breakpointot raksz a programodba a forráskód bal szélén lévő sávra kattintva. Ekkor ott egy piros kör jelenik meg, és a futás leszünetelődik amikor odaér.
Ekkor a Locals fülön, alapból bal lenn látod a változóid aktuális értékét. -
Karma
félisten
válasz
zsambek
#5509
üzenetére
Ne add fel! Ott vagy a megoldás kapujában, csak kimerített, hogy túl sok újdonság szakadt rád az elmúlt pár órában. És légy még egy kicsit türelemmel, mert imperatívan ez nem megy egy lépésben.
A legfontosabb alapszabály, amit most be kell tartanod: ne nyúlj a dictionaryhez módosítási szándékkal. A második: ne nyúlj a dictionaryhez módosítási szándékkal. Kőtáblába vésted!
Azt az előző túra során felépítetted, tedd el biztos helyre, és használd úgy, mint egy papíralapú szótárat szokás: keresgélj benne a címszavak alapján.
Van egy rendezett kulcslistád. Tudod róla, hogy hossz szerint növekvő sorrendben vannak a kulcsok benne. Akkor hol van a leghosszabb kulcs?
Természetesen a lista végén
Szedd elő az utolsó elemet és jegyezd fel a hosszát.Utána foreach ciklussal menj végig a kulcsokon, és ha az aktuális kulcs ugyanolyan hosszú, mint az előbb megjegyzett szám, akkor vedd elő a szótárból az ehhez a kulcshoz tartozó szavak listáját, és írd ki a szavakat.
Próbáld meg leírni C#-ban ezeket a mondatokat.
--- ez itt a vágás helye ---
Ha elakadnál, megírom én is:
int maxLength = orderedKeys[orderedKeys.Count - 1];
foreach (string key in orderedKeys)
{
if (key.Length == maxLength)
{
List<string> words = dict[key];
foreach (string word in words)
{
Console.WriteLine(word);
}
}
}A hetedik feladat ezután pofonegyszerű, hiszen ugyanez a foreach (in orderedKeys) ciklus kell, és nem kell bele if, csak egy string.Join(). Ja meg fájlba kell írni képernyő helyett.
Apropó, ha esetleg valami nem fordulna, akkor bocs. Ezt mind fejből írtam, mint az előzőeket is. -
Karma
félisten
válasz
zsambek
#5507
üzenetére
Az első blokk teljesen jó. Azért kell egyébként a ContainsKey, mert a kulcsok között akarsz keresni. A Dictionarynek van Contains és ContainsValue metódusa is, az előbbi konkrét kulcs-érték párost próbál nézni, az utóbbi pedig az értékek között.
Tömböt már tudsz rendezni az egyparaméteres Array.Sorttal, így igazából mindent tudsz
Listákat rendezni nagyon hasonlóan lehet, csak nem kell hozzá külső segítség: van nekik saját Sort metódusuk.A Sort metódusoknak van olyan formája, ahol te mondod meg, hogy hogyan kell rendezni. Ezt megmutatom példával.
Illetve hiányzik az a lépés, hogy hogyan csinálsz szabadon módosítható listát a Keysből. Ez is elég beszédes.
Jöjjön a kód:List<string> orderedKeys = new List<string>(dict.Keys); // új lista létrehozása a Keys alapján
// És itt jön a lényeg: a rendező függvény.
// Kap két elemet, és egy számot ad vissza, ami a két elem egymáshoz való viszonyát mutatja.
orderedKeys.Sort((szo1, szo2) => {
if (szo1.Length < szo2.Length) return -1; // Negatív szám: az első elem előrébb kerül
if (szo2.Length < szo2.Length) return 1; // Pozitív szám: a második elem kerül előrébb
return szo1.CompareTo(szo2); // ugyanolyan hosszúak? döntsön az ABC-sorrend.
}); -
Karma
félisten
válasz
zsambek
#5503
üzenetére
No én is utolértem magam közben, válaszolok erre is...
Egyetértek, a feladatsor határozottan nehezebb mint a korábbi. Bár az oktatás is követné ezt színvonalban. Érződik, hogy próbálják a Pascalt leépíteni (ez önmagában nem baj), csak ennek eszközéül azt választották, hogy az ezt választó diákokat jól megszivatják...
Említettem kicsit korábban, hogy a hetedik és a hatodik feladat ugyanaz, és jobban jársz, ha ebben a sorrendben próbálod őket megoldani. A hetedik tényleg "baromi" nehéz, sokkal nagyobb ráfordítást igényel, mint a korábbi évek zárófeladatai.
Mondjuk annyi különbség van, hogy itt nem kell neked azon gondolkodnod, hogy "mit is kéne kihoznom a meglévő adatokból hogy válaszolhassak a kérdésre?", mert kerek perec leírták, hogy mi a cél: olyan szerkezetet kell felépítened, mint amit a "rendezett" oszlopban látsz. A kérdés csak a "hogyan?".
Ez most az a szituáció, hogy egy vagy két darab sima, egydimenziós lista nem elég. Ez egy "fésűs lista" is lehetne (ahogy a közoktatás csúfolja), de szerintem célravezetőbb, ha kapásból Dictionaryt építesz belőle.
Méghozzá egy Dictionary<string, List<string>>-et, amivel a kulcs az ABC-rendezett szó, és a hozzá tartozó listában vannak a konkrét szavak a szótárból.
A stratégia a következő:
0) Csinálsz egy ilyen Dictionary objektumot (továbbiakban: dict)
1) Ciklusban, egyszer végigmész a szótáron. Minden elemére:
1/a) veszed a szó ABC-rendezett alakját (továbbiakban: key)
1/b) a dict.ContainsKey(key) metódussal megnézed, hogy az adott kulccsal találkoztál-e már
- ha igen, akkor dict[key]-jel megszerzed a hozzá tartozó listát, és annak az Add metódusával eldugod a szót
- ha viszont nem, akkor létrehozol egy új List<string>-et, belerakod a szót, és a listát elteszed a dict-ben a key-hez. Pl.: dict[key] = list;
2) Ha a végére értél, nincs más dolgod, mint rendezni a dict.Keys-t a kulcs hossza alapján, és e szerint kiírni.A hatodik feladat pedig annyi, hogy veszed a maximális hosszú kulcsokat, és sorban kiírod a képernyőre a hozzá tartozó szavakat. Ha a dict megvan, ez pofonegyszerű
Érzem, hogy a 2) lépés elég nagy logikai ugrás, de azért remélem a gondolatmenet átjön. Ha nem, akkor szólj feltétlen.
És egyébként LINQ-kel az egész egy sor.
-
Karma
félisten
válasz
zsambek
#5501
üzenetére
Sajnos ez csak részpontszámos megoldás, ugyanis ha a leghosszabb szavak a listában:
kecskebeka
bekakecske
kabekecske...
biatorbagy
agybaboritAkkor csak a kecskebéka anagrammáit írod ki, a feladat pedig azt akarná, hogy mind az öt szó legyen ott, egymásután a kecskések, és utána párban a biatorbágyosok.
-
Karma
félisten
válasz
zsambek
#5499
üzenetére
A var annyit csinál, hogy nem kell kiírnod a pontos típust, ha az egyértelmű a fordítónak; neked meg kevesebbet kell gépelni.
A new char[szo.Length] teljes mértékben felesleges, hiszen a következő sorban a ToCharArray létrehozza magának a tömböt. Más szóval célszerű elhagyni (de az is lehet, hogy a fordító magától kiveszi, hiszen értelmetlen.)
Ergo a következő sorok egyenértékűek:
1)
char[] temp;
temp = szo.ToCharArray();2)
char[] temp = szo.ToCharArray();3)
var temp = szo.ToCharArray();Viszont a var kulcsszót nem használhatnád az első esetben. Nem írhatsz olyat, hogy var temp; mert ekkor nem tudja a fordító hogy mi lesz ott.
A stringek nem módosíthatóak, nem tudod őket helyben rendezni úgy, mint az Array.Sort a tömböket. Ezért is csináltunk belőle tömböt, rendeztük a tömböt, majd hoztunk létre egy új stringet a rendezett tartalommal.
-
Karma
félisten
válasz
zsambek
#5497
üzenetére
Az "otos"-t elfelejtetted rendezni
Egyébként spórolhatsz az ismételgetéssel, ha csinálsz egy metódust a rendezett alak kigenerálásához (lásd harmadik feladat). Itt egy példa, ahogy összevontam, lényegesen egyszerűbb, és még SequenceEquals se kell hozzá. De legalább már azt is láttad és megértetted
-
Karma
félisten
válasz
zsambek
#5495
üzenetére
A string és a karaktertömb két teljesen külön dolog. A karaktertömb csak egy buta tároló, ami a saját hosszán és elemein kívül semmit se kezel, míg a string tud rengeteg spéci műveletet, ami szövegekkel kapcsolatos. Az egyik közülük két szöveg összehasonlítása karakterenként (ez hívódik meg a == operátoron keresztül), de a Replace, Trim, PadLeft metódusai mind hasznosak például.
Amivel megtéveszthettelek (végülis én ajánlgattam korábban) az az, hogy a [ ] operátorral eléred a karaktereket egyesével. De ez is csak egy a string hasznos funkciói közül, attól még egy másik állatfaj.
Széljegyzet: string[] ketszo = new string[2]; A kiemelt rész felesleges, mert az értéket az első adandó alkalommal eldobod.
Széljegyzet 2: szerintem == 2 helyett >= 2-t akartál írni.
-
Karma
félisten
válasz
zsambek
#5493
üzenetére
Az a gond itt, hogy a tömböket nem lehet se == operátorral, se Equals hívással összehasonlítani, mert az nem tartalom alapján veti őket össze, hanem csak annyit néz, hanem kvázi hogy a memóriacímük egyezik-e. Mivel két külön tömbről van szó, valószínűleg sose fog egyezni.
Ehelyett: otos == temp2 írd ezt: otos.SequenceEqual(temp2). (Kell hozzá using System.Linq; a programod elején).
(#5492) Dj Sügi: Windows Formsban nem vagyok annyira járatos, de az biztos, hogy az ilyen kérdések feltétele helyett előszedném a TextBox doksiját, és megnézném, mit tud. Meg a Google-t, például google://textbox windows forms disable selection, a második találat elég bíztató.
-
Karma
félisten
válasz
zsambek
#5489
üzenetére
A megoldásodat nem néztem még, csak a feladatot, de azért spoilereznék egy kicsit. A harmadik feladat szándékosan az, ami: ezzel akarnak rávezetni arra, hogy két szó akkor (és csak akkor) anagrammája egymásnak, ha az ABC sorrendbe rendezett alakjai megegyeznek egymással!
Így mindjárt sokkal egyszerűbb lesz az ötös (végigszaladsz a szavakon, és minden olyat kiírsz, amiknek megegyezik az átrendezett alakja), a hetedik és a hatodik feladat meg ugyanaz pepitában. Ajánlom is ebben a sorrendben megoldani őket.
LINQ-kel megint egy-egy sor, mint általában, de egyébként se bonyolult. Egy jó rendezési feltétel kell hozzá: az elsődleges szempont a szó hossza, egyenlő hossz esetén pedig az abc-rendezett alakokat kell egymáshoz hasonlítani.
-
-
#5485
Karma
félisten
trisztan94
#5483
Karma
félisten
válasz
trisztan94
#5483
üzenetére
A CustomMessageBox hergelését javasolnám inkább, például a "gyári" gombjai helyett a Contentbe rakj egy vízszintes Gridben három gombot.
A korábbi kérdéseidre: oda tedd a Taskot, ahol releváns. Megjeleníted valahol at eredményét? Akkor VM. Befolyásolja a hívásaidat? Akkor Service (avagy Model kicsit tágabban értelmezve).
A utility osztályokat és extensionöket én egy külön Utility névtérbe szoktam rakni, aztán usingolom ahol kell. A nyelvi fájl akár maradhat is a gyökérben.
adam014: Akkor ezek szerint sose használtál Popupot.
-
Karma
félisten
-
Karma
félisten
válasz
Pttypang
#5470
üzenetére
Maga az ObservableObject nem egy nagy szám, anno belinkeltem a teljes forráskódját, amit berakhatsz a projektedbe. (google://ObservableObject.cs+Mvvmlight)
Ha meg ezt nem akarod valamiért, akkor kézzel is implementálhatod az INotifyPropertyChanged interfészt, ami a változáskövetéshez kell.
-
Karma
félisten
Nagyon hasonlít a többdimenziós tömbre, épp csak semmi köze hozzá.
A lényegi különbség az, hogy míg a tömböket az elemek sorszámával indexeled, és csak így tudsz benne keresni; a dictionaryben lévő elemeket a kulcs (első paraméter) szerint közvetlenül előszedheted, nem kell ciklusban bejárni.
Például ha van egy Dictionary<string, List<string>>-ed, amiben a következő elemeket tárolod (pszeudokód, nem C#!):
d = {
"6262" => ["mama", "nana"],
"272" => ["arc"],
...
}Akkor d["6262"] hívással azonnal megkapod a hozzá tartozó kételemű listát.
De persze csinálhatsz többdimenziós tömböket is, éljen a korlátolt Pascal szelleme, mit érdekel engem... Feltéve hogy ha mérnök informatikus pályára készülsz megfogadod, hogy mindezt a tébolyt elfelejted és megtanulod rendesen használni a nyelvet.
-
#5469
Karma
félisten
trisztan94
#5467
Karma
félisten
válasz
trisztan94
#5467
üzenetére
Papíron ez egy követhető stratégia így, ahogy vázoltad.
Én személy szerint mindig vart írok, amennyiben lehet (a kivétel: nem azonnal inicializált lokális változók), a többit úgyis tudja az IDE.
Hibakezelésre meg a BugSense-et tudom javasolni.
-
Karma
félisten
Változtatás nélkül futtattam a kódod, nekem rendben kiírta a fájlt. Valamit elnézhettél.
Széljegyzetek vol. 2:
- Az egy darab stringnek felesleges külön structot létrehozni, használd közvetlenül a string típust.
- Kézzel csukogatás helyett használd a using kulcsszót a StreamReader és a StreamWriter használata körül. Egyébként is szerencsésebb azonnal lezárni a fájlt amint végeztél vele, mint a program végén.
- A szó-szám konverziót mégiscsak ki kéne tenni külön metódusba, mert felesleges háromszor leírni. Sőt. -
Karma
félisten
Azt még nem látom (telefonon olvasva a kódot), hogy mi baja van a kiírásnak - látom a writer le van zárva, az lett volna az első gyanúsítottam.
A 7-8-9. feladatokhoz az kellene, hogy a mostani szólista helyett egy Dictionaryt építs, ami a az egyes kódokhoz hozzárendeli azon szavak listáját, amikhez az a kód tartozik.
Így a hetedik feladat egy egyszerű kiíratás, a nyolcadik egy tökegyszerű ciklusban kiíratás, a kilencedik meg egy maximumkeresés (a leghosszabb listát keresed a dictionaryben).
Széljegyzet: Az abc char[] teljesen felesleges, mert a stringnek is van [] művelete, és pont ugyanazt csinálja, mint a házi char[]-öd.
-
Karma
félisten
Jelen felállásban a clientSocket (borzalmas névválasztás listának) tagváltozóból kapcsolatonként van egy példány. Azaz minden kapcsolatot külön listába pakolsz bele, így nyilván minden üzenet visszapattan önmagára.
A gyors és ocsmány megoldása a problémának az, hogy a listát statické teszed. Az elegáns meg az lenne, hogy a kapcsolatok listájának kezelését egy másik osztálynak kéne végeznie.
-
#5445
Karma
félisten
trisztan94
#5444
Karma
félisten
válasz
trisztan94
#5444
üzenetére
Ha fenn van az SDK, bekerül a start menübe egy "Application Deployment" nevű program. Azzal elég könnyen fel tudja telepíteni az XAP-t, nem kell parancssorban meg külső csodával varázsolnia.
-
#5443
Karma
félisten
trisztan94
#5442
Karma
félisten
válasz
trisztan94
#5442
üzenetére
Nem nagyon. WP7 időben volt XDA-n egy kiollózott Application Deployment app, amit önmagában is lehetett használni, de WP8-on nem próbáltam.
Csinálhatsz béta feltöltést is egyébként, és akkor a dev unlock se kell, csak sokkal több az átfutási ideje.
-
Karma
félisten
Szívesen.
Amúgy a gyakorlatban nem szükséges saját delegate-et definiálni minden egyes eseményhez, sőt van egy konkrét konvenció is: az események elküldik az esemény forrását (önmagukat) és valami paramétert, amit egy EventArgs-ból származó osztályba csomagol.
Például egy WinForms Click eseménykezelő így néz ki, figyeld a sender és e paramétereket:
private void button1_Click(object sender, System.EventArgs e)
{
// ...
}Ezt elősegítendő van egy gyári delegate típus, az EventHandler<T>, ami összefogja a sendert és az e-t egybe. Itt meg van egy teljes példa a használatára, célszerű neked is igénybe venned.
-
Karma
félisten
Nos akkor a kiegészítés: ha így küldesz eseményt több szálas környezetben, megtörténhet hogy valamelyik szálon pont abban a pillanatban iratkozik le az utolsó érdekelt, miután a nullcheck lefutott, de az esemény még nem lett elküldve. Azaz befut az if belsejébe, mégis NullReferenceException a vége!
Ezt elkerülni pofonegyszerű: le kell másolni a feliratkozásokat lokálisan, és azzal dolgozni.
Kódban így néz ki:var tmp = TestStatusChanged;
if (tmp != null)
{
tmp("valami");
} -
Karma
félisten
Bekommenteztem az eseményes példát. Sorszámoztam, hogy milyen sorrendben ajánlom olvasásra a kommenteket.
Említettem, hogy majd kifejtem, hogy kellene helyesen eseményt generálni - ez most nem fér bele az időmbe, de majd pótlom.
-
Karma
félisten
El persze, mondjuk nekem is puskáznom kell. Ami biztos: attól, hogy háttérszálon végzed a rajzolást, még nem mentesülsz az eseménykezelés szabályai alól. Nem rajzolhatsz akármikor, közvetlenül a képernyőre, ez kőbe van vésve.
Amit tehetsz helyette az egy Bitmap létrehozása, mint afféle vászon - a háttérszálon erre végzed a bonyolult rajzolást. Ha kész vagy, átszólsz UI szálon, hogy új tartalom van, és a Paint eseménykezelő ezt a bitmapet egy lépésben kirajzolja. Vagy PictureBoxot használsz, és annak odaadod a kész képet, hogy jelenítse meg.
Ezt most nem sikerült annyira érthetően megfogalmaznom, amiért bocs. Majd ha úgy alakul és a VS-em is feléled, írok valami példát.
-
#5428
Karma
félisten
trisztan94
#5427
Karma
félisten
válasz
trisztan94
#5427
üzenetére
Meg mondjuk az előzőek mellett csinálhatnád azt is, hogy egy kicsit gondolkozol mielőtt ajtóstul berontasz a pöcegödörbe...
Miért kéne egy szerencsétlen Viewnak, XAML szinten foglalkoznia azzal, hogy jó helyre húzod-e? Miért kéne TextBox a gomb belsejébe (ami egy szöveges bevitelő mező) egy szöveg megjelenítéséhez? Miért gomb egyáltalán, ha nem használod semmire a gombnyomást? Meg hasonló kérdések merültek fel bennem, aztán elvesztem.
-
Karma
félisten
Meg. Totális fogalomzavarban vagy a rajzolással kapcsolatban.
Itt például van egy gyorstalpaló példa, amiben benne van minden ami kell neked.
Tételesen:
1) Rajzolni csak és kizárólag a Paint esemény hatására lehet, és csak UI szálon. Te most háttérszálon "bele a nagyvilágba" rajzolsz, ezzel a Windows különösebben nem foglalkozik. Bár meglep, hogy nem robban fel.
Szóval vegyél fel egy Paint eseménykezelőt, és annak a belsejébe tedd a rajzoló kódot - de szigorúan csak annyit, ami a vonal pillanatnyi állapotát kirajzolja! Semmi ciklus vagy várakozás!
2) Háttérszál helyett használj Timert, amivel periodikusan megnövelsz egy változót, majd meghívod a Form Invalidate() metódusát.
Ez jelzi a rendszernek, hogy szitu van, szeretnéd újrarajzolni a Formot. A rendszer meg hamarosan meghívja a Paint eseménykezelődet. -
Karma
félisten
válasz
zsambek
#5417
üzenetére
A negyedik feladat idegesítőbb kicsit, mert ilyen szerencsétlenül sikerült ábrázolniuk a napokat
. Figyelmen kívül hagyva a szökőnapokat (végülis ők is írják a példában, hogy ápr. 30-at 31+28+31+30-cal számolták ki) azért nem lehetetlen kiszámolni a napokat.Egy lehetséges megoldás:
- Kell egy 12 elemű int tömb (itt most én is azt használnék
), amibe az egyes hónapokra bontva gyűjtöd a foglalt napokat.
- Kell egy 12 elemű konstans tömb, amiben benne vannak a hónapok hosszai (31, 28, 31, stb...).
- Ciklusban végigmész a foglalásokon. A konstans tömbből tudod, hogy egy adott hónap hol kezdődik és hol ér véget (az i-edik hónap az előző hónaphosszok összegénél kezdődik), és ezt kivonod a foglalás kezdő és végpontjából. Megoldani teljesen nem akarom, úgyhogy a pontos számítást rád hagynám.
- Kiírod az eredménytömböt. -
Karma
félisten
válasz
zsambek
#5417
üzenetére
Az ötödik feladattal annyira nem vagy messze. Ha tudod, hogy hány foglalás érinti az adott szakaszt (ezt számolos ki a ciklusoddal), és hogy hány szoba van (lásd feladat: 27), akkor csak egy kivonásra vagy a megoldástól.
Mondjuk a feltétel nem helyes, mert csak azt észleled, ha a vizsgált foglalás eleje és vége is belül esik a kérdéses időszakon. Azt is számolni kell, ha valaki az időszakon belül érkezik, de csak később megy el; meg azt is, ha korábban jött és közben megy el.
Ha kicsit belegondolsz, intervallumok metszetéről van szó. Ha van metszet, akkor ++.
-
Karma
félisten
válasz
Pttypang
#5415
üzenetére
Egyébként ha nem akarsz függőleges eltolásokat (mint a példádban), hanem egy vízszintes sorba tennél több akár eltérő stílusú, külön-külön bindolt TextBlockot, akkor tudsz spórolni a layouton egy kicsit. A vízszintes StackPanel helyett használhatsz egyetlen TextBlockot, benne Runokkal az egyes szakaszoknak.
Tehát pl. a példádban:
<TextBlock ...közös stílus...>
<Run Text="{Binding LineFrom}" FontWeight="Bold" /> to: <Run Text="{Binding LineTo}"/>
</TextBlock>A Boldot példaként tettem oda.
-
Karma
félisten
válasz
Pttypang
#5410
üzenetére
Az egyértelmű szerintem itt ki is merült. Na jó még egy failsafe: ugye nem használsz DisplayMemberPath-ot a template-tel együtt? Azt tudom, hogy a sima ItemTemplate azonnal kiabál, fullnál viszont nem tudom.
Egyébként milyen jellegű eltérést mutat a sablonodhoz képest?
-
Karma
félisten
válasz
MATEO6600
#5404
üzenetére
N-edjére nekifutva a gondolatnak megkockáztatom, hogy nem is baj, ha nem érti az algoritmust teljesen a diák. Sokat nem nyer azzal, hogy mechanikusan belevasalják szorzótábla módján a "programozási tételeket", aztán vagy megérti és megszereti, vagy végigszenvedi ahogy a tanár pazarolja a saját és az osztály idejét valamire, amivel az életben nem találkozik újra. Ennél még a humán tárgyak is hasznosabbak.
Inkább kéne alapozni a sikerélményre, és azon sokat dob a LINQ is.
-
Karma
félisten
válasz
MATEO6600
#5400
üzenetére
A LINQ tényleg "túl nagy" könnyítés, de ezt én is írtam. Egyetértek veled abban, hogy egy ilyen eszköz kézbevétele előtt hasznos lenne, hogy a diák értse a különböző algoritmusokat, és ha olyan környezetbe kerül, meg is tudjon írni magától egy kiválasztást, min/max keresést, stb.
De még ezt sem teljesíti a mostani tananyag rendesen. Az egész programozás témakört céltalannak és átgondolatlannak érzem – főleg ha a tényleges lefolyását és eredményét látom az infóóráknak.
A listákkal kapcsolatban máshogy gondolom. A lista, mint adatszerkezet, algoritmikusan is érdekesebb, mint egy tömb. Ha meg az érettségi feladatokat meg a valós felhasználást nézzük, végtelenül hasznosabbak is.
Kicsit hasonló a történet, mint amit szüleim meséltek az angol oktatásról, amikor tömegesen képezték át magukat az orosztanárok angoltanárrá úgy, hogy pár leckével jártak előrébb a tananyaggal, mint amit órán leadtak. Csak itt az induló nyelv a Pascal, a cél meg a C#.
Új hozzászólás Aktív témák
Hirdetés
● ha kódot szúrsz be, használd a PROGRAMKÓD formázási funkciót!
- Naim Mu-so 2 Vezetéknélküli all-in-one hi-fi rendszer
- Új/Bontatlan/Garis Google Pixel 9 Peony
- R7 9800X3D/XFX 7900GRE/2x16GB DDR5 6000Mhz/2TB NVMe SSD
- Szép állapot!! Hátlapon kisebb kopások!!! Samsung Galaxy S20 FE SM-G780G/DS - világoskék
- MacBook Air M1 / 2020 / Ezüst / 13" / 256 GB / 8 GB / DOBOZ / GYÁRI TARTOZÉKOK /
- ALIENWARE Area-51 R6 Threadripper Edition 1920X
- BESZÁMÍTÁS! MSI B450M-A R7 2700X 16GB DDR4 512GB SSD GTX 1070 8GB Cooler Master MasterBox Lite5 500W
- MacBook White unibody eladó töltőárban
- AKCIÓ! Apple iPad Pro 13 2024 M4 512GB Cellular tablet garanciával hibátlan működéssel
- Bomba ár! Dell Latitude E5570 Touch - i5-6300U I 8GB I 256SSD I 15,6" FHD I HDMI I CAM I W10 I Gari
Állásajánlatok
Cég: FOTC
Város: Budapest