Development ideas

AppDomains - Why and How ?

2012-01-29T22:45:00.002Z

Finally I've found time for this post, which I was planning last year already.
So, where you may need an AppDomain in your application, how you'll treat it and what are the benefits of using it? I'll try to answer to those question. Read further.
Let's start from the theory: An Application Domain represents an isolated environment in a managed .net application process. Saying roughly those are sub-process layers, where the code will execute. The important features of Applicaiton Domains I'd like to mention here are the following:
1. An applicaiton domain has its own - isolated from others, memory
2. Those can be loaded and unloaded dynamically. Unloading an applicaiton domain will unload all the assemblies loaded in that applicaiton domain (there are still some cases when this is not true, although non-practical cases).
Now let's try to find a usage. Imagine a scenario, where the applicaiton needs to load a component from non-trusted source. There are several issues with this, and the most important for me are Security and Reliability.
Security: you never know what the code in that component is doing behind the scenes.
Reliability: the component can be non-well designed, leaving holes for exceptions to arise.
Let's first concentrate on the case, if we are going to handle such scenario without application domains. Of course for interaction with that third-party component there will be a well-defined interface, and every call of a method of that interface (actually an instnace of 3-rd party component, which I will call Component X further) will be wrapped in a try-catch block. But what if the component does something else behind the scenes ? For example it can has a background thread which does some other processing. In this case, your handlers won't be able to handle exceptions coming from that background processed code, because those are not on the stack of a thread you've just called a method in. So what will happen ? I won't go into details here, but will say that an exception coming out from such backgroun thread (which is not properly caught in Component X, will finally take your process down, and you'll have no chance to react, cause have no handlers at all.
Don't blame me here, cause I'm not going into some special cases here, like WinForms, where you can handle all the exceptions on the Application level by registering to ThreadException event.
On the reliability side - you don't know what the code is doing from data-accessing perspective. So there are limited choices for you to react here - limit your own application permissions to not allow the Component X to do something wrong. But still, you will share the same address space in memory with that component.
Ok, now let's jump to the usage of application domains for this scenario, and see how those will solve the above mentioned problems.
First, in FCL (Framework Class Library) there is a type called AppDomain, which is handling management and interaction with application domains. So let me from now on call application domains just AppDomain for the sake of simplicity only.
Well, the proper design for the above scenario will be the following:
1. Create an AppDomain


AppDomain tmpDomain = AppDomain.CreateDomain("ComponentX Domain");

2. Register for the UnhandledException event of that AppDomain


tmpDomain.UnhandledException += new UnhandledExceptionEventHandler(OnComponentDomain_UnhandledException);

3. Add proper permissions to that AppDomain (this is called sandboxing - limiting permissions)
// Leaving code for this section, because this is out of scope from this article
4. Load the Component X assembly into that AppDomain


Assembly tmpComponentAssembly = tmpDomain.Load(AssemblyName.GetAssemblyName("./ComponentX.dll"));

5. Create Component X instance in that AppDomain.
6. Create a proxy in our AppDomain to interact with Component X instance in the new-created domain(because the memory of each AppDomain is isolated, the process of passing data between AppDomain-s involves serialization and deserialization of that data, and whole the process is refered as Marshalling).


Type tmpComponentType = GetComponentTypeFromAssembly(tmpComponentAssembly, typeof(IComponentContract).Name);
IComponentContract tmpComponentProxy = tmpDomain.CreateInstanceAndUnwrap(tmpComponentAssembly.FullName, tmpComponentType.FullName) as IComponentContract;

7. After finishing working with Component X unload AppDomain of Component X to free up memory. This will also unload the assembly loaded in that AppDomain.


// This call is missing in the example solution attached to this article.
tmpDomain.Unload();

Great, this solves the security problem and what about the reliability? The AppDomain type (in Net Framework 4.0) defines an event called UnhandledException. Unfortunately there is no way to handle that exception and continue the normal flow of the application, but the good thing here is that you get your "last-chance" to save state, or log the exception, and even schedule a task in OS to start a new instance of your application. There are several important aspects you should be aware of regarding this event: "This event can be handled in any Applicaiton Domain, although its not necessarily raised in the application domain, where the exception occured. An exception is unhandled only if the entire stack for the thread has been unwound without finding an applicable exception handler, so the first place the event can be raised is in the application domain where the thread originated.
If the UnhandledException event is handled in the default application domain, it is raised there for any unhandled exception in any thread, no matter what application domain the thread started in. If the thread started in an application domain that has an event handler for UnhandledException, the event is raised in that application domain. If that application domain is not the default application domain, and there is also an event handler in the default application domain, the event is raised in both application domains." The quoted part I've taken from MSDN documentation cause it very well explains that event propogation. I still recommend you to read the MSDN page.
In the section above I've specified the exact version of Net Framework because in the earlier versions the behavior was slightly different. Here is another section from MSDN for earlier versions: "In the .NET Framework versions 1.0 and 1.1, an unhandled exception that occurs in a thread other than the main application thread is caught by the runtime and therefore does not cause the application to terminate. Thus, it is possible for the UnhandledException event to be raised without the application terminating. Starting with the .NET Framework version 2.0, this backstop for unhandled exceptions in child threads was removed, because the cumulative effect of such silent failures included performance degradation, corrupted data, and lockups, all of which were difficult to debug."
I've also created a small solution with code representing the scenario described in this article. Click here to download the example codes.

Comparing IPAddress-es

2012-01-27T15:56:00.002Z

Recently I was struggling with a LINQ expression, where I had a comparison of two ip addresses. Like used to - the comparison was done by the == operator, which was the cause of the headache.
NEVER USE == WITH IPAddress.
Seems IPAddress have no its own overrie for ==, and because it's a reference type that operator is just comparing two addresses(whether those point to the same location in memory or not). And I was getting false for equal ip address comparison.
You can just try to do the following:


    bool areEqual = IPAddress.Parse("150.148.1.54") == IPAddress.Parse("150.148.1.54");
    // the areEqual now is false

So the proper way to compare them is to use the Equals method, which IPAddress type has an override for:


    bool areEqual = IPAddress.Parse("150.148.1.54").Equals(IPAddress.Parse("150.148.1.54"));
    // and now the areEqual will be true

Good luck with your coding.

ASP.Net: Application Pools, Application Domains and/or processes

2011-11-21T08:42:00.001Z

Hi all.

Today I just wanted to bring some light on the way ASP.Net handles requests. So let's start from scratch.

What is ASP.Net itself from OS perspective ?
ASP.Net is just a process called aspnet_wp.exe. How in that case it's stable against application crashes - read further.

In the last question we've mentioned something called Application.What is that ? Ok, Application is an atomic unit of the ASP.Net process - it's the type of the objects, which are responsible for processing client requests. But there is a good and important trick here, which ASP.Net process takes care of - the Application Domains. In fact, for each application (which is represented by a vritual directory in IIS) ASP.Net creates a separate AppDomain, and everything related to specific application happens in the boundaries of that domain. This makes one Application be resistant against others' crashes.
So for each request coming from the client, ASP.Net "creates" (I will cover this a bit later) a separate Application type instance (Application object) to handle that request. Why I've quoted the creates word, is because that's not the case and there is a nice optimization done under the hood: as soon as the application being started (AppDomain for that application being created), ASP.Net creates a pool of up to 100 instances of Application classes to not spend time on heavy object-creation operation on each request. So, finally, what we get, is that for each request a "random" existing Application instance processes that request.
This brings us to one important point: Never keep state in Application instance, or even if you need to take into account the fact that the instnace you've written some state to most probably will be chosen to process request from other clients as well.
All this is great, but seems we're missing something: where do the Application Pools stand in whole this architecture ? Ok, time to change your understanding about Application Pools, because those are just number of settings, which can be applied to different applications. Applicaiton Pools are just a conveniet way to group important settings alltogether and then be able to apply them to any application you'd like to.

I think this is all for this post.
Good luck in your development.

Better Work Environment: Bigger Screens

2011-11-02T21:43:00.000Z

It's almost 5 years I used to work on two monitors, and now sometimes feel the need of the third one. Yes, it's very handy to work on several, but there is a drawback as well: you get used to it and its getting harder and harder to work on a single one at home.
Today, I had to spent some time on my WP7 game (which is in the Marketplace from february), and suddenly thought about moving from 22" Samsung (monitor) to 32" Samsung (TV). And you know what - that's amazing - clear picture, wide area to work and you can see every long line of your code (I'm not fan of splitting lines by enters).

Silverlight: Control visibility based on several properties' values

2011-11-01T16:49:00.000Z

Hi there.

During last few months I've noticed that many people are struggling with problems like object visibility based on parameters.
And here I will try to make this more easy for some of them.
So, let's begin. First of all let me make a not about the IValueConverter interface, introduced in silverlight framework. That's really a very usefull contract, especially when you get used to converters. You now ask about converters ? Sure: A converter is there to help you to convert a value to match the expected result and vice-versa. That's a mechanism, which adopts the input to output, assuming that the output is fully depending on input.
So, how does it work ? Let's assume we have the following XAML:

    <TextBlock Text="Dummy text" Visibility="{Binding Path=DummyTextVisibility}" />

Most of the developers will go this way - trying to match the properties to the UI expectations. But this is NOT CORRECT ! Just think - You're trying to bend your logic to match the View ? Everywhere, in every study about UI development you read that separation is something everyone is trying to achieve (I mean presentation and logic separation). And here you try to adopt the logic based on presentation.
So which is correct ? The correct way to handle this is to not think about the presentation layer at all, when you're developing the business layer. And as soon as you think this way, you see, that it would be much natural to have something like this:

    <TextBlock Text="Dummy text" Visibility="{Binding Path=IsDummyTextVisible}" />

But wait... will this work ? Sure not, cause the Visibility property expecting something of type System.Windows.Visibility, and you've just passed in a bool.
Here the Converter comes in: it lets you to bind to anything logical, and then get what you want to get from it, so it will let us write the following, assuming that we have defined BoolToVisibilityConverter:

  <cnv:BoolToVisibilityConverter x:Key="boolToVisibility" />
   ...
   <TextBlock Text="Dummy text" Visibility="{Binding Path=IsDummyTextVisible,Converter={StaticResource boolToVisibility}}" />

We assume here also that the xmlns:cnv was imported in the root tag, and that the <cnb:BoolToVisibilityConverer ... was defined in the resources section.
And here is the code for the BoolToVisibilityConverter:

public class BoolToVisibilityConverter:IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        try
        {
            return (bool)value ? Visibility.Visible : Visibility.Collapsed;
        }
        catch (Exception ex)
        {
            return Visibility.Collapsed;
        }
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        /// some logic here if you're going to use this
    }
}

Great. Now we have everything in place except the thing, that in some cases you will need to make an object visible depending on two parameters - control is going to be visible if both those parameters are visible. Don't waste your time looking for some complex solutions, just wrap your control in a Panel control, and bind its visibility to the other parameter you'd like to:

<Grid Visibility="{Binding Path=SecondParameter, Converter={StaticResource boolToVisibility}}">
    <TextBlock Text="Dummy text" Visibility="{Binding Path=IsDummyTextVisible,Converter={StaticResource boolToVisibility}}" />
<Grid>

So, that's it. Enjoy :)

Improving .Net Framework

2011-10-20T15:08:00.000+01:00

I was thinking a lot of times about a way of forcing types to have some common constructor. Of course this can be achieved by abstract classes - but the derieved classes can hide it. So the way I was hoping it to be is through the interfaces - to be able to specify a signature of a contructor, the implementing types should have.
Am so happy that Microsoft has Connect :) So my idea is already there - go and vote for it here

Let's see what will they decide.

Remote Assistance within MVVM based applications

2011-10-18T00:18:00.000+01:00

Even we - IT professionals, require a lot of web assistance during our daily life. One of the cases I was facing several days ago was a problem during the payment for an item in Amazon. As usual, the user calls to the support, describes the situation, gets a lot of clarifying questions, and being asked for about three times to repeat, just to ensure that he hasn't missed something.
This is a problem - a big problem both for the customer, who is facing a problem and the support guy, who is just unable to vividly see the situation happening on the customer machine. And the thing the Support man can dreams of in those cases - is a remote connection.
Of course in 99.9% of cases such a luxary will be impossible, and the reason is only the firewalls, the client - who doesn't even know what the remote desktop connection is, ... .
But all we are living in an eWorld - and most of the things we do are related to the internet - onlin shopping, emails, some new account registration, blogging, ... . So I thought that there must be a better way of support, and there is. Of course, it won't fit the requirements of all the users, but it can cover most of the cases. And in this blogpost I will try to bring the idea I do have which can change the way of support.
So let's imagine that the application, which we're adding the support for is designed using MVVM pattern. What does this mean ? This means, that whole the logic of the application is being handled by the ViewModel class instance (in simple case there can be only one class in ViewModel layer). And based on any change on that class the UI is being changed accordingly. So what if someone, who is using the same application, will be able to simulate the same changes in the same order on a ViewModel layer obects on his machine, as the user on his machine ? This will mean, that the UI on both machines will have the same state after every single change, which, in its place, means that both users will have the same view. All this is true, until there is some User-Specific logic in the appilcation, which can change the way the Application behaves depending the logged in user. Let's for now leave this open point for later discussion (in this post of course), and assume that there is a solution for this as well, and both users can log in by the same user.
So, if we will come up with some service, which transmitts any change from one application instance to another we will have a simple screen sharing between those two users. To acomplish this we need a centralized way of transfering the changes in one ViewModel to another.
Remember that a ViewModel class in Silverlight, implements the INotifyPropertyChanged interface, which in its place defines the PropertyChanged event. And any change which can cause the UI to update, being tranfered to the UI throught firing this event. So what we can do is by simply registering to the ViewModel class instance's PropertyChanged event, and pass any change of any property to a service (I will not go into the code, but will just concentrate on the logic here. Please write your comments to the post, and I will try to respond shortly). Transfering to the service all this data is no enough, because there must be some unique token, which by the data should be identified. And this token should be shared with the other party (The support guy in our case), so he will be able to attach his UI to that token as a listener on the service, so any change coming to the service should be transfered to the Support Application Instance (SAI later: the application instance which the support guy has onpened on his machine for remote assistance). This will now bring any UI change to the SAI.
So in this case we got something which is very like a screen sharing application - but the actual sharing. Of course this is a lot already, and the Support guy will know now how the user goes from one point from another in the UI, but let's not stop on this, and continue developing the idea.
Based on all this we can achieve the same from the other side, and bring any change that is being done on the SAI, to the Customer Application. This will mean already, that the application is being remotely controlled.
And that's all. Of course I haven't spent time describing minor things like the user must first allow the Support guy to remotely see his changes, and how he is going to get that unique token, ... and a lot more, but I tryed to explain whole the working solution I do see, which I hope, can bring a big change to the online application support.

All the best to all of you, and enjoy :)

How I used to handle project ideas

2011-10-13T22:35:00.002+01:00

Maybe this is usual, maybe not, but I'm used to write down all the ideas I periodically have which can make difference.
Everything started about 5 years ago, when I've started writing down all the ideas I am having. I'll be short - they were a lot. And I was creating really big documents for each of them - describing everything there about my vision in detail. And always was hoping, that once I will find somebody - who will be interested in those, and will let me make them real, cause they mainly were really big.
I did a lot of reading on finding investers for projects - really a lot, and several times I has been contacted by different people from different countries saying, that they want to invest. Maybe I was not so good in communication, maybe they were just trying to get the idea and go away, I don't know, but the fact is that I now feel, that the only person, who will once bring those ideas to life - is me, and nobody else will be ever such intersted in bringing them to life.
Although now I understand that those were just dreams and nobody will ever live with those ideas, and people, event those "investers" who invest in something, are looking for money first, althought some projects are about to make lifes of many people much easier, funnier, ... .
After so many years of looking around, I've thought about something different, because I believe - there are always many solutions for any problem, and when you think there are no ways out from some situation - be sure - there are, and think again. You now ask - what I've tried ? Ok, I've tried to do it with help of people, who share my opinions, my views and my vision. So several times I managed to find such people about 3 or 4, and we were jumping on some project. That was great, although I was getting tired a lot because that was about 3-4 hours every day after work (sometimes at nights). I was ok with that, althought people, who I was working with - were giving up after few days. Of course I understand them - they want to get money for their work, and even if they feel that the project will go live and time will set everything in its place, and they will be happy with the income, they were living by the problems they had that moment. I really understand them, and don't blame anyone of them, cause they still are my friends.
So I do continue to collect my ideas and hope that once I will be able to make them real by my own investments. Time will show :)

And thanks for following.

Dialogs in MVVM (Silverlight)

2011-10-04T18:56:00.000+01:00

Several days ago I was facing a problem, when was trying to open/show a dialog from in my MVVM application.
The actual problem is that I want that dialog also to be bound to a ViewModel instance - controlling it.
There are many approaches to handle this. I will present one of them - which I am satisfied with.
So, let's start. What I want is to have a DialogViewModel instance in my main ViewModel object, which is the DataContext of the current page, and which from from I'm going to open the dialog.
When thinking of MVVM itself you think that is much be something like setting a property and a dialog must show up - THAT IS CORRECT ! And that is what I'm going to achieve.
So just to give a small example of code, how the structure should be:

public class PageViewModel
{
    private DialogViewModel dialogVM = new DialogViewModel();

    public DialogViewModel DialogVM
    {
        get
        {
            return this.dialogVM;
        }
    }
}

public class DialogViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private bool show = false;

    private void NotifyPropertyChange(string argPropertyName)
    {
        PropertyChangedEventHandler tmpEH = this.PropertyChanged;
        if(tmpEH != null)
            tmpEH(this, new PropertyChangeEventArgs(argPropertyName));
    }

    // Here comes a lot of logic like dialog commands, ... which I will not include in this article

    public bool Show
    {
        get
        {
            return this.show;
        }
        set
        {
            if(value != this.show)
            {
                this.show = value;
                this.NotifyPropertyChange("Show");
            }
        }
    }
}

This is quiete enough for the ViewModel layer. So this is really what I've described enough. You will now ask - how should this boolean change (althought it supposed to be such thing) affect the dialog to appear - keep reading.
The simple approach (which won't work with ChildWindow derieved dialogs) is to add a dialog definition into the XAML and bind its Visibility property to the DialogVM.Show property, using a BoolToVisibilityConverter (am sure you'll be able to write something like this yourself). But when you'll try to do this, the dialog will behabe strange - it will really be not what you wanted - and you'll notice a lot of issues with it. Maybe in further versions of Silverlight this way of showing dialogs also will be possible - but not yet.
So, the second approach, I'll keep with, is to create a helper class, derieved from Control class. This will be the actual bridge between the DialogVM and the dialog we're going to show.
Here what the helper control will look like:

public class DialogHelper : Control
{
    //...
}

But an empty class is not going to be any helpfull for us. And here the core of the solution is: we're going to add a DependencyProperty to this control - to enable it to be bound to anything, bind it with the DialogVM.Show property and finally handle the change of that dependency property.

public class DialogHelper : Control
{
    private static readonly DependencyProperty ShowProperty = DependencyProperty.Register("Show", typeof(bool), typeof(DialogHelper), new PropertyMetadata(false, new PropertyChangedCallback(OnShowChanged)));

    private static void OnShowChanged(DependencyObject argSender, DependencyPropertyChangedEventArgs argEA)
    {
        ConfirmationDialogHelper tmpSender = argSender as ConfirmationDialogHelper;
        if(tmpSender.Show)
        {
            DialogToShow tmpDialog = new DialogToShow();
            //The following line makes sure that the dialog also will work based on MVVM
            tmpDialog.DataContext = (this.DataContext as PageViewModel).DialogVM;
            tmpDialog.Show();
        }
    }
}

So, finally, here is the way you should handle it in MVVM - ENJOY !!!

P.S.
Please sorry for any code typos, cause I was typing it right into the blog editor - with no IntelliSence support.

Silverlight - WCF: NotFound Exception

2011-07-28T10:29:00.000+01:00

Hi all.

Today I'll try to cover a problem, which many Silverlight developers are facing, trying to make WCF service calls. So the problem is that there are a lot of cases, when the client will get "NotFound" error, and here are the possible reasons for that.
(Make a note, that I will assume that the service is actually running, and you're calling to correct endpoint).
1. The amount of data being transfered is more than the limits - the service and clients are configured for. Remember, even if you haven't manually configured those values, there are some defaults. So this can be a cause for such an exception. Here is a good link as a start point for this case.
2. When a method returs something, which contains, or itself is an Enum type, and you've overriden the default values of that enum, by giving different values to its members, and there is no value with 0, then you'll have the same. This is because during serialization, if you won't assign any value to those members, which are type of the Enum, they will get default value (they are value type), which is 0 for Enums, and the Serializer will try to serialize the 0 to any of the marked values, which don't contain 0, so you'll end up by a Serialization Exception on service side, which won't be handled on client and will come back as a NotFound error.

Good luck with your development.

Memory Leaks in Silverlight Toolkit

2011-07-07T18:55:00.000+01:00

Hi all.
In this post I'll try to share my previous experience about memory leaks I've faced in one of projects I've working on.
The problem was in DateTimPicker control of the Silverlight Toolkit, and also in Accordion. Seems those were not being garbage collected and causing all the stuff related to them even with event handlers to stay there in memory.
So here are few simple tips to follow to avoid such things: Always be sure that you've unregistered any event handlers from the above mentioned controls, because those will make the objects, which in those handlers defined to also stay in memory.
If the controls are defined in a XAML file, just remember to remove it from its parent container. All this is easily handled by a simple interface implemented on a control level (you can call it IReleasable for example), and just call the Release method (defined in this interface) from the Page's unload point. And in this method do this "detach" from the leaking control. Why the unload is not a proper place- because for a control it may fire many times - as the Load event.

Good luck with Silverlight development.

Silverlight: MEF and other approaches

2011-03-18T18:04:00.000Z

Hi all.

Today I'd like to concentrate to the discussion about the MEF: a relatively new framework for dynamically loading Silverlight content.
It was amazing from the first point of view, and we have decided to use it. The process started.
Of course it's easy: use some simple attributes, mark the exportable types you want in your .xap packages with those attributes and that's it - you'll have them whenever you'll need them, and everything will be ok.
Yes, all this is right, BUT ...
There is a big BUT about this MEF: when you application will come a bit bigger - and it will come to this stage, because you are already using MEF, so that was your intention to avoid loading such a big application, you'll find out that instead of downloading each library/assembly only once from the server, you'll download it as many times, as you have it in each downloadable .XAP.
This became a big problem, when my app with all those xaps grown to ~14Mb. What to do?
Of course there is always a better way to go. And here one, which I have implemented and is satisfied with:
The .Net Framework is such a good thing :) I have created a simple attribute, which was aimed to mark the assembly references for the assembly it's applied to. And the second part, is that I've created a small asynchronous Assembly Loader, which is using this information from the described attribute, and downloads all those dependencies, when you ask it to download an assembly. If this assembly is already downloaded, you'll just get that instance, otherwise it will download it, it's references, and when everything is ready to be used, it fires this amzaing "AssemblyLoaded" event, which to I was able to react. So finally, avoiding this dll duplication (another .dll hell) I've reduced the size of the app from 13.6Mb to 3.8Mb. And one more thing - it works excellent and much faster.

Context menu in Silverlight

2011-02-28T20:38:00.001Z

Hi all.

Few months ago I was trying to find a standard way to implement a context menu, but could find no solution which I liked. So finally decided to write something from scratch.
I will not go down into the details here, just will give the idea here.
So first of all I thought, that the menu can contain several kind of items:
1. Items, which are system(application) wide, and you will have them in your entire application, anywhere you'd click. The "About" menu item appears under this case.
2. Items, which are based on the control type, which on the user clicks the right mouse button: these can be buttons, textboxes, anything derieved from Control. Into this point I have added the Cut, Copy, Paste items for textboxes.
3. Items, bound to exact controls - concrete instances. In this case, only when you click on the specified instances, the items should appear there in the menu.

The implementation is quite simple, so I will not include any code here. But if you'll need just write me, and I will be happy to help.

So, this is all.

The interview I failed

2011-02-13T06:07:00.000Z

It was in march 2008- in early march. I was in an interview process for Microsoft Ireland. Also, the same time, I was looking for a local job in Yerevan for the case I fail. But seems I was not been ready to fail. Anyway - the last stage of the interview to Microsoft passed. I was expecting the results. But the next day was I had to send a task, which I got from the CQG office in Yerevan to finish as a part of my interview process. I was not ablt to work on the task so good. And the next day the last tet-a-tet interview started.
Question from the interviewer:
-What is a thread?
-(I was silent. Had nothing in my mind to tell them. Was absolutely empty minded and was just trying to say something but ... I was not able to.)
-What is a process ?
-(Again the same)
-How would you make the program you've sent, to run better for multicore processors?
-(Silence)

Started reviewing the code I sent them:
-Why you wrote this part in this way?
-I really don't know, cause it is much better to write it in [telling which exactly] way.
-Strange, you know the correct answer, but you have written in not the best way here.

Here was the influence of the Microsoft on me. I was expecting the results... and was packing all my things to relocate.

This was my only interview in Armenia, which, I failed. And this was stupid.

This is all I'd like to share with all of you in this post. Always, when going to an interview, forget about any kind of excitement - this is the key to success.

Windows Phone 7 development

2011-02-11T11:12:00.001Z

Hi all.

Few months ago Microsoft has announced about its new mobile platform: Windows Phone 7. And here the pursuit started. Thousands of developers started looking into it to develop something new.
The same way I did. Decided to start from scratch a month ago - to develop a simple Tetris game. First I've investigated the market - there were several such games, but all had very small playground, which was not user friendly (by me). So the core of my idea was to make the playground as much, as the phone screen is.
Microsoft did really good job by creating a lot of restrictions for the apps, which you are going to expose on the marketplace. There is a big doc of guideance you have to follow.
After few days of development, when I had the game skeleton ready, I've started investigating the way to publish it. First I had to register withing the AppHub( this costs 99$). After the registration (which is not available for any country) I had to wait two weeks to be validated. One of those validation points being handled by GeoTrust (a partner company responsible for registrant validation), and this was the longest part to wait for.
Registration is done, and the only step left is to wait until Microsoft verifies your application. This stage took them only a day. And finally, my app is on the marketplace. This is the start, and it was really easy. So I will continue my app development for WP7 - for a great mobile platform.

Audit/history tracking with EF 4.0

2010-09-01T13:50:00.000+01:00

I have spent last two days investigating ways to track change history for an entity. And finally came up with a good idea, which I'd like to share with everyone.
There is a great feature in auto-generated entity code (in the entity data model designer file): support of partial methods.
For each property in an entity there are two partial methods generated:
On[PropertyName]Changed(), On[PropertyName]Changing({property type} value).

This is a great feature wich we are going to use.
Let's see first when to track the changes - what is the best point to keep the history. It's not good idea to make this in the OnXXXChanged method, cause this can be caused a lot, but most of those calls will never affect the entity data. So the best time to do it is when the SaveChanges() method for the Context is called. But how to handle that: The ObjectContext calss, which from our datacontext class is derieved, fires an event named SavingChanges, and also has a partial method, called OnContextCreated.

So first of all lets create a partial class with the same name and within the same namespace as the context class of our entities, and define a partial method named OnContextCreated in it:


public partial class MyModelEntities
{
    partial void OnContextCreated()
    {

    }
}

Now let's create an interface IAuditableEntity, which the entities needing to track the history should implement.


internal interface IAuditableEntity
{
    void AuditChanges(MyModelEntities argContext);
}

This interface defines a method, which should be called, when the SaveChanges() method should be called on the Context instance. In our partial context class add the following code:


public partial class MyModelEntities
{
    partial void OnContextCreated()
    {
        this.SavingChanges += new EventHandler(MyModelEntities_SavingChanges);
    }

    private void MyModelEntities_SavingChanges(object sender, EventArgs e)
    {
        IEnumerable tmpEntries = this.ObjectStateManager.GetObjectStateEntries(System.Data.EntityState.Modified);
        foreach (ObjectStateEntry tmpEntry in tmpEntries)
        {
            if (tmpEntry.Entity is IAuditableEntity)
            {
                (tmpEntry.Entity as IAuditableEntity).AuditChanges(this);
            }
        }
    }
}

This code will make the Context class to call the AuditChanges method of all the entities, implementing the IAuditableEntity interface before updating the datastore with new values. This means, that in the AuditChanges method body in the entity instance you will have control over the actions related to the history tracking. The other side is up to you - how to implement on the data layer the history tracking itself.
Have fun.

ASP.Net Session lost when deleting folder

2010-03-27T05:30:00.000Z

Hi there.
The last days of my coding brought me to a problem with loosing session state in my ASP.Net application, when deleting a folder during the request processing.
The thing is that when you delete a folder which is under the root folder of your application, then the structure of the application is being changed, and the IIS recycles that application. This means that the issue will be only in case of InProc Session State, which keeps the session state in memory.
Hope this will be helpfull.

Have a great weekend.

Working with WebBrowser Control

2010-02-26T14:01:00.000Z

One of the most interesting issues I had experienced and which for I was not able to find a solution in inet - was problem related to WebBrowser control.
The thing is that when I was trying to access the Document property of the WebBrowser control instance, I was getting "Invalid cast exception".
The thing is that the WebBrowser control is designed to work in one thread. So to fix this you must only check the InvokeRequired property and if it's value is true, then call the logic from the delegate, given into browser.Invoke(...) method.
This is all the stuff.
Lucky coding ...

ASP.Net AJAX: Working with update panels

2010-01-18T04:43:00.000Z

This post is for the people, who think that using update panels is nothing else but just add it to the page. This is not true !

I have noticed that a some developers are using update panels, as some kind of "metadata checkbox" - placing one update panel to wrap all the content of the page in its ContentTemplate. So in this post I will try to explain what exactly the UpdatePanels are for and how most from them.

First of all UpdatePanels are markers, which let you mark small, separate updateable areas on the page. Try to look at your page as a group of functionally independent areas. Decide which areas should be updated asynchronously and wrap those area code with UpdatePanel. Don't forget to include one <asp:ScriptManager runat="server" ... control on the page.

Job is done - you have the structure. But there is currently no difference from the page PV in what you had before (putting whole the content into one UpdatePanel) and what you currently got. Because by default The UpdateMode property of the UpdatePanel is set to Always, which makes the UpdatePanel to update its content on any postback. To fix this we just set the UpdateMode property of the needle UpdatePanel to Conditional. This makes the UpdatePanel to update its content by explicit requests (triggers, or just call to the Update() method of the UpdatePanel).

Now let's walk over a small example. Imagine you have a page with three UupdatePanels. All of them has some randomly generating content (random number for test). The first contains a button, which causes postback and has UpdateMode set to Always. The second also has UpdateMode set to always. The last UpdatePanel's UpdateMode is set to Conditional.

Now try to click the first button. This will update both update panels (which has UpdateMode set to Always). The third UpdatePanel whill keep it's content as was. Now click the third updatePanel's button. This will update all the three. Now add a handler to the first button's click event and call the Update() method of the third UpdatePanel). You will see that now after clicking the first button again all the updatePanels are being updated.

I have also attached a small code example (like the one described above). Hope it will help you to go deeper: http://www.sendspace.com/file/2lrs1w

Best place for data-binding

2009-12-09T06:18:00.000Z

In the last 3 months I was involved in development of ASP.Net websites. All the projects were started when I joined them, so a lot of code was written.
All the data-related modifications were implemented in this manner:

make the databinding on page_load event

handle control events (button click, checkbox check, ...) and make the databinding after any change

This was confusing, when we have several controls causing events, which was causing to do the same databinding several times.
So a question arised - how to reduce the number of databindings - where to make the dtabinding. And here is my answer: Do all the data-related changes on PreRender stage. This have a lot of good pooints:

It runs only once per request

It runs after all control events, which ensures, that no more flow-changes will arise.

This was a good solution these projects and hope it will also help some of you.

LoadControl problem in ASP.Net

2009-10-06T08:55:00.000+01:00

Today I met a problem and it made me angry enough to make some dumb checks and found an interesting thing conecrning the runtime control loading. I was trying to load controls using the LoadControl method in this way (using this overload of the method): LoadControl(type, object[]). This seemed ok - the control is being instanciated but when I was trying to access a property of it - found that all the inner controls were not loaded and I was getting NullReferenceException.
And here was the solution - seems that the LoadControl(string) overload works much more better and using this overload you can get the required control with all its properties initialized.
Good luck.

Get all the best from VS.Net

2009-10-03T10:24:00.001+01:00

After moving to a new company I have found that all the developers here have installed some addons on the VisualStudio.Net 2008 which make it load slower and found that they only use it for some features like outline.
This make me to write this post about the best and also most important feature in VS.Net, which is not expsed by default (only in VS.Net 2003). This feature is just Class View Synchronization with the class/struct, your cursor is in. So here how you can enable it.
1. In the toolbar area right click and select Customize... from the opened context menu.
2. Go to the Toolbars tab, and enable the ContextMenus item in the list. This will make a new toolbar appear in the toolbars.
3. Go to the Commands tab of the Customize window, and select the View item in the Categories list.
4. Now navigate to the Synchronize Class View item in the Commands part of the same tab. Drag it to the new added toolbars Editor Context Menus item (a menu will appear), and drop somewhere in the Code Window submenu.
Here it is. Now you can use that amazing feature from your context menu.

Looking for an invester

2009-06-09T13:37:00.000+01:00

After two years of private work, I got several project ideas, which currently are waiting for their time to be implementd. But ... they are big, and they have a lot of investments. I tried to look into different websites, which were offering some kind of "find-an-invester" solutions. But all of them were somehow alike, and had some non-friendly points in the policy. So I have decied write this blog - post and ask someone, who will read it and will be interested in investing in really good projects, which will become into huge companies later.

Thanks a lot

Underhood of the "ref" keyword

2009-05-11T13:44:00.000+01:00

One of the most interesting keywords in C# is the "ref" keyword. This is a argument parameter, which causes the method (indexer, constructor...) parameters to be passed by reference.
Let's take a look to the following code snippet:

public void TestFunction(int argValue)
{
      argValue++;
}

When we pass an argument to this function a new copy of the argument is being created and the function operates on the copy - not the real object. Because the copy of a reference again points to the sane location, we get no difference using the "ref" keyword with the reference-parameters (in most cases).
Now let's add a ref keyword before the parameter declaration:

public void TestFunction(ref int argValue)
{
      argValue++;
}

In the previous example we will get no result because the ++ operation was done on a copy of the object. But if we now pass the an integer to the function (when calling the function now, already, we have to add the "ref" keyword also here), we will get the increase of the value of the original memory, because this keyword makes the function to operate on the reference of the given parameter.

And here is the most important case. Many developers see no difference in "ref" keyword when using it with reference types. But... let's now review the following interesting example:

public void TestFunction(object argParam)
{
      argParam = null;
}

When entering this function the CLR will create a copy of the reference and will operated on it. But because the copied reference will refer to the same object on the heap, we will get the same result using the object's methods. And when we assign null to the argParam in the function body, we will just remove the copied reference of the parameter, which will take no modification on the real object.

And now, let's add the ref keyword before the param declaration:

public void TestFunction(ref object argParam)
{
      argParam = null;
}

Here comes the specific behavior of the keyword. No copy of the reference is being created during function call, so when we assign a null value to the argument, we remove the original reference from the memory, and ... in the calling context - lose the reference to the object.

Developing distributed software

2009-04-13T10:42:00.000+01:00

After development of the first version of the "Legends Of Noobia" server (MMORPG game server, written on .Net) I thought about later versions of it where the distributed features should be surely included. And here comes the main question - how to extend an existing application to support distribution ?
Here what came on my mind first - distributed TCP messageing system. because this component will let me attach the same game server (for this special case, but can be any other application) instance on different servers, where the DTMS (Distributed TCP/IP Messaging Server) node will be configured and run in the same way as it was used to.
Now let's go deeper into details to understand the idea of the DTMS. Imagine a graph, where each node is a configured instance of the system. Let's call each node a Physical Node. Each physical node is simple TCP/IP Server which accepts client connection. But - here comes the main idea - it also accepts connections from neighbour nodes (Physical Nodes from other servers, or even from the same server but another instance) and becomes a node of the distriubuted messaging graph. When a client sends a message - the server distributes this messages through all the neighbour nodes. This let's two clients, being connected to different physical nodes send/receive messages with/to each other.
To support private messaging we can add the recepient identifier to the header of the message. Each node, receiving the message, checks whether the recepient is connected to the system through it and if so, it sends the message to the client, otherwise it distributes the message to all nodes, except the one, which from it received the message.
In the same - easy, way the system can also support group messaging simply adding a group identifier to each message.

Using previously indtroduced Tween

2009-03-06T11:13:00.000Z

In my previous post I introduced a Tween class, which lets you to manipulate object Properties in timely manner.
Let's consider we have a simple button on client area, which has "btnButton" name. The following code will change the button's width from 50 to 300 pixels in 3 seconds (3000 milliseconds).


    Tween tmpTween = new Tween();
    tmpTween.MaxValue = 300;
    tmpTween.MinValue = 50;
    tmpTween.Period = 10000;
    tmpTween.Target = this.btnTest;
    tmpTween.Property = "Height";
    tmpTween.Start();

Tween in Silverlight

2009-03-06T09:34:00.001Z

During my Silverlight development I noticed that I need a feature which present in Adobe Flash - the tween. It's a class which lets you to increase a property for a given object from MinValue to MaxValue in a given time period.
So I have implemented it in C# for Silverlight 2. Here is the code for it.


///ITween.cs - Tween support for Silverlight 2
///The code is written by Artak Mkrtchyan
///Exposed under GNU license at http://mkartak.blogspot.com
///Contact me by: mkartak@gmail.com
public interface ITween
{
    void Start();
    void Stop();

    double Period
    {
        get;
        set;
    }

    object Target
    {
        get;
        set;
    }

    string Property
    {
        get;
        set;
    }

    double MinValue
    {
        get;
        set;
    }

    double MaxValue
    {
        get;
        set;
    }
}


///Tween.cs - Tween support for Silverlight 2
///The code is written by Artak Mkrtchyan
///Exposed under GNU license at http://mkartak.blogspot.com
///Contact me by: mkartak@gmail.com
public class Tween : ITween
{
    private object target;
    private string property;

    private double period;

    private double minValue;
    private double maxValue;

    private bool started = false;
    private PropertyInfo targetPropertyInfo;
    private double currentValue;

    private DispatcherTimer timer;

    public Tween()
    {

    }

    #region ITween Members

    public void Start()
    {
        if (!this.started)
        {
            if (this.Period < 0)
            {
                throw new ArgumentOutOfRangeException("Period must be more than zero");
            }

            if (this.Target == null)
            {
                throw new ArgumentNullException("Target");
            }

            if (this.Property == null)
            {
                throw new ArgumentNullException("Property");
            }

            if (this.Property.Trim() == String.Empty)
            {
                throw new ArgumentException("Property must have a value");
            }

            this.started = true;

            this.targetPropertyInfo = this.Target.GetType().GetProperty(this.Property);
            this.currentValue = this.MinValue;
            this.timer = new DispatcherTimer();
            this.timer.Tick += new EventHandler(this.OnTimerEvent);
            this.timer.Interval = TimeSpan.FromMilliseconds(this.MinPeriod);
            this.timer.Start();
        }
    }

    public void Stop()
    {
        if (this.started)
        {
            this.started = false;
            this.timer.Stop();
        }
    }

    public double Period
    {
        get
        {
            return this.period;
        }
        set
        {
            this.period = value;
        }
    }

    public object Target
    {
        get
        {
            return this.target;
        }
        set
        {
            this.target = value;
        }
    }

    public string Property
    {
        get
        {
            return this.property;
        }
        set
        {
            this.property = value;
        }
    }

    public double MinValue
    {
        get
        {
            return this.minValue;
        }
        set
        {
            if (this.started)
            {
                throw new Exception("Unable to change value during progress");
            }

            if (value >= this.maxValue)
            {
                throw new ArgumentException("MinValue must be less than the maxValue");
            }

            this.minValue = value;
        }
    }

    public double MaxValue
    {
        get
        {
            return this.maxValue;
        }
        set
        {
            if (this.started)
            {
                throw new Exception("Unable to change value during progress");
            }

            if (value <= this.minValue)
            {
                throw new ArgumentException("MaxValue must be more than the minValue");
            }

            this.maxValue = value;
        }
    }

    #endregion

    private double Step
    {
        get
        {
            return (this.MaxValue - this.MinValue) / StepCount;
        }
    }

    private double Speed
    {
        get
        {
            return (this.MaxValue - this.MinValue) / this.Period;
        }
    }

    private double StepCount
    {
        get
        {
            return Math.Ceiling(this.Period / this.MinPeriod);
        }
    }

    private int MinPeriod
    {
        get
        {
            return 10;
        }
    }

    private void OnTimerEvent(object sender, EventArgs e)
    {
        if (this.started)
        {
            lock (this)
            {
                this.currentValue = Math.Min(this.currentValue + this.Step, this.MaxValue);

                this.targetPropertyInfo.SetValue(this.Target, this.currentValue, null);

                if (this.currentValue == this.MaxValue)
                {
                    this.Stop();
                }
            }
        }
    }
}

Introducing LegendsOfNoobia

2009-02-13T19:32:00.000Z

Legends Of Noobia is an online multi-player role-playing game (MORPG).
After the quick registration of your character, you appear in a city center of mystical Noobia! You may communicate with other warriors, chat with those that are in the same location with you and also outside of it (such as shout which makes everyone hear your message).
You begin moving around different locations in the world where various NPCs (non-player characters) meet you. Some are kind - just polite and hospitable citizens of Noobia, and some ... awfully angry. You
suddenly find you in a pine forest where a green snail is crawling slowly over the leaves and a spider is looking at you from its web. And you decide to attack one of them. Started the fight and ...
Wooow! you killed him and gained a level ! The more you gain levels the stronger you become, and the harder it becomes to kill you. The more powerful NPCs you kill, the more experience you gain. At high levels, however, you definitely will not be able to struggle one alone against the 20 leveled Dracula sleeping in old graves, and may consider acting with a team in order to kill such a monster.
Your goal is not just killing and gaining levels, but also fighting together with other players in a team, helping each other, by hints, messages and most importantly - by healing.
Check out this flash game and try out your strength by just browsing: www.legendsofnoobia.com.

Remoting through interfaces

2008-10-28T06:14:00.000Z

When we are going to use Remoting, we always think about the proxy classes, which should surely be deployed with the client-app. But is that the best approach?
The OOP tells us to understand the interaction through the intercaces, this means that components should interact only by contracts. Why don’t we use this approach in Remoting. This is surely possible. And this is better approach.
Let’s review this part of code:

public class RemotedObject:MarshalByRefObject
{
 public void SomeMethod()
 {
  //… some code here
 }
}

Let’s update the code above and add a contract of interacting with it:

public class RemotedObject:MarshalByRefObject, IRemotedObjectContract
{
 public void SomeMethod()
 {
  //… some code here
 }
}

//The interface is defined in a new module
public interface IRemotedObjectContract
{
 void SomeMetod();
}

The remoted object now can be called through IRemotedObjectContract interface. But we should place the interface definition in a separate module, so it will be referenced from the main (RemotedObject) assembly, and also it will be referenced from the client. So now, the client have not to generate a proxy class by hand and attach that module, but it will be enough just to reference the interface-owner module and all is ready. Notice, that nothing should change on the server side. But on the client side for accessing the object we will have something like:

//…
IRemotedObjectInterface tmpRemote = (IRemotedObjectInterface)Activator.GetObject(typeof(IRemotedObjectInterface), tmpUrl);
//Use the retrieved tmpRemote interface to interact with the remote object

So, this is all, and this is really good approach in .Net Remoting.

Implementing "C/C++" [union] in .Net

2008-10-26T15:19:00.000Z

To improve performance, the CLR is capable of arranging the fields of a type any way it chooses. When you define a type, you can tell the CLR whether it must keep the type's fields in the same order as the developer specified them or whether it can reorder them as it sees fit.
The System.Runtime.InteropServices.StructLayoutAttribute attribute is used to tell the CLR what to do (how to layout the fields). You can pass LayoutKind.Auto as a value to the above specified attribute to have the CLR arrange the fields, or LayoutKind.Sequential, to have the CLR preserve the given layout, or LayoutKind.Explicit, to explicitly arrange the fields in memory by using offsets.
Microsoft's C# compiler selects LayoutKind.Auto for reference types, and LayoutKind.Sequential for value types.
As was mentioned above, the StructLayoutAttribute also allows you to explicitly indicate the offset of each field by passin LayoutKind.Explicit to its constructor. Then you apply an instance of the System.Runtime.InteropServices.FieldOffsetAttribute attribute to each field passing to this attribute's constructor an Int32, indicating the offset of the field's first byte from the beginning of the instance in bytes. Here is an example:


[StructLayout(LayoutKind.Explicit)]
public struct CUnionAlternate
{
   [FieldOffset(0)]
   byte byteField;
   [FieldOffset(0)]
   short shortField;
}

Optimizing Garbage Collection

2008-10-24T12:59:00.001+01:00

Weak References

There is a way to affect the performance of the garbage collection, which is introduced in .Net through the WeakReferences.
When an object points to another one, this is called strong reference, or just reference, as we used to say, and in this case the GC will not collect that obhject as a "garbage". The WeakReferences are kind of references, the objects, which they point to can be collected, and if later they will be accessed throug the WeakReference, the access will fail.
The managed heap contains two internal data structures whose sole purpose is to manage weak references: short and long weak reference tables.
If an object has a short weak reference to itself, and is collected, then it's finalization method doesn't run, and it is being collected immediately. For the long weak reference, when the garbage collector collects object pointed to by the long weak reference table only after determining that the object's storage is reclaimable. If the object has a Finalize method, the Finalize method has been called and the object was not resurrected.
These two tables simply contain pointers to objects allocated within the managed heap. Initially, both tables are empty. When you create a WeakReference object, an object is not allocated from the managed heap. Instead, an empty slot in one of the weak reference tables is located; short weak references use the short weak reference table and long weak references use the long weak reference table.

Generations

Since garbage collection cannot complete without stopping the entire program, it can cause pauses at arbitrary times during the execution of the program. Those pauses can also prevent programs from responding quickly enough to satisfy the requirements of real-time systems.
One of the improvments of the GC is called generations. A generational garbage collector takes into account two facts:

Newly created objects tend to have short lives.
The older an object is, the longer it will survive.

Those collectors group objects by “age” and collect younger objects more often than older objects. All new objects added to the heap can be said to be in generation “0”, until the heap gets filled up which invokes garbage collection. As most objects are short-lived, only a small percentage of “young“ objects are likely to survive their first collection. Once an object survives the first garbage collection, it gets promoted to generation “1”. Objects, which are created after some generation stage are considered as on the “0” generation. The garbage collector gets invoked next only when the sub-heap of generation “0” gets filled up. All objects in generation “1” that survive get compacted and promoted to generation “2”. All survivors in generation “0” also get compacted and promoted to generation “1”. Generation “0” then contains no objects, but, as already was mentiond”, all newer objects after GC go into generation “0”.
Generation “2” is the maximum generation supported by the runtime's garbage collector. When future collections occur, any surviving objects currently in generation 2 simply stay in generation “2”.
Thus, dividing the heap into generations of objects and collecting and compacting younger generation objects improves the efficiency of the basic underlying garbage collection algorithm by reclaiming a significant amount of space from the heap and also being faster than if the collector had examined the objects in all generations.
This is all about garbage collectors, which, I think every, .Net developer must know.

Understanding the Garbage Collection

2008-10-23T09:14:00.000+01:00

One of the most important parts of the .Net framework is the Garbage Collector. Instead of letting you to take care of all the memory you have used, it automatically collects all unnecessary "garbage" when it's time. But how? This is the question I am going to discuss in this article.

The .NET CLR (Common Language Runtime) requires that all resources be allocated from the managed heap. The developer never need to free objects from the managed heap -they are automatically freed when they are no longer needed by the application. When the garbage collector runs, it checks for objects in the managed heap that are no longer needed by the application and performs the necessary operations to reclaim their memory. Because each type of the .Net is described by its Metadata, the garbage collector always knows, how to free up the unnecessary memory.
So, the garbage collector starts its job by locating the roots of the application.

The roots are:

all the global and static pointers
local variable pointers (which are on a thread's stack)
registers, which contain pointers to objects in the managed heap
pointers to the objects from the Freachable queue

The list of active roots is being maintained by the JIT compiler and CLR, and is made acceptable to the GC algorithm.
The GC works in two phases. Let's review them in detail.

The first phase (Marking)

(when the GC starts, it makes an assumption, that all the objects in the heap are garbage)

identification of roots
building the live object graph (GC runs through the roots and identifies live objects using the metadata of the objects)

To avoid the cycling process, if the GC tryes to add an object to the graph, which is already there, then the path, which by the object was found, is being ignored, and no more down-level searches are being made.
When the check for all the roots is done, all the alive objects are being added into the graph, so any other objects, surely, is garbage.

And now comes the second phase (Compacting).

GC walks through the heap linearly looking for garbage blocks of memory.
GC shifts non-garbage objects down in memory (of course, by updating all the references to the moved objects), making them easy reachable by removing all the gaps in the heap

After this phase the pointer is set to the end of the last object in the heap, referencing the place, where new object can be allocated on heap.

Finalization

Whenever a new object, having a Finalize method, is allocated on the heap a pointer to the object is placed in an internal data structure called Finalization queue. When an object is not reachable, the garbage collector considers the object garbage. The garbage collector scans the finalization queue looking for pointers to these objects. When a pointer is found, the pointer is removed from the finalization queue and appended to another internal data structure called Freachable queue, making the object no longer a part of the garbage. At this point, the garbage collector has finished identifying garbage. The garbage collector compacts the reclaimable memory and the special runtime thread empties the freachable queue, executing each object's Finalize method.
The next time the garbage collector is invoked, it sees that the finalized objects are truly garbage and the memory for those objects is then, simply freed.
It is recommended to avoid using Finalize method, unless required. Finalize methods increase memory pressure by not letting the memory and the resources used by that object to be released, until two garbage collections. Since you do not have control on the order in which the finalize methods are executed, it may lead to unpredictable results.
In my next article I will try to explain, how to optimize the GC.

Displaying IFrame contents in DIV containers

2008-10-06T13:39:00.000+01:00

There are a lot of situations, when we need to show a web-content from another URL on our web-site. The standard solution for these situations is the IFrame tag. But it's not good approach to use IFrame, because it's resource consuming approach. The better approach, of course, is to use DIV container, and show the needed content in it.
That is not hard in 90% of situations, but there are special cases, when we really need help.

The problem There is a flash movie on the target webpage, which takes flashvars as input, and uses them. But when we use the simple ([DIV].innerHTML = [Iframe].innerHTML) mechanism, we get for example the links not work, or some other issues with those movies.

The thing is, that when we are getting the OBJECT tag content using the innerHTML property, we get it modified, but not the original content. And the problem is that the modified content removes the "flashvars" attribute content.

The solution is to use some kind of ruse. Instead of using the innerHTML property to get all the inner PARAM objects, which represent the parameters, we are getting them directly through the document's getElementsByTag() method call, and passing "PARAM" as an argument. This returns the original list of params, which then can be applyed to the new created object element using document.createElement("object") syntax.

But there is one more situation left. Huge number of these movies use events, which are handled by the webpages. And those scripts are being defined in the header part of the page.
To be sure that those cases are also fixed, we should read all the script tags from the header of the page, and add them (dynamically creating new script tags on our document object, to make the browser to run through the code instructions, not to ignore them) to the header of our document.

So, wish now you will never face this problem.

Removing list items in AS2/AS3

2008-09-03T03:36:00.000+01:00

Let's suppose, we have some kind of custom list, elements of which has UI representation. A big problem for the beginner developers is that when they remove the items from the list, some of them still stay there, on the stage, and function normal. They are being removed only after several remove function calls.
Here is a code snippet describing such a situation:


public class TestClass{
     private var items:Array;
     public function RemoveItems():void{
          for (var i:int = 0; i < this.items.length; i++){
               RemoveItem(this.items[i]);
          }
     }

     public function RemoveItem(argItem:Item):void{
          var tmpIndex:int = this.items.indexOf(argItem);
          if (tmpIndex != -1){
               this.items.splice(tmpIndex, 1);
          }
     }
}

This usually happens, when the developer has already written a RemoveItem function, which also removes some event handlers or cast appropriate events on Remove. And when the developer needs to clear the list he wish to use that function. That is right. But the thing here is, that using the first iteration in RemoveItems function we will only iterate through about the half of all the items. The indexer i will grow up, but the same time the length of the items list will decrease, removing each item from it.
Sometime this causes big problems.

The best way to avoid this situation, is to use non length-dependent iteration. That is, i.e. while.
So if we just change the for (...) with while (this.items.length > 0){... we will win.

Module-Oriented development

2008-08-04T11:38:00.000+01:00

One of the most important aspects of the development process is the flexibility. Most developers think, that flexibility is also affects to the core of the process, but that also affects the UI of the application.
There are situations, which in some parts (modules) of the application UI stop responding, and all the other UI elements stop responding because of that.
This is just an example, when we need module-oriented development as the main idea for whole the development process.
Let's start from a simple example. So we have a UI application. First of all we can define virtual blocks of UI, each of which should represent a module. For example, let's suppose we should have a search part and toolbar part on the GUI. But our application should not contain all that stuff in it. Each part should be represented by a module. So we should have a Search Module, and a Toolbar Module. Each module should be represented by a separete assembly.
And our application should have a configuration file (xml), where it should keep paths for all installed modules. When it should start, it should just go through the records in the config file. For each module it should give a GUI container, where each module muust be drawn.
During the initialization the application should initialize all the modules first and then start. Using this approach should give us ability to connect different parts of our GUI to different assemlyies. So if for exampl we have not some assemly, it should just not load. This also gives the main application ability to control all the modules work, by giving them appropriate security rules.
Also we should be able to unload the modules, which work bad, during runtime and be error - free.
To gain this, we must define an interface, which should be implemented by each Module. The application should work only with the interface for modules.

The module-oriented development applies not only to GUI applications, but to any type of applications, which cann be represented as multi-module structure.

Simple Socket Server

2008-08-04T07:05:00.000+01:00

The idea of creating a good socket-server depends on several factors, which should surely be calculated in accordance to the requirements of the given task.
The most simple socket server exampl is the "One-Thread" server, which does all the job in its main thread. But this is not good enought for system, which should give a lot of time to each connected client to process.
Here come the threads. In this case, each client has its own (separete) thread, which in it works, and does its tasks as long as it need. Here is the main idea of most client-server applications.
The example project represents a simple Socket-Server, which keeps track of all connected clietns. Each client is represented by a ConnectionUser class instnace on the server. That class has a single "Run" method, which starts the processor of that client in a separete thread.
The project is a VS.Net 2005 Solution, but I have also included the source files in the post.


##########################################################################
############################SimpleServer.cs###############################

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;

namespace SimpleSocketServer
{
    public class SimpleServer
    {
        /// 
        /// The port, to be listened for connection requests
        /// 

        private int portToListen = -1;

        /// 
        /// The listener object, which through the clients should connect
        /// 

        private TcpListener listener;

        /// 
        /// Keeps the state of the server
        /// 

        private bool isStarted = false;

        /// 
        /// The list of connected users
        /// 

        private List users = new List();

        /// 
        /// Creates an instance of a SimpleServer class
        /// 

        public SimpleServer()
        {

        }

        /// 
        /// Creates an instance of a SimpleServer class configured for listening the given port
        /// 

        /// The port to be listened
        public SimpleServer(int argPortToListen)
        {
            this.PortToListen = argPortToListen;
        }

        /// 
        /// Starts the server on the pre-specified port.
        /// If the port was not specified, throws an Exception
        /// 

        public void Start()
        {
            if (portToListen == -1)
            {
                throw new Exception("No port specified for the listener");
            }

            isStarted = true;
            listener = new TcpListener(this.portToListen);
            try
            {
                listener.Start();
                while (isStarted)
                {
                    try
                    {
                        //Get the TcpClient instance for the connection
                        TcpClient tmpNewClient = listener.AcceptTcpClient();

                        //Pass the retrieved object to the new processing unit
                        //that unit in a new threads
                        ConnectionUser tmpNewUser = new ConnectionUser(tmpNewClient);

                        tmpNewUser.ConnectionClosed += new EventHandler(ConnectionUser_ConnectionClosed);

                        lock (this.users)
                        {
                            //add the new user to the track list
                            this.users.Add(tmpNewUser);
                        }

                        //Start processing the client in a new thread
                        tmpNewUser.Run();
                    }
                    catch (Exception ex)
                    {

                    }
                }
            }
            catch (Exception e)
            {
                //Handler code here
            }
        }

        /// 
        /// Handles the ConnectionClosed event of each connected user
        /// 

        /// The sender of the event
        /// The event arguments
        protected void ConnectionUser_ConnectionClosed(object sender, EventArgs e)
        {
            lock (this.users)
            {
                ConnectionUser tmpUser = sender as ConnectionUser;
                tmpUser.ConnectionClosed -= new EventHandler(ConnectionUser_ConnectionClosed);
                if (this.users.Remove(sender as ConnectionUser))
                {
                    Console.WriteLine("Client disconnected");
                }
            }
        }

        /// 
        /// Stops the server instance
        /// 

        public void Stop()
        {
            this.isStarted = false;
            this.listener.Stop();

            foreach (ConnectionUser tmpUser in users)
            {
                tmpUser.Stop();
            }
        }

        /// 
        /// Gets or sets the port
        /// 

        public int PortToListen
        {
            get
            {
                return this.portToListen;
            }

            set
            {
                if (value <= 0)
                {
                    throw new ArgumentOutOfRangeException();
                }

                this.portToListen = value;
            }
        }
    }
}


##########################################################################
###########################ConnectionUser.cs##############################
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using System.IO;

namespace SimpleSocketServer
{
    /// 
    /// The class, which uses a single TcpClient
    /// connection for communication with remote host
    /// 

    public class ConnectionUser
    {
        public event EventHandler ConnectionClosed;

        protected TcpClient connection;
        private bool isStarted = false;

        public ConnectionUser(TcpClient argClient)
        {
            this.connection = argClient;
        }

        /// 
        /// Starts a new Thread and runs current instance in that thread
        /// 

        public void Run()
        {
            Thread tmpNewThread = new Thread(new ThreadStart(StartProcessing));
            tmpNewThread.Start();
        }


        /// 
        /// The processor method, which keeps whole logic of the processor unit
        /// Must be overriden in all descendant classes.
        /// 

        protected virtual void StartProcessing()
        {
            isStarted = true;
        }

        /// 
        /// Gets the Network stream of the underlying connection
        /// 

        protected Stream NetworkStream
        {
            get
            {
                return connection.GetStream();
            }
        }


        /// 
        /// Stops the new-thread processor
        /// 

        public void Stop()
        {
            this.isStarted = false;
            this.connection.Close();
        }

        /// 
        /// Handles the connection close events
        /// 

        private void OnConnectionClose()
        {
            if (this.ConnectionClosed != null)
            {
                this.ConnectionClosed(this, null);
            }
        }
    }
}

(De)Serialization of simple data (parser)

2008-07-24T07:02:00.000+01:00

Different people are finding creating a parser quite a hard job. But the main “ring” in it is to understand not some development problem, but is to find a good representation (format) for the serializer and deserializer. This means that the hardest part of the parser is to find good delimiters for the task.
So let’s begin from creating a parser, for a simple binary tree. Let’s suppose that each node of that tree can have two (left and right) child nodes, and also a value. Then let’s choose some simple format for serialization. Here is a simple example.

{LeftChild|Value:RightChild}

This will surely work, if our content (values of nodes) does not contain any characters like “:” or “{”, “}”.

And now let’s look at a simple example:
{{{|4:}|3:{|5:{|2:}}}
Let’s understand the above written example. The root node of the tree has a value of 3. It has a left child, which has value of 4 and has no child nodes – it’s a leaf node. The right child of the root node is a node, with a value of 5. It has no left child, but has a right child, which has a value of 2. And that node is also a leaf node. So now we finally have an appropriate imagination about the example given above.
Now we can create a parser for it very easy. Most starting developers are trying to use recursive functions to create parsers, but they usually miss an important aspect, that if in that case the (for example) tree, which they are going to parse is too big, they will get a “Memory overflow” exception. This means that the best way to create a parser is to use sequential parsing algorithm.

Here is the code for the upper example on C#.


public class TreeNode
{
    public const char NODE_START = '{';
    public const char NODE_END = '}';
    public const char LEFT_SEPARATOR = '|';
    public const char RIGHT_SEPARATOR = ':';

    private int value;
    private TreeNode leftChild;
    private TreeNode rightChild;
    private TreeNode parentNode;

    public static TreeNode Parse(string argString)
    {
        //The format for the input node is:
        //{[leftChild]|value:[rightChild]}

        TreeNode tmpCurrentRoot = null;
        int tmpPosition = 0;
        ParseStage tmpStage = ParseStage.LeftChild;
        while (tmpPosition < argString.Length)
        {
            switch (argString[tmpPosition])
            {
                case NODE_START:
                    //Create a new node with the current parent
                    TreeNode tmpNewNode = new TreeNode(tmpCurrentRoot);
                    if (tmpCurrentRoot != null)
                    {
                        if (tmpStage == ParseStage.LeftChild)
                        {
                            tmpCurrentRoot.LeftChild = tmpNewNode;
                        }
                        else if (tmpStage == ParseStage.RightChild)
                        {
                            tmpCurrentRoot.RightChild = tmpNewNode;
                        }
                    }
                    //Set the pointer of current node to the new created one
                    tmpCurrentRoot = tmpNewNode;
                    tmpStage = ParseStage.LeftChild;

                    tmpPosition++;
                    break;

                case LEFT_SEPARATOR:
                    tmpStage = ParseStage.Value;
                    tmpPosition++;
                    break;

                case RIGHT_SEPARATOR:
                    tmpStage = ParseStage.RightChild;
                    tmpPosition++;
                    break;

                case NODE_END:
                    if (tmpCurrentRoot.ParentNode == null)
                    {
                        return tmpCurrentRoot;
                    }
                    else
                    {
                        if (tmpCurrentRoot == tmpCurrentRoot.ParentNode.LeftChild)
                        {
                            tmpStage = ParseStage.LeftChild;
                        }
                        else
                        {
                            tmpStage = ParseStage.RightChild;
                        }
                        tmpCurrentRoot = tmpCurrentRoot.ParentNode;
                    }
                    tmpPosition++;
                    break;

                default:
                    if (tmpStage == ParseStage.Value)
                    {
                        string tmpValueStr = argString.Substring(tmpPosition, argString.IndexOf(RIGHT_SEPARATOR, tmpPosition) - tmpPosition);
                        tmpCurrentRoot.Value = Int32.Parse(tmpValueStr);
                        tmpPosition += tmpValueStr.Length;
                        tmpStage = ParseStage.RightChild;
                    }
                    break;
            }
        }

        throw new Exception("ERROR DURING PARSING");
    }

    public TreeNode(TreeNode argParentNode)
    {
        this.parentNode = argParentNode;
        leftChild = null;
        rightChild = null;
        value = 0;
    }

    public int Value
    {
        get
        {
            return this.value;
        }
        set
        {
            this.value = value;
        }
    }

    public TreeNode LeftChild
    {
        get
        {
            return this.leftChild;
        }

        set
        {
            this.leftChild = value;
            if (this.leftChild != null)
            {
                this.leftChild.parentNode = this;
            }
        }
    }

    public TreeNode RightChild
    {
        get
        {
            return this.rightChild;
        }
        set
        {
            this.rightChild = value;
            if (this.rightChild != null)
            {
                this.rightChild.ParentNode = this;
            }
        }
    }

    public TreeNode ParentNode
    {
        get
        {
            return this.parentNode;
        }
        set
        {
            this.parentNode = value;
        }
    }

    public override string ToString()
    {
        string tmpResult = String.Empty;
        tmpResult += NODE_START;
        if (this.leftChild != null)
        {
            tmpResult += this.leftChild.ToString();
        }
        tmpResult += LEFT_SEPARATOR;
        tmpResult += this.value;
        tmpResult += RIGHT_SEPARATOR;

        if (this.rightChild != null)
        {
            tmpResult += this.rightChild.ToString();
        }

        tmpResult += NODE_END;
        return tmpResult;
    }

    protected enum ParseStage
    {
        LeftChild,
        Value,
        RightChild
    }
}

Singleton pattern realisation

2008-06-10T08:34:00.000+01:00

The most often meeting design pattern, which is really used, is, by me, the Singleton.

And here is it's implementation on C#.


public class SingletonClass
{
    private static SingletonClass instance;

    private SingletonClass()
    {
        return Instanse;
    }

    public static SingletonClass Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new SingletonClass();
            }
            return instance;
        }
    }
}

Repeating processes and animations

2008-05-17T05:31:00.000+01:00

During the work we meet some problems with repeating some processes or animations periodically. For exampl we have some animation, which we want to loop or some process. Here is the implementation for it. I will first write down the actionscript 2 implementation of it using non-documented Animation class, which is just a wrapper of a movieClip, with more functionality like start(), stop() and which casts "COMPLETED" event.
We should write a class for dynamically repeat the animation until the stop method hasn't been called.

//AS 2.0 implementation
class AnimRepeater{

    private var _isStarted : Boolean;

    private var _clipName : MovieClip;

    private var _animationLoop : Animation;

    public function AnimRepeater(clipName : String) {

        _clipName = clipName;

    }

    public function start() : Void {

        if (!_isStarted) {

           _isStarted = true;

           updateAnim();

        }

    }

    public function stop() : Void {

        if (_isStarted) {

           _isStarted = false;

        }

    }

    private function updateAnim() : Void {

       if (_isStarted) {

           var autoDelete : Boolean = true;

           _animationLoop = new Animation(_clipName, "animName", autoDelete);

           _animationLoop.addEventListener(Animation.FINISHED, Delegate.create(this, updateAnim));

           _animationLoop.start();

        }

    }

}

For C# let's add some flexibility. We should use a IProcess interface, which should be used to controll the process which should be repeated.

public delegate void ProcessEventHandler(IProcess argProcess, EventArgs argEventArgs);

interface IProcess

{

    public event ProcessEventHandler Finished;

    public void start();

    public void stop();

}

public class ProcessRepeater : IProcess

{

    protected bool isStarted;

    protected IProcess processToRepeat;

    public event ProcessEventHandler Finished;

    public ProcessRepeater(IProcess argProcess)

    {

       processToRepeat = argProcess;

       isStarted = false;

    }

    public void start()

    {

       if (!isStarted)

       {

          isStarted = true;

          updateProcess();

       }

    }

    public void stop()

    {

       if (isStarted)

       {

          isStarted = false;

          processToRepeat.stop();

          processToRepeat.Finished -= new ProcessEventHandler(updateProcess);

       }

    }

    protected void updateProcess()

    {

       if (isStarted)

       {

          processToRepeat.Finished += new ProcessEventHandler(updateProcess);

          processToRepeat.start();

       }

    }

    private void updateProcess(IProcess argProcess, EventArgs argEventArgs)

    {

       updateProcess();

    }

}

Enumerations in ActionScript 2.0

2008-05-13T10:22:00.000+01:00

Here is an alternate for Enumerations in ActionScript 2.0. Just add an item with needed name as a member to the class (as _NORMAL or _ENUM_ITEM) and then use them through the "get" functions from another code.

/**
* @author Artak Mkrtchyan
*/
class EnumTypeName extends Number
{
private static var _NORMAL:EnumTypeName = EnumTypeName(0);
private static var _ENUM_ITEM:EnumTypeName = EnumTypeName(1);

private function EnumTypeName(value:Number){

}

public static function get NORMAL() : EnumTypeName {
return _NORMAL;
}

public static function get _ENUM_ITEM() : EnumTypeName {
return _ENUM_ITEM;
}
}

////////////////////////////////
//And here is the usage of this

//.... another class
public function test():Void{
var testVar:EnumTypeName;

testVar = EnumTypeName.NORMAL;
}
//.... other code