Dariusz Gil - DARIO-G - programista, projektant

Softio.pl w grupie fajnych stron w kolorze fioletowym

developer@dario-g.com — Tue, 10 Nov 2009 00:45:31 GMT

Moja strona firmowa Softio.pl została wyróżniona przez Spyrestudios (należący do grupy Smashing Network) i znalazła się w spisie 25 fajnych stron, gdzie kolorem dominującym jest fiolet. :)

Ot, tak chciałem się pochwalić :)

ASP.NET MVC 2.0 Beta i licencja GoLive

developer@dario-g.com — Tue, 17 Nov 2009 21:54:13 GMT

Phil Haack poinformował, że ASP.NET MVC 2.0 w wersji Beta jest już dostępny. Ważniejsze jednak jest to, że wersja ta posiada odpowiedni zapis w licencji pozwalający na używanie ASP.NET MVC 2 w aplikacjach używanych produkcyjnie. Innymi słowy jeśli ktoś planuje w najbliższym czasie udostępnić/sprzedać program oparty o ten framework i chciałby użyć w niej funkcjonalności z wersji 2.0 to od tego momentu już spokojnie można. Data annotations i typowane helpery do budowy interfejsu oraz szablony helperów kuszą, a jakże. :)

Oczywiście należy pamiętać, że nie jest to jeszcze pełna wersja, więc do systemów strategicznych jeszcze się nie nadaje. :)

Mini Static Content Delivery - paczki i konfiguracja

developer@dario-g.com — Thu, 19 Nov 2009 01:13:57 GMT

W poprzednim poście poświęconym Mscd opisałem możliwości. Teraz zajmę się sposobem tworzenia paczek. Tak jak już wspominałem Paczki dają możliwość upakowania wielu plików jednego rodzaju i wysłanie zawartości w odpowiedzi na jedno żądanie. Paczka do działania nie potrzebuje żadnej konfiguracji. Wystarczy utworzyć katalog i wgrać do niego pliki. Mamy do dyspozycji dwa rodzaje paczek. Paczki z kontentem JavaScript (pliki *.js) oraz Stylesheet aka styles (pliki *.css). Tworzenie paczki Zakładając, że stworzymy paczkę styli należy w katalogu głównym naszej aplikacji serwującej kontent statyczny utworzyć katalog "styles". Każdy katalog znajdujący się w styles będzie paczką, która może zawierać zero lub więcej plików. Paczkę ze skryptami robi się analogicznie, przyczym katalog z takimi paczkami nazywamy "scripts". Przykład:

styles
admin
portal

Powyższy układ katalogu definiuje nam dwie paczki dla cssów. Paczkę admin co sugeruje, że tu będą się znajdować pliki formatujące wyświetlanie części administracyjnej oraz paczkę portal, czyli style dla stron portalu. :) Jak używać? Nie pisałem o tym wcześniej, ale w projekcie klienckim, czyli takim, który korzysta z usług Mscd korzystamy z metod, które dostarcza "Softio.Mscd.Client". Biblioteczka ta definiuje szereg metod, które pozwalają nam w zautomatyzowany sposób odwoływać się kodzie HTML po zasoby wystawiane przez Mscd. Wszystkie metody są zaimplementowane w klasie StaticFile.Przykładowe użycia są dostepne w projekcie Mscd.Example, który można pobrać z CodePlex. Metody StylesPackage/ScriptsPackage Metoda ta tworzy link odwołujący się do paczki o podanej nazwie.Na przykład:

   1:  <link type="stylesheet" type="text/css" media="projection, screen" href="<%=StaticFile.StylesPackage("portal") %>" />

Oczywiście lepiej mieć metodę, która nam zbuduje tag LINK i wtedy wywołanie wyglądało by tak:

   1:  <%=Html.StyleSheet(StaticFile.StylesPackage("portal")) %>

Wynik działania:

<link href="http://static.softio.pl/styles/Site_Default_vFF05165E.css" media="all" rel="stylesheet" type="text/css" />

Wywołanie dla skryptów działa analogicznie. Metoda Href Metoda Href pozwala na odwołanie się do dowolnego (pojedynczego) pliku, który jest wystawiany przez Mscd oraz nie znajduje się w paczce. Bardzo dobrze sprawdza się do obrazków. Odwołanie takie daje nam buforowanie i wersjonowanie, o czym już wcześniej pisałem. Przykład:

   1:  <%=Html.Image(StaticFile.Href("images/bizpark.png"), "Softio jest uczestnikiem programu Microsoft BizPark") %>

Wynik działania metody:

<img src="http://static.softio.pl/images/bizpark_vC45B22D2.png" alt="Softio jest uczestnikiem programu Microsoft BizPark" title="Softio jest uczestnikiem programu Microsoft BizPark" />

Konfiguracja Mscd.Server Po stronie projektu serwującego kontent mamy możliwość ustawienia kilku parametrów. Poniżej spis wszystkich możliwości, które definiuje się w pliku web.config w sekcji appSettings. MSCD.ExpiredInDays (domyślnie 0) Określa ilość czasu (w dniach) ile kontent ma pozostać w buforze przeglądarki. MSCD.ContentEncoding (domyślnie UTF8) Określa kodowanie plików js i css. MSCD.AllowedFileTypes (domyślnie: .CSS, .JS, .HTML, .HTM, .PNG, .JPEG, .JPG, .GIF, .BMP, .SWF, .TXT) Określa rozszerzenia plików, które są obsługiwane przez Mscd. W innym przypadku plik będzie wystawiany standardowo przez IIS. MSCD.CompressedFileTypes (domyślnie: .CSS, .HTML, .HTM) Określa rozszerzenia plików, które będą kompresowane (GZip lub Deflate). MSCD.RootDirectory (domyślnie: pusty_string) Określa nazwę katalogu, gdzie znajdują się katalogi styles i scripts. Dzięki temu można przenieść je z katalogu głównego w inne miejsce, na przykład: /packages. Konfiguracja Mscd.Client Po stronie HTMLa, gdzie wstawiamy kod odwołujący się do zasobów mamy następujące możliwości konfiguracji: MSCD.ResourcesDirectory (wymagane) Określa katalog fizyczny na dysku, gdzie znajdują się zasoby udostępniane przez Mscd. Potrzebne jest to do kontrolowania zmiany wersji. Jeśli aplikacja Mscd jest podkatalogiem dla aplikacji głównej (bardzo często tak jest w przypadku usług hostingowych) lub Mscd.Server jest tą samą aplikacją co aplikacja główna to można podać ścieżkę virtualną, na przykład "~/static", która zostanie zamieniona wewnątrz na fizyczną. MSCD.StaticSiteAddress (wymagane) Adres aplikacji Mscd, na przykład: http://static.softio.pl. Ciekawostką jest to iż adres także można podać jako adres virtualny, na przykład: ~/static. Takie użycie ma sens, kiedy aplikacja Mscd nie ma osobnej domeny, a jest jednie katalogiem virtualnym na tym samym serwerze co aplikacja główna. MSCD.StaticSiteSecuredChannel (nie wymagane, domyślnie: false) Określa czy dostęp do aplikacji Mscd jest kanałem szyfrowanym (https). Pełny opis API na CodePlex już niedługo, a w następnym poście o Mscd - instalacja.

Białe znaki (white space) w Visual Studio

developer@dario-g.com — Fri, 20 Nov 2009 00:23:12 GMT

Taka mała ciekawostka. Jak włączyć widoczność białych znaków w Visual Studio 2008? Wystarczy kombinacja klawiszy:

Ctrl + E + S

Kombinacja działa naprzemiennie, tzn. wciskając ją ponownie oznaczenie białych znaków zniknie. U mnie widać je tak:

Niestety nie jestem w stanie sprawdzić czy ten skrót działa w VS 2005, ale domniemam, że tak. :)

Pracujesz w domu - musisz takie mieć ;)

developer@dario-g.com — Sat, 21 Nov 2009 01:00:48 GMT

Niedawno minął rok, odkąd pracuję w domu. Bywa różnie, czasem Oskarek poprzeszkadza, czasem człowiek rozproszy swoją uwagę na coś innego, ale ogólnie, muszę sobie przyznać, że potrafię się skupić na robocie. Szczególnie pomocne są przy tym słuchawki :) Do tej pory miałem takie malutkie, douszne, ale.... dźwięk nie ten. Niedawno zakupiłem troszkę większe. Zakup w sumie budżetowy, ale jakość dźwięku jak dla mnie super.

Teraz mogę nawet 14 godzin non-stop... Oczywiście żartuję, ale wszystkim tym, którzy zastanawiają się nad wyborem, polecam. Szczególnie do laptopa, który nie ma zbyt dobrej karty dźwiękowej. :)

Nowy Rok 2010

developer@dario-g.com — Fri, 01 Jan 2010 12:17:45 GMT

Samych sukcesów w Nowym Roku, oby spełniły się wszystkie marzenia, nawet te najbardziej skryte :)

Oby wszystkie projekty ukończyły się terminowo, zmieściły się w budżecie i klienci byli zadowoleni :) Tego wszystkim Wam i sobie życzę :)

UpdateModel bez stringów

developer@dario-g.com — Sun, 24 Jan 2010 22:08:58 GMT

Metoda UpdateModel jest metodą dostępną w klasie kontrolera, która w automagiczny sposób przepisze wartości przesłane z formularza do naszego obiektu modelu. Niestety przepisze wszystkie jakie tylko zostały przesłane. A co jeśli nie chcemy przepisywać wszystkich? Wystarczy podać listę dopuszczonych wartości do przepisywania. Niestety lista ta to nic innego jak array stringów. Poniżej prezentuję kawałek kodu, który dzięki kilku prostym zabiegom pozwala na typowane przekazanie listy właściwości. Stringi won! Najpierw stworzyłem bazową klasę kontrolera, która zawiera spreparowaną metodę UpdateModel. Niestety nie da się użyć ExtensionsMethod, gdyż UpdateModel jest protected.

   1:  public abstract class ControllerExt : Controller

   2:  {

   3:      protected void UpdateModel(TModel model, params Expressionobject>>[] property) where TModel : class

   4:      {

   5:          var props = new List<string>(property.Length);

   6:          foreach (var p in property)

   7:          {

   8:              var memberExpression = RemoveUnary(p.Body) as MemberExpression;

   9:              if (memberExpression == null)

  10:              {

  11:                  throw new NullReferenceException("Can not retrieve info about member of {0}".FormatThis(typeof(TModel).Name));

  12:              }

  13:              props.Add(memberExpression.Member.Name);

  14:          }

  15:          this.UpdateModel(model, props.ToArray());

  16:      }

17:

  18:      private static Expression RemoveUnary(Expression body)

  19:      {

  20:          var unary = body as UnaryExpression;

  21:          if (unary != null)

  22:          {

  23:              return unary.Operand;

  24:          }

  25:          return body;

  26:      }

  27:  }

Dzięki temu zabiegowi każdy kontroler dziedziczący po naszym nowym kontrolerze bazowym będzie wyposażony w metodę, której użycie wygląda następująco:

   1:  // Gdzieś w metodzie akcji kontrolera

   2:  UpdateModel<MyModel>(model, x => x.Number);

Oczywiście można tu się pokusić o jakąś optymalizację i buforowanie listy właściwości dla podanego typu modelu. Miłej zabawy :)

FormatWith - inne implementacje

developer@dario-g.com — Mon, 25 Jan 2010 00:43:13 GMT

Łukasz Kurzyniec wspomniał o bardzo fajnym sposobie formatowania stringa, gdzie zamiast kolejnych indeksów {0}, {1}, itd podaje się nazwy właściwości, a jako źródło obiekt je posiadający. Niestety nie mogłem dodać komentarza na blogu Łukasza, stąd ten post. Swego czasu Phill Haack zainteresował się tym tematem i pokazał inne implementacje. Obecnie dzięki Niemu używam implementacji Henri'ego, która to mimo większej ilości kodu okazała się najszybsza. Dodatkowo w swojej implementacji dodałem jedno przeciążenie, dzięki któremu możemy określi czy brak właściwości odpowiadającej znalezionemu parametrowi ma wyrzucić wyjątek czy też nie. Przydatne przy bardziej zaawansowanym formatowaniu/parsowaniu. Poniżej przeklejam kod, aby nigdzie się nie zgubił ;) Acha, u mnie ta metoda nazywa się FormatNamed.

   1:  public static string FormatNamed(this string format, object source)

   2:  {

   3:      return FormatNamed(format, source, false);

   4:  }

5:

   6:  public static string FormatNamed(this string format, object source, bool ignoreNotFound)

   7:  {

   8:      if (format == null)

   9:      {

  10:          throw new ArgumentNullException("format");

  11:      }

12:

  13:      StringBuilder result = new StringBuilder(format.Length * 2);

14:

  15:      using (var reader = new StringReader(format))

  16:      {

  17:          StringBuilder expression = new StringBuilder();

  18:          int @char = -1;

19:

  20:          State state = State.OutsideExpression;

  21:          do

  22:          {

  23:              switch (state)

  24:              {

  25:                  case State.OutsideExpression:

  26:                      @char = reader.Read();

  27:                      switch (@char)

  28:                      {

  29:                          case -1:

  30:                              state = State.End;

  31:                              break;

  32:                          case '{':

  33:                              state = State.OnOpenBracket;

  34:                              break;

  35:                          case '}':

  36:                              state = State.OnCloseBracket;

  37:                              break;

  38:                          default:

  39:                              result.Append((char)@char);

  40:                              break;

  41:                      }

  42:                      break;

  43:                  case State.OnOpenBracket:

  44:                      @char = reader.Read();

  45:                      switch (@char)

  46:                      {

  47:                          case -1:

  48:                              throw new FormatException();

  49:                          case '{':

  50:                              result.Append('{');

  51:                              state = State.OutsideExpression;

  52:                              break;

  53:                          default:

  54:                              expression.Append((char)@char);

  55:                              state = State.InsideExpression;

  56:                              break;

  57:                      }

  58:                      break;

  59:                  case State.InsideExpression:

  60:                      @char = reader.Read();

  61:                      switch (@char)

  62:                      {

  63:                          case -1:

  64:                              throw new FormatException();

  65:                          case '}':

  66:                              result.Append(OutExpression(source, expression.ToString(), ignoreNotFound));

  67:                              expression.Length = 0;

  68:                              state = State.OutsideExpression;

  69:                              break;

  70:                          default:

  71:                              expression.Append((char)@char);

  72:                              break;

  73:                      }

  74:                      break;

  75:                  case State.OnCloseBracket:

  76:                      @char = reader.Read();

  77:                      switch (@char)

  78:                      {

  79:                          case '}':

  80:                              result.Append('}');

  81:                              state = State.OutsideExpression;

  82:                              break;

  83:                          default:

  84:                              throw new FormatException();

  85:                      }

  86:                      break;

  87:                  default:

  88:                      throw new InvalidOperationException("Invalid state.");

  89:              }

  90:          } while (state != State.End);

  91:      }

92:

  93:      return result.ToString();

  94:  }

95:

  96:  private static string OutExpression(object source, string expression, bool ignoreNotFound)

  97:  {

  98:      string format = "";

  99:      string orygexpression = expression;

 100:

 101:      int colonIndex = expression.IndexOf(':');

 102:      if (colonIndex > 0)

 103:      {

 104:          format = expression.Substring(colonIndex + 1);

 105:          expression = expression.Substring(0, colonIndex);

 106:      }

 107:

 108:      try

 109:      {

 110:          if (String.IsNullOrEmpty(format))

 111:          {

 112:              return (DataBinder.Eval(source, expression) ?? "").ToString();

 113:          }

 114:          return DataBinder.Eval(source, expression, "{0:" + format + "}") ?? "";

 115:      }

 116:      catch (HttpException)

 117:      {

 118:          if (!ignoreNotFound)

 119:          {

 120:              throw new FormatException();

 121:          }

 122:          else

 123:          {

 124:              return orygexpression;

 125:          }

 126:      }

 127:  }

 128:

 129:  private enum State

 130:  {

 131:      OutsideExpression,

 132:      OnOpenBracket,

 133:      InsideExpression,

 134:      OnCloseBracket,

 135:      End

 136:  }

web.config dla widoków asp.net mvc

developer@dario-g.com — Tue, 26 Jan 2010 00:59:51 GMT

Poprawne widoki w projekcie asp.net mvc nie powinny posiadać plików codebehind. Ponadto nie powinny posiadać żadnej logiki. Mają służyć jedynie prezentacji/wizualizacji danych oraz zbierania informacji, które będą przesyłane do kontrolera. W związku z tym całe ustrojstowo typu auto-zdarzenia (znane z WebForms'ów), viewstate'y, czy nawet dostęp do obiektu sesji powinno być wyłączone/zablokowane. Wybrane wartości:

autoEventWireup="false"
compilationMode="Auto"
enableEventValidation="false"
enableViewState="false"
enableViewStateMac="false"
maintainScrollPositionOnPostBack="false"
viewStateEncryptionMode="Never"
smartNavigation="false"
enableSessionState="ReadOnly"
validateRequest="false"

Poniżej zamieszczam do pobrania web.config dla MVC 1.0, który zawiera odpowiednio wpisane wartości. Podany plik należy wgrać do katalogu Views. Pobierz web.config z katalogu Views dla ASP.NET MVC 1.0

Kilka metod ułatwiających pracę z obiektem sesji

developer@dario-g.com — Mon, 01 Feb 2010 22:47:49 GMT

Przechowywanie obiektów w sesji nie jest ogólnie wskazane ze względu na szybkość działania strony (poza typem InProc) jak i ulotność miejsca składowania (InProc). Mimo wszystko czasami trzeba. Aby ułatwić sobie pracę z obiektem sesji napisałem kilka pomocniczych metod rozszerzających możliwości HttpSessionStateBase. Bardzo często zdarzają się przypadki przechowania czegoś na chwilę w kontekście użytkownika. Określamy zatem jakiś klucz i dodajemy do sesji. W innym miejscu aplikacji znów musimy posłużyć się tym samym kluczem, pod którym schowaliśmy sobie jakieś dane w sesji. A gdyby tak pozbyć się tego klucza i tworzyć go po cichu automatycznie? Na takim pomyśle opiera się działanie poniższych metod. Oczywiście nie zawsze da się pozbyć klucza dlatego też wszystkie metody mają dodatkowe przeciążenie. Dodatkowo wszystkie metody są typowane. Podstawowymi działaniami są zapamiętanie obiektu w sesji i jego pobranie. Do tego służą odpowiednio metody AddItem oraz GetItem. Przykładowo zapamiętujemy i odczytujemy obiekt typu UserContext w następujący sposób:

   1:  var ctx = new UserContext();

   2:  Session.AddItem<UserContext>(ctx);

   3:  // ...

   4:  // W innym miejscu aplikacji

   5:  var ctx2 = Session.GetItem<UserContext>();

Kod całej klasy zawierającej wszystkie metody znajduje się poniżej.

   1:  public static class HttpSessionExtensions

   2:  {

   3:      public static void AddItem<T>(this HttpSessionStateBase s, T value) where T : class

   4:      {

   5:          AddItem<T>(s, value, "");

   6:      }

7:

   8:      public static void AddItem<T>(this HttpSessionStateBase s, T value, string key)

   9:      {

  10:          s.Add(typeof(T).FullName + key, value);

  11:      }

12:

  13:      public static T GetItem<T>(this HttpSessionStateBase s) where T : class

  14:      {

  15:          return GetItem<T>(s, "");

  16:      }

17:

  18:      public static T GetItem<T>(this HttpSessionStateBase s, string key)

  19:      {

  20:          var value = s[typeof(T).FullName + key];

  21:          return  value == null ? default(T) : (T)s[typeof(T).FullName + key];

  22:      }

23:

  24:      public static T TakeItem<T>(this HttpSessionStateBase s) where T : class

  25:      {

  26:          return TakeItem<T>(s, "");

  27:      }

28:

  29:      public static T TakeItem<T>(this HttpSessionStateBase s, string key)

  30:      {

  31:          var value = GetItem<T>(s, key);

  32:          RemoveItem<T>(s, key);

  33:          return value;

  34:      }

35:

  36:      public static void RemoveItem<T>(this HttpSessionStateBase s) where T : class

  37:      {

  38:          RemoveItem<T>(s, "");

  39:      }

40:

  41:      public static void RemoveItem<T>(this HttpSessionStateBase s, string key)

  42:      {

  43:          s.Remove(typeof(T).FullName + key);

  44:      }

  45:  }

Nie będę opisywał wszystkich pokolei, bo doskonale widać co każda z nich robi. Proszę się częstować :) PS
Tak naprawdę są to metody, które rozszerzają HttpSessionStateBase z frameworka ASP.NET MVC, ale wystarczy zamienić klasę bazową na HttpSessionState, aby kod działał poprawnie w klasycznych WebFormsach.

devblogi, devpytania i Telerik

developer@dario-g.com — Wed, 10 Mar 2010 23:28:23 GMT

Jakiś czas temu w polskim internecie pojawił się serwis devpytania.pl. Przypadł mi odrazu do gustu, gdyż jest odzwierciedleniem znanego serwisu stackoverflow.com. Zarejestrowałem się i często zaglądałem. Znalazło się kilka osób co potrzebowali pomocy, więc co wiedziałem to napisałem.

Jakoś tak samo wyszło, że troszkę tych odpowiedzi się uzbierało co zostało zauważone przez grono tworzące devXXX (devblogi i devpytania) i dostałem upominek w postaci kontrolek Telerika czego zupełnie się nie spodziewałem. W tym miejscu chciałbym podziękować szanownemu gronu. :) Prezencik iście zacny. Dzięki :)