Articles | TomasP.Net

Dynamic Lookup in F#

Tomas Petricek — Wed, 04 Jun 2008 01:50:08 GMT

Many people view dynamic and statically-typed languages as two distinct groups (and this is often a reason for never-ending discussions). In this article, I'll try to show one interesting example, which demonstrates that these two groups are not in fact that distinct and that you can implement a common dynamic language feature in F#, which is undoubtedly statically-typed. The feature that I'm talking about is dynamic invoke using a symbolic representation of the member (this is something that can be done using symbols in Ruby, but I'll shortly explain what exactly I mean).

I intentionally wrote statically-typed and dynamic instead of dynamically-typed. In my understanding dynamic is a broader term while dynamically-typed and statically-typed are of course two distinct groups. On the other side dynamic refers to language features that are usually available in dynamically-typed languages, just because it is easy to support them in a nice way. This doesn't mean that having a dynamic feature in a statically-typed language would be impossible - it is just more difficult to implement it in a way that would be similarly elegant.

F# Support for ASP.NET and Notes on Samples

Tomas Petricek — Sat, 08 Mar 2008 23:07:29 GMT

As I mentioned earlier, I spent three months as an intern in Microsoft Research in Cambridge last year and I was working with Don Syme and James Margetson from the F# team. Most of the time I was working on the F# Web Toolkit, which I introduced on the blog some time ago [1], but I also worked on a few additions that are now part of the F# release. Probably the most useful addition is a new implementation of the CodeDOM provider for the F# language which makes it possible to use ASP.NET smoothly from F# (but it can be used in some other scenarios as well) together with two ASP.NET sample applications that you can explore and use as a basis for your web sites. This was actually a part of the distribution for a few months now (I of course wanted to write this article much earlier...), so you may have already noticed, but anyway, I'd still like to write down a short description of these ASP.NET samples and also a few tips for those who're interested in writing web applications in F#.

Writing Silverlight applications in PHP

Tomas Petricek — Fri, 07 Dec 2007 17:16:14 GMT

In my last post about Phalanger I mentioned that our important goal is to support the Silverlight (2.0) platform. Shortly Silverlight is a cross-browser platform that can be used for developing client-side components that run in the web browser and contain rich media, graphics and can interactively communicate with the user. The language that can be used for writing Silverlight code can be in general any .NET language, so our goal is to allow using PHP by making Phalanger compatible with Silverlight.

First steps were already made and it is becoming possible to write some very interesting things in Silverlight using PHP, there is of course still a lot of work to do and we're discussing the future development with PHP development team (you can join the mailing list PHP on DLR for more info). In this article we will first show a very basic Silverlight example that uses PHP and later I will shortly comment more complicated example - a game (quite addicting, so be careful :-)!) where you have to fly with helicopter and avoid the walls. The source code for helicopter game is also attached, so feel free to modify it or create similar games!

If you can't wait to try the demos before looking at the sources, here are the links:

Simple car demo - Click on the car and it will move!
Helicopter game demo - Click left button to fly up!

Infinite Cheese Fractal using WPF 3D and F#

Tomas Petricek — Sat, 24 Nov 2007 23:22:04 GMT

I always liked fractals, because they look like objects from another world, but on the other side if you look at some things in our world you can see many similarities with fractals (but not quite as ideal with the infinite level of precision). One of my favorite fractals is 3D version of Sierpinski carpet [1], which itself is based on very famous Cantor set. Quite long time ago I thought that it would be nice to implement animation of flying through this fractal, but I was never good in 3D graphics and it looked like a lot of work, so I never get to doing it. Luckily, now with F#, which makes it very easy to write the code to generate the fractal and with WPF 3D, which can be easily used to animate the fractal, I finally had everything I needed to do it, so here it is!

Asynchronous Programming in C# using Iterators

Tomas Petricek — Thu, 15 Nov 2007 03:08:35 GMT

In this article we will look how to write programs that perform asynchronous operations without the typical inversion of control. To briefly introduce what I mean by 'asynchronous' and 'inversion of control' - asynchronous refers to programs that perform some long running operations that don't necessary block a calling thread, for example accessing the network, calling web services or performing any other I/O operation in general. The inversion of control refers to the code structure that you have to use when writing a code that explicitly passes a C# delegate as a callback to the asynchronous method (typically called BeginSomething in .NET). The asynchronous method calls the delegate when the operation completes, which reverses the way you write the code - instead of encoding the control flow using typical language constructs (e.g. while loop) you have to use global variables and write your own control mechanism.

The funny thing about this article is that it could have been written at least 3 years ago when a beta version of Visual Studio 2005 and C# 2.0 became first available, but it is using iterators in a slightly bizarre way, so it is not easy to realize that this is possible. Actually, I will use some C# 3.0 methods in the article as well, but only extension methods and mainly just to keep the code nicer. As with my earlier article about building LINQ queries at runtime, I realized that it can be done in C# when I was playing with the F# solution (called F# Asynchronous Workflows), where this approach is very natural, so I will shortly mention the F# implementation as well.

F# Overview (IV.) - Language Oriented Programming

Tomas Petricek — Sat, 03 Nov 2007 00:00:04 GMT

In the fourth article of the F# overview series, I will shortly describe how I understad the language oriented paradigm and how the F# language can be used for developing libraries using this paradigm. We will look how discriminated unions relate to this paradigm and at three specific features that support this paradigm, namely active patterns, computation expressions and quotations.

Defining precisely what the term language oriented programming means in context of the F# language would be difficult, so I will instead explain a few examples that will demonstrate how I understand it. In general, the goal of language oriented programming is to develop a language that would be suitable for some (more specific) class of tasks and use this language for solving these tasks. Of course, developing a real programming language is extremely complex problem, so there are several ways for making it easier. As the most elementary example, you can look at XML files (with certain schema) as language that are processed by your program and solve some specific problem (for example configuring the application). As a side note, I should mention that I'm not particularly happy with the term ‘language’ in this context, because the term can be used for describing a wide range of techniques from very trivial constructs to a complex object-oriented class libraries, but I have not seen any better term for the class of techniques that I’m going to talk about.

F# Overview (III.) - Imperative and Object-Oriented Programming

Tomas Petricek — Sat, 03 Nov 2007 00:00:03 GMT

In the third part of the F# Overview article series, we will look at language features that are mostly well known, because they are present in most of the currently used programming languages. Indeed, I'm talking about imperative programming, which is a common way for storing and manipulating application data and about object oriented programming which is used for structuring complex programs.

In general, F# tries to make using them together with the functional constructs described in the previous part [^] as natural as possible, which yields several very powerful language constructs.

F# Overview (II.) - Functional Programming

Tomas Petricek — Sat, 03 Nov 2007 00:00:02 GMT

In the second part of the F# overview we will look at functional programming, which is probably the most important paradigm used with the F# language, because F# is built on the same grounds as many functional languages. We will first examine the standard F# data types, which are useful to allow the functional programming style and we will also look at a few functional tricks.

As already mentioned in the Introduction for this article series, F# is a typed functional language, by which I mean that types of all values are determined during the compile-time. However, thanks to the use of a type inference, the types are explicitly specified in the code very rarely as we will see in the following examples. Basic data types (aside from a standard set of primitive numeric and textual types that are present in any .NET language) available in F# are tuple, discriminated union, record, array, list, function and object. In the following quick overview, we will use the F# interactive, which is a tool that compiles and executes the entered text on the fly.

F# Overview (I.) - Introduction

Tomas Petricek — Sat, 03 Nov 2007 00:00:01 GMT

In my bachelor thesis I included a short introduction that covered all of the important aspects of the F# programming language and I thought that it may be useful to extend it a little bit to cover also a topics that were not important for my thesis and post it as an article, so there is one and relatively short article that introduces all the interesting F# features. The article got however a bit longer than I expected, so I decided to split it into a three parts that would introduce three different paradigms that are supported by F#. Of course, this series won't teach you everything about F#, but it tries to cover the main F# design goals and (hopefully) presents all the features that make F# interesting and worth learning. In this first part I will shortly introduce F# and the supported paradigms that will be discussed in the upcoming articles.

F# Quotations Samples on CodePlex

Tomas Petricek — Thu, 20 Sep 2007 04:33:49 GMT

Some time ago, Granville Barnett (see his homepage and old blog [^] or a new blog [^]) had a great idea and started a CodePlex project called F# Samples [^] to host various samples written in F# to demonstrate the most important concepts of both functional programming and F#. I quite like this idea, so I asked Granville if I could join and add some samples that I wrote and today I finally found a time to update what I wanted to upload to the latest version of F# and put it online.

Building LINQ Queries at Runtime in F#

Tomas Petricek — Sat, 18 Aug 2007 02:38:11 GMT

In an article about building LINQ queries at runtime in C# 3.0, I described how you can build a LINQ query dynamically, for example by combining a set of conditions using the 'or' operator in the where clause. I mentioned that the way I implemented it is largely influenced by the F# language, which provides very natural way for manipulations with code like this. In this article I will first shortly introduce FLINQ sample, which is an F# library implementing LINQ support and than I will implement the same examples I presented in the earlier article in F#.

Building LINQ Queries at Runtime in C#

Tomas Petricek — Mon, 30 Jul 2007 02:10:17 GMT

Since the first beta versions of LINQ we could hear comments that it is perfect for queries known at compile-time, however it is not possible to use it for building queries dynamically at runtime. In this article I show that this can be actually done very well for most of the common cases. The solution offered by Microsoft (mentioned in [1]) is to build query from a string, however this has many limitations and it in fact goes completely against what LINQ tries to achieve, which is writing queries in a type-safe way with full compile-time checking. In this article I will first show a few support functions to make the life a bit easier and then we will use them for building two sample applications that allows user to build a query dynamically. The solution is largely motivated by my previous use of F#, where working with “expressions” is possible at more advanced level, however I’ll write about F# later and now let’s get back to C# 3.0...

F# Web Tools: "Ajax" applications made simple

Tomas Petricek — Fri, 13 Jul 2007 04:32:29 GMT

Traditional "Ajax" application consists of the server-side code and the client-side part written in JavaScript (the more dynamicity you want, the larger JS files you have to write), which exchanges some data with the server-side code using XmlHttpRequest, typically in JSON format. I think this approach has 3 main problems, which we tried to solve in F# Web Toolkit. There are a few projects that try to solve some of them already - the most interesting projects are Volta from Microsoft [1], Links language [3] from the University of Edinburgh and Google Web Toolkit [2], but none of the projects solve all three problems at once.

Limited client-side environment
Discontinuity between server and client side
Components in web frameworks are only server-side

The aim of the F# Web Toolkit is to solve all these three problems...

Using PHP objects from C# in a type-safe way

Tomas Petricek — Mon, 30 Apr 2007 01:26:24 GMT

When you want to call PHP scripts from mainstream .NET languages, like C# you can follow two different ways. First you can use the pure mode as I demonstrated in one of the earlier articles on PHP application called Texy!. This approach can be used only for some specific applications, because pure mode has several restrictions - the two most important restrictions are that no global code or inclusions are allowed (you have to specify all source files during the compilation), but thanks to this restrictions Phalanger is able to produce classes that are compatible with .NET and can be called from C#. Second option is to create object dynamically by its name and perform all method invocations by name too. This approach can be used with any PHP scripts, but it isn't very convenient. In this article we present new features in the Phalanger beta 4 which extend the second approach and make it possible to use objects from any PHP script in C# using type-safe way.

Keep your multi-core CPU busy with F#

Tomas Petricek — Sat, 24 Mar 2007 23:13:48 GMT

The growth of computer CPU speed is slowly being replaced by the growth of number of CPUs (or cores) in the computer at least for the close future. This causes a revolution in the way software is written, because traditional and most widely used way of writing concurrent applications using threads is difficult and brings several serious issues. Some predictions say that within a few years, almost every computer will have about 16 cores, so there is a huge need for programming paradigms or idioms that help developers write concurrent software easily (see also The Free Lunch Is Over [^] written by Herb Sutter).

Functional programming languages (especially pure functional languages) are interesting from this point of view, because the program doesn't have side-effects which makes it very easy to parallelize it (programs in pure functional languages can't have any side-effects by design, in other functional languages like F# the side-effects can be eliminated by following functional programming style).

This article describes the code that makes it possible to parallelize some common F# constructs like the List.map and List.filter...

CLinq - LINQ support for the C++/CLI language

Tomas Petricek — Fri, 02 Mar 2007 17:11:05 GMT

I started working on this project, because I attended C++ class at our university and I had to do some application in C++. Because I hate doing useless projects I wanted to work on something interesting and so I started thinking whether it would be possible to enable LINQ support in C++/CLI...

C++/CLI is a very flexible language and the following example proves that enabling LINQ support in C++/CLI isn't impossible. The following database query returns name of contact and company for all customers living in London:

// create connection to database
NorthwindData db(".. connection string ..");

// declare database query
Expr<Customers^> cvar = Var<Customers^>("c");
CQuery<String^>^ q = db.QCustomers
  ->Where(clq::fun(cvar, cvar.City == "London"))
  ->Select(clq::fun(cvar, 
      cvar.ContactName + Expr<String^>(", ") + cvar.CompanyName));

// execute query and output results
for each(String^ s in q->Query)
  Console::WriteLine(s);

If you are interested in more information about CLinq project you can...

Overload resolution in Phalanger

Tomas Petricek — Thu, 15 Feb 2007 21:46:45 GMT

PHP language itself doesn't method support overloading (having two methods with same name, but different number or types of parameters). This brings an interesting problem to Phalanger, because most of .NET languages support this and if we want to be able to call any .NET object from PHP we need to add support (at least) for calling of overloaded methods. The latest Phalanger release contains overload resolution described in the Integrating PHP with CLR document [1].

For example, when calling the Console::WriteLine method (which has a lot of overloads), Phalanger dynamically generates a piece of code that we call dynamic stub, which is responsible for choosing the most appropriate overload depending on the actual parameter types. This stub is generated only once for every method, which makes this implementation very efficient. The difficult part of overload resolution is, how can the stub determine what is the best overload? PHP language has a lot of implicit conversions, so when you pass the string "10.2 Little Piggies" to a method it can be implicitly converted to float (10.2) (For more details see [2]). Another example of implicit conversion is that any boolean value can be converted to string (empty string or string "0" are converted to false, every other string is converted to true).

In this article I'll describe how does the dynamic stub look like in current version of Phalanger, what problems can it cause and how are we going to fix it in the future version!

Compiling Texy! with Phalanger

Tomas Petricek — Mon, 12 Feb 2007 00:45:45 GMT

Texy! [1] is a convertor from text format (similar to formats used in some wiki applications) to valid XHTML code written in PHP. The syntax is described at Texy! web page [2]. Unfortunately, it is only in Czech language, but the syntax is very straightforward, so you can understand it without learning Czech :-).

In this article, we'll examine how to compile Texy! using Phalanger in pure mode. In this mode it is possible to use objects from PHP like any other .NET objects, so we can later used the compiled assembly for example in the following C# code:

// Create instance of Texy! parser
Texy t = new Texy();
// Call the 'process' method and cast result to string
string parsed = (string)t.process(txtTexy.Text);
// Display parsed text using literal
ltrOutput.Text = parsed;

Can't return anonymous type from method? Really?

Tomas Petricek — Tue, 23 Jan 2007 23:54:31 GMT

One of the new features introduced in C# 3.0 which will be available in Visual Studio "Orcas" (currently in CTP version) is anonymous type. Anonymous type is something very similar to tuple type from Cω [1] (which is based on tuple types known from many functional programming languages including F#). Anonymous types are extremely useful in LINQ queries, because it allows you to construct type with several properties without declaring the type (with all the properties). Example of query with anonymous type looks like this:

var q = from c in db.Customers
          where c.Country = "Czech Republic"
          select new { FullName=c.Name+" "+c.Surname, Address=c.Address };

Ok, it's probabbly not the best example, but it demonstrates the point - you want to return some information from query and you don't need to declare type that contains FullName and Address properties before, because you need it only for this single query (and you want to return only these two fields, so you don't transfer additional data that you don't need from database).

Now let's get to the second point...

Concepts behind the C# 3.0 language

Tomas Petricek — Sun, 15 Oct 2006 15:19:03 GMT

One of the lectures that I attended last year was Programming Methodology and Philosophy of Programming Languages. The lecture was mostly about history of programming languages and how several features evolved, disappeared and than after many years appeared again in another programming language.

As I final work I decided to write an article that describes ideas that influenced the design of the C# 3.0 language. Some of these features are known from functional languages (for example from LISP or Haskell), some other were developed at Microsoft Research and appeared in the F# language or Cω. I also wanted to show in what ways are these features limited in the C# 3.0. I think that thanks to these limitation, the C# 3.0 is still a simple (or at least not difficult) to understand which is very important for mainstream language, but I find it interesting to know what is possible in other (less limited) languages.

You can also download the article in PDF (404kB)
The article is also available at CodeProject.com

F# metaprogramming and classes

Tomas Petricek — Sat, 14 Oct 2006 01:36:10 GMT

F# quotations allows you to easily write programs that manipulate with data representation of program source code. If you're not familiar with quotations I recommend reading my previous article [1] that contains short introduction to this topic first. Quotations can be used for example for translating subset of the F# language to another code representation or another language.

To get the quotation data of the expression you can either use <@ .. @> operator or resolveTopDef function. In the first case the code written between the "<@" and "@>" is converted to data during the compilation. The resolveTopDef function allows you to get quotation data of top-level definition (function) from compiled library at runtime (you have to use --quotation-data command line switch while compiling the library). I mentioned that quotations can be used to represent only subset of the F# language. Currently, one of the quotation limitations is that it's not possible to enclose the whole class in the quotation operators. It is also not possible to get the representation of the whole class at runtime nor the representation of class members (for example methods).

In this article I'll present a simple method that makes it possible to use F# quotations for working with classes as well, however this is rather a prototype that can be used for experimenting and discovering areas where working with classes might be useful, not a fully working solution.

F# quotations visualizer - reloaded!

Tomas Petricek — Sun, 01 Oct 2006 21:39:06 GMT

Some time ago, I wrote an article about useful utility called F# quotations visualizer. This utility can be used to show visual representation of F# quotations, that can represent (subset of) source code written in F#. There are two ways that you can use to get F# quotations - first is using operators <@@ ... @@> (this returns quotation of the code written inside the operator), second method is to get quotation of top level definition from compiled F# assembly (you have to explicitly enable this using command line switch --enable-quotation-data while compiling assembly).

Because I added several new features to the original Quotations visualizer, I decided to publish the latest version - here is the list of main improvements:

Rewritten using active patterns (new F# language feature)
It is possible to extract quotations from compiled F# assembly (if it contains quotation data)
Added support for several missing language constructs

ASP.NET web applications in F#

Tomas Petricek — Sun, 13 Aug 2006 21:06:33 GMT

CodeDOM (Code Document Object Model) is set of objects (located in System.CodeDom namespace) that can be used for representing logical structure of .NET source code. These classes are used for generating Web service references (using wsdl.exe tool), for generating typed datasets and in many other situations. The most interesting use of CodeDOM classes is in ASP.NET where ASP.NET generates code from aspx/ascx files and compiles this code into web site assemblies (together with the code written in code behind files).

This means, that you can use any language for developing ASP.NET web sites, as long as you implement CodeDOM provider that generates source code from CodeDOM structure and can compile these source files (this can be simply done by executing command line compiler). I was recently working on CodeProvider for the F# language, and finally it supports everything what is needed by ASP.NET (however it is complete and it doesn't work for example with wsdl.exe). Using this CodeDOM provider you can write ENTIRE web site in F# (including in-line code enclosed in <% ... source code ... %>). I also created project template for F# web site that can be imported to Visual Studio 2005, so you can easilly try writing web pages in F#...

LINQ extensions - Simplified keyword search

Tomas Petricek — Fri, 28 Jul 2006 03:57:38 GMT

Recently, I came across interesting question at LINQ Forums (Dynamic conditions: How to achieve multiple "OR" conditions with LINQ? [1]). The question is whether LINQ (and especially LINQ to SQL) provides any simple way to return only records that contain one or more of specified keywords in the name. The question looks simple, but it is simple only if you know the number of keywords that you want to look for. In this case you can write following LINQ query:

// Products that contain "kwd1" or "kwd2" in the name 
var q = from p in db.Products
    where p.ProductName.Contains("kwd1") || p.ProductName.Contains("kwd2")
    select p;

The problem with previous code is that you can't use it if the list of keywords is dynamically entered by user (and so its length may vary). Of course, if you want to run query on in-memory data, you can get very nice results by writing extension method called ContainsAny that performs test for keyword array, but if you want to be able to translate query to SQL, the situation is a bit complicated.

F# quotations visualizer

Tomas Petricek — Wed, 21 Jun 2006 02:20:03 GMT

I already explained what F# quotations are and I explained how you can do some simple manipulations with it. In this article I'd like to present an application that I wrote and that can be helpful when working with quotations. It displays clear graphical representation of given F# quotation (using Windows Forms TreeView control).

Calling functions in LINQ queries

Tomas Petricek — Sat, 10 Jun 2006 14:26:52 GMT

The LINQ Project [^] is an extension to .NET Framework and most important .NET languages (C# and VB.Net) that extends these languages with query operators and some language features that make it possible to integrate queries in the languages. Thanks to LINQ you can write queries that read data from database (or any other data source). For example, imagine that you want to write set of queries for eshop and you need to perform a price calculation in more queries. The problem with LINQ queries is that you can't simply call a function written in C# that calculates price. The following example is NOT WORKING for this reason:

// function used in filter
static decimal CalcPrice(Nwind.Product p)
{
  return p.UnitPrice * 1.19m;
}

// query that uses MyFunc
var q = 
  from p in db.Products
  where CalcPrice(p) > 30m
  select p

I think that this is a big limitation, because when you want to keep some more complex logic in the data access layer you should be able to reuse parts of queries that are similar across more queries. The good thing is that with latest release, LINQ became extensible so it is possible to write a extensions that allow this scenario...

You can also download the article in PDF (80kB)

F# - Simple quotations transofration

Tomas Petricek — Sun, 28 May 2006 15:58:20 GMT

This article describes very simple code that I wrote while learning how to work with the F# quotations library. Using the F# quotations you can get tree representation of the quoted expression. This allows you to write code that takes code written in F# as data and performs some code analysis or compiles/translates that code to different language. This is very similar to the new C# 3.0 expression trees where you can get expression tree from lambda expression and translate this tree for example to SQL (using DLINQ). However expression trees in C# 3.0 are very limited when compared with F# quotations, so that's one of the many reasons why F# is interesting language.

.NET, C# - Používání a psaní enumerátorů

Tomas Petricek — Sun, 21 May 2006 03:14:53 GMT

V tomto článku se podíváme na psaní vlastních kolekcí, které implementují rozhraní IEnumerable a lze je tedy procházet pomocí příkazu foreach.

.NET - Stahování souborů z internetu

Tomas Petricek — Sun, 09 Apr 2006 13:42:35 GMT

V tomto úvodu jsou popsané základní postupy pro stahování textových a binárních souborů z internetu.

C# - Dokumentace pomocí XML komentářů

Tomas Petricek — Sun, 09 Apr 2006 02:15:43 GMT

V tomto článku se dočtete jakým způsobem lze v jazyce C# pomocí XML komentářů a nástroje NDoc vytvářet dokumentaci.

Aho-Corasick string matching in C#

Tomas Petricek — Sun, 04 Dec 2005 00:18:30 GMT

I implemented this algorithm because I worked on one project where we needed to filter bad language in comments submited by users (You wouldn't believe what anonymous users sometimes write). First I tried simple solution using String.IndexOf and using Regex, but none of these solutions was very suitable for this problem, so I decided to implement Aho-Corasick algorithm which is probabbly the best algorithm for this purpose.

Article (published here an on CodeProject.com) describes implementation of this algorithm for pattern matching. In simple words this algorithm can be used for searching text for specified keywords. This implementation is usefull when you have a set of keywords and you want to find all occurences in text or check if any of the keywords is present in the text. You should use this algorithm especially if you have large number of keywords that don't change often, because in this case it is much more efficient than other algorithms that can be simply implemented using .NET class library.

Aho-Corasick search algorithm is very efficient if you want to find large number of keywords in the text, but if you want to search only for a few keywords it is better to use simple method using String.IndexOf.

.NET - Globalizace a lokalizace aplikací (2.)

Tomas Petricek — Sun, 17 Jul 2005 17:00:55 GMT

V druhé části tutoriálu o lokalizaci a globalizaci aplikací se dočtete o tom jak vytvářet více-jazyčné aplikace.

Multi column layout control

Tomas Petricek — Thu, 07 Jul 2005 16:31:19 GMT

Asp.Net control that allows developers to display articles in multi-column layout.

.NET - Globalizace a lokalizace aplikací (1.)

Tomas Petricek — Wed, 06 Jul 2005 00:44:35 GMT

V tomto tutoriálu se dočtete o tom, jak vytvářet aplikace, které fungují nezávisle na lokálním nastavení.

.NET - Literatura a webové stránky

Tomas Petricek — Sat, 02 Jul 2005 18:55:35 GMT

Tento článek se snaží poskytnout seznam kvalitních knih a webových stránek s .Net tématikou a poradí vám kde hledat odpovědi na vaše otázky.

.NET - Úvod do Reflection

Tomas Petricek — Sun, 19 Jun 2005 00:07:18 GMT

V tomto článku se podíváme na to co umožňuje Reflection. Ukážeme si jak lze za běhu zjišťovat informace o objektech a jak je lze používat.

WinForms - Vývoj TabletPC aplikací

Tomas Petricek — Sat, 11 Jun 2005 03:03:34 GMT

V tomto článku naleznete několik ukázek popisujících tvorbu programů pro platformu TabletPC.

C# - Unsafe kód a ukazatele

Tomas Petricek — Sun, 05 Jun 2005 21:36:53 GMT

Tento článek popisuje jak lze v jazyce C# pracovat s ukazateli a obsahuje ukázku přímého přístupu do paměti bitmapy.

.NET - Kolekce a seznamy objektů

Tomas Petricek — Sun, 05 Jun 2005 21:19:02 GMT

Tento článek popisuje práci s poli a základními kolekcemi jako je ArrayList a Hashtable pod platformou .Net.

ASP.NET - Ovládací prvky používající JavaScript

Tomas Petricek — Sun, 05 Jun 2005 21:16:27 GMT

V tomto tutoriálu jsou popsány základní techniky, které je potřeba znát při tvorbě ovládacích prvků založených na JavaScriptu.

ASP.NET - Dynamické vytváření ovládacích prvků

Tomas Petricek — Thu, 05 May 2005 23:24:15 GMT

Tento tutoriál vysvětluje, jakým způsobem lze z kódu stránky dynamicky vytvářet ovládací prvky a jak lze uchovávat nastavení těchto prvků.

.Net - Používání Windows API funkcí

Tomas Petricek — Mon, 25 Apr 2005 01:11:52 GMT

Tento článek vysvětluje, jak je možné používat WinAPI funkce pomocí platform invoke v .Net aplikaci.

WinForms - Screensaver a kreslení pomocí GDI+

Tomas Petricek — Mon, 11 Apr 2005 21:29:25 GMT

Tento článek vysvětluje jak lze za použití objektově orientovaného programování vytvořit spořič obrazovky v .NETu

WinForms - Aplikace s podporou pluginů

Tomas Petricek — Fri, 01 Apr 2005 00:19:58 GMT

Tento úvod vysvětluje jak lze v .Net aplikaci umožnit rozšiřování pomocí pluginů a jak přistupovat k nastavení v konfiguračním souboru.

WinForms - Spolupráce mezi více formuláři

Tomas Petricek — Thu, 31 Mar 2005 23:26:19 GMT

Tento článek popisuje základy spolupráce mezi více formuláři ve Windows Forms aplikaci.

Avalon - Okna a panely v XAML

Tomas Petricek — Tue, 22 Mar 2005 01:53:33 GMT

Tento článek se snaží shrnout pár základních principů v Avalonu, což je framework pro tvorbu uživatelského rozhraní v nadcházející verzi Windows (Longhorn).

Práce s programem Windows Messenger

Tomas Petricek — Tue, 08 Mar 2005 02:20:05 GMT

Co vše lze dělat pomocí COM objektů programu Windows Messenger

Asp.Net 2 - Master pages

Tomas Petricek — Mon, 03 Jan 2005 00:00:00 GMT

Problém jednotného vzhledu a společných některých částí stránky je v nové verzi Asp.Net řešen pomocí tzv. master pages. Funguje to tak, že v master stránce je kód, který má být stejný na všech stránkách a ostatní stránky dodávají pouze obsah... Master pages v Asp.Net 2 je již poměrně známá a velmi očekávaná věc. V tomto článku jsem se pokusil doplnit známé fakty o některé další zajímavosti týkající se master pages, jako je například dynamické načítání master stránky a další.

Universal enumeration editor control

Tomas Petricek — Fri, 31 Dec 2004 03:54:54 GMT

Asp.Net and WinForms control for editing any enumeration data type

Fractal snow screensaver

Tomas Petricek — Fri, 31 Dec 2004 03:40:15 GMT

Describes how to draw snowflakes using fractals and contains a nice snow screensaver.

Asp.Net 2 - Kompilace

Tomas Petricek — Sun, 05 Dec 2004 00:00:00 GMT

Jak je to s dynamickou kompilací v Asp.Net 2 a co bude jinak oproti aktuální verzi

ASP.NET Popup Control

Tomas Petricek — Sat, 20 Nov 2004 04:07:14 GMT

Highly customizable JavaScript popup control for web page wrapped in ASP.NET custom control.

Graphical ASP.NET Controls

Tomas Petricek — Sat, 20 Nov 2004 03:25:26 GMT

Graphical radio button and check box ASP.NET controls