Programowanie

Usprawnienia pracy z prostymi providerami ADO.NET

2008-05-06T11:35:00.001+02:00

Ostatnio musiałem przenieść dane z nowobudowanego systemu do pewnego dość starego systemu, który korzysta z serwera PostgreSQL. Z tej racji, że system ów jest dość mało znormalizowany podstawowa tabela zawiera mnóstwo kolumn (brrr np. 15 kolumn z poszczególnymi pozycjami planu zajęć). Trochę trwało przygotowanie danych w takim układzie w postaci DataTable, potem pozostało mi tylko napisanie kodu obsługującego zapis danych do bazy postgresowej. W tym celu użyłem darmowego sterownika Npgsql, który jednak ma małe wsparcie do designera, co nie przeszkadza zbyt bardzo przy pisaniu poleceń sql dla znormalizowanych tabel. Jednak dla tabeli z 76 kolumnami oznaczało to perspektywę wklepywania ogromnego tasiemca z treścią sql, a potem jeszcze dłuższego z definiowaniem parametrów polecenia.

Pierwszy problem rozwiązałem przenosząc treść poleceń sql (a właściwie tylko Insert, bo inne nie były mi potrzebne), do osobnego pliku tekstowego znajdującego się w zasobach. Z drugim problemem poradziłem sobie przyjmując założenie, że nazwy parametrów używanych w sql-u będą takie same jak nazwy kolumn w źródłowym obiekcie DataTable, a typ parametru będzie wyznaczany przez typ kolumny z tegoż DataTable. Przy przyjęciu tych założeń wystarczyło w pętli przejść po wszystkich kolumnach tabeli i utworzyć odpowiednie parametry polecenia sql. Kod realizujący ten pomysł umieściłem w następującej klasie:

using System.Collections.Generic;
using System.Data;
using Npgsql;
using NpgsqlTypes;

namespace Utils
{
    internal class NpgsqlTableMapping
    {
        private readonly Dictionary<System.Type, NpgsqlDbType> npgsqlConversions;

        public NpgsqlTableMapping()
        {
            npgsqlConversions = new Dictionary<System.Type, NpgsqlDbType>();

            npgsqlConversions.Add(typeof(string), NpgsqlDbType.Varchar);
            npgsqlConversions.Add(typeof(int), NpgsqlDbType.Integer);
            npgsqlConversions.Add(typeof(short), NpgsqlDbType.Smallint);
            npgsqlConversions.Add(typeof(byte), NpgsqlDbType.Smallint);
            npgsqlConversions.Add(typeof(decimal), NpgsqlDbType.Numeric);
            npgsqlConversions.Add(typeof(bool), NpgsqlDbType.Bit);
        }

        public void AddMappings(NpgsqlCommand command, DataTable table)
        {
            foreach (DataColumn column in table.Columns)
            {
                string parameterName = column.ColumnName;
                NpgsqlDbType parameterType = npgsqlConversions[
                    column.DataType];

                NpgsqlParameter parameter = command.Parameters.Add(
                    parameterName, parameterType);
                parameter.SourceColumn = column.ColumnName;
            }
        }
    }
}

Jak widać nie ma tutaj żadnych czarów, a tylko prosty słownik typów .netowych z odpowiadającymi im typami Npgsql (nie wszystkimi, a tylko tymi, które były mi potrzebne. Teraz jednak kod obiektu dal zapisujący dane do bazy postgresowej jest dużo krótszy:

using System.Data;
using Npgsql;
using NpgsqlTypes;

using Utils;

namespace ODDI.VirtualDictionaryDAL
{
    public class LearningOffersDAL
    {
        private NpgsqlDataAdapter adapter;
        private NpgsqlConnection connection;

        public LearningOffersDAL()
        {
            InitPostgreConnection();
        }

        private void InitPostgreConnection()
        {
            string connectionString = System.Configuration.ConfigurationManager.
                ConnectionStrings["PostgreServer"].ConnectionString;

            this.connection = new NpgsqlConnection(connectionString);
        }

        private bool initedOffersAdapter = false;
        private void InitOffersAdapter(DataTable table)
        {
            if(!initedOffersAdapter)
            {
                string sql = Sgh.ODDI.VirtualDictionaryDAL.Properties.
                    Resources.InsertLearningOffer;
                
                NpgsqlCommand insertCommand = new NpgsqlCommand(sql, connection);
                insertCommand.Parameters.Add("YearSemester", NpgsqlDbType.Integer);

                adapter = new NpgsqlDataAdapter();
                adapter.InsertCommand = insertCommand;

                NpgsqlTableMapping mappings = new NpgsqlTableMapping();
                mappings.AddMappings(this.adapter.InsertCommand, table);

                initedOffersAdapter = true;
            }
        }

        public void Update(DataTable table, int yearSemester)
        {
            InitOffersAdapter(table);

            this.adapter.InsertCommand.Parameters["YearSemester"].
                Value = yearSemester;

            this.adapter.Update(table);
        }
    }
}

Użycie obiektu NpgsqlTableMapping nie przeszkadza w dodaniu dodatkowych parametrów (tutaj YearSemester). Wadą jest natomiast to, że polecenie może być przygotowane dopiero przy pierwszym update, kiedy znana jest definicja źródłowego DataTable.

Pola tekstowe o wysokości zależnej od rodzaju rekordu

2008-04-17T12:09:00.001+02:00

Ostatnio przygotowując raport w technologii RDLC stanąłem przed koniecznością ustalenia wysokości pól tekstowych w zależności od typu oferty, tak by rekordów typu A było tylko cztery na stronie, typu B sześć, a C 10.

Z tej racji, że raporty rdlc mogą być renderowane w różny sposób, to nie generują zdarzeń pozwalający na bierząco korygować wysokość (albo też generować indeks czy spis treści). Stąd też wybrałem inne rozwiązanie: ustalenie właściwości "CanGrow" pola tekstowego na true oraz zmienianie liczby linii zawartych w odpowiedniej komórce tabeli źródłowej. Teraz pozostało opracować kod do wyliczania wysokości, aby się łatwiej testował, to najpierw zdefiniowałem pomocniczy interfejs:

public interface ITextMeasurer
{
    int NoOfLines(string text);
}

A potem jego implementacja:

using System;
using System.Drawing;

namespace Utilities.Graphics
{
    public class TextMeasurer : ITextMeasurer, IDisposable
    {
        private readonly SizeF layoutArea;
        private readonly Font font;
        private readonly System.Drawing.Graphics graphics;
        private readonly float oneLineHeight;

        public TextMeasurer(string fontName, float fontSize,
            float maxWidthInCm, float maxHeightInCm, 
            byte totalHorizontalPadding) :
            
            this(new Font(fontName, fontSize), maxWidthInCm, maxHeightInCm, 
                totalHorizontalPadding)
        {}

        public TextMeasurer(Font font, float maxWidthInCm, 
            float maxHeightInCm,
            byte totalHorizontalPadding)
        {
            this.font = font;
            Bitmap bmp = new Bitmap(1, 1);
            graphics = System.Drawing.Graphics.FromImage(bmp);
            float width = (float)(maxWidthInCm / 2.54) * 
                bmp.HorizontalResolution - totalHorizontalPadding;

            float height = maxHeightInCm * bmp.VerticalResolution;
            layoutArea = new SizeF(width, height);

            oneLineHeight = GetTextSize("W").Height;
        }

        public SizeF GetTextSize(string text)
        {
            return graphics.MeasureString(text, font, layoutArea,
                StringFormat.GenericTypographic);
        }

        public int NoOfLines(string text)
        {
            float textHeight = GetTextSize(text).Height;
            return (int)(textHeight / oneLineHeight);
        }

        #region IDisposable Members

        public void Dispose()
        {
            graphics.Dispose();
        }

        #endregion
    }
}

Jak widać, w powyższym rozwiązaniu korzystam z metody MeasureString pomocniczego obiektu graphics. Tak więc pozostało wykorzystać wyliczenie wysokości tekstu i w razie potrzeby dodać pare linii:

using System.Text;
using Sgh.Utilities.Graphics;

namespace Utilities.Texts
{
    public class Corrector
    {
        private readonly ITextMeasurer textMeasurer;

        public Corrector(ITextMeasurer textMeasurer)
        {
            this.textMeasurer = textMeasurer;
        }

        public string CorrectHeight(string inputString, int outputLinesCount)
        {
            int currentNoOfLines = textMeasurer.NoOfLines(inputString);

            if (currentNoOfLines == outputLinesCount)
            {
                return inputString;
            }
                
            return AddEmptyLinesToString(inputString, 
                outputLinesCount - currentNoOfLines);
        }

        private static string AddEmptyLinesToString(
            string inputString, int noLinesToAdd)
        {
            StringBuilder builder = new StringBuilder();
            builder.Append(inputString);
            
            for (int i = 0; i < noLinesToAdd; i++)
            {
                builder.Append("\r\n ");
            }

            return builder.ToString();
        }
    }
}

Jednak okazało się, że czasami w danych źródłowych jest więcej linii tekstu niż może pomieścić w komórcę, tak więc oprócz dodawania pustych wierszy konieczne jest dodanie przycinanie nadmiarowych, tak więc zmodyfikowałem kod metody CurrentHeight:

public string CorrectHeight(string inputString, int outputLinesCount)
{
    int currentNoOfLines = textMeasurer.NoOfLines(inputString);

    if (currentNoOfLines > outputLinesCount)
    {
        LineRemover remover = new LineRemover(inputString, 
            outputLinesCount, textMeasurer);

        inputString = remover.OutputString;
        currentNoOfLines = remover.TextHeight;
    }

    if (currentNoOfLines == outputLinesCount)
    {
        return inputString;
    }
        
    return AddEmptyLinesToString(inputString, 
        outputLinesCount - currentNoOfLines);
}

Jak widać teraz wykorzystywany jest obiekt klasy LineRemover. Tnąc tekst wzdłuż spacji / znaków końca wiersza (za pomocą wyrażenia regularnego), wykorzystuje wyszukiwanie binarne do znaleznienia takiego miejsca, dla którego długość ciągu jest największa, a wysokość napisu jest nie wyższa od wymaganej.

using System.Collections.Generic;
using System.Text.RegularExpressions;
using Utilities.Graphics;

namespace Utilities.Texts
{
    public class LineRemover
    {
        private readonly string outputString;
        private int textHeight;

        public LineRemover(string inputString, int outputLinesCount,
            ITextMeasurer textMeasurer)
        {
            this.outputString = RemoveLines(inputString, 
                outputLinesCount, textMeasurer);
        }

        public string OutputString
        {
            get { return this.outputString; }
        }

        public int TextHeight
        {
            get { return this.textHeight; }
        }

        private string RemoveLines(string inputString, 
            int outputLinesCount,
            ITextMeasurer textMeasurer)
        {
            List<int> whitespaces = FindWhitespaces(inputString);

            int lowIndex = 0;
            int highIndex = whitespaces.Count;

            while (highIndex > lowIndex + 1)
            {
                int currentIndex = (lowIndex + highIndex) / 2;
                string currentText = inputString.Substring(0, 
                    whitespaces[currentIndex]);

                textHeight = textMeasurer.NoOfLines(currentText);

                if (textHeight > outputLinesCount)
                {
                    highIndex = currentIndex;
                }
                else
                {
                    lowIndex = currentIndex;
                }
            }

            return inputString.Substring(0, whitespaces[lowIndex]);
        }

        private List<int> FindWhitespaces(string inputString)
        {
            string pattern = @"\s+";
            Regex regex = new Regex(pattern, RegexOptions.Compiled);

            MatchCollection matches = regex.Matches(inputString);
            List<int> whitespaces = new List<int>();
            whitespaces.Add(0); // first char
            foreach (Match match in matches)
            {
                whitespaces.Add(match.Index);
            }

            whitespaces.Add(inputString.Length);

            return whitespaces;
        }
    }
}

Przykład wykorzystania:

float widthInCm = 8f;

using (TextMeasurer textMeasurer = new TextMeasurer(
    "Arial", 8f, widthInCm, 20f, 4))
{
    Corrector textCorrector = new Corrector(textMeasurer);

    foreach(FramesDataSet.OffersListRow oneOffer in offers)
    {
        string authorsString = oneOffer.AuthorsString;
        int linesCount = textMeasurer.NoOfLines(oneOffer.AuthorsString);

        if (oneOffer.OfferType == 3)
        {
            authorsString = textCorrector.CorrectHeight(authorsString, 2);
        }
        else if (oneOffer.Level == 1 || oneOffer.Level == 2)
        {
            authorsString = textCorrector.CorrectHeight(authorsString, 27);
        }
        else
        {
            authorsString = textCorrector.CorrectHeight(authorsString, 13);
        }
        oneOffer.AuthorsString = authorsString;
    }
}

Raport prawie gotowy, pozostał tylko problem z niedziałającym zgodnie z oczekiwaniami PageBreak (zamiast nowej strony jest nowa kolumna). Ale to temat na kolejny artykuł ;).

Sumowanie danych w obiekcie DataTable

2008-04-08T10:31:00.001+02:00

Miałem ostatnio potrzebę sumowania danych szczegółowych. I nie chodziło tu tylko o dane numeryczne, co można byłoby załatwić wyrażeniami typu Sum(Childs!NazwaRelacji.NazwaPola), lecz także tekstowe, np. nazwy autorów, tak, by każdy znalazł się w osobnym wierszu, czy też sumowanie symboli kierunków, tak by zaprezentować wszystkie kierunki dla danej oferty oddzielone przecinkami.

Będąc jeszcze w erze pre-LINQ, stąd skorzystałem z rozwiązania tradycyjnego, opartego na obiektach DataTable: sumując dane z jednej tabeli (źródłowej) i aktualizując wartości w drugiej tabeli (wyjściowej).

Oparłem się na pomocniczych obiektach sumujących implementujących prosty interfejs:

public interface ISummator
{
    void AddOneValue(DataRow inputRow);
    void SaveResult(DataRow outputRow);
    void Clear();
}

Przykładowy summator tekstowy:

public class SimpleStringSummator : ISummator
{
    private readonly string separator;
    private readonly DataColumn inputColumn;
    private readonly DataColumn outputColumn;
    private StringBuilder stringBuilder;

    public SimpleStringSummator(string separator,
        DataColumn inputColumn, DataColumn outputColumn)
    {
        this.separator = separator;
        this.inputColumn = inputColumn;
        this.outputColumn = outputColumn;
        this.stringBuilder = new StringBuilder();
    }

    public void AddOneValue(DataRow inputRow)
    {
        if (stringBuilder.Length > 0)
        {
            stringBuilder.Append(separator);
        }
        stringBuilder.Append(inputRow[inputColumn]);
    }

    public void SaveResult(DataRow outputRow)
    {
        outputRow[outputColumn] = stringBuilder.ToString();
    }

    public void Clear()
    {
        this.stringBuilder = new StringBuilder();
    }
}

Jak widać summator w konstruktorze dostaje kolumny, z których będzie pobierał dane i potem przy każdym wywołaniu metody AddOneValue dodaje bieżącą wartość do wewnętrznego bufora, którym jest obiekt klasy StringBuilder.

Przykład summatora numerycznego:

public class IntSummator : ISummator
{
    private readonly DataColumn inputColumn;
    private readonly DataColumn outputColumn;
    private int value;

    public IntSummator(DataColumn inputColumn,
        DataColumn outputColumn)
    {
        this.inputColumn = inputColumn;
        this.outputColumn = outputColumn;
    }

    public void AddOneValue(DataRow inputRow)
    {
        value += (int)inputRow[inputColumn];
    }

    public void SaveResult(DataRow outputRow)
    {
        outputRow[outputColumn] = this.value;
    }

    public void Clear()
    {
        this.value = 0;
    }
}

A sama operacja sumowania odbywa się w obiekcie klasy DataTableJoiner:

public class DataTableJoiner
{
    private readonly DataColumn groupByColumn;
    private readonly ISummator[] summators;

    public DataTableJoiner(DataColumn groupByColumn,
        ISummator[] summators)
    {
        this.groupByColumn = groupByColumn;
        this.summators = summators;
    }

    public DataTableJoiner(DataColumn groupByColumn, ISummator summator) :
        this(groupByColumn, new ISummator[]{summator})
    {}
    
    public void JoinData(DataRow[] inputRows, DataTable outputTable)
    {
        if (inputRows.Length == 0)
            return;
     
        object previousGroupByColumnValue = null;

        foreach (DataRow oneRow in inputRows)
        {
            object currentGroupByColumnValue = oneRow[groupByColumn];
            bool newValue = !currentGroupByColumnValue.
                                 Equals(previousGroupByColumnValue);

            foreach (ISummator summator in summators)
            {
                if (newValue && previousGroupByColumnValue != null)
                {
                    DataRow outputRow = outputTable.Rows.Find(
                        previousGroupByColumnValue);
                    summator.SaveResult(outputRow);
                    summator.Clear();
                }
                summator.AddOneValue(oneRow);
            }
            if (newValue)
            {
                previousGroupByColumnValue = currentGroupByColumnValue;
            }
        }

        DataRow lastRow = outputTable.Rows.Find(previousGroupByColumnValue);
        foreach (ISummator summator in summators)
        {
            summator.SaveResult(lastRow);                
        }
    }
}

Przykład wykorzystania:

public void MultiColumnsJoin()
{
    //definicja tabeli źródłowej
    DataTable offersTable = new DataTable();
    DataColumn offerIdColumn = offersTable.Columns.Add(
        "OfferId", typeof(int));

    DataColumn directionColumn = offersTable.Columns.Add(
        "DirectionCode");
    DataColumn hoursCountColumn = offersTable.Columns.Add(
        "HoursCount", typeof(int));

    //dodanie rekordów w tabeli źródłowej
    offersTable.Rows.Add(1, "Eko", 5);
    offersTable.Rows.Add(1, "Fin", 10);
    offersTable.Rows.Add(1, "Geo", 1);

    offersTable.Rows.Add(2, "Fin", 3);

    //definicja tabeli wyjściowej
    DataTable outputTable = new DataTable();
    DataColumn pk = outputTable.Columns.Add("OfferId", typeof(int));
    DataColumn outputDirectionColumn = outputTable.Columns.Add(
        "SumDirections");
    DataColumn outputHoursColumn = outputTable.Columns.Add(
        "TotalHours", typeof(int));

    outputTable.PrimaryKey = new DataColumn[] { pk };

    //dodanie rekordów w tabeli wyjściowej
    outputTable.Rows.Add(1);
    outputTable.Rows.Add(2);

    ISummator directionSummator = new SimpleStringSummator(",",
        directionColumn, outputDirectionColumn);

    ISummator hoursSummator = new IntSummator(
        hoursCountColumn, outputHoursColumn);

    DataTableJoiner joiner = new DataTableJoiner(offerIdColumn,
        new ISummator[] { directionSummator, hoursSummator });

    joiner.JoinData(offersTable.Select(), outputTable);

    foreach (DataRow oneRow in outputTable.Rows)
    {
        System.Console.WriteLine(
            "Key: {0}, direction string: {1}, hours: {2}",
            oneRow[pk], oneRow[outputDirectionColumn],
            oneRow[outputHoursColumn]);
    }
}

Teraz muszę zastanowić się jak to zrobić w LINQu :)

Hurtowe pobieranie rekordów podrzędnych z bazy Oracle

2008-03-17T09:32:00.001+01:00

Mając chwilę czasu, spróbowałem znaleźć rozwiązanie tegoż samego problemu, co w poprzednim poście, ale już w oparciu o metody specyficzne dla serwera Oracle.

Po pobieżnej analizie linków wyszukanych na Google postanowiłem skorzystać z istniejącej w providerze Oracle.DataAccess możliwości przekazywania do procedury PLSQL tablic asocjacyjnych. Swój kod oparłem na rozwiązaniu opublikowanego w artykule Nicka N. Główną modyfikacją było przeniesienie definicji funkcji konwertującej tablice SQL i PLSQL do osobnego pakietu, tak by tego kodu nie trzeba było powielać używając w innych procedurach.

Definicja pomocniczego typu SQL:

Create Or Replace Type TableOfInts Is Table Of Int;
/

Definicja pakietu z definicją typu PLSQL i funkcją konwertującą dane z tego typu na typ SQL:

Create Or Replace PACKAGE HelpersPack AS
  TYPE AssociativeArray is table of Int Index By Binary_Integer;
  Function AssociativeArray2Tbl(p_arr In AssociativeArray) 
    Return TableOfInts;

END HelpersPack;
/

Create Or Replace Package Body HelpersPack As
    Function AssociativeArray2Tbl(p_Arr In AssociativeArray) 
    Return TableOfInts
    As
        l_Data TableOfInts := TableOfInts();
    Begin
        For i In 1..p_Arr.Last
        Loop
            l_Data.Extend;
            l_Data(l_Data.count ) := p_Arr(i);
        End Loop;
        Return l_Data;
  End;

END HelpersPack;

Sama zaś procedura ściągająca dane dla wybranych wartości klucza głównego może wyglądać tak:

Create Or Replace Procedure GetLearningOffersPrograms(
  p_OffersIds In HelpersPack.AssociativeArray,
  p_Cursor Out Sys_RefCursor)
As
  v_tmparray TableOfInts;
Begin
  v_tmpArray := HelpersPack.AssociativeArray2Tbl(p_OffersIds);

  Open p_Cursor For

    Select
      *
    From
      LearningOffersPrograms
    Where
      OfferId In (Select column_value From Table(v_tmpArray))
    Order By
      Position;
END;

A jej uruchomienie po stronie klienta .netowego:

public void LoadProgramsWithArray(DataSet data, int[] offersIds, 
    string tableName)
{
    string connectionString = System.Configuration.ConfigurationManager.
            ConnectionStrings["OracleServer"].ConnectionString;

    using (OracleConnection con = new OracleConnection(connectionString))
    {
        con.Open();
        
        OracleCommand cmd = new OracleCommand(
            "GetLearningOffersPrograms", con);
        cmd.CommandType = CommandType.StoredProcedure;

        cmd.Parameters.Add("p_OffersIds", OracleDbType.Int32, 
            offersIds, ParameterDirection.Input);

        cmd.Parameters.Add("p_Cursor", OracleDbType.RefCursor, 
            ParameterDirection.Output);

        OracleDataAdapter adapter = new OracleDataAdapter(cmd);
        adapter.Fill(data, tableName);
    }
}

Pobieżne testy powyższego podejścia pokazują, że wzrost wydajności w stosunku do poprzedniego rozwiązania (opartego na dynamicznym budowaniu zapytania po stronie klienta) jest relatywnie mały. Przypuszczam jednak, że w innych warunkach (np. większej liczbie rekordów) korzyści z wykonywania całego kodu po stronie serwera będą większe.

Hurtowe pobieranie z bazy rekordów podrzędnych

2008-03-12T14:49:00.001+01:00

W aktualnie budowanej przeze mnie aplikacji dość często występuje następujący schemat działania:

pobranie określonych danych z podstawowych tabel wg rozbudowanych kryteriów, np. wyszukanie określonych ofert,
dla każdergo rekordu z podstawowych tabel pobranie danych z tabel pomocniczych, czyli np. programów dla wszystkich wyszukanych ofert.

Pobieranie danych z tabel podrzędnych można zrealizować na różne sposoby:

użycie widoków parametrycznych - nie ma czegoś takiego w SQL Serverze albo Oracle, ale jest np. w Accessie - zapytanie może pobierać dane z innego zapytania parametrycznego.
pobieranie danych w pętli dla każdego rekordu podstawowego - rozwiązanie mało wydajne,
użycie do pobierania danych z tabel pomocniczych zapytań zawierających takie same kryteria jak zapytania zasadnicze - dużo pisania i trudniejszy w utrzymaniu kod (poprawki należy nanosić w wielu miejscach),
wykorzystanie tymczasowych tabel z wartościami kluczy z tabel podstawowych, dla których należy pobrać dane z tabel szczegółowych,
hurtowe pobranie danych z tabel podrzędnych dla wszystkich rekordów jakie występują w tabeli nadrzędnej i to rozwiązanie wydaje mi się najwygodniejsze.

Hurtowe pobieranie danych z bazy realizowałem do tej pory (na SQL Serverze) przez przekazywanie do procedury składowanej parametru typu Varchar z listą kluczy, np.: Exec GetAllProducts @ProductsIds ='1,2,103,54,89'. A procedura przechowywana z tego varchara wyciągała tabelę wartości, którą już bezproblemowo można było wykorzystać w zapytaniu. Począwszy od SQL Servera 2005 można używać jako parametrów xml-i, tak więc zamiast stringa z wartościami kluczy można przekazać do niej odpowiedni string xml, ale tego pomysłu nie miałem jeszcze okazji testować w praktyce.

Z tej racji, że system, który aktualnie rozwijam, korzysta z serwera Oracle, a Oracle na razie znam w małym zakresie, to na szybko postanowiłem skorzystać z innego pomysłu: dynamicznego budowania po stronie aplikacji SQL, tak by w klauzuli Where zawierał on wszystkie potrzebne wartości kluczy, czyli Select * From Products Where ProductId In(1,2,103,54,89).

Sprawa jest prosta - wystarczy użyć obiekt StringBuilder i posklejać wszystkie klucze w jeden ciąg, a potem wykonać wygenerowane zapytanie. Jednak szybko napotkałem w Oracle ograniczenie do 1000 warunków w In (i być może w całym Where). Stąd też zmodyfikowałem swój kod, tak by ładowanie danych przebiegało w pakietach po 1000 kluczy.

Poniżej zamieszczam finalny kod klasy, która zajmuje się ładowaniem danych w ten sposób. Aby nie ograniczać się do jednego serwera (Oracle), skorzystałem z uniwersalnych obiektów, czyli IDbConnection i metody Load DataTable przyjmującej jako źródło obiekt IDataReader:

using System.Data;
using System.Text;

namespace GdnKonsulting.Helpers
{
    public class MultipleValuesLoader
    {
        private readonly IDbConnection connection;
        private readonly int maxExpressionsCount;

        public MultipleValuesLoader(
            IDbConnection connection,
            int maxExpressionsCount)
        {
            this.connection = connection;
            this.maxExpressionsCount = maxExpressionsCount;
        }

        public void Load(DataTable table, 
            string sqlFormatString, int[] inputParameters)
        {
            ConnectionState state = connection.State;

            try
            {
                connection.Open();

                int currentIndex = 0;
                int totalCount = inputParameters.Length;

                table.DataSet.EnforceConstraints = false;

                while (currentIndex < totalCount)
                {
                    int endTo = currentIndex + maxExpressionsCount;
                    if (endTo > totalCount)
                        endTo = totalCount;

                    string sqlString = GetSqlString(sqlFormatString,
                        inputParameters, currentIndex, endTo);

                    IDbCommand command = connection.CreateCommand();
                    command.CommandText = sqlString;

                    IDataReader reader = command.ExecuteReader();
                    table.Load(reader);

                    currentIndex = endTo;
                }

                table.DataSet.EnforceConstraints = true;
            }
            finally
            {
                if(state != ConnectionState.Open)
                    connection.Close();
            }
        }

        private static string GetSqlString(string sqlFormatString,
            int[] inputParameters, int startFrom, int endTo)
        {
            StringBuilder sql = new StringBuilder();

            for (int i = startFrom; i < endTo; i++)
            {
                sql.Append(inputParameters[i]);
                sql.Append(",");
            }
            //remove last seperator
            sql.Remove(sql.Length - 1, 1);

            return string.Format(sqlFormatString, sql.ToString());
        }
    }
}

Wkrótce i ta implementacja ulegnie zmianie, po widzę, że będę miał potrzebę ściągania danych nie tylko dla tabel z kluczem opartym na polu int, ale też na stringach.

Przykład wykorzystania:

public void LoadLearningOffersPrograms(DataSet data, int[] offersIds)
{
    string sqlFormatString = "Select * From LearningOffersPrograms " +
        "Where OfferId In({0}) Order By OfferId, Position";

    MultipleValuesLoader loader = new MultipleValuesLoader(
        this.oracleConnection1, 1000);

    loader.Load(data.Tables["Programs"], sqlFormatString, offersIds);
}

Porównanie wydajności: dla około 2 tys. ofert czas ściągania w pętli wszystkich programów dla każdej oferty osobno wyniósł 9 sekund, natomiast po wykorzystaniu zaproponowanej powyżej metody czas spadł do około 0.4 sekundy, czyli około 20 razy szybciej :). Wariant nieco mniej generyczny, z wykorzystaniem OracleConnection i OracleDataAdaptera, który był pierwszą implementacją pomysłu był nieco szybszy - ok. 0.35 sekundy.

Kopia bazy ODBC do pliku mdb

2008-03-06T00:03:00.001+01:00

Ostatnio miałem potrzebę zrobienia kopii bazy systemu, nad którym aktualnie pracuję. Docelowo chciałbym do wszystkich tabel dodać logowanie zmian, ale do tego czasu chciałem mieć czytelne migawki danych. Z tej racji, że baza źródłowa jest na razie dość mała, oraz ze względu na powszechność jako format docelowy wybrałem mdb, czyli bazę accessową.

Archiwizacja danych odbywa się w dwóch fazach:

pobranie listy tabel przy użyciu metody GetSchema i ODBC,
utworzenie w pętli tabel wynikowych za pomocą accessowej składni Select * Into TabelaWynikowa From TabelaZrodlowa IN '' [ODBC;CiagPolaczenia];

Kod nieco uproszczonej wersji:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Odbc;
using System.Data.OleDb;

namespace GdnKonsulting.BackupToMdbLogic
{
    public class TransferData
    {
        private readonly string connectionString;
        private readonly string schemaName;
        private readonly string tmpFile;
        private readonly string outputFileName;

        public TransferData(string connectionString, string schemaName,
            string outputFileName)
        {
            this.connectionString = connectionString;
            this.schemaName = schemaName;
            this.outputFileName = outputFileName;
            this.tmpFile = System.IO.Path.GetTempFileName();
        }

        public void CreateDbAndTransferAllTables()
        {
            AdoxWorker.CreateDatabase(this.tmpFile);
            List<string> tablesList = ReadTablesList();
            ImportDataToDb(this.tmpFile, tablesList);
        }

        private List<string> ReadTablesList()
        {
            using (OdbcConnection connection = new OdbcConnection(connectionString))
            {

                connection.Open();
                DataTable tables = connection.GetSchema("TABLES", 
                    new string[] { null, schemaName });

                List<string> result = new List<string>();
                foreach (DataRow row in tables.Rows)
                {
                    result.Add(tableName);                    
                }
                return result;
            }
        }

        private void ImportDataToDb(string outputFileName, List<string> tablesList)
        {
            string connectionString = String.Format("Provider=Microsoft.Jet.OLEDB.4.0;" +
                "Data Source={0}", outputFileName);

            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand command = connection.CreateCommand();

                connection.Open();
                foreach (string tableName in tablesList)
                {
                    string commandText = String.Format(
                        "Select * Into {0} From {1} IN '' [ODBC;{2}];",
                        tableName, tableName, this.connectionString);

                    command.CommandText = commandText;
                    command.ExecuteNonQuery();
                }
            }
        }
    }
}

I przykładowe wywołanie:

string connectionString = "Driver={Microsoft ODBC for Oracle};" +
    "Server=ORCL;Uid=userName;Pwd=hasło;";

TransferData transfer = new TransferData(
    connectionString, "userName", "C:\Backup.mdb");

W wersji produkcyjnej mam kilka ulepszeń:

kompresję pliku accessowego.
dodanie zdarzenia wywoływanego po udanym zapisie tabeli do pliku wyjściowego, by niezwłocznie informować o tym użytkownika,
filtrowanie tabel (np. z oraclowych tabel znajdujących się w koszu, czyli o nazwach zaczynających się od "BIN$"),
dodawanie do nazw tabel wynikowych nazwy schematu - na przewidywaną ewentualność importu danych z kilku schematów.

Aha, dodam jeszcze kod tworzący nowy plik mdb:

    public static class AdoxWorker
    {
        public static void CreateDatabase(string fileName)
        {
            ADOX.CatalogClass cat = new ADOX.CatalogClass();

            cat.Create("Provider=Microsoft.Jet.OLEDB.4.0;" +
                 "Data Source=" + fileName + ";" +
                 "Jet OLEDB:Engine Type=5");
        }
    }

Jak widać jest to wersja wymagająca wcześniejszego podłączenia bibliotek ADOX

To byłoby na tyle :).

Obsługa złożonych uprawnień użytkowników

2008-02-12T07:44:00.001+01:00

W artykule "Definiowanie złożonych uprawnień użytkowników" opisałem koncepcję struktury danych służącej do przechowywania informacji o uprawnieniach użytkowników. Dalszą częścią pracy nad uprawnieniami było zaprojektowanie komponentu .netowego do wyliczania uprawnienień użytkownika do określonych komponentów.

Wymagania:

a. szybkie wyszukiwanie danych, tak by narzut określania uprawnień nie był zbyt duży,

b. stosunkowo małe wymagania pamięciowe, tak by możliwe było przechowywanie w pamięci (stanie Sesji) kilkuset profili zabezpieczeń (na razie nie przewiduję większego obciążenia systemu:).

Pierwszym pomysłem, na który zwróciłem uwagę, było załadowanie danych z bazy danych do pliku xml, a następnie przeszukiwanie tegoż pliku za pomocą zapytań XPath. Niewątpliwą zaletą takiego rozwiązania byłoby mała zajętość pamięci - w stanie sesji można byłoby przechowwywać tylko ten xml. Jednak przyjęta koncepcja uprawnień oznaczałaby konieczność wielokrotnego przeszukiwania wszystkich węzłów, co niewątpliwie odbiłoby się na wydajności.

W końcu zdecydowałem się na wykorzystanie struktury drzewiastej:

Na najniższym poziomie jest obiekt typu CRUD, który zawiera informację o uprawnieniach użytkownika do poszczególnych czynności (create, read, update i delete). Uprawnienia są przechowywane w formie trójwartościowych enumów AuthorizationType, którę we właściwościach publicznych typu CanCreate…CanDelete są konwertowane na wartości true/false (grant => true, pozostałe => false).

Obiekty AuthorizationNode przechowują informację o poszczególnych węzłach, każdy z nich ma kolekcję obiektów typu Condition, które definiują warunki i posiadają określone uprawnienia jeśli warunki są spełnione. Dla określonych danych wejściowych można określić które warunki są spełnione i używając arytmetyki uprawnień zaprezentowanej w poprzednim artykule można wyliczyć uprawnienia sumaryczne. Do wyliczania uprawnień użyłem biblioteki ecalc z http://www.codeproject.com/KB/cs/ExpressionEval.aspx.

Dla poprawy wydajności uprawnienia wyliczane są raz, poza tym uprawnienia wyliczane są tylko dla tych gałęzi, dla których taka informacja jest pobierana (zazwyczaj też z gałęzi nadrzędnych). Oczywiście wiąże to się z konicznością kasowane poprzednich wyliczeń przy zmianie danych (metoda SetCurrentData ustawia wszystkie uprawnienia rekurencyjnie w dół dla całego drzewa na null).

Na początku jako dane źródłowe wykorzystywałem obiekty typu DataRow, jednak by umożliwić wykorzystywanie innych typów danych utworzyłem interfejs IDataContainer, który zawiera jedynie indeksator:

    public interface IDataContainer
    {
        object this[string fieldName] {get; }
    }

Dodałem dwie jego implementacje SimpleDataContainer korzystająca z obiektu Dictionary<string, object> oraz DataRowDataContainer wykorzystującą DataRow, kod tego ostatniego:

    internal class DataRowDataContainer : IDataContainer
    {
        private DataRow dataRow;

        public DataRowDataContainer(DataRow row)
        {
            this.dataRow = row;
        }

        public DataRow DataRow
        {
            get { return dataRow; }
            set { dataRow = value; }
        }

        public object this[string fieldName]
        {
            get 
            { return dataRow[fieldName]; }
        }
    }

Dla uproszczenia najczęściej wykonywanych zadań rozszerzyłem klasę AuthorizationNode o kilka dodatkowych metod.

Np. metoda GetNonInsertableChilds zwraca kolekcję nazw wszystkich dzieci, które nie są dostępne przy dodawaniu nowych danych.

Przykłady wykorzystania uprawnień:

        [Test]
        public void CheckJamesBondsRightsToOffers()
        {
            // additional method that set up current 
            // user
            Identity.SetCurrentIdentiy("james bond");

            // componente that load privileages data 
            // for current user 
            ComponentAuthorizationBL logic = 
                new ComponentAuthorizationBL();

            ComponentAuthorization authorization =
                logic.GetComponentAuthorization();

            // load some data 
            Dictionary<string, object> dictionary = 
                new Dictionary<string, object>();
            dictionary.Add("OwnOffer", false);
            dictionary.Add("ReferenceBookId", 1);
            dictionary.Add("OfferType", (short)OfferType.Standard);

            authorization.SetCurrentData(dictionary);

            // evaluate privelages for one node
            CRUD crud = authorization.GetCRUD("LearningOffers/MainData");

            Assert.IsTrue(crud.CanRead);
            Assert.IsFalse(crud.CanCreate);
        }

cdn :).

Zamykanie splash screena z innego wątku

2008-02-05T01:23:00.001+01:00

Od jakiegoś czasu dodaję do swoich produkcji splash screen wyświetlany w czasie uruchamiania aplikacji. Do tej pory było to statyczne okienko z jakimś miłym do oka obrazkiem oraz komunikatem proszącym użytkownika o chwilę cierpliwości. Kod wyglądał mniej więcej tak:

        static void Main()
        {
            SplashForm startForm = new SplashForm();
            startForm.Show();
            Application.DoEvents();

            MainForm.Run(startForm);
        }

Natomiast w kodzie głównego formularza aplikacji splash form był zamykany:

    public partial class MainForm : System.Windows.Forms.Form
    {
        public MainForm()
        {
            InitializeComponent();
        }

        private IDisposable splashObject;
        public IDisposable SplashObject
        {
            set { this.splashObject = value; }
        }

        public static void Run(IDisposable splashObject)
        {
            MainForm frm = new MainForm();
            frm.SplashObject = splashObject;

            Application.Run(frm);
        }

        private void MainForm_Shown(object sender, EventArgs e)
        {
            if (splashObject != null)
            {
                splashObject.Dispose();
            }
        }

Jak widać otwarty formularz startowy był przekazywany do głównego formularza aplikacji, a dopiero po załadowaniu tegoż był niszczony.

Przy okazji realizowania ostatniej aplikacji zapragnąłem zdynamizowania splash screena. Po paru eksperymentach uzyskałem satysfakcjonujące mnie rozwiązanie, w którym wykorzystałem oddzielny wątek w którym tworzony jest formularz startowy wyposażony w oddzielną pętlę komunikatów:

        private static void ShowSplashScreenInOtherThread()
        {
            ThreadStart starter = delegate
            {
                SplashForm startForm = new SplashForm();
                Application.Run(startForm);
            };
            new Thread(starter).Start();
        }

Teraz pozostało tylko rozwiązać problem jak zamknąć niepotrzebny już formularz startowy z poziomu głównego formularza aplikacji? Próba przekazania do głównego formularza aplikacji referencji do wątku, w którym działa splash screen, a potem użycie Abort - skuteczne ale kilkusekundowa zwłoka.

Rozwiązanie:

Utworzyłem pomocniczy obiekt DisposeTrigger, który implementuje standardowy interfejs IDisposable w ten sposób, że przy Dispose generuje zdarzenie Disposing:

    public class DisposeTrigger : IDisposable
    {
        public event EventHandler Disposing;
        protected virtual void OnDisposing(EventArgs e)
        {
            if (Disposing != null)
            {
                Disposing(this, e);
            }
        }
        #region IDisposable Members

        public void Dispose()
        {
            OnDisposing(EventArgs.Empty);
        }

        #endregion
    }

Obiekt ten stał się łącznikiem między wątkiem splash screena, a głównym wątkiem aplikacji. W kodzie splash screena dodałem obsługę zdarzenia Disposing:

    public partial class SplashForm : Form
    {
        public SplashForm(DisposeTrigger trigger)
        {
            InitializeComponent();
            trigger.Disposing += new EventHandler(trigger_Disposing);
        }

        void trigger_Disposing(object sender, EventArgs e)
        {
            CloseSplashScreen();
        }

        private delegate void CloseHandler();
        private void CloseSplashScreen()
        {
            if (this.InvokeRequired)
            {
                CloseHandler handler = CloseSplashScreen;
                this.Invoke(handler);
            }
            else
            {
                Application.ExitThread();
            }
        }
    }

Natomiast w metodzie Main tworzony jest obiekt DisposeTrigger, przekazywany zarówno do konstruktora splash screena jak i do głównego formularza aplikacji:

        static void Main()
        {
            DisposeTrigger splashDisposing = new DisposeTrigger();
            ShowSplashScreenInOtherThread(splashDisposing);
                
            MainForm.Run(splashDisposing);
        }

        private static void ShowSplashScreenInOtherThread(
            DisposeTrigger trigger)
        {
            ThreadStart starter = delegate
            {
                SplashForm startForm = new SplashForm(trigger);
                Application.Run(startForm);
            };
            new Thread(starter).Start();
        }

Jak widać wcześniej napisane aplikacje korzystające z mojego frameworka będą dalej działały bez konieczności jakiejkolwiek modyfikacji.

Definiowanie złożonych uprawnień użytkowników

2008-01-30T04:03:00.001+01:00

Ostatnio zmagałem się z problemem w miarę eleganckiego opisu uprawnień użytkowników do aplikacji webowej. Chciałem skorzystać z wbudowanych mechanizmów Role Base Security, ale okazało się, że potrzebuję większej ziarnistości uprawnień.

Przykłady potrzebnych mi uprawnień:

"użytkownicy powinni mieć dostęp do wszystkich ofert złożonych przez siebie, lecz aktualnie mogą edytować tylko oferty określonego typu, natomiast inne mogą tylko czytać",
"zwykli użytkownicy nie mogą ustalać sygnatur złożonych ofert - to mogą czynić tylko managerowie",
"różne typy ofert udostępniają do edycji różne zestawy pól" itd.

Przez pewien czas zastanawiałem się w jakiej postaci opisać uprawnienia. Pierwszy pomysł był taki, zdefiniować je w pliku xml, np.:

<Permisions>
  <LearningOffers C="True" R="True" U="True" D="True">
    <MainData>
      <OfferId C="False" U="False" />
      <Signature C="False" U="False" />
      <Title OfferType="Standardowa" C="False" U="False" />
    </MainData>
    <Teams OfferType='Konkursowa,Standardowa' />
    <TemplateOffers OfferType='Szablon' />    
  </LearningOffers>
  <LearningOffers OwnOffer="True" R="True" />
  <LearningOffers OfferType="Konkursowa" C="False" U="False"/>
</Permisions>

To nawet sensownie wygląda, choć powtarzanie gałęzi LearningOffers, tak by wpisać wszystkie możliwe warunki jest IMHO mało xml-owe.

Ale sprawa się komplikuje jak uwzględni się role, do których może przynależeć użytkownik. Wówczas dla każdej roli należałoby zdefiniować osobne uprawnienia, co znacząco wydłuży rozmiar definicji uprawnień dla wszystkich. Poza tym część użytkowników będzie należeć do kilku ról, więc dla nich należałoby wybrać największe dostępne uprawnienia.

Tak więc, nie przekreślając całkiem xml w samej aplikacji, postanowiłem definiować uprawnienia w innej postaci.

Create Table ComponentAuthorizations(
  ComponentPath Varchar(1000) Not Null,
  Role Varchar(30) Not Null,
  Condition Varchar(200),
  CanCreate Numeric(1) Not Null,
  CanRead Numeric(1) Not Null,
  CanUpdate Numeric(1) Not Null,
  CanDelete Numeric(1) Not Null,

  Constraint Uq_ComponentAuthorizations Unique(
    ComponentPath, Role, Condition)
)

I potem przykładowe dane:

ComponentPath	Role	Condition	CanCreate	CanRead	CanUpdate	CanDelete
Teachers			0	0	0	0
Teachers	Manager		0	1	1	0
Teachers	Teacher	[OwnOffer] = true	0	1	1	0
Teachers/OldTeacherCode	Teacher		0	1	0	0
Teachers/OldTeacherCode	Manager		0	1	1	0
LearningOffers	Teacher	([OfferType] = 2) and ([OwnOffer] = true)	1	1	1	1
LearningOffers	Teacher	[OfferType] = 1	0	1	0	0
LearningOffers	Manager		1	1	1	1

Założenia wyliczania uprawnień dla określonego komponentu:

jeżeli użytkownik przynależy do kilku grup, to dla danego poziomu i warunku wybierane są najwyższe uprawnienia (CRUD),
dla każdego poziomu uprawnienia są sumowane binarnie, czyli jeśli spełniony jest jakikolwiek warunek dla którego uprawnienia są typu 1, to ostateczne uprawnienia też będą wynosić 1,
uprawnienia komponentów niższego rzędu (dzieci) nie mogą być wyższe niż uprawnienia rodziców.

Potem przemyślałem jeszcze powyższy schemat i postanowiłem obok poziomów uprawnień 0 (Absent, czyli brak uprawnień) i 1 (Grant, czyli są uprawnienia), dodać trzeci poziom uprawnień: -1 (Revoke), który będzie oznaczał wycofanie uprawnień: w przypadku spełnienia jakiegokolwiek warunku z poziomem -1 ostatecznie użytkownik nie będzie miał uprawnień do danego komponentu.

Ostateczna arytmetyka uprawnień:

Lp.	Warunek pierwszy	Warunek drugi	Łączne uprawnienia
1	Absent	Absent	Absent
2	Absent	Grant	Grant
3	Grant	Absent	Grant
4	Grant	Grant	Grant
5	Grant	Revoke	Revoke
6	Absent	Revoke	Revoke

I potem przykład wycofania uprawnień:

LearningOffers		[ReferenceBookId] < 5	-1	-1	-1	-1
LearningOffers	Manager	[ReferenceBookId] < 5	-1	1	-1	-1

Powyższe warunki zabierają wszystkim uprawnienia do odczytu i edycji ofert z ReferenceBookId mniejszym od 5, natomiast Managerowie mają w dalszym ciągu prawa do odczytu tychże ofert.

W następnym artykule napiszę o tym jak wykorzystałem tę definicję uprawnień na poziomie aplikacji.

MsAccCorrector

2008-01-22T08:53:00.001+01:00

Większość użytkowników Accessa zauważyła, że Access w tworzonych nowych obiektach, np. formularzach, raportach, używa zlokalizowanych nazw, np. "szczegóły", "nagłówek", itp. Póki uruchamiamy takową aplikację na komputerze z zainstalowaną polską wersją Accessa, w dodatku na polskim systemie Windows, to nie ma żadnego problemu. Jednak jeśli zaczynamy wyślemy aplikację dla osoby mającej np. wersję angielską, to pojawiają się problemy. W tej sytuacji należy usunąć wszystkie polskie literki.

Przy okazji realizacji dla jednego z klientów modernizacji rozwijanej od długiego czasu aplikacji accessowej, tak by działała poprawnie z runtime accessowym, opracowałem przy współpracy z Maciejem Tokarzem aplikację konwertującą polskie znaki. Potem oprócz zamiany polskich znaków dodaliśmy także wyszukiwanie określonych fraz w całym pliku accessowym.

Obsługa

Aplikacja jest prosta w obsłudze, choć fakt, że korzysta z wyrażeń regularnych może odstraszyć potencjalnych użytkowników. Dla początkujących regexowców polecam instalację świetnego edytora Expresso, który udostępnia łatwy w obsłudzę interfejs do projektowania wyrażeń regularnych.

Setup aplikacji można ściągnąć stąd.

Aplikacja jest napisana w VB.NET i jeśli znajdą się chętni, by ją rozwijać, to mogę wrzucić projekt na jakiś publiczny serwer, np.: http://code.google.com/hosting/.

Słownie złotych w c#

2007-08-18T11:36:00.001+02:00

Swoją przygodę z programowaniem zacząłem od napisania w VBA excelowym potrzebnej mi funkcji konwertującej liczby z postaci numerycznej do słownej - stąd darzę tę funkcję dużym sentymentem :-).

Ostatnio potrzebowałem takiej funkcjonalności w aplikacji c#, nie chcąc bezpośrednio korzystać z dość starego kodu, napisałem nową fukcją, aczkolwiek opartą na niemal tym samym algorytmie, co 10 lat wcześniej.

Zasadnicza różnica w stosunku do poprzedniej implementacji, polega na tym, że dane tekstowe umieściłem w pliku xml, a nie bezpośrednio w kodzie programu, co moim zdaniem poprawiło czytelność kodu.

Dane te są dwojga rodzaju: liczebniki słownie oraz odmiana końcówek.

Fragment pliku xml z liczebnikami słownie:

    <NumbersToText>
        <Number value="1">jeden</Number>
        <Number value="2">dwa</Number>
        <Number value="3">trzy</Number>
    </NumbersToText>

Fragment pliku xml z końcówkami:

    <Declinations>
        <Noun position="0">
            <NominativeSingular>grosz</NominativeSingular>
            <NominativePlural>grosze</NominativePlural>
            <GenitivePlural>grosze</GenitivePlural>
        </Noun>
        <Noun position="1">
            <NominativeSingular>złoty</NominativeSingular>
            <NominativePlural>złote</NominativePlural>
            <GenitivePlural>złotych</GenitivePlural>
        </Noun>
    </Declinations>

Oczywiście w kodzie samej funkcji musiałem dodać przeszukiwanie pliku xml, do czego użyłem xpath:

        private string OneAmount(int number)
        {
            string xpath = String.Format(
                @"/Data/NumbersToText/Number[@value={0}]", number);

            XmlNode node = doc.SelectSingleNode(xpath);
            return (node != null ? node.InnerText : null);
        }

        private string OneDeclination(int position, string declination)
        {
            string xpath = String.Format(
                @"/Data/Declinations/Noun[@position={0}]/{1}", 
                position, declination);

            XmlNode node = doc.SelectSingleNode(xpath);
            return (node != null ? node.InnerText : null);
        }

Potem mając już wyciągnięte odpowiednie wartości słowne mogłem zrobić z nich użytek konwertując poszczególne segmenty trzycyfrowe:

        private List<string> Number3DigitToTextList(int number, int position)
        {
            if (number <= 1 || (number >= 10 && number <= 19))
                return SimpleNumber(number, position);
            else
                return ComplicatedNumber(number, position);
        }

        private List<string> SimpleNumber(int number, int position)
        {
            List<string> result = new List<string>();
            result.Add(OneAmount(number));

            if (number == 1)
                result.Add(OneDeclination(position, "NominativeSingular"));
            else
                result.Add(OneDeclination(position, "GenitivePlural"));

            return result;
        }

        private List<string> ComplicatedNumber(int number, int position)
        {
            List<string> result = new List<string>();

            if (number >= 100)
            {
                int hundreds = (number / 100) * 100;
                result.Add(OneAmount(hundreds));
                number = number - hundreds;
            }

            int tens = (number / 10) * 10;
            if (tens != 0)
            {
                result.Add(OneAmount(tens));
            }

            int ones = number - tens;
            if (ones != 0)
            {
                result.Add(OneAmount(ones));
            }

            if (ones == 1 || ones == 0 || ones > 4)
                result.Add(OneDeclination(position, "GenitivePlural"));
            else
                result.Add(OneDeclination(position, "NominativePlural"));

            return result;
        }

W celu zwiększenia czytelności funkcję Number3DigitToTextList rozbiłem na dwie: konwertującą 0, 1 i liczby -naście oraz drugą konwertującą pozostałe liczby.

Teraz tylko pozostało podzielić liczbę wejściową na segmenty trzycyfrowe i obrobić powyższą funkcją. By nie zanudzać, zainteresowanych zachęcam do pobrania przykładowego projektu w VS2005 z funkcją AmountToTextPL.

Używanie DataSetów globalnych

2007-07-09T16:28:00.001+02:00

Czasami w wielu miejscach aplikacji używane są te same dane, przykładem mogą być słowniki, czy też listy klientów. Jeśli danych w tychże tabelach jest stosunkowo niewiele, a dodatkowo dane te są rzadko modyfikowane, to warto pokusić się o przechowywanie w pamięci wszystkich rekordów w takiej postaci by były one dostępne dla wszystkich komponentów aplikacji.

Sigletony - tak, ale nie do końca... Czasami jednak istnieje potrzeba pozostawienia możliwości utworzenia nowej instancji - przykład: DataSet zawierający dane klientów. Dane klientów pochodzą z zewnętrznego systemu, jednak w prawie wszystkich polach wyboru w aplikacji interesuje nas tylko pewna wybrana grupa klientów, natomiast w kontrolce służącej do wyboru klientów z systemu zewnętrznego kryteria wyboru mogą być zupełnie inne.

Stąd koncepcja globalnej instancji, która jest zwracana przez DataSet. Przykład:

    public partial class DictionariesDataSet
    {
        private static DictionariesDataSet globalInstance;

        public static DictionariesDataSet GlobalInstance
        {
            get
            {
                if (globalInstance == null)
                {
                    globalInstance = new DictionariesDataSet();
                }
                return globalInstance;
            }
        }
    }

Jak widać umieściłem ten kod w kodzie używanego datasetu, stąd też użycie takiego globalnego obiektu jest dość intuicyjne, przykład:

this.dictionariesDataSet = DictionariesDataSet.GlobalInstance;

Wadą rozwiązania jest to, że w osobnym miejscu trzeba załadować wszystkie globalne datasety, ale nie chciałem rezygnować z wykorzystywanego od dłuższego czasu wydzielenia kodu DAL i typowanych DataSetów do osobnych bibliotek. I o ile dopuszczam, że DAL może wiedzieć o konkretnych DataSetach, do których ładuje dane, to nie chciałbym wprowadzać odwrotnej zależności, czyli udostępniania komponentowi z DataSetami wiedzy (i referencji) o konkretnym DAL. Z kolei zastanawiałem się nad umieszczeniem powyższego singletonu na poziomie DAL, ale też nie mogłem się przekonać do tego pomysłu.

Prosta separacja logiki od prezentacji przy użyciu DataSetów

2007-07-08T20:32:00.001+02:00

ADO.NET wprowadziło nowe kontenery danych: DataSety i to w dwóch wersjach: zwykłe i typowane. Szczególnie te drugie przypadły mi do gustu i właśnie z nich najczęściej korzystam.

W pierwszych aplikacjach ładowałem dane do tych datasetów bezpośrednio w kodzie kontrolek prezentujących dane dla użytkownika. Takie rozwiązanie ma trochę zalet, np. szybsza implementacja prostych kontrolek, łatwiejsze grupowanie kontrolek w większe komponenty (bo każda kontrolka sama ładuje dane). Jednak mieszanie warstwy prezentacji z warstwą logiki biznesowej zaczęło mi coraz bardziej doskwierać, stąd zacząłem się zastanawiać nad zmianą koncepcji.

Zainteresowałem się wzorcem Model View Controller, jednak do tej pory nie jestem w stanie się do niego przekonać (ale niewykluczone, że kiedyś tak się stanie). Jeśli dobrze rozumiem MVC, to kontroler jest obiektem, który pobiera dane z modelu i prezentuje w widoku. Ale przecież .NET Framework obsługuje wiązanie kontrolek do źródeł danych (obiektów, w tym datasetów).

Na początek postanowiłem podzielić kod tylko na odrębne klasy widoki i kontrolera oraz z datasetów przenoszących dane między nimi:

W tej koncepcji kontroler ładuje dataset i przekazuje go do widoku, zajmuje się też zapisem danych oraz wykonywaniem innych poleceń, natomiast widok odpowiada za prezentację danych.

Gdy zaczynałem korzystać z tego podejścia miałem do dyspozycji VS2003. Po położeniu na formę odpowiedniego datasetu (np. o nazwie myDataSet) można było do niego przybindować poszczególne kontrolki wizualne (datagridy, textboxy, comboboxy itp). Dopóki ładowanie danych odbywało się w samej kontrolce, to nie było problemu, jednak po separacji widoku i kontrolera pojawił się problem z przekazaniem danych do widoku.

Jednak proste przypisanie this.myDataSet = value nie aktualizowało bindingu, a jedynie zmieniało zawartość prywatnej zmiennej myDataSet - teraz wskazywała ona inny obiekt, jednak kontrolki w dalszym ciągu były zbindowane do obiektu tej samej klasy, ale utworzonego przez kod wygenerowany przez designera. Aby rozwiązać ten problem najpierw zacząłem kopiować z designera kod bindujący i ponawiałem bindowanie po każdorazowej zmianie datasetu źródłowego.

Potem znalazłem inne rozwiązanie w postaci wykorzystania metody Merge. A więc kontroler przekazywał do widoku swoją instancję klasy MyDataSet, a widok kasował zawartość swojego datasetu źródłowego i dołączał wszystkie rekordy z datasetu przekazanego przez kontroler. Oczywiście przy zapisie danych sekwencja zdarzeń musiała być odwrotna: kontroler pobierał dataset źródłowy wiew i dołączał go wyczyszczonego swojego datasetu, a potem zapisywał dane do bazy danych.

Ta gimnastyka z danymi jest na pewno nieunikniona przy aplikacji gdzie warstwy są wyodrębnione i np. znajdują się na osobnych maszynach, natomiast w przypadku mniejszych aplikacji miałem wrażenie, że tylko zaciemniają zrozumienie kodu, poza tym dane się rozmnożyły - kontroler miał jedną wersję danych, a widoki inną, dodatkowo z tych samych danych może korzystać kilka widoków np. komponent obsługujący dane klientów oraz komponent do obsługi faktur, a równocześnie istniała potrzeba by wszystkie widoki prezentowały tą samą wersję danych, a więc po wprowadzeniu nowego klienta powinien on być od razu dostępny w komponencie faktur. Zatem, pojawiają się problemy z synchronizacją danych.

Na ratunek przyszedł .NET 2.0 wraz z nowym obiektem BindingSource. Teraz kontrolki można bindować nie bezpośrednio do datasetu, lecz do myBindingSource, a dopiero do tegoż obiekt można przypiąć dataset. Kontroler przy otwarciu widoku ustawia jego właściwość MyDataSet, a w kodzie tej właściwości ustawiana jest nowa wartość DataSource obiektu myBindingSource. I to tyle - wszystko działa jak należy - kodu jest znacznie mniej, nie ma konieczności przebindowywanie kontrolek, a równocześnie wszystkie widoki obsługiwane przez tego samego kontrolera mają takie same dane.

A czy teraz metoda Merge pozostaje u mnie bez pracy? Nie, przydaje się przy asynchronicznym ładowaniu danych do datasetu. Kontroler ładuje dane w osobnym wątku do nowo utworzonego datasetu, a po ich załadowaniu za pomocą Invoke przechodzi na wątek GUI i tam metodą Merge dodaje załadowane dane.

Na koniec taka refleksja: już niedługo wchodzi Orcas, a w nim zupełnie nowe ADO.NET Entity Framework, a więc konieczność porzucenia starych koncepcji (w tym tej powyższej) i żmudne wypracowanie nowych rozwiązań :-).

Proste szablony do formatowania napisów

2007-07-06T04:43:00.001+02:00

Pisanie własnego bloga zaczynam od opisu rozwiązania problemu, z którym borykał się jeden z moich znajomych. Otóż chciał on dać użytkownikom swojej aplikacji możliwość wyboru formatu numeru faktury, bo jak zapewne wiecie: jedni chcą mieć „FV-0102”, inni „FV-000102/2007”, a jeszcze inni „Faktura nr 102/2007/07”.

Ostatnimi czasy eksperymentowałem trochę z biblioteką String Template. Jest to narzędzie, które się świetnie nadaje do rozwiązania tego typu problemów, aczkolwiek po dość powierzchownym rozpoznaniu wydaje mi się, że byłyby kłopoty z określaniem różnego formatu dla różnych danych tego samego typu.

Jednak biblioteka ta jest dość skomplikowana, więc postanowiłem zaproponować wykorzystanie wyrażeń regularnych i napisałem mu szkic w VB.NET. Dziś przerobiłem tamten kod na c# i w tej postaci zamieszczam poniżej:

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public class FormatString
{
    private string templateString;
    private Regex regex;

    public FormatString(string templateString)
    {
        this.templateString = templateString;
        string pattern = @"\$(?<Source>\w+)" + 
            @"(?:;\sFormat\((?<Format>.*?)\))?\$";

        this.regex = new Regex(pattern, 
            RegexOptions.IgnoreCase | 
            RegexOptions.CultureInvariant | 
            RegexOptions.IgnorePatternWhitespace);
    }

    public string Transform(Dictionary<string, object> valueList)
    {
        return regex.Replace(templateString, delegate(Match match){
            string fieldName = match.Groups["Source"].Value;

            // jeśli nie ma parametru w źródle to zwróć pusty string
            if (!valueList.ContainsKey(fieldName))
            {
                return String.Empty;
            }

            object sourceValue = valueList[fieldName];
            string format = match.Groups["Format"].Value;

            return String.Format("{0:" + format + "}", sourceValue);
        });
    }
}

Jak widać kod jest naprawdę prosty, a najtrudniejszym elementem jest samo wyrażenie regularne, które wyszukuje we wzorcu wystąpienie wyrażenia $NazwaPola; Format(ciąg formatujący)$, przy czym ciąg formatujący jest opcjonalny. A potem każde takie wyrażenie jest zastępowane bieżącą wartością odpowiedniego parametru przekazanego w postaci słownika nazwa / wartość parametru.

Aha, pora na testy - przykładowy kod:

    class Test
    {
        public static void Main()
        {
            // proste formatowanie 
            //string templateString = "$NrFaktury$ / $Data; Format(yy)$";

            // formatowanie bardziej złożone
            string templateString = "FV $NrFaktury; Format(00000)$ / " +
                @"$Data; Format(yyyy\/MM)$ $nic$";

            FormatString format = new FormatString(templateString);

            Dictionary<string, object> currentValues = 
                new Dictionary<string, object>();
            currentValues.Add("NrFaktury", 102);
            currentValues.Add("Data", DateTime.Now);

            string result = format.Transform(currentValues);
            System.Console.WriteLine(result);
        }
    }

Przy pisaniu wyrażenia regularnego korzystałem z pomocy Expresso, które gorącą polecam wszystkim miłośnikom regexów :). A tu wrzuciłem demo w VB.NET, tutaj kod był nieco dłuższy, bo VB.NET nie ma metod anonimowych.