Lukask Blog : C#

Archiv prezentací

lukaashek — Fri, 04 Dec 2009 09:59:36 GMT

Konečně jsem se odhodlal k tomu abych všechny svoje prezentace umístil na jedno místo. Prohlédnout, případně stáhnout si je můžete na adrese http://cid-443d88037e0a0331.skydrive.live.com/self.aspx/Prezentace Jedná se především o prezentace, které jsem měl na VŠB TU-Ostrava

WCF Simple Charting Extensibility

lukaashek — Tue, 29 Sep 2009 17:03:38 GMT

Už je to nějakou dobu (myslím si, že to bylo v době vydání charting controlu pro .NET) co jsem si napsal takové rozšíření pro WCF, které sbíralo údaje o tom kdy a kolikrát byla na službe zavolána konkrétní metoda a následně vizualizovalo pomocí těchto grafů buď ve WinForm či WebForm aplikaci. O možnostech rozšíření si můžete přečíst na 1 a 2.

Moje rozšíření vypadá následovně:

     public class MessageInspector : IDispatchMessageInspector

    {

       public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)

       {

           DateTime date = DateTime.Now;

           var path = string.Format("{0}_{1}.xml", date.Month, date.Year);

           string uri = Path.Combine(ConfigurationManager.AppSettings["reportsDir"], path);

           DailyReport report = new DailyReport(uri, date.Day);

           var action = request.Headers.Action.Split('/');

           report.UpdateCalls(action[action.Length - 1]);

           return null;

       }

       public void BeforeSendReply(ref Message reply, object correlationState)

       {

       }

    }

Ve třídě MessageInspector provedu implementaci metody AfterReceiveRequest, tedy jakmile dorazí požadavek na server, získám si aktuální měsíc a rok a podle toho otevřu konkrétní xml soubor (strukturu xml souboru uvedu později). Dále si zjistím název operace, která se volá a inkrementuju počet volání.

    public class MessageEndpointBehavior : IEndpointBehavior

    {

        public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)

        {

        }

        public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)

        {

        }

        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)

        {

            new DailyReport(endpointDispatcher.DispatchRuntime.Operations.Select(x => x.Name), DateTime.Now);

            endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new MessageInspector());

        }

        public void Validate(ServiceEndpoint endpoint)

        {

        }

    }

Třída MessageEndpointbehavior mi zaregistruje mého message inspectora a zárověn vytvoří defaultní strukturu pro daný měsíc. Z vlasnosti endpointDispatcher.DispatchRuntime.Operations si získám seznam všech operací, které mi služba nabízí a vytvořím strukturu xml, která vypadá následovně:

    <?xml version="1.0" encoding="utf-8" standalone="no"?>

    <WCFSimpleChart month="9" year="2009">

      <days>

        <day no="1">

          <operations>

            <operation name="GetProducts">

              <calls>0</calls>

            </operation>

          </operations>

        </day>

        <day no="2">

          <operations>

            <operation name="GetProducts">

              <calls>0</calls>

            </operation>

          </operations>

        </day>

      </days>

    </WCFSimpleChart>

V atributu je uveden měsíc a rok, dále pokračuje elementem days, kde jsou jednotlivé dny daného měsíce a každý den má element operations, kde jsou jednotlivé operace a počet jejich volání v tom konkrétním dni.

Návod na nasazení rozšíření naleznete již ve zminovaných článcích v úvodu tohoto článku.

Rozšíření mám tedy hotové, a ted jak vypadá moje WinForm aplikace, která bude data vizualizovat. Ukážu jen zde takový nástřel pár řádků a výsledný obrázek jak to vypadá, ale kdo by měl zájem to studovat více, tak ať se mi ozve a já mu to pošlu (Nechci to zde uvádět, protože jsem si s stím hrál jedno odpoledne a hodně věcí nefunguje)

    string uri = "\9_2009.xml";

    //DailyReport report = new DailyReport(uri, 3);

    WeeklyReport report = new WeeklyReport(uri, new Week(DateTime.Parse("24.9.2009"), true));

    System.Windows.Forms.DataVisualization.Charting.Chart chart1 = report.GenerateWinReport();

    chart1.Dock = DockStyle.Fill;

    this.Controls.Add(chart1);

V konstruktoru formuláře řeknu, že si chci vygenerovat týdenní report a předám mu uri na xml dokument a počáteční datum týdne (druhý parametr slouží pro rozpoznání jestli se má zobrazit celý týden – 7 dní, nebo jenom “pracovní” – tedy 5 dní). No a nakonec zavolám metodu GenerateWinReport, která vytvoří jednoduchý graf (viz. obrázek):

To je vše a myslím si, že kdyby se na tom zapracovalo tak by to mohla být docela zajímavá utilitka pro vizualizaci vytíženosti WCF služeb :-)

Lukáš

App(Web).config – Sdílení v týmu

lukaashek — Thu, 24 Sep 2009 12:58:57 GMT

Často se mi stává, že při vývoji v týmu potřebuju mít např. connection string podle sebe. I když mám k dispozici nějakou sdílenou databázi, tak rád provádím “harakiri” u sebe na notebooku. Jako source control používám TFS, takže pokud si upravím App.config, změny se projeví i u ostatních a neaktualizovat vždy na nejnovější verzi web.configu mě spíše děsí. Napadlo mě, co takhle vracet jednotlivé konfigurační hodnoty, podle uživatele. Každý z nás je přihlášen do systému pod nějakým účtem tak proč toho nevyužít. App.config by mohl například vypadat následovně:

     <?xml version="1.0" encoding="utf-8" ?>

    <configuration>

      <connectionStrings>

        <add name="release" connectionString="..."/>

        <add name="lukas" connectionString="lukas nb"/>

        <add name="pepa" connectionString="pepa nb"/>

      </connectionStrings>

    </configuration>

existovalo by tedy několik variant connection stringu a stačilo by nyní pak vytvořit třídu, která by podle identity vracela správnou hodnotu:

    public static class Config

    {

        public static string ConnectionString

        {

            get

            {

    #if DEBUG

                WindowsIdentity identity = WindowsIdentity.GetCurrent();

                if (identity == null)

                    throw new Exception("Nelze overit identitu");

                switch (identity.Name.ToLower())

                {

                    case "ac\\kubisl":

                        return ConfigurationManager.ConnectionStrings["lukas"].ConnectionString;

                    case "pepa":

                        return ConfigurationManager.ConnectionStrings["pepa"].ConnectionString;

                    default:

                        return ConfigurationManager.ConnectionStrings["release"].ConnectionString;

                }

    #endif

                return ConfigurationManager.ConnectionStrings["release"].ConnectionString;

            }

        }

    }

Řešili jste někdy podobný problém a máte nějaké elegantní řešení?

LINQ to SQL DataContext Best Practices

lukaashek — Wed, 23 Sep 2009 18:39:17 GMT

LINQ to SQL používá (používalo) docela dost lidí (podle mě). Mezi “uživatele” patřím i já, ale jelikož mě docela zajímá oblast návrhových vzorů a různých “best practices” tak mě zajímalo, zda něco podobného existuje i pro LINQ to SQL. Něco ve smyslu jak správně vytvořit datovou vrstu s podporou LINQ to SQL. Našel jsem plno zajímavých odkazů, ale ne přesně to co jsem chtěl, tak jsem jednotlivé segmenty kódu od jiných autorů dal dohromady + přidal svojí myšlenku a vzniklo něco co mě docela zaujalo, ale ještě jsem to nestihl nikde použít :-)

Podle článku http://oddiandeveloper.blogspot.com/2009/01/linq-best-practice-1-repository-pattern.html jsem trošku upravil Repository pattern a vytvořil si následující rozhraní a třídu:

     public interface IRepository<T> where T:class 

    {

        /// <summary>

        /// Vrati vsechny prvky

        /// </summary>

        /// <returns></returns>

        IEnumerable<T> All();

        /// <summary>

        /// Vrati vsechny prvky podle zadane podminky

        /// </summary>

        /// <param name="exp">Podminka pro hledani</param>

        /// <returns></returns>

        IEnumerable<T> FindAll(System.Linq.Expressions.Expression<Func<T, bool>> exp);

        /// <summary>

        /// Vrati konkretni prvek

        /// </summary>

        /// <param name="exp"></param>

        /// <returns></returns>

        T Single(System.Linq.Expressions.Expression<Func<T, bool>> exp);

        /// <summary>

        /// Vrati prvni prvek v kolekci

        /// </summary>

        /// <returns></returns>

        T First();

        /// <summary>

        /// Vrati prvni prvek podle zadane podminky

        /// </summary>

        /// <param name="exp">Podminka pro hledani</param>

        /// <returns></returns>

        T First(System.Linq.Expressions.Expression<Func<T, bool>> exp);

        /// <summary>

        /// Vrati posledni prvek v kolekci

        /// </summary>

        /// <returns></returns>

        T Last();

        /// <summary>

        /// Oznaci entitu jako pripravenou pro smazani, po zavolani SaveAll bude entita vymazana z database

        /// </summary>

        /// <param name="entity"></param>

        void Delete(T entity);

        /// <summary>

        /// Vytvori novou instanci entity, po zavolani SaveAll bude entita vlozena do databaze

        /// </summary>

        /// <returns></returns>

        T CreateInstance();

        /// <summary>

        /// Ulozi vsechny provedene zmeny

        /// </summary>

        void SaveAll();

    }

    public class Repository<T> : IRepository<T> where T:class 

    {

      public static Repository<T> Instance

      {

          get { return new Repository<T>();}

      }

      #region IRepository<T> Members

      public IEnumerable<T> All()

      {

          return GetTable();

      }

      public IEnumerable<T> FindAll(System.Linq.Expressions.Expression<Func<T, bool>> exp)

      {

          return GetTable().Where(exp);

      }

      public T Single(System.Linq.Expressions.Expression<Func<T, bool>> exp)

      {

          return FindAll(exp).SingleOrDefault();

      }

      public T First()

      {

          return All().FirstOrDefault();

      }

      public T First(System.Linq.Expressions.Expression<Func<T, bool>> exp)

      {

          return FindAll(exp).FirstOrDefault();

      }

      public T Last()

      {

          return All().LastOrDefault();

      }

      public void Delete(T entity)

      {

          GetTable().DeleteOnSubmit(entity);

      }

      public T CreateInstance()

      {

          T entity = Activator.CreateInstance<T>();

          GetTable().InsertOnSubmit(entity);

          return entity;

      }

      public void SaveAll()

      {

          DbDataContext.Instance.SubmitChanges();

      }

      #endregion

      private Table<T> GetTable()

      {

          return DbDataContext.Instance.GetTable<T>();

      }

    }

Jakmile budu chtít provést nějaký dotaz, vždy volám metodu GetTable, která volá vlastnost DbDataContext o které zatím nic nevíme. Tato vlastnost vrátí instanci našeho DataContextu, ale o tom trošku později.

Když mám toto hotové, je důležité si uvědomit kdy budeme chtít vytvářet instanci DataContext objektu. Někde píšou při každém provedení dotazu, jinde na úrovni UI, nebo třeba jeden pro celou aplikaci. Já jsem zastáncem vytvoření jednoho datacontextu pro celou aplikaci. Rick Strahl uvedl na svém blogu zajímavý článek Linq to SQL DataContext Lifetime Management právě o životnosti DataContextu. Opět použiju kousek cizího kódu a tedy třídu, která se nám postará o DataContext

    /// <summary>

    /// Vytvori/vrati data context svazany s threadem nebo web requestem

    /// </summary>

    internal class DataContextFactory

    {

       #region Constants

       /// <summary>

       /// Vychozi klic pouzivany pro ukladani datakontextu

       /// </summary>

       private const string DefaultKey = "DATA_CONTEXT";

       static readonly object Locker = new object();

       #endregion

       #region Public methods

       /// <summary>

       /// Vrati/vytvori data kontext svazany bud s threadem nebo web requestem

       /// </summary>

       /// <param name="key">klic pro ulozeni datakontextu</param>

       /// <returns></returns>

       public static DataContext GetScopedDataContext(string key)

       {

           lock (Locker)

           {

               if (HttpContext.Current != null)

                   return (DataContext)GetWebRequestScopedDataContextInternal(key);

               return (DataContext)GetThreadScopedDataContextInternal(key);

           }

       }

       /// <summary>

       /// Vrati/vytvori data kontext svazany bud s threadem nebo web requestem

       /// </summary>

       /// <returns></returns>

       public static DataContext GetScopedDataContext()

       {

           lock (Locker)

           {

               if (HttpContext.Current != null)

                   return (DataContext)GetWebRequestScopedDataContextInternal(null);

               return (DataContext)GetThreadScopedDataContextInternal(null);

           }

       }

       #endregion

       #region Other methods

       private static object GetThreadScopedDataContextInternal(string key)

       {

           if (key == null)

               key = DefaultKey; //+ Thread.CurrentContext.ContextID;

           var threadData = Thread.GetNamedDataSlot(key);

           object context = null;

           if (threadData != null)

               context = Thread.GetData(threadData);

           if (context == null)

           {

               context = CreateInstance();

               if (context != null)

               {

                   if (threadData == null)

                       threadData = Thread.AllocateNamedDataSlot(key);

                   Thread.SetData(threadData, context);

               }

           }

           return context;

       }

       private static object CreateInstance()

       {

           DataContext context = null;

           if (ConfigurationManager.GetSection("DataContextSection") != null)

           {

               var section = ConfigurationManager.GetSection("DataContextSection") as DataContextSection;

               string connectionString = ConfigurationManager.ConnectionStrings[section.ConnectionString].ConnectionString;

               string strType = section.Type;

               string strAsm = section.Assembly;

               ObjectHandle handle = Activator.CreateInstance(strAsm, strType);

               if (handle != null)

               {

                   object instance = handle.Unwrap();

                   if (instance != null)

                   {

                       Type type = instance.GetType();

                       if (connectionString == null)

                           context = (DataContext)Activator.CreateInstance(type);

                       else

                           context = (DataContext)Activator.CreateInstance(type, connectionString);

                       context.Log = Console.Out;

                   }

               }

           }

           return context;

       }

       private static object GetWebRequestScopedDataContextInternal(string key)

       {

           object context;

           if (HttpContext.Current == null)

           {

               context = CreateInstance();

               return context;

           }

           // vytvori unikatni klic pro webrequest/context

           if (key == null)

               key = DefaultKey + HttpContext.Current.GetHashCode().ToString("x"); //+ Thread.CurrentContext.ContextID; 

           context = HttpContext.Current.Items[key];

           if (context == null)

           {

               context = CreateInstance();

               if (context != null)

                   HttpContext.Current.Items[key] = context;

           }

           return context;

       }

       #endregion

    }

    internal class DbDataContext

    {

        public static DataContext Instance

        {

            get { return DataContextFactory.GetScopedDataContext(); }

        }

    }

Když se podíváte do třídy DataContextFactory na metodu CreateInstance tak uvidíte, že se zde načítají hodnoty z konfiguračního souboru.

Už bylo dost kopírování :-) a teď přichází na řadu to vylepšení, které mě napadlo. Když vytvářím totiž projekt, který bude používat LINQ to SQL tak vždycky musím řešit životnost mého DataContextu, což je otravné a já bych to chtěl mít pouze v dll-ce, kterou bych si přidal do projektu a do configu nastavil pouze potřebné věci, o zbytek už by se pak starala ta moje dll-ka. Konfigurační soubor má následující vlasnosti:

Type – Namespace.MyDataContext (typ datacontextu, abych mohl vytvořit instanci)
Assemlby – název assembly ve které se datacontext nachází
ConnectionString – název connection stringu, který se vytvoři po přidání LINQ to SQL do projektu

A třída, která má tohle na starost vypadá následovně:

    internal class DataContextSection : ConfigurationSection

    {

        [ConfigurationProperty("Type")]

        public string Type

        {

            get { return (string)this["Type"]; }

            set { this["Type"] = value;}

        }

        [ConfigurationProperty("Assembly")]

        public string Assembly

        {

            get { return (string)this["Assembly"]; }

            set { this["Assembly"] = value; }

        }

        [ConfigurationProperty("ConnectionString")]

        public string ConnectionString

        {

            get { return (string)this["ConnectionString"]; }

            set { this["ConnectionString"] = value; }

        }

    }

Nyní je moje dll-ka hotova a můžeme jí použít jak třeba ve WinForm tak WebForm:

WinForm:

Přidám si referenci na mojí dll-ku a upravím pouze konfigurační soubor:

    <?xml version="1.0" encoding="utf-8" ?>

    <configuration>

        <configSections>

          <section name="DataContextSection" type="DAL.DataContextSection, DAL, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />

        </configSections>

        <connectionStrings>

            <add name="DAL.Desktop.Properties.Settings.KnihyConnectionString"

                connectionString="Data Source=.;Initial Catalog=Knihy;Integrated Security=True"

                providerName="System.Data.SqlClient" />

        </connectionStrings>

      <DataContextSection ConnectionString="DAL.Desktop.Properties.Settings.KnihyConnectionString"

                          Type="DAL.Desktop.DataClasses1DataContext"

                          Assembly="DAL.Desktop, Version=1.0.0.0"/> 

    </configuration>

V configu mám connection string, který se jmenuje DAL.Desktop.Properties.Settings.KnihyConnectionString. Nyní pouze přidám mojí sekci DataContextSection, kde vyplním název connection stringu, který je využíván DataContextem, typ a assembly a můžu začít tvořit vlastní část programu, která se bude starat o přístup do databáze, např.

Získání všech položek z konkrétní tabulky

        var autori = Repository<Autori>.Instance.All().ToList();

        dataGridView1.DataSource = autori;

Vytvoření nového záznamu

        var diskuze = Repository<Diskuze>.Instance.CreateInstance();

        diskuze.Text = "erer";

        diskuze.IdAutor = 1;

        Repository<Diskuze>.Instance.SaveAll();

Vyhledávání podle různých kritérií

        var diskuze = Repository<Diskuze>.Instance.FindAll(p => p.Text.Contains("a")).ToList();

        dataGridView1.DataSource = diskuze;

Smazání záznamu

        var entity = Repository<Diskuze>.Instance.Single(p => p.Text == "erer");

        Repository<Diskuze>.Instance.Delete(entity);

        Repository<Diskuze>.Instance.SaveAll();

To je vše a nyní bych uvítal vaše názory. Znáte nějaké “Best practices” pro použití LINQ to SQL ?

WCF – Správa instancí

lukaashek — Tue, 07 Apr 2009 17:24:48 GMT

V dnešním článku se podíváme na možnosti ovlivnění vytváření instancí naší služby. Spravovat instance můžeme několika způsoby. Prvním způsobem je využití vlastnosti InstanceContextMode, který může nabývat těchto hodnot:

InstanceContextMode.PerCall
InstanceContextMode.PerSession (default)
InstanceContextMode.Single

Pokud nenastavíme žádný mód, defaultně je nastaveno PerSerssion, což zajistí, že je vytvořena pouze jedna instance, která existuje po celou dobu session. Pokud je nastaven mód PerCall, je vždy při zavolání jakékoliv operace vytvořena nová instance. V posledním případě, pokud nastavíme mód na Single, zajístíme vytvoření pouze jediné instance. Instance je vytvořena ve chvíli, kdy první klient pošle požadavek na naší službu.

Víme tedy co jednotlivé módy znamenají a nyní se podíváme jak jednotlivé módy nastavit

     [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]

    public class Service1 : IService1

    {

    }

Ve chvíli, kdy provádíme implementaci našeho ServiceContractu (rozhraní), označíme třídu atributem ServiceBehavior, ve kterém můžeme nastavit hodnotu InstanceContextMode na jednu z požadovaných hodnot.

Druhým způsobem jak manipulovat s instancemi, je využití atributu OperationBehavior a vlastnosti ReleaseInstanceMode. Tato vlastnost může nabývat opět několika hodnot:

ReleaseInstanceMode.AfterCall
ReleaseInstanceMode.BeforeAndAfterCall
ReleaseInstanceMode.BeforeCall
ReleaseInstanceMode.None

Co to přesně znamená? Pokud označíme implementaci naší metody tímto atributem a nastavíme ho např. na hodnotu AfterCall, stane se to, že po provedení operace dojde k uvolnění instance i v případě, že je nastaven InstanceContextMode.Single. Hodnota BeforeAndAfterCall provede uvolnění instance ještě před zavoláním metody a ihned po ukončení volání metody. BeforeCall je opak AfterCall, tedy dojde k uvolnění před zavoláním metody.

Jak nastavíme tento mód můžete vidět zde:

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]

    public class Service1 : IService1

    {       

        [OperationBehavior(ReleaseInstanceMode = ReleaseInstanceMode.AfterCall)]

        public void Zaplat()

        {

            foreach (var s in zbozi)

            {

                Console.WriteLine("  " + s);

            }

            Console.WriteLine("Zaplaceno");

        }

    }

Jak jste mohli vidět, ovlivnění životnosti naší služba je jen otázkou jednoduchého nastavení patřičných atributů.

Enum.GetValues(Type enumType) vs. Enum.GetNames(Type enumType)

lukaashek — Wed, 01 Apr 2009 20:08:50 GMT

Dneska jsem si hrál s třídou Enum a zkoušel metody

GetValues
GetNames
GetName

Vytvořil jsem si enum:

     public enum Tituly

    {

        Bc = 1,

        Ing,

        PhD

    }

a dále testovací aplikaci:

    class Program

    {

        static void Main(string[] args)

        {

            var tituly = Enum.GetNames(typeof (Tituly));

            var hodnoty = Enum.GetValues(typeof(Tituly));

            string titul = Enum.GetName(typeof (Tituly), 1);

        }

    }

Když spustím aplikaci, v proměnné tituly mám hodnoty Bc, Ing a PhD, tedy vše co očekávám. Ovšem v proměnné hodnoty mám opět hodnoty “Bc., Ing a Phd” tedy to co jsem zřejmě neočekával. Dobrá tedy, provedeme menší úprava, nepoužijeme var. Nyní vypadá kód následovně:

    class Program

    {

        static void Main(string[] args)

        {

            var tituly = Enum.GetNames(typeof (Tituly));

            int[] hodnoty = (int[]) Enum.GetValues(typeof (Tituly));

            string titul = Enum.GetName(typeof (Tituly), 1);

        }

    }

Nyní když spustím aplikaci tak mám v poli hodnoty pouze otazníky, respektivě nic, viz obrázek

Pokud ovšem toto pole začnu procházet v cyklu foreach a vypisovat jednotlivé hodnoty, dostanu jako výsledek hodnoty 1,2 a 3.

Zkoušel jsem na internetu hledat vysvětlení pro toto chování, ale nic zajímavého jsem nenalezl. Najde se někdo kdo by mi k tomuto chování řekl něco bližšího :-)

Generics – How to cast string, int, DateTime, etc. to T – part II.

lukaashek — Thu, 26 Mar 2009 09:29:03 GMT

A few days ago I posted article about casting built-in types to T. Now, I found more easy solution then my. New implementation of casting built-in types to T uses TypeConverter class and looks like

     public static class ImporterUtils

    {

        public static T ChangeType<T>(XElement source, string name)

        {

            if (source.Element(name) != null)

                return (T) ChangeType(typeof (T), source.Element(name).Value);

            return default(T);

        }

        private static object ChangeType(Type type, string value)

        {

            TypeConverter tr = TypeDescriptor.GetConverter(type);

            return tr.ConvertFrom(value);

        }

    }

This is really easy implementation, isn’t it?

Generics – How to cast string, int, DateTime, etc. to T

lukaashek — Wed, 18 Mar 2009 13:15:34 GMT

I’m parsing XML using LINQ to XML and I want to make my work easier. So I created class that looks like:

     public static class ImporterUtils

    {

        public static T GetValueFromElement<T>(XElement source, string name)

        {

            // if element exists, return it

            if (source.Element(name) != null)

                return (T) (source.Element(name).Value);

            return default(T);

        }

    }

But it’s incorrect! The class has compiler error: “Cannot convert type ‘String’ to ‘T’ ”. After few minutes I found solution:

    public static class ImporterUtils

      {

          public static T GetValueFromElement<T>(XElement source, string name)

          {

              // if element exists, return it

              if (source.Element(name) != null)

                  return CastFromGeneric<T>(source.Element(name).Value);

              return default(T);

          }

          // cast string to T

          private static T CastFromGeneric<T>(string value)

          {

              switch (typeof(T).Name)

              {

                  case "DateTime":

                      return (T) (object) DateTime.Parse(value);

                  case "Int32":

                      return (T)(object)Int32.Parse(value);

                  case "Double":

                      return (T)(object)Double.Parse(value);

                  case "String":

                      return (T) (object) value;

                  default:

                      if (typeof(T).IsEnum) return (T)Enum.Parse(typeof(T), value);

                      return default(T);

              }

          }

      }

The class was compiled successfully and everything works fine, but I have one question: Why I must cast specific type (string, DateTime) to object and then to T? What’s a reason?

Lukas

Parsování dokumentu pomocí LINQ to XML

lukaashek — Thu, 12 Mar 2009 16:58:00 GMT

Zrovna jsem se dostal do situace, kdy jsem potřeboval zpracovat údaje ze vstupního XML souboru. Dejme tomu, že vstupní XML soubor vypadá následovně:

   1: <?xml version="1.0" encoding="utf-8" ?>   2: <Books xmlns="http://www.test.com">   3:   <Book id="1">   4:     <Name></Name>   5:     <Title></Title>   6:   </Book>   7:   <Book id="2">   8:     <Name></Name>   9:     <Title></Title>  10:   </Book>  11: </Books>

Z toho co znám o LINQ to XML vím, že když chci získat seznam všech elementů book, stačí provést implementaci následovně:

   1: XDocument doc = XDocument.Load("..//..//Books2.xml");   2: var books = doc.Descendants("Book");

V tomhle případě jsem se ovšem mýlil a k mému překvapení byla výsledkem prázdná kolekce. Hmm asi po hodině jsem zjistil, že pokud odeberu z XML souboru atribut xmlns, bude výsledek takový jaký jsem očekával, tedy kolekce obsahující elementy book. Co tedy z atributem xmlns? Po brouzdání na internetu jsem narazi nal radu jak na to. Pokud upravíme kód následovně:

   1: XNamespace xmlns = "http://www.test.com";   2: XDocument doc = XDocument.Load("..//..//Books2.xml");   3: var books = doc.Descendants(xmlns + "Book");

bude stejné volání rovněž úspěšné. Snad to někomu pomůže, já se s tím totiž nějakou chvíli natrápil :-)

Lukáš

LINQ to SQL + Reflexe

lukaashek — Fri, 09 Jan 2009 16:02:15 GMT

Při vývoji aplikace, která obsahuje docela hodně tabulek jsem se dostal do situace, kdy jsem potřeboval vrátit konkrétní položku podle ID. Nechtělo se mi ovšem pro každou z X tříd psát metodu, která bude dělat pořád to stejné.

Vytvořil jsem si tedy generickou metodu GetObjectByID

public static T GetObjectByID<T>(int id) where T : class
{
    if (id < 0)
        throw new ArgumentException("id");

    Type objectType = typeof(T);
    Type columnType = typeof (ColumnAttribute);

    // ziskam si sloupec PK
    PropertyInfo pkProperty = objectType.GetProperties().Where(
        prop => prop.GetCustomAttributes(typeof (ColumnAttribute), false).First() != null &&
                ((ColumnAttribute) prop.GetCustomAttributes(typeof (ColumnAttribute), false).First()).
                    IsPrimaryKey
        ).First();

    // vytvorim si vyraz
    ParameterExpression parameter = ParameterExpression.Parameter(objectType, "CurentTable");
    var predicate = Expression.Lambda<Func<T, bool>>(Expression.Equal(
                        Expression.Property(parameter, objectType.GetProperty(pkProperty.Name)),
                        Expression.Constant(id)),
                    parameter);

    return Db.GetTable<T>().Where(predicate).FirstOrDefault();
}

Jelikož potřebuju hledat podle ID, tak si z konkrétního objektu musím najít takovou vlastnost, která je označena atributem CollumnAttribute a zárověn je i primární klíč. Jakmile mám nalezenou konkrétní vlastnost, tak si vytvořím predikát, který obsahuje výraz pro porovnání mojí nalezené vlastnost (PK) s id, které je parametrem mojí metody.

Na základě generického typu T si získám tabulku a na konkrétní tabulce zavolám extensní metodu Where, kde jí jako parametr předám ten můj predikát. Nyní už jen vrátím výsledek a je to. Myslím si, že to ušetří docela dost času :-)

Ještě zde přidám ukázku, jak provádět hledání podle více ID, ale to už je jednodušší

public static IQueryable<T> GetObjectsByID<T>(IEnumerable<int> ids) where T : class 
{
    List<T> result = new List<T>();

    foreach (var id in ids)
    {
        result.Add(GetObjectByID<T>(id));
    }
    return result.AsQueryable();
}

Lukáš

WCF - IQueryable tedy ne

lukaashek — Wed, 26 Nov 2008 00:27:00 GMT

V článku WCF - Vytvoření služby jsem vytvořil službu, kde metodu GetProducts měla návratový typ IQueryable<Product>. Dneska jsem si vytvářel WPF aplikaci, ve které jsem hostoval mojí službu a klienta, abych otestoval funkcionalitu. Ovšem zde nastala chyba, že mi nefungovala komunikace jak přes http tak i přes tcp a vždy mi to vyhodilo dvě různé chyby.

http: An error occurred while receiving the HTTP response to http://localhost:9990/SimpleService/ShopService.svc. This could be due to the service endpoint binding not using the HTTP protocol. This could also be due to an HTTP request context being aborted by the server (possibly due to the service shutting down). See server logs for more details.

tcp: The socket connection was aborted. This could be caused by an error processing your message or a receive timeout being exceeded by the remote host, or an underlying network resource issue. Local socket timeout was '00:00:58.3900000'.

Chybu jsem hledal všude možně, ale pořád nic. Až po delší době jsem prozkoumal WSDL dokument od mojí služby, kterou jsem měl ještě vypublikovanou na IIS a tam jsem zjistil, že návratovým typem mojí metody je "anyType". Zkusil jsem tedy změnit návratový typ na IEnumerable<Product> a nyní vše funguje tak jak má.

S tím jsem se ovšem nespokojil a pátral proč tomu tak je a našel jsem informaci o tom, že expression by se dal velmi těžko serializovat a proto IQueryable není serializovatelný...

Rada na závěr: Když budete vytvářet WCF služby, tak se vyvarujte použití IQueryable...

Dynamické vytváření EventHandlerů

lukaashek — Fri, 07 Nov 2008 18:10:00 GMT

Dnes jsem si na jednom fóru přečetl příspěvek, kde měl uživatel následující problém: Měl vytvořených několik EventHandlerů

public static void A(object sender, EventArgs e)
{
    MessageBox.Show("a");
}
...
public static void H(object sender, EventArgs e)
{
    MessageBox.Show("h");
}

a chtěl, že když uživatel klikne na tlačítko tak se aby provedla událost, kterou si přečetl ze vstupního souboru (ve vstupním souboru byl pouze seznam metod, tedy A, B, C, atd.). Docela dlouho mi trvalo než jsem se dopídil k řešení a tady je:

// získám si objekt EventInfo reprezentující událost Click
EventInfo eInfo = typeof(Button).GetEvent("Click");
// název obslužné metody získám z ComboBoxu (alternativa ke vstupnímu souboru)
// ComboBox obsahuje seznam metod (A, B, C, atd.)
string methodName = comboBox1.SelectedItem.ToString();
// na základě názvu obslužné metody si získám objekt MethodInfo
MethodInfo mInfo = typeof(Form1).GetMethod(methodName);
// a nakonec zavolám mojí metodu s parametry eInfo a mIinfo
AddEventHandler(eInfo, mInfo);

Moje metoda AddEventHandler zaregitruje posluchače pro událost Click

private void AddEventHandler(EventInfo eInfo, MethodInfo mInfo)
{
    // Vytvořím si delegáta, kde prvním parametrem bude typ (EventHandler),
    // druhým null a třetím metoda, která mi obslouží danou událost
    Delegate d = Delegate.CreateDelegate(eInfo.EventHandlerType, null, mInfo);
    // pomocí metody GetAddMethod bude schopni přidat EventHandler danému zdroji (tlačítku)
    MethodInfo addHandler = eInfo.GetAddMethod();
    // vytvořím si pole parametrů - parametr ovšem bude jeden a to delegát, který bude obsluhovat událost
    Object[] handlerArgs = { d };
    // a na závěr provedeme přidání EventHandleru našemu tlačíku
    addHandler.Invoke(button1, handlerArgs);
}

Třeba to někomu pomůže. I já sám se jednou setkal s podobným problémem a vyřešil jsem to tehdy buď použitím switche či konstrukce if-else. Tohle řešení mi ovšem příjde efektivnější. Přece jen, kdybych měl 100 obslužných metod, tak bych těch if-else konstrukcí bylo docela požehnaně.