Soci (Soczó Zsolt) szakmai blogja

2009.09.30.

Sandcastle és társai

Filed under: .NET,C#,Szakmai élet,Visual Studio,VS 2005,VS 2008 — Soczó Zsolt @ 19:42

Az NDoc halott, van helyette SandCastle. Nagyon jó, imádom. Ezzel csinálják a VS doksiját is. Van még kétely valakiben?
Az is jó, hogy nem kell kézzel írnom a konfigját, mert van hozzá Sandcastle Help File Builder, ami hasonló GUI, mint az ndochoz volt.
Aztán, hogy ne kelljen sokat gépelni az xml kommenteket, ott a GhostDoc. Beépül a VS-be, és CTRL-ALT-D-vel létrehoz egy komment vázat az adott kódrészhez. Meglepően ügyesen, ha angol neveket használunk a kódban.
Mindhárom eszköz zseniális és INGYENES. Aki ezek után nem dokumentálja a kódját, annak 1-es. :)

C# XML kommentek

Filed under: .NET,C#,Szakmai élet — Soczó Zsolt @ 09:46

Ha valaki szeretne rászánni 2 órát, hogy alaposan megértse, íme egy jó doksi hozzá.

2009.09.28.

Unraveling the Mysteries of .NET 2.0 Configuration

Filed under: .NET,Szakmai élet — Soczó Zsolt @ 14:30

Számomra rém unalmas téma, de ettől függetlenül nagyon fontos. Mivel elég gyéren dokumentálta le az ms, az itteni cikkek életmentőek lehetnek, akinek ezzel kell foglalkozni.

2009.09.23.

Az embereket nem érdekli a tudomány?

Filed under: Élet — Soczó Zsolt @ 19:27

Akkor miért nincs már szinte sehol szabad hely a Kutatók Éjszakája programon?
Én még délután pont elcsíptem egy nagyfeszültségű bemutatót a BME V1-ben. Annak idején jártam villámvédelem előadásra, abban az egyik alkalommal a laborban voltunk, ahol egy 600000V-os trafó húzta az ívet, meg beültünk a Faraday kalickába is, hogy jól belecsapjon a villám. Remélem most ez meg tudom mutatni Bálintnak is.

INVARIANT vs. ORDINAL újra

Filed under: .NET,C#,Szakmai élet — Soczó Zsolt @ 08:51

A korábban írt cikkhez kapcsolódó anyag, ebből már jobban átjön a különbség:
New Recommendations for Using Strings in Microsoft .NET 2.0.

* DO: Use StringComparison.Ordinal or OrdinalIgnoreCase for comparisons as your safe default for culture-agnostic string matching.
* DO: Use StringComparison.Ordinal and OrdinalIgnoreCase comparisons for increased speed.
* DO: Use StringComparison.CurrentCulture-based string operations when displaying the output to the user.
* DO: Switch current use of string operations based on the invariant culture to use the non-linguistic StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase when the comparison is linguistically irrelevant (symbolic, for example).
* DO: Use ToUpperInvariant rather than ToLowerInvariant when normalizing strings for comparison.
* DON’T: Use overloads for string operations that don’t explicitly or implicitly specify the string comparison mechanism.
* DON’T: Use StringComparison.InvariantCulture-based string operations in most cases; one of the few exceptions would be persisting linguistically meaningful but culturally-agnostic data.

Ebből az jön le, hogy használd vagy az ordinalt, vagy a “kulturált” megoldást, de ha lehet ne az invariantot.

# Ordinal comparisons are string comparisons in which each byte of each string is compared without linguistic interpretation. This is essentially a C runtime strcmp. Thus, “windows” would not match “Windows.” Where the context dictates that strings should be matched exactly, or demands conservative matching policy, this comparison should be used. Additionally, ordinal comparisons are the fastest because they apply no linguistic rules when determining a result.

# Case insensitive ordinal comparisons are the next most conservative, and ignore most casing. Thus, “windows” would match “Windows.” When dealing with ASCII characters, this policy is equivalent to that of StringComparison.Ordinal, but with the usual ASCII casing ignored. Thus, any character in [A, Z] (\u0041-\u005A) matches the corresponding one in [a,z] (\u0061-\007A). Casing outside the ASCII range uses the invariant culture’s tables…

Oridinal, case sensitive bináris összehasonlítás, gyors, ok.
Oridinal, case insensitive ascii karakterek esetén egyenlőnek tekinti a kis-nagybetűket, más karakterek esetén átvált az invariantra. Praktikusan szerintem ez azt jelenti, hogy ordinal case insensitive == invariant case insensitive.
Update: Jogos az előbbi, mert: “Comparisons made using OrdinalIgnoreCase are behaviorally the composition of two calls: calling ToUpperInvariant on both string arguments, and doing an Ordinal comparison.”

Közelebbről:

using System;

class Program
{
static void Main(string[] args)
{
string kisalma = “alma”;
string nagyalma = “Alma”;
Compare(kisalma, nagyalma);
Console.WriteLine();
kisalma = “őlma”;
nagyalma = “Őlma”;
Compare(kisalma, nagyalma);
}

private static void Compare(string a, string b)
{
Test(a, b, StringComparison.CurrentCulture);
Test(a, b, StringComparison.CurrentCultureIgnoreCase);
Test(a, b, StringComparison.InvariantCulture);
Test(a, b, StringComparison.InvariantCultureIgnoreCase);
Test(a, b, StringComparison.Ordinal);
Test(a, b, StringComparison.OrdinalIgnoreCase);
}

private static void Test(string a, string b, StringComparison c)
{
int compRes = string.Compare(a, b, c);

Console.WriteLine(“{0}, {1} {2} {3}”, c, a,
compRes == 0 ? “==” : (compRes < 0 ? "<": ">“),
b);
}
}

CurrentCulture, alma < Alma
CurrentCultureIgnoreCase, alma == Alma
InvariantCulture, alma < Alma
InvariantCultureIgnoreCase, alma == Alma
Ordinal, alma > Alma
OrdinalIgnoreCase, alma == Alma

CurrentCulture, őlma < Őlma
CurrentCultureIgnoreCase, őlma == Őlma
InvariantCulture, őlma < Őlma
InvariantCultureIgnoreCase, őlma == Őlma
Ordinal, őlma > Őlma
OrdinalIgnoreCase, őlma == Őlma

Nem teljes a teszt, de látható, hogy az ordinal másként sorrendez, mint az invariant, nem nyelvi szempontok szerint, ezért is nem való GUI-hoz, de tudja, hogy a kis ő-nek a nagy Ő a párja. Az invariant se elég okos persze, mivel általános, nem ismeri egy adott nyelv szabályait, pl.

Thread.CurrentThread.CurrentCulture = new CultureInfo(“hu-hu”);
a = “cukor”;
b = “csoki”;
Compare(a, b);

CurrentCulture, cukor < csoki CurrentCultureIgnoreCase, cukor < csoki InvariantCulture, cukor > csoki
InvariantCultureIgnoreCase, cukor > csoki
Ordinal, cukor > csoki
OrdinalIgnoreCase, cukor > csoki

A cukor után van a csoki magyarban, mivel van csé betűnk. Az invariant értelemszerűen nem tud erről, ezért a csokit cé, es, okinak olvassa, és így is rendez.

Ezek után egyet kell értsek a cikkel, használjuk kulturált kultúrát nyelvi rendezéshez, fájl elérési utakhoz, ojjektum nevekhez, stb. oridinalt, az invariantot meg felejtsük el.
Legalábbis ma így látom. Comments welcome.

MethodBase.GetCurrentMethod Method

Filed under: .NET,C#,Szakmai élet — Soczó Zsolt @ 08:14

Ismerős? Pl. logoláshoz jól jöhet.

2009.09.22.

Comparison confusion: INVARIANT vs. ORDINAL

Filed under: .NET,Szakmai élet — Soczó Zsolt @ 17:40

Elolvastam a fenti cikket, és nem jutottam sokkal előbbre. A Ordinal vs. többi az ok, de az Invariant nem jött át. Ha valakinek igen, írja meg kérem.

Windows Cache Extension for PHP

Filed under: Optimalizálás,Szakmai élet,Windows 2008 R2 — Soczó Zsolt @ 13:02

Hamarosan kipróbálom a jószágot. Folyamatban van egy munkám, amiben egy ismert websiteot migrálnak át Windows 2008R2 alá, valamilyen linuxról. Megnézzük, ugyanazon a vason mit lehet majd kihozni a php scriptekből Windows alatt. Ha már lúd, legyen kövér, megnézem ezt a Windows Cache Extension for PHP-t is, mennyit dob a teljesítményen.
A mérésből esettanulmányt írok, így majd meg lehet nézni a végeredményt.

Resharper

Filed under: .NET,C#,Szakmai élet — Soczó Zsolt @ 09:16

A következő néhány hónapban egy rakat .NET oktatást tartok egy cégnek Marcell jóvoltából (ezúttal is köszönöm neki az üzletet).
A cégnél szabványosítani fogják a Resharpert, egy VS kiegészítő addint. Többször felraktam már a gépemre, de mindig levettem, mert idegesített, hogy mindent átszab a VS-ben. Én mindent shortcutokkal érek el, azokra jól ráül, aztán feljön a saját felülete. Ezzel az agyamra ment, sokat okoskodott, mindig leszedtem.
Most, hogy tanuljam, mire az oktatás jön, újra felraktam, és használom nap mint nap. Telepítés után azt kértem tőle, nem telepedjen rá minden shortcutra, így már egész jól megvagyunk.
Ami viszont igen kellemes meglepetés volt, hogy már két hibát is kiszúrt. Az egyikben egy paraméter értékét az ugyanolyan nevű mezőbe raktam bele, csak valahogy lemaradt a this. Triviális hiba, de nem tűnt fel a sok paraméter között. A másik kicsit ravaszabb.

Process[] p = Process.GetProcessesByName(“…”);
if (p == null) …

Mi a hiba eben a kódban? A resharper jól kiszúrta, hogy az if kifejezése mindig true false. Miért? Így néz ki a GetProcessesByName vége:

Process[] array = new Process[list.Count];
list.CopyTo(array, 0);
return array;

Nulla hosszú tömb jön vissza, ha nincs ilyen nevű processz. Nem rakétatudomány, mégis könnyű elrontani. A Resharper meg észrevette. Megtartjuk, szeretjük.

2009.09.21.

Az IFormattable, IFormatProvider, ICustomFormatter működése

Filed under: .NET,C#,Szakmai élet — Soczó Zsolt @ 19:30

Ebből pontosan meg lehet érteni, mi zajlik a háttérben.

Mire való az IEquatable?

Filed under: .NET,C#,Szakmai élet — Soczó Zsolt @ 17:25

Ha value type-ot írsz, és azon gyors, boxolás nélküli egyenlőségvizsgálatot akarsz csinálni, akkor implementáld ezt az interfészt.
Másképp az object.Equals fut le, ami miatt boxolni kell. Hasonló a helyzet az IComparable-lel is.
Érdemes megnézni debuggerben, mikor-mi fut le, ha implementáljuk az interfészt, és ha kikommentezzük az implementációt:

using System;
using System.Collections.Generic;

internal struct MyStruct : IEquatable
{
public MyStruct(int a)
{
this.a = a;
}

private readonly int a;

public override bool Equals(object obj)
{
return base.Equals(obj);
}
public override int GetHashCode()
{
return base.GetHashCode();
}

#region IEquatable Members

public bool Equals(MyStruct other)
{
return other.a == a;
}

#endregion
}
class Program
{
static void Main()
{
List l = new List {new MyStruct(33)};
l.Contains(new MyStruct(22));
}
}

2009.09.15.

Hacktivity előadásom

Filed under: Architektúra,Design,Felhívás,Security,Szakmai élet — Soczó Zsolt @ 12:58

Hétvégén lesz a Hacktivity konferencia, ahol NEM arról fogok beszélni, ami ki van írva.
Gál Tamással ketten kaptunk 45 percet, amiben GT a VPN Windows7/R2 új alternatíváiról beszél, én pedig arról, hogy egy akkora cég, mint az MS hogyan képes felzárkózni a hekkerek generálta biztonsági kihíváshoz. Az előadásom fele érdekességekkel, történetekkel lesz tele, belső infók, mit tesz az ms a jobb kódminőség érdekében, a másik felében pedig konkrét példákat mutatok be, amelyek demonstrálják, hogy a különböző támadási típusok esetén (privilege escalation, stb.) hogyan zárkóztak fel a termékek, mint a Windowsok vagy az IIS.
Szeretettel várok mindenkit, aki ráér hétvégén hekkerkedni.

Powered by WordPress