Trochę o zwalnianiu zasobów

Home

Każdy dobry programista wie, że po skończeniu pracy z obiektem klasy implementującej interfejs IDisposable należy wywołać metodę Dispose (jawnie bądź nie jawnie). Dlatego kiedy ostatnio zobaczyłem kod, w którym programista beztrosko raz po raz tworzy ikonę, a następnie radośnie o niej zapomina powodując wzrost liczby obiektów GDI przez usta przeszły mi dość niecenzuralne słowa. Oczywiście od razu poprawiłem kod w mniej więcej taki sposób:

using(Icon icon = GetIcon())
{
   ...
}

Nic prostszego można powiedzieć. Jednak przy następnym uruchomieniu aplikacji ku mojemu zdziwieniu liczba obiektów GDI znowu zaczęła rosnąć. Zaglądam, więc do metody GetIcon. A tam widzę coś takiego:

return Icon.FromHandle(handle);

Nie kojarząc za bardzo metody FromHandle zaglądam do dokumentacji, a tam jest napisane coś takiego:

When using this method you must dispose of the resulting icon using the DestroyIcon method in the Win32 API to ensure the resources are released.

Kolejny mój krok to oczywiście sprawdzenie czy wywołanie DestroyIcon działa. Metodę tą należy zadeklarować w następujący sposób:

[System.Runtime.InteropServices.DllImport("user32.dll", CharSet=CharSet.Auto)]
extern static bool DestroyIcon(IntPtr handle);

Jej użycie oczywiście rozwiązało problem. Co dociekliwsi mogą jeszcze zapytać czemu wywołanie Dispose nie wystarcza. Sprawa jest dość ciekawa. Okazuje się, że klasa Icon używa wewnętrznie DestroyIcon do zwalniania zasobów ale tylko i wyłącznie wtedy kiedy jest właścicielem tych zasobów to jest kiedy sama je zaalokuje. W momencie tworzenia ikony przy pomocy uchwytu dostarczonego z zewnątrz trzeba samemu zadbać o jego zwolnienie.

Reasumując w opisanym przypadku dwóch programistów zrobiło dwa poważne błędy. Pierwszy zapomniał o zwolnieniu zasobów, a drugi o dokładnym przeczytaniu dokumentacji. Metoda GetIcon powinna zostać napisana tak aby korzystający z niej programista nie musiał posiadać wiedzy "tajemnej" aby dobrze jej użyć.

Kontrolki ASP.NET i zdarzenia

Home

Dzisiaj napiszę o rzeczy bardzo prostej ale, o której jednak zdarzyło mi się zapomnieć przez co zmarnowałem trochę czasu. Sytuacja miała miejsce kiedy pracowałem nad kontrolkę, która na swoim interfejsie publicznym między innymi udostępniała zdarzenia SelectionChanged. W kodzie wyglądało to jakoś tak:

...
public event EventHandler SelectionChanged;
...

Po jej napisaniu zabrałem się do testowania i jedną z rzeczy jaką chciałem sprawdzić było to czy zdarzenie jest generowane w odpowiednim momencie. Umieściłem więc kontrolkę na stronie w taki sposób:

...
<cc1:MyControl id="Control1" runat="server" SelectionChanged="Control1_SelectionChanged" />
...

Uruchamiam stronę i coś nie działa. Po krótkiej chwili dochodzę do wniosku, że coś musi być nie tak z zdarzeniem. Stawiam, więc w kodzie pułapkę i odświeżam stronę. Chwila debugu i konsternacja. Kod działa prawidłowo ale w momencie kiedy następuje próba wygenerowania zdarzenia okazuje się, że SelectionChanged równa się null.

Zaczynam sprawdzać czy nigdzie nie zrobiłem literówki itd. Uruchamiam kod ponownie i ciągle to samo. W końcu przypominam sobie, że aby deklaratywnie podczepić się pod zdarzenie kontrolki trzeba użyć przedrostka On. Kod powinien więc wyglądać jak poniżej:

...
<cc1:MyControl id="Control1" runat="server" OnSelectionChanged="Control1_SelectionChanged" />
...

Raportowanie

Home

Ostatnio poznałem nieznany mi wcześniej, a prosty sposób tworzenia raportów i zapisywania ich do formatu PDF czy Excel. Działa on zarówno w kontekście aplikacji ASP.NET jak i w aplikacjach Windows Forms i innych. Mam tutaj na myśli klasy z przestrzeni nazw Microsoft.Reporting.WebForm (w przypadku aplikacji stacjonarnych chodzi o przestrzeń Microsoft.Reporting.WinForms).

W przestrzeni Microsoft.Reporting.WebForm znajdziemy wiele rzeczy, najważniejsze to po pierwsze kontrolka ReportViewer do prezentowania raportów. Po drugie klasy LocalReport oraz ServerReport służące odpowiednio wykonywaniu raportów lokalnie oraz zdalnie na serwerze. Źródłem danych dla raportów może być oczywiście relacyjna baza danych ale również obiekty biznesowe. Definicja raportu to dokument XML stworzony przy pomocy języka RDL (ang. Report Definition Language).

Zanim przeję dalej podam założenia/wymagania jakimi się kierowałem:

• Raporty chcę zapisywać do formatu PDF i Excel.
• Proces generowania raportu ma odbywać się lokalnie bez połączenia z bazą danych.
• Dane mam zapisane w obiekcie klasy DataTable.

Po pierwsze musiałem znaleźć sposób dynamicznego generowania definicji raportów. Język RDL nie wygląda na trudny ale nie zmienia to faktu, że go nie znam. Po krótkich poszukiwaniach napotkałem na ten artykuł Lesson 4: Creating Code to Generate the Report Definition File. Zaprezentowany tam kod tworzy plik z definicją raportu jako dane wejściowe przyjmując: listę pól/kolumn, zapytanie do bazy danych oraz connection string. Jak widać kod jest przydatny ale nie do końca ponieważ nie odpowiada postawionym wymaganiom. Jak sie jednak okazało konieczne modyfikacje były bardzo proste. Pomijając zmianę argumentów wejściowych metody, delikatną modyfikację logiki wystarczyło, że jako zapytanie do bazy danych oraz connection string przekazałem pusty ciąg znaków String.Empty. Cała metoda jest dość długa ale w gruncie rzeczy nie zawiera niczego skomplikowanego. Dopowiem tylko, że liczba kolumn generowanego raportu zależy od liczby kolumn w przekezanym do metody obiekcie klasy DataTable. Pełny kod został pokazany poniżej.

Pokaż/Ukryj kod

/// 

/// Generuje definicję raportu dla podanej tabeli.
/// 
/// Strumień w jakim zostanie umieszczona definicja
/// Tabela z danymi wejściowymi dla raportu. Definicja raportu będzie miała tyle
/// kolumn co ta tabela.
/// stream == null
/// dt == null
/// Nie można pisać do strumienia
/// Na podstawie: http://msdn.microsoft.com/en-us/library/ms170239(SQL.90).aspx
public static void GenerateRdl(Stream stream, DataTable dt)
{
  if (stream == null)
    throw new ArgumentNullException("stream");

  if (dt == null)
    throw new ArgumentNullException("dt");

  if (!stream.CanWrite)
    throw new InvalidOperationException("Cannot write to stream!");

 XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
 writer.Formatting = Formatting.Indented;

 // Report element
 writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
 writer.WriteStartElement("Report");
 writer.WriteAttributeString("xmlns", null, "http://schemas.microsoft.com/sqlserver/reporting/2003/10/reportdefinition");
 writer.WriteElementString("Width", "6in");
 writer.WriteElementString("TopMargin", "2cm");
 writer.WriteElementString("BottomMargin", "2cm");
 writer.WriteElementString("LeftMargin", "2cm");
 writer.WriteElementString("RightMargin", "2cm");

 // DataSource element
 writer.WriteStartElement("DataSources");
 writer.WriteStartElement("DataSource");
 writer.WriteAttributeString("Name", null, "DummyDataSource");
 writer.WriteStartElement("ConnectionProperties");
 writer.WriteElementString("DataProvider", "SQL");
 writer.WriteElementString("ConnectString", String.Empty);
 writer.WriteElementString("IntegratedSecurity", "true");
 writer.WriteEndElement(); // ConnectionProperties
 writer.WriteEndElement(); // DataSource
 writer.WriteEndElement(); // DataSources

 // DataSet element
 writer.WriteStartElement("DataSets");
 writer.WriteStartElement("DataSet");
 writer.WriteAttributeString("Name", null, "DummyDataSet");

 // Query element
 writer.WriteStartElement("Query");
 writer.WriteElementString("DataSourceName", "DummyDataSource");
 writer.WriteElementString("CommandType", "Text");
 writer.WriteElementString("CommandText", String.Empty);
 writer.WriteElementString("Timeout", "30");
 writer.WriteEndElement(); // Query

 // Fields elements
 writer.WriteStartElement("Fields");
 foreach (DataColumn dc in dt.Columns)
 {
  writer.WriteStartElement("Field");
  writer.WriteAttributeString("Name", null, dc.ColumnName);
  writer.WriteElementString("DataField", null, dc.ColumnName);
  writer.WriteEndElement(); // Field
 }

 // End previous elements
 writer.WriteEndElement(); // Fields
 writer.WriteEndElement(); // DataSet
 writer.WriteEndElement(); // DataSets

 // Body element
 writer.WriteStartElement("Body");
 writer.WriteElementString("Height", "5in");

 // ReportItems element
 writer.WriteStartElement("ReportItems");

 // Title
 writer.WriteStartElement("Textbox");
 writer.WriteAttributeString("Name", null, "Title");

 writer.WriteStartElement("Style");
 writer.WriteElementString("FontWeight", "700");
 writer.WriteEndElement(); // Style

 writer.WriteElementString("Top", "0.5cm");
 writer.WriteElementString("Left", "2cm");
 writer.WriteElementString("Height", "1cm");
 writer.WriteElementString("Value", "Raport");
 writer.WriteEndElement(); // Textbox

 // Table element
 writer.WriteStartElement("Table");
 writer.WriteAttributeString("Name", null, "DummyTable");
 writer.WriteElementString("DataSetName", "DummyDataSet");
 writer.WriteElementString("Top", ".5in");
 writer.WriteElementString("Left", ".5in");
 writer.WriteElementString("Height", ".5in");
 writer.WriteElementString("Width", (dt.Columns.Count * 1.5) + "in");

 // Table Columns
 writer.WriteStartElement("TableColumns");
 foreach (DataColumn dc in dt.Columns)
 {
  writer.WriteStartElement("TableColumn");
  writer.WriteElementString("Width", "1.5in");
  writer.WriteEndElement(); // TableColumn
 }
 writer.WriteEndElement(); // TableColumns

 // Header Row
 writer.WriteStartElement("Header");
 writer.WriteStartElement("TableRows");
 writer.WriteStartElement("TableRow");
 writer.WriteElementString("Height", ".25in");
 writer.WriteStartElement("TableCells");

 foreach (DataColumn dc in dt.Columns)
 {
  writer.WriteStartElement("TableCell");
  writer.WriteStartElement("ReportItems");

  // Textbox
  writer.WriteStartElement("Textbox");
  writer.WriteAttributeString("Name", null, "Header" + dc.ColumnName);

  writer.WriteStartElement("Style");
  writer.WriteElementString("TextDecoration", "Underline");
  writer.WriteEndElement(); // Style

  writer.WriteElementString("Top", "0in");
  writer.WriteElementString("Left", "0in");
  writer.WriteElementString("Height", ".5in");
  writer.WriteElementString("Width", "1.5in");
  writer.WriteElementString("Value", dc.Caption);
  writer.WriteEndElement(); // Textbox

  writer.WriteEndElement(); // ReportItems
  writer.WriteEndElement(); // TableCell
 }

 writer.WriteEndElement(); // TableCells
 writer.WriteEndElement(); // TableRow
 writer.WriteEndElement(); // TableRows
 writer.WriteEndElement(); // Header

 // Details Row
 writer.WriteStartElement("Details");
 writer.WriteStartElement("TableRows");
 writer.WriteStartElement("TableRow");
 writer.WriteElementString("Height", ".25in");
 writer.WriteStartElement("TableCells");

 foreach (DataColumn dc in dt.Columns)
 {
  writer.WriteStartElement("TableCell");
  writer.WriteStartElement("ReportItems");

  // Textbox
  writer.WriteStartElement("Textbox");
  writer.WriteAttributeString("Name", null, dc.ColumnName);

  writer.WriteElementString("Top", "0in");
  writer.WriteElementString("Left", "0in");
  writer.WriteElementString("Height", ".5in");
  writer.WriteElementString("Width", "1.5in");
  writer.WriteElementString("Value", "=Fields!" + dc.ColumnName + ".Value");
  writer.WriteElementString("HideDuplicates", "DummyDataSet");
  writer.WriteEndElement(); // Textbox

  writer.WriteEndElement(); // ReportItems
  writer.WriteEndElement(); // TableCell
 }

 // End Details element and children   
 writer.WriteEndElement(); // TableCells
 writer.WriteEndElement(); // TableRow
 writer.WriteEndElement(); // TableRows
 writer.WriteEndElement(); // Details

 // End table element and end report definition file
 writer.WriteEndElement(); // Table
 writer.WriteEndElement(); // ReportItems
 writer.WriteEndElement(); // Body

 writer.WriteEndElement(); // Report

 // Flush the writer and close the stream
 writer.Flush();
 stream.Flush();
 stream.Close();
}

Proces generowania raportu wynikowego w żądanym formacie również jest prosty. Poniższy fragment kody generuje raport w formacie PDF. Żeby wytworzyć arkusz programu Excel to metody Render należy przekazać ciąg znaków "Excel". Zmienna reportPath powinna zawierać ścieżkę do pliku z definicją raportu stworzonego przez pokazaną wcześniej metodę. Zmienna dataTable to z kolei tabela z danymi do zapisania w żądanym formacie. Powinna to być ta sama tabela, która została przekazana do metody GenerateRdl.

...
FileStream fs = File.OpenWrite( reportPath);
GenerateRdl(fs, dataTable);

LocalReport lr = new LocalReport();
lr.ReportPath = reportPath;
lr.DataSources.Add(new ReportDataSource("DummyDataSet", dataTable));

string deviceInfo = "<DeviceInfo><SimplePageHeaders>True</SimplePageHeaders></DeviceInfo>";
string mimeType = null;
string encoding = null;
string ext = null;
string[] streamids = null;
Warning[] warnings = null;
byte[] bytes = lr.Render("PDF", deviceInfo, out mimeType, out encoding, out ext, out streamids, out warnings);
...

GridView oraz puste źródło danych

Home

Programistom używającym kontrolki GridView na co dzień znany jest zapewne fakt, że w przypadku pustego źródła danych kontrolka nie generuje żadnego widocznego markup'u. W szczególności nie będą widoczne nagłówki kolumn czy wiersz dodający.

Kiedy w wyszukiwarce wpiszemy hasło Show GridView if datasource is empty otrzymamy oczywiście mnóstwo rozwiązań tego problemu. Niestety pośród nich nie znajdziemy, a przynajmniej ja nie znalazłem, satysfakcjonującej odpowiedzi dotyczącej źródła danych typu ObjectDataSource. Nie będziemy natomiast osamotnienie jeśli używamy SqlDataSource. Ale co jeśli nie chcemy, nie możemy lub najzwyczajniej w świecie nie chce nam się zmieniać używanego typu źródła danych. Ja zastosowałem rozwiązanie, które opisałem poniżej.

Dla ustalenia uwagi załóżmy, że metoda dostarczająca danych wygląda następująco:

public static IEnumerable GetData()
{
  return _data;
}

Zacznijmy od zmodyfikowania tej metody w ten sposób aby zawsze zwróciła niepustą kolekcję:

public static IEnumerable GetData()
{
  if(_data.Count == 0)
  {
    _data.Add(new TestClass());
  }
  
  return _data;
}

Oczywiście teraz wszystko zadziała z wyjątkiem tego, że na kontrolce pojawi się jakiś "dziwny", sztuczny obiekt. Można temu jednak zaradzić zmieniając lekko definicję TestClass:

public class TestClass
{
  ...
  public bool IsFake
  {
    get; set;
  }
  ...
}

Przy okazji zmodyfikujemy ponownie metodę GetData:

public static IEnumerable GetData()
{
  if(_data.Count == 0)
  {
    _data.Add(new TestClass() { IsFake = true; });
  }
  
  return _data;
}

Ostatni element rozwiązania do podczepienie się pod zdarzenie OnRowDataBound kontrolki GridView w celu sterowania widocznością wierszy:

protected void GridView_RowDataBound(object sender, GridViewRowEventArgs e)
{
  TestClass ts = e.Row.DataItem as TestClass;
  if(ts != null && ts.IsFake)
  {
    e.Row.Visible = false;
  }
}

Rozwiązanie można jeszcze rozszerzyć o usunięcie sztucznego obiektu z kolekcji w momencie kiedy pojawią się "prawdziwe" dane ale moim zdaniem nie jest to konieczne.

Trochę na temat oferty ESRI

Home

Tak jak obiecałem w ostatnim poście teraz poświęcę trochę czasu na omówienie oferty firmy ESRI, która dla kogoś nie związanego na co dzień z GIS'ami może wydać się niezrozumiała i zagmatwana i taka mówiąc szczerze jest. Sądzę, że takie zestawienie może być ciekawe i przydatne dla kogoś stawiającego pierwsze kroki w świecie geograficznych systemów informacyjnych (wiem to z własnego doświadczenie) i nie tylko. A więc zaczynamy.

Po pierwsze wyróżnijmy dwie kategorie produktów. W pierwszej umieścimy gotowe, pudełkowo aplikacje, a w drugiej rozwiązania przeznaczone dla programistów. W pierwszej znajdziemy:

• ArcGIS Desktop. Flagowa aplikacja, a raczej zestaw aplikacji ESRI pozwalających na przeglądanie i analizowanie zgromadzonych danych geograficznych, zarządzanie nimi, edytowanie, tworzenie i tysiące innych rzeczy. Najważniejsze składowe pakietu ArcGIS Desktop to aplikacja administracyjna ArcCatalog, właściwa aplikacja do oglądania i przetwarzania danych czyli ArcMap oraz ArcGlobe służąca do pracy z danymi trójwymiarowymi. W obecnej chwili ArcGIS Desktop dostępne jest w trzech wersjach różniących się między sobą zakresem funkcjonalności. Są to odpowiednio: ArcView, ArcEditor oraz ArcInfo.



• ArcView. To nie tylko nazwa jednej z wersji ArcGIS Desktop ale również nazwa starej aplikacji będącej w prostej linii jej poprzedniczką.



• ArcGIS Server. Dedykowany do zastosowań GIS'owych serwer aplikacyjny. Dostarcza bogaty zestaw usług webowych takich jak: geokodowanie, lokalizowanie... oraz umożliwia tworzenie własnych. Pozwala na publikowania w sieci danych geograficznych oraz zawiera kilka platform do tworzenia mapowych aplikacji WWW i mobilnych. ArcGIS Server sprzedawany jest w wersjach: Basic, Standard oraz Enterprise. ESRI stworzyła również zestaw specjalizowanych rozszerzeń dla serwera np.: do analiz i modelowania 3D.



• ArcPad. Dedykowana dla urządzeń mobilnych aplikacja o dużych możliwościach konfiguracyjnych pozwalających na dostosowanie do konkretnych potrzeb. Również aplikacja wykonująca synchronizację pomiędzy urządzeniem mobilnych, a centralną bazą danych.



• ArcSDE. Nakładka na relacyjną bazę danych, uruchamiana jako usługa, umożliwiająca przechowywanie w niej danych przestrzennych.



• ArcGIS Explorer. Prosty klient dla ArcGIS Server umożliwiający przeglądanie danych geograficznych dostępnych w sieci, na przykład w serwisie ArcGIS Online. Ta aplikacja jest w całości darmowa.



• ArcReader. Aplikacja o podobnej funckjonalności co ArcGIS Explorer ale służąca do przeglądania danych przestrzennych stworzonych w ArcGIS Desktop i opublikowanych przy pomocy aplikacji ArcPublisher. Również darmowa.



• ArcIMS. W pewnym uproszczeniu poprzednik ArcGIS Server. ESRI zaleca użycie następcy.



• ArcGIS for AutoCAD. Darmowe narzędzia zapewniające interoperacyjność pomiędzy rozwiązaniami ESRI i AutoCAD.



• ArcPublisher. Rozszerzenie ArcGIS Desktop o możliwość publikowania map w sieci.

Ofertę dla developerów tworzą natomiast:

• MapObjects. Stare API programistyczne umożliwiające tworzenie okienkowych aplikacji mapowych. Technologia używana coraz rzadziej.



• ArcObjects. Zestaw komponentów COM w oparciu, o które zostały stworzone prawie wszystkie produkty z oferty ESRI: ArcGIS Desktop
, ArcGIS Server, ArcGIS Engine itd.


• ArcGIS Engine. Platforma programistyczna (COM, .NET, Java i C++) oparta o ArcObjects służąca tworzeniu aplikacji okienkowych oraz do dostosowywania aplikacji z pakietu ArcGIS Desktop do swoich potrzeb.



• ArcGIS Mobile. Platforma programistyczna (C#, Java) do tworzenia aplikacji mobilnych sprzedawana razem z ArcGIS Server w wersji Enterprise.



• Web ADF (Application Development Framework). Platforma programistyczna do tworzenia aplikacji WWW sprzedawana razem z ArcGIS Server w wersji Standard. Dostępna dla .NET i Java . W przypadku .NET oparta oczywiście o ASP.NET Ajax.



• ArcGIS Web Mapping APIs. Zestaw interfejsów programistycznych/bibliotek do tworzenia aplikacji mapowych w WPF/Silverlight, JavaScript i Flex darmowych do niekomercyjnego użytku. W porównaniu do Web ADF ma bardzo ograniczone możliwości.

Przegląd ten pomimo, że dość długi nie jest kompletny. Zawiera jednak większość, a z pewnością najważniejsze z produktów z oferty firmy ESRI. Można również spierać się co do użytego przeze mnie podziału. Z mojego doświadczenie wynika jednak, że z tej gromady Arc'ów może być trudno wyłowić to co jest przydatne dla programisty.