If you’re a developer doing WPF development, you really need to be using Expression Blend.

Yes, I know the party line on WPF development runs something like this:

• Every Dev team should have at least 1 developer and 1 designer
• Developers can’t design decent-looking GUIs to save their soul
• Designers can’t be trusted with code, or anything close to code (excepting XAML)
• Devs will open a project in Visual Studio and do all of their work there
• Designers will open the same project in Blend and do all of their work there
• Devs wear button-up shirts that don’t match their Dockers
• Designers wear brand-name labels and artsy little berets

While much has changed since – language and controls evolved, iEverything is the mantra, Visual Studio got decent UI designer for WPF/Silverlight – but our mentality never changes once set – developers are all about code, and would use XAML editor rather than any UI tools, and UX folks would scream and bash them for not using proper tools.

The post Which came first – the chicken or the egg – WPF, Developers and Designers – old tale appeared first on Dragonsoft Technology View.

Some of it is expected since on initial start up, a number of Crystal assemblies and objects need to be created and this does take time.
I want to emphasize that discussion below is related to the first run of any reports. We have to actually restart/reset IIS to see problem again.

Note: There was a question about IIS’ Application Pools recycling which could cause similar effect. Make sure your application pool is set properly.

Setting up a playground

Let’s assume ASP.Net pages were already migrated to use .Net 3.x and look at what happen behind the scene.

Remember that after restart IIS starts from ground up. This means several things in respect to our page content:

• .Net assemblies need to be preloaded and validated if necessary.
  Since Crystal Reports 2008 comes as .Net 2.0-based core and we may already moved to .Net 3.x, CR2008 Engine and some additional files need to be loaded and validated aside from one which already used by any previously loaded pages.
• For each session engine would create a cached version of RPT file in temp folder.
• Some code would have to be brought to the client machine for Viewer to operate properly.
• Database connection established, data retrieved, processed, paged and sent to the client Viewer.

That about it, now we ready to work with reports. Please notice that after that initial load, any other reports would come up faster. We could even close the browser or use another browser (ex. go from IE to FF) and it would be still faster than the first time, so there is something important about the first step above…

Combing the sand

Let’s try to break the IIS initialization process to get more detailed view.

Since we already had some ASP.Net pages loaded before coming to CR related page, we could disregard .Net core initialization procedure. It is there on IIS side: used and ready.

Ok, next thing is CR engine related stuff. There is some 5Mb of files in crystalreportviewers12 folder to support CR Viewer in ASP.Net and we need to send some of them over the network. In addition to that there is Crystal Reports Engine assemblies which need to be loaded by IIS at the time of the first use. And this is our spot to dig.

If we try and trace what exactly going on we would notice that aside from IIS loading a few dozen assemblies, there is also process associated with trying connect to CRL.VERISIGN.NET.

What is it?

“Problem” is that assemblies are Authenticode signed and therefore need to be verified or it technical terms they need to be checked against Certificate Revocation List (CRL) by Publisher for Code Access Security (CAS).

Default behavior is that they need to be verified by the certificate authority. If certificate is not present on the same machine (I have my doubts that SAP doing anything about that, but I could be wrong), validation need to be done via central repository mentioned above, or if machine does not have network/internet access the .NET thread might timeout waiting to connect.

Yes, by performing strong name signing of assemblies or placing the CA certificate on the same machine issue would be avoided, but it seems not being a case.

Building the castle

Since assemblies are provided by SAP, we cannot remove digital signature and it is a hassle to keep certificates current by obtaining them from CA every time they expire. Let’s concentrate on the Publisher mentioned above and turn it off.

It is all-or-nothing solution since it would require turning off CRC for the entire IIS.

When working with regular .Net apps, it can be done on the app level (assuming we already have fix for .Net 2.0) by adding the following section in <Application>.exe.config

<configuration>
  <runtime>
    <generatePublisherEvidence enabled="false"/>
  </runtime>
</configuration>

This new element described in this MSDN article. Interesting note there (why not to turn it then by default? Oh, security concerns… UAC anyone?):

We recommend that services use the <generatePublisherEvidence> element to improve startup performance. Using this element can also help avoid delays that can cause a time-out and the cancellation of the service startup.

Since there is no such config file for our ASP.Net app (web.config would not work here, because it defines settings that are only AppDomain wide and we need process wide for aspnet_isapi.dll being the hosting environment for the runtime), we would have to turn code access security (CAS) publisher policy off for the entire IIS.
There are two options:

• Create a file called w3wp.exe.config (for IIS6, or aspnet_wp.exe.config for IIS5). This will affect all .NET based web applications on the system.
• Or to specify this in machine.config, but then this affects every .NET application on the machine and is not available for override in individual Apps.

Adding the summer cabin

There is one more step which could be taken to improve performance by preloading some of the core assemblies while site visitor is doing something else.
I wouldn’t go into much details here, since it is implementation/application environment specific, but just give a hint:

• some other place in application, create a background process which would create CR document object, load some not essential report file, retrieve some data and then disapear without the trace. This would allow Crystal Reports Engine being initialized in the background offsetting time needed for the actual CR related page load. Don’t force garbage collection though, this may cancel desired effect.

Results

In some situation I observed 50% to 70% drop in start-up time…
Have fun!

The post Crystal Reports 2008 and ASP.Net : speed up the first session appeared first on Dragonsoft Technology View.

When writing code in .Net some of us take many things for granted and not always keep in mind that many operations are performed in the context of the unmanaged code or in the “old way”…

File operations or legacy code wrappers are perfect example.
Just because library is available as managed code, it does not mean that everything has ability to “self-heal”.
For example in code file is open for edit with lock being placed.
If the file in not closed explicitly, it would be a responsibility of the owner process to release the lock at the time of releasing associated resources – when process is destroyed.

With garbage collection, just because we are no longer using/owning the process/object, it does not mean that it has been destroyed immediately after. GC management core will release object when it “feels” fit, therefore introducing latency into the process.

Off course, proper way would be to be more careful within the code and make sure any locks are released in managed and predictable way: Open/Close, Lock/Unlock, … Easy solution, but not always accessible, especially when working with 3rd party libraries.

So instead, we can force GC manager to “collect garbage” in-place with the following small code:

// See code follow up below
System.GC.Collect();
System.GC.WaitForPendingFinalizers();

What does it do?
First call will instruct GC manager to start the process (1), while second (2) will make sure that we wait for process to be completed.

In the case of the file locks, only after GC has released process which placed the lock in the first place, we can manipulate with the file (ex. delete, rename, move).

The post File locks or when garbage collection goes bad appeared first on Dragonsoft Technology View.

What is Assert or Assertion?

By its definition Assert:

• state categorically
• affirm: to declare or affirm solemnly and formally as true
• insist: assert to be true
• In Computing (wiki): “an assert is a predicate (i.e., a true–false statement) placed in a program to indicate that the developer thinks that the predicate is always true at that place”

In general, using assert in the code proven to be useful in many situations because it “checks for a condition and outputs the call stack if the condition is false” and it could help to debug some strange situations in the code.

Assert is your friend

This method is for programmers to use. But what happen often when something is convenient, it started to be used excessively. Why it is happening?

Let’s look at the declaration of Assert in C# (3.x). There are two versions of the Assert(): Debug.Assert() and Trace.Assert(), both in System.Diagnostics namespace.

// Checks for a condition and outputs the call stack
// if the condition is false

[ConditionalAttribute("TRACE")]
public static void Assert(bool condition)

[ConditionalAttribute("TRACE")]
public static void Assert(bool condition, string message)

[ConditionalAttribute("DEBUG")]
public static void Assert(bool condition)

[ConditionalAttribute("DEBUG")]
public static void Assert(bool condition, string message)

As we can see from above code, Assert is to be used for Testing and Debugging and therefore should not be used as a way to present any information to the end-user.

Helping yourself

As useful as it seems, even then Assert infrastructure may not be used to full extend. In the sample declarations above we can see that logic can be invoked with and without providing any additional information.
Imagine how useful is a message “Project raised an Assert in line X” compare to “Project raised an Assert with the Message in line X”.
First option gives you idea where something failed, where second actually tells you what went wrongand where. Let’s use power of the tool-set and provide ourselves with useful information.

Assert is NOT for an end-user

I was asked recently (this seems to be a ongoing discussion) – “Why a programmer should not be using asserts as a regular approach in code conditions validation even when it comes to a production code?”

By default, Assert would show a message box with some information and the current Call Stack. This information, while being helpful to the developer, would not tell much to the user.

With custom TraceListener introduced, message can be hidden from the user and information could be stored, but it is not how it should be used by definition.

If information is expected to be presented to the user in any form, it could be achieved in a form not an exceptional, intended for debugging, situation, but by using regular methods: message box, application log, Windows event log, etc.
Even in the case of component development it is desired to use exceptions (raise/throw) to “bubble” proper message to the error handling layer.

The throw statement is used to signal the occurrence of an anomalous situation (exception) during the program execution.

Assert is a conditional logic

Last, final and probably major concern here is that in Release environment Debug and even Trace functionality would be disabled and therefore, any code/logic which depend on Assert() would be suppressed and all the nice validations became worthless (see declaration above)… and Access Violation errors starting pop up unexpectedly.

The post Assert is your friend… not an end-user’s appeared first on Dragonsoft Technology View.

Not long time ago Waterfall Model of development prevailed. Very formalized, well described and structured, very structured… and it was “too much” which killed it… like a grandpa, it collected a lot of knowledge and experience, but he was to old and slow to keep up with the grandson… So was WF model – developers wanted something better and simpler, with built-in flexibility and after few iterations we’ve got “Agile model” and “XP programming” emerged. “Spiral” development cycles… “loose” modeling… like with JPEG, developers got “loose compression” of software process definition.

Not that we are loosing quality of the development, but we define the development process with desired level of formality/quality.

Remember in “Pirates of Caribbean” – pirates have “the pirate code”. Not being the law, it was a code of conduct which was helping keep the structure and discipline.

Same for “free spirit” development models, there is the need for some “guidelines” or “rules” everybody can understand and follow if want to achieve structure and efficiency. For the process there is an Agile methodology, and for the code/architecture there are Design Patterns.

First introduced over 30 years ago, term “Patterns” surfaced in software industry several time: originally in 1977, then in 1987 and then finally in 1994.
Since that time and Object Oriented Design becoming main stream in Software Industry it transformed into a common terminology.
It still come in “waves” to one company or another, coming ashore and and then retracting back to the sea of the theories. But with Object Oriented Programming being a mainstream in evolution of software development, Patterns or Design Patterns knowledge become a common base.

Today you hear about it everywhere – “What design pattern did you use?”, “application blocks“, etc.

To think about it, there is nothing new here. As an OO developer you may used it just a minute ago.

So let’s name a few basic one (I am going to use pattern classification presented here or you can refer to The Source – “Design  Patterns” by Gamma/Helm/Johnson/Vlissides (Amazon)):

• Abstract Factory – allows manage/create instances of several types of classes – generic access.
  A-ha! In .Net the perfect example would be generics and reflection – there you are working with objects without precise knowledge of their type or parameters.
• Singleton – have you ever created global instance of the class? This is a one example for you.
• Adapter – we heard it somewhere recently… Aaaa… OleDBDataAdapter… From MSDN: “The OleDbDataAdapter serves as a bridge between a DataSet and data source for retrieving and saving data”
• Bridge – have you moved from Single/mono-design applications to C/S or created front-end ASP.Net page for your Application Server back-end? Then you have separated interface from implementation of the logic, or used a Bridge pattern.
• Proxy – Accessing your web-service from your code? Then you have most likely using some sort of Proxy class.

And then you look at WPF and see more complex like WPF patterns.

You start with just 3 groups of two dozen design patterns and you end up with many more. Some are more common then others. As it did happen with XP and Agile, and other “new” things, it all falls back to the knowledge of terminology and “buzz” words.

What does knowledge of DP give you? In reality it can come to – “not much” and “a lot”. Statements contradicting each other? Well.

Let’s look at the definition:

Design Pattern is a general reusable solution to a commonly occurring problem in software design. It helps a designer/developer/architect get a design “right” faster.

As you can see from definition, you may know them from acquired knowledge, common experience. After several years of development, you have your own patterns/templates, common practices in solving common problems. As a result, learning about “Design Patterns” may not  give you much of the new knowledge, but may help establish common grounds for discussion with the friend in next cubicle.

Ok, lets come back to original idea of .Net and design patterns. Why is it so important these days? Is it important to bring two together?

.Net framework, C# in particular, become a fine example of Object Oriented Design implementation. With language structures and Object Models present in .Net framework, it is important to understand principles of Object Oriented Design and Object Oriented Programming.

Object-oriented design (OOD) is a programming paradigm that began in the late 60’s as software programs became more and more complex. The idea behind the approach was to build software systems by modeling them based on the real-world objects that they were trying to represent.

Object-oriented programming (OOP) is a programming paradigm that uses “objects” and their interactions to design applications and computer programs. Programming techniques may include features such as encapsulation, modularity, polymorphism, and inheritance.

Combine them all and you will get .Net 3.x – WPF/WCF/LINQ frameworks. With WPF patterns and all, in order to get most out of the framework theory part of OOD/OOP become even more important because it is built-in/core part of the new concepts behind class/event/organization model of the latest edition of the framework.

You just thought that you know it all about C#? Well… it is time to start the next learning cycle.

PS. There are few things to read and watch:

• “Tales from the Smart Client” by John Gossman, Microsoft Architect for WPF and Silverlight. … You will find many posts about design and patterns in WPF.
• Another good source is dnrTV!. It now has more then a hundred shows discussing different aspects of .Net framework application: training videos, interviews and more…

The post .Net and Design Patterns appeared first on Dragonsoft Technology View.

There are plenty of 3rd party solutions on the market which would help you include some kind of charting support with your ASP pages and WinForms applications – ChartFX, Dundas Chart – these are just few from many available on the market today.

As it turned out, Microsoft has decided to add out-of-the-box support for Charting as well – <asp:chart runat=”server”/>.
Read about it here – New ASP.NET Charting Control: <asp:chart runat=”server”/> by Scott Guthrie – everything you need to know about the .Net 3.5 framework new addition.

For  additional information also visit Alex Gorev’s blog.

Note 1: Even though caption says it is ASP.Net solution, in the original you would find link to WinForms sample as well.
Note 2: Do not worry about Dundas copyright – “Microsoft acquired Dundas Data Visualization Intellectual Property in April 2007.”

The post ASP.Net/WF : New built-in .Net Charting control appeared first on Dragonsoft Technology View.

If you visited PDC 2008, then you probably already heard that Microsoft had officially presented a new .Net framework/API which would be available as part of Windows 7.

If you have missed PDC 2008 this year, you can watch it online here

• Developing for Microsoft Surface
• Windows 7: Developing Multi-touch Applications

The post Windows 7 and multi-touch – continued appeared first on Dragonsoft Technology View.

Not anymore – default or optional parameters would appear in C# of some near future – .Net 4.0 (this is 70+ minutes you have to listen to):

1. dynamic language support and Dynamically Typed Objects
2. concurrent applications, multi-core support, parallel programming
3. befriend C# with VB#
4. default and named parameters
5. Compiler as service, compiler API, code delegate, code text as script
6. more…

Being the father of Delphi and then C#, he could not resist from sharing/exploring further many ideas which we have seen since Delphi 1.0 – VCL, data access, and many other things.

I have always considered C# being a Delphi 2.0 – which Delphi could become if Anders would have an opportunity to extend it at Borland.

Few thoughts:

#1. very nice simplification to the coding practices. Too powerful perhaps? Well, generics were as such when introduced and now we cannot live without it… PHP/Python anyone? Delphi classes from C# without reflection, interfaces or delegation…

#3. Is interesting statement from Microsoft since they did try hard to decommission VB and have not succeeded. I think Borland/CodeGear has tried the same with Delphi and has not succeed with that either. Evolution of the language is inevitable, it has to follow the trend. And I am glad with Prism announced this is something which would be a thing of the past.

#4. default parameters… Finally… a named parameters? mmm… interesting…

#5 as component developer I would love to see this feature in Delphi for dynamic deployment. As a developer I am looking forward for Delphi scripting capabilities…

PS. It is nice to see an acknowledge of his work at Borland in his PDC2008 introduction

Before joining Microsoft in 1996, Hejlsberg was one of the first employees of Borland International Inc. As principal engineer, he was the original author of Turbo Pascal, a revolutionary integrated development environment, and chief architect of its successor, Delphi.

The post Future of C# – v 4.0 at PDC 2008 appeared first on Dragonsoft Technology View.

Since it is not a first time around and appear to be very common situation with dynamic pages, I thought it may be useful to write about it once and then just refer to this post later.

1. We have a table with the following structure:
   

   ID

   ParentID

   Name

2. We also have a stored procedure usp_GetGroupList which would return data from table above.
3. And on our ASP page we have a TreeView control called myTreeView

Few things we are trying to achieve:

1. Small code
2. Minimum of database access

Well, code would not be too complex after all:

private void PopulateTree()
{
    // Populate dataset with data for later use
    DataSet dsList = new DataSet();
    SqlConnection conn = new SqlConnection(myConnectionString);
    conn.Open();
    try
    {
        SqlCommand cmd = new SqlCommand("usp_GetGroupList", conn);
        cmd.CommandType = CommandType.StoredProcedure;
        SqlDataAdapter adapt = new SqlDataAdapter(cmd);
        adapt.Fill(dsList);
    }
    finally
    {
        conn.Close();
    }

    // Clear the tree
    myTreeView.Nodes.Clear();
    PopulateTreeNode(dsList, null, "0");
}

private void PopulateTreeNode(DataSet dsList, TreeNode parent, string parentID)
{
    TreeNodeCollection baseNodes;
    string rowID;
    TreeNode node;

    if (parent == null)
    {
        baseNodes = myTreeView.Nodes;
    }
    else
    {
        baseNodes = parent.ChildNodes;
    }

    foreach (DataRow dsRow in dsList.Tables[0].Select("ParentID = " + parentID))
    {
        node = new TreeNode();
        node.Text = dsRow["Name"].ToString();
        rowID = dsRow["ID"].ToString();
        node.Value = rowID;
        node.SelectAction = TreeNodeSelectAction.Select;

        // Add link back to itself so selected group could be changed
        node.NavigateUrl = "~/default.aspx?id=" + rowID;
        baseNodes.Add(node);

        // Use recusion to populate child nodes
        PopulateTreeNode(dsList, node, rowID);

        // Preselect the node for current group
        if (node.Value == Request.QueryString["id"])
        {
            node.Selected = true;
        }
    }
}

The post Populate TreeView from table in ASP.Net appeared first on Dragonsoft Technology View.