ICollection<Knowledge>

A Comparison of Java Stream API and C# LINQ for Declarative Collection Operations

2023-06-21T20:44:00.005+05:30

Java Stream API and C# LINQ share a common goal of working with collections in a declarative approach. While LINQ has been around since 2007 with the .NET Framework 3.5, Java Stream API is a more recent addition introduced with Java 8 in 2014. Although both support functional programming paradigms, they differ in their syntax and usage. In this article, we will compare these two.

Syntax and Language Integration:

Both Java Stream API and C# LINQ provide declarative approaches for dealing with collections and support functional paradigms. LINQ goes a step further by also supporting SQL-like query expressions, providing a more comprehensive declarative approach. The Stream API, on the other hand, is a library in Java and does not have direct integration with language features. However, it can be used with other language features such as lambda expressions, method references, and default methods in interfaces.

Functional Programming Paradigm:

Both Java Stream API and C# LINQ embrace functional programming principles. They allow you to write concise and expressive code by utilizing lambda expressions and functional interfaces. Java Stream API provides functional interfaces such as Predicate, Function, and Consumer, while C# LINQ supports lambda expressions and functional interfaces like Func and Action.

Lazy Evaluation and Eager Evaluation:

Java Stream API and C# LINQ both follow the principle of lazy evaluation. Intermediate operations in both APIs are not executed until a terminal operation is called. This approach enables more efficient processing of large datasets, as only the required data is processed when needed.

Database Integration:

The Java Stream API primarily focuses on in-memory collections and does not have built-in support for direct database integration. However, libraries like Hibernate provide integration between Java streams and databases. On the other hand, C# LINQ has extensive support for querying databases. It seamlessly integrates with Entity Framework, LINQ to SQL, and other ORMs, allowing you to write LINQ queries directly against the database.

Asynchronous Programming:

Java 8 introduced CompletableFuture, which can be combined with the Stream API for asynchronous processing of data streams. Parallel stream processing can be achieved using the parallel() method. In C#, asynchronous programming is facilitated by the async and await keywords. LINQ queries can be combined with Task and async methods to execute queries asynchronously.

Comparison of Collection Operations between LINQ and Stream API:

Filtering Elements:

Both LINQ and Stream API offer methods for filtering elements based on specific conditions. In LINQ, you can use the Where() method, while Stream API provides the filter() method.

Java Stream API:

java
stream.filter(element -> element > 5)
      .forEach(System.out::println);

C# LINQ:

csharp
var filtered = collection.Where(element => element > 5);
foreach (var element in filtered)
{
    Console.WriteLine(element);
}

Mapping Elements:

Both LINQ and Stream API provide methods for transforming elements. LINQ offers the Select() method, while Stream API provides the map() method.

Java Stream API:

java
stream.map(element -> element * 2)
      .forEach(System.out::println);

C# LINQ:

csharp
var mapped = collection.Select(element => element * 2);
foreach (var element in mapped)
{
    Console.WriteLine(element);
}

Sorting Elements:

Both LINQ and Stream API allow sorting elements. In LINQ, you can use the OrderBy() or OrderByDescending() methods, while Stream API provides the sorted() method.

Java Stream API:

java
stream.sorted()
      .forEach(System.out::println);

C# LINQ:

csharp
var sorted = collection.OrderBy(element => element);
foreach (var element in sorted)
{
    Console.WriteLine(element);
}

Aggregating Elements:

Both LINQ and Stream API support aggregating elements using methods like Sum(), Average(), Min(), and Max().

Java Stream API:

java
int sum = stream.reduce(0, (a, b) -> a + b);

C# LINQ:
```
csharp
int sum = collection.Sum();
```

Grouping Elements:

Both LINQ and Stream API enable grouping elements based on specific criteria. LINQ provides the GroupBy() method, while Stream API offers the Collectors.groupingBy() method.

Java Stream API:

java
Map<String, List<String>> grouped = stream.collect(Collectors.groupingBy(element -> element.substring(0, 1)));

C# LINQ:

csharp
var grouped = collection.GroupBy(element => element.Substring(0, 1));

Joining Elements:

Both LINQ and Stream API support joining elements from multiple collections. LINQ provides the Join() method, while Stream API offers the flatMap() and Collectors.joining() methods.

Java Stream API:

java
String joined = stream.collect(Collectors.joining(", "));

C# LINQ:

csharp
string joined = string.Join(", ", collection);

Checking for Element Existence:

Both LINQ and Stream API provide methods for checking the existence of specific elements.

Java Stream API:

java
boolean anyMatch = stream.anyMatch(element -> element > 10);

C# LINQ:

csharpe
bool anyMatch = collection.Any(element => element > 10);

Tree vs Forest in Graph theory

2023-06-09T08:00:00.003+05:30

In graph theory, a tree and a forest are both special types of graphs that do not contain cycles.

Here is difference between tree and forest.

	Tree	Forest
Definition	A connected acyclic graph	A collection of disjoint trees
Components	Only one tree	Multiple trees
Connectivity	All vertices are connected	Each tree is connected but trees are disjoint
Cycles	No cycles	No cycles in individual trees
Number of Edges	n-1 (where n is the number of vertices)	Sum of edges in all trees
Root	A tree can have a designated root vertex	Each tree in the forest can have its root
Paths	Unique path between any two vertices	Paths are unique within each tree
Examples	Family tree, hierarchical structure	Multiple disconnected network components
Examples

Reproduce Issues while debugging

2012-08-31T23:25:00.001+05:30

Reproduce Issues while debugging

Software developers live and breathe debugging. It’s an essential and integral part of our day-to-day job. Whenever we are confronted with any bug in code, our typical first question is, “How can I reproduce this issue?” Any problems that cannot be reproduced are generally considered tricky to resolve. In order to really understand the challenges with debugging hard to reproduce issues, let’s walk through a few scenarios here.

Let’s say you are working on your company’s flagship product. While writing some code you come across some bugs. Frankly there is nothing abnormal in this scenario and as a software developer you always strive to minimize the number of bugs in your code. Most developers would just fix those bugs and move on.

Now let’s say your product is with the QA team and during testing they find some bugs in the product. Again, there is nothing exciting in this scenario because this is a typical step in the software development lifecycle.

Suppose that your product is released and deployed to customer sites. And only after release do you start getting complaints like application crashing, slow performance or the application has hung. Suppose these are problems that haven’t been seen before so your team may try to reproduce the problem but have no luck with it. As far as you can tell there is no hardware or software configuration difference that can cause this problem. So now you have to debug this problem that you cannot reproduce. What can you do here?

Let’s go a step even further. Let’s say your product is deployed to several customer sites. It’s working fine for all of them except one. At that site the client observes problems like app crashing and the application will hang. Your team cannot re-produce this problem in-house. You know this client generates most of the revenue for your company and because of product downtime, your company is losing money as well. This is really a pressure game; your team will be under lot of pressure to resolve these problem ASAP that you don’t know how to reproduce. These last two scenarios describe what it means to debug hard to reproduce issues. This article will talk about some approaches that you can take to tackle these types of situations.

Post-Mortem Debugging

For the situations described above, there are some proven methodologies that you can use to get to bottom of the issues. The main idea behind these methodologies is that when a process is in an unhealthy state, the process itself contains critical data that you can use to find what’s going on. If somehow you can look into the memory space of processes and get to the right data structures, there is a very good chance that you can find the root cause of problem. This methodology is called post-mortem debugging. Figure 1 describes the steps involved in the process.

Figure 1: Steps involved in post-mortem debugging.

Post-mortem debugging involves two steps. First you write code to take a snapshot of processes which gives us a file with the extension dmp. This file is called a dump file. The critical thing here is the timing of generating process dump. You will have to generate process dump when the problem is actually happening. If you take a snapshot of a process when it is in a healthy state, then it may not contain the data that can help you figure out the root cause of the problem. The second step is to analyze the dump file. You can use one of several debuggers to perform this type of analysis such ascdb, nstd, Windbg, DebugDiag. You can even use Visual Studio for this type of analysis.

The chief advantage of this two-steps approach is that for analyzing the dump file, you don’t have to be on the same machine where the problem is happening. Once you generate the dump file, you can move it to any other computer for analysis. This is a huge benefit, because if the problem is happening at a client production data center, their system administrator will not be too eager to grant you permissions for dump file analysis.

What Is a Dump File?

Before I delve into details of how to capture a process dump file, let me explain what a dump file is. A dump file is basically a portion of process virtual memory that contains information like threads running in process, their call stacks, objects present on stack, objects present on the heap and exception records. All of this data becomes part of a dump file when you generate a memory snapshot. You can use dump files to troubleshoot problems like sluggish performance, application hangs or crashes.

When capturing a process dump, it is really important to use the right set of tools according to your target process. For instance, if your application is 32-bit running on a 64-bit operating system, you should use a 32-bit debugger to generate process dump. If you don’t use the correct version of the debugger, you will likely see incorrect call stacks that can completely throw off your analysis in the wrong direction.

You’ll use various tools available to generate process dumps. Which tools you use will depend upon the type of problem you are encountering. For example, a tool that you might use to generate process dump in a hang scenario, may not be very effective when you are investigating a crash or high CPU scenario. Given that most of the time you will have to use these tools in a production environment, generally you will prefer to use tools that have the smallest footprint. In this article I will discuss the following four tools for generating a dump file.

Task manager
ADPlus
ProcDump
DebugDiag

Let’s take look at how to generate a process dump using each of these tools.

Task Manager

The easiest way to generate a process dump is by using Task Manager. Starting from Windows Vista, Task Manager provides an option to generate a process dump. If you happen to use any operating system before Vista (e.g., Windows XP) you will not get this option within Task Manager. It is extremely simple to generate a dump file. All you have to do is launch Task Manager, click on the Processes tab, right-click to select a process and choose Create Dump File from the popup menu as shown in Figure 2.

Figure 2: Generating dump file using Task Manager.

Once you click the Create Dump File option, Windows will create a snapshot of the selected process and will save the snapshot in the temp directory. Keep in mind that if you want to create a dump file for a 32-bit process running on a 64-bit OS, you should use the 32-bit version of Task Manager, which is typically located at C:\Windows\SysWOW64.

Even though generating a process dump using Task Manager is straightforward, it is still a manual process. You’ll encounter certain situations where generating process dump using Task Manager will not be trivial. Let’s say your application crashes intermittently at unpredictable times. In this situation, it is not practical to have someone monitoring the process in Task Manager and click Create Dump File at exactly the right time when the application crashes. Other tools are better suited in this type of situation. That’s where this next tool, ADPlus, comes into the picture.

ADPlus

ADPlus is a powerful and flexible tool to automate the dump file generation process. You can download it for free from Microsoft’s website at microsoft.com/whdc/devtools/debugging/default.mspx. ADPlus is part of what is called “Debugging Tools for Windows.” Earlier versions of ADPlus used to be a Visual Basic Script (vbs) file, but now ADPlus is available as a managed executable application. The older vbs scripts file is still part of that download. You can run ADPlus as a command-line application using switches to control the mode of operation and type of dump file you want to generate. ADPlus can also work using a configuration file that allows far more granular control to end users.

ADPlus supports two different execution modes for taking a snapshot of a faulty process.

Hang mode. As the name suggests, this mode is typically used to troubleshoot processes that exhibit hang-like symptoms. Examples could be resource starvation due to high CPU usage, sluggish performance, etc.
Crash mode. This mode is used when you have to troubleshoot processes exhibiting crash behavior.

Let’s take a look at couple of examples of how ADPlus can be used in these two modes. When you use ADPlus in hang mode, it’s pretty much the same action as generating a dump file using Task Manager. The following code snippet shows the command to use for generating a dump file in hang mode.

ADPlus -hang -pn CodeMagHangDemo.exe -o E:\Dumps

You start running this command using the hang switch. This switch instructs ADPlus to generate a dump file as soon as the command executes. The example used the -pn switch to define the target process name but it could have used the -p switch to configure a process by its process ID. The -p switch is useful in situations where you have more than one instance of the same process running and you want to generate a dump file for a particular instance. Finally, the example above uses the -o switch to configure the path where the dump file should be created.

Now let’s take a look at another example of using ADPlus to generate a dump file of an application that crashes at random times. Listing 1shows the code used to exhibit this crash behavior. The example simulates randomness by asking the user to press a key.

In this scenario, using ADPlus in hang mode will not be a good choice as it’s not possible to predict when the process will crash. The following code snippet shows the command line to run ADPlus in crash mode.

ADPlus -crash -pn CodeMagCrashDemo.exe -o E:\Dumps

The primary difference between the two command lines is the use of a -hang vs. a -crash switch. When you run ADPlus in crash mode, a debugger gets attached to the target process and it waits for an unhandled exception to be raised. Once a process raises an exception, the debugger writes out the dump file.

The real flexibility of ADPlus comes from the long list of switches it supports. It uses an XML-based configuration file to provide granular control for items like when to generate a dump file, what actions should be taken and the type of dump file to create. ADPlus comes with a help document that provides details on switches and configuration file management.

ProcDump

ProcDump is another command-line tool used to generate dump files. You can download this free utility from Microsoft’s website athttp://technet.microsoft.com/en-us/sysinternals/dd996900.aspx. Just like ADPlus, you can use ProcDump to monitor processes for hang or crashing issues. However, you get to see the real flexibility of ProcDump when you have to generate a dump file based on complex threshold criteria. Let’s take a look at an example. Figure 3shows the CPU usage as consumed by our sample application CodeMagHighCPUDemo.

Figure 3: Application with short and sustained high-CPU spikes.

As you can see from Figure 3, our sample application consumes high CPU cycles intermittently. A few times, these CPU spikes are short, but you can also see sustained high CPU usage. Generally speaking, sustained high-CPU spikes for longer duration will be more concerning, and if you don’t know what is causing it, the next step will be to take a process dump when it’s consuming high CPU for a sustained period of time. Figure 4 shows the ProcDump command and its output.

Figure 4: ProcDump command and its output.

The command line for this example sets up ProcDump by first using the -c switch to configure the threshold for CPU usage. This example uses a threshold of 75%. The command line adds a -s switch to indicate that the dump file should be generated only when the CPU usage threshold exceeds 10 seconds. Finally, the command line indicates the application name (CodeMagHighCPUDemo.exe) that ProcDump will monitor. As you can see from the output of the ProcDump command in Figure 4, CPU usage hit the 75% threshold but it didn’t stay there for 10 seconds. However, when there was sustained CPU usage for 10 seconds, ProcDump generated the dump file.

ProcDump offers several other very useful switches. For instance, this example only generated one dump file. In some situations you might like to get more than one dump file. In that case you can use the -n switch to configure the number of dump files you would like to get. Another useful parameter is -u, which you can use to configure CPU usage relative to a single core, which could be quite handy when you are running process on a multi-core machine. Another interesting switch, -w, will make ProcDump wait for a target process to be launched in case it’s not already running. One more parameter I find interesting is -p, which you can use to configure thresholds based on specific performance counters.

I highly encourage readers to run the ProcDump -? command or look at the product documentation at http://technet.microsoft.com/en-us/sysinternals/dd996900.aspx and go over other switches supported by this tool.

DebugDiag

Debug Diagnostic Tool (DebugDiag) is yet another tool to troubleshoot issues like memory leaks, hangs, crashes etc. You can download it from the Microsoft Download Center. What makes it different from ADPlus or ProcDump is that it provides an easy to use UI to configure your rules and thresholds for capturing dump files. In addition, DebugDiag also has the ability to analyze dump files and determine the root cause of issues. The analysis service uses an extensible object model that a developer can use to write their own custom analysis scripts.

Before I delve into details of how to generate a crash dump via DebugDiag, let’s take a brief look at its four primary building blocks.

User Interface

Figure 5 displays DebugDiag’s main user interface. You’ll use it to configure the rules and threshold to generate process dump as well as for dump files analysis.

Figure 5: DebugDiag UI.

Host

Host application (DbgHost.exe) is used to perform post-mortem debugging on the dump file with the help of a control script. This script defines what actions the debugger takes for analyzing the dump files.

Service

DebugDiag contains a Windows service application that runs as a background process primarily to attach and detach host to target processes for crashing applications. In addition, this service also facilitates hang application detection, collection of performance monitor logs and dump counter maintenance, etc.

Leak Tracker

Leak Tracker is a dynamic link library used to monitor processes for troubleshooting memory leaks.

Collecting a Crash Dump with DebugDiag

Let’s take a look at how you can use DebugDiag to collect a crash dump. For this example, from the main UI (Figure 5) you will click the Add Rule button. This will take you to the Select Rule Type dialog box shown in Figure 6.

Figure 6: DebugDiag - Select Rule Type.

This dialog lets you configure a rule type. For this example, choose the Crash option and click Next. Now you can select the target type, as shown in Figure 7. This dialog box offers you several options. For this example, choose the A specific process option and then click Next.

Figure 7: DebugDiag - Select Target Type.

You should see the Select Target dialog box (Figure 8) for selecting a specific process. You can either choose a particular process instance or you can just type a process name.

Figure 8: DebugDiag - Select Target.

Once you select a target process and click Next, you’ll get a chance to configure some advanced optional parameters (Figure 9). You can set things like the number of dump files to generate, actions to be taken for first chance exception, etc. This example doesn’t require advanced configuration so leave the default settings and click Next.

Figure 9: DebugDiag - Advanced Configuration.

You’ll now see Figure 10 which lets you provide a name for this newly defined rule and choose a path for the dump file. Leave the defaults and click Next.

Figure 10: DebugDiag - Dump Location and Rule Name.

On the last screen (Figure 11) you can choose to either activate this rule right away or leave it to activate at another time. If you don’t activate the rule right away, you will still have the ability to activate the rule later. For this demo, choose Activate the rule now and then click Finish.

Figure 11: DebugDiag - Rule Activation.

At this point the rule is configured. If you launch the sample application, CodeMagCrashDemo.exe, you should get a crash dump file at the configured location.

DebugDiag UI makes it very easy to configure different types of rules, however, it may not be your first choice tool for capturing process dump in a production envionment due to installation requirements of its components. DebugDiag also contains a simplified UI just for performing dump file analysis called Debug Diagnostics Tool (Analysis Only). It lets you generate process dumps from any of the light-weight tools discussed above and then use DebugDiag Analysis Only to analyze those dump files to find the root cause of an application’s problem.

Dump File Analysis

Now that you have learned several different ways of capturing process dump, let me discuss how to analyze dump files. Like I mentioned earlier there are several different debuggers. In this article I will show you how to use DebugDiag. As shown in Figure 12, DebugDiag UI has an Advanced Analysis tab that can help you to perform analysis on a dump file. First you have to choose the analysis script you want to execute. Out of box, DebugDiag provides useful analysis script for problems like crash, hang, performance and memory issues. You can also add your own custom scripts. In this article we’ll analyze the dump file for CodeMagHangDemo process to try to solve why the application hangs. From the list of Available Analysis Scripts, choose the option for Crash/Hang Analyzers. Next, you can add the dump file by clicking the Add Data Files button. In some cases, you may get more than one process dump file. For example, if your application is hosted under IIS and if that IIS instance contains multiple web applications, you will see multiple w3wp.exe processes active at a time. In this case, if DebugDiag is configured to generate crash dump via process name (and not process ID) you will end up getting multiple dump files, one for each of the running w3wp process. In this situation you may not be sure as to which w3wp process needs to be analyzed. Your best choice will be add all those dump files by using the Add Data Files button.

Figure 12: DebugDiag - Analysis Tab.

Once the analysis script and data file are set up, click the Start Analysis button. DebugDiag will analyze the dump file and will produce an HTML report that you can open in a browser. As shown in Figure 13, the report starts with a summary of issues that it has found. In the later part of this report, it contains more information about the process, threads in process, their call stack, etc. In this particular case, the report warns that thread 0 is making a sleep call. Click on thread # 0 to learn further details about it.

Figure 13: DebugDiag - Analysis Summary.

Figure 14 shows the details of thread 0 including the call stack. From this report we can conclude that the process goes into hang state because it makes a Sleep call.

Figure 14: DebugDiag - Thread Report.

Summary

This article described the challenges associated with debugging hard-to-reproduce issues. It introduced post-mortem debugging and also looked at various tools that can help you to generate a dump file and later analyze those files. All the demos in this article are very basic. These tools provide much more flexible configurations too. I strongly encourage readers to read the support documentation of these tools and get familiar with those additional features.

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

Value Coercion in WPF

2012-05-16T00:43:00.000+05:30

What is value coercion?

If you are not familiar with value coercion, it is simply a mechanism by which related (or “interdependent”) dependency properties can be kept in sync and valid.

The quintessential example can be found within the Slider control. A Slider has both Minimum and Maximum properties. Clearly, it would be a problem if the Maximum value were allowed to fall below the Minimum value. Value coercion is used to prevent this invalid state from occuring.

In WPF, the Slider control (or more specifically, the RangeBase control) ensures that these property values stay valid by using a feature of the dependency property metadata called a CoerceValueCallback. Whenever the Maximum property value changes, it is passed through this coercion function. If the Maximum value happens to be less than the Minimum value, the function will coerce it to be equal to the Minimum value so that it is valid.

The coercion routine for the Maximum property looks something like this:

private static object CoerceMaximum(DependencyObject d,
    object value)
{
    double min = ((RangeBase)d).Minimum;
    double max = (double)value;
    if (max < min) return min;
    return value;
}

Whenever the related Minimum property changes, the control explicitly coerces the Maximum property. This ensures that the Maximum value stays valid with respect to the new Minimum value.

The property changed callback for the Minimum property looks similar to this:

WPF Architecture

2012-05-16T00:19:00.001+05:30

Today I would like to discuss some core part of WPF architecutre. in WPF ,Presentation Framework, Core Presentation and Media Integration Layer (milcore) Are The Three Major components of WPF architecture. These Are the Major portions of the WPF code. Milcore is cash en Unmanaged Code in order to enable tight integration with DirectX. DirectX engine is responsible for all display in WPF, allowing for efficient hardware and software rendering. CLR Provides fine control over the memory and execution. The composition engine in milcore is Extremely sensitive performance, and required giving up Many advantages of the CLR to gain performance
for more details click on below link

WPF Architecture

INotifyPropertyChanged For ViewModel or For Model ?

2012-05-16T00:18:00.001+05:30

INotifyPropertyChanged For ViewModel or For Model ?

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

INotifyPropertyChanged For ViewModel or For Model ?

2012-04-03T22:02:00.003+05:30

INotifyPropertyChanged For ViewModel or For Model ?

2012-04-03T22:02:00.001+05:30

INotifyPropertyChanged For ViewModel or For Model ?

ASP.NET bugs in IE10

2011-09-29T23:12:00.000+05:30

Hi guys,
Today I have test one of my web application on IE10 and I found that my application is on working properly. in IE10. So at 1st glance I was bashing Microsoft for such poor IE version. but latter I found that my web application is not working not due to IE 10 but due to ASP.NET framework itself. How ?

when I debug my application in IE10 with F12 then I found that there is no _dopostback function of javascript is defined..!!! in my page.. how come it possible..
this is the job of ASP.NET webform frameworks. So after doing lots of google, I found that when engineers of ASP.NET webform framework were developing this they have not though IE version can go beyond 9.

So when request come from IE 10 in ASP.NET web application then it version number of IE 10 is consider as unknown browser (and older browse as well) hence ASP.NET framework does not include those javascript.
So culprit is browser definition system in ASP.NET framework.!!

but thanks to Asp.net 's engineer in Microsoft who solve this problem with hotfixes.

If you PC or server has .NET 2.2/3.0/3.5 then : http://support.microsoft.com/kb/2600100
and if it has .NET 4.0 then : http://support.microsoft.com/kb/2600088

but if you have very old version of .net that is .Net 1.1 then please upgrade your web application in to at least 2.0

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

developer stack in new window 8

2011-09-20T00:16:00.002+05:30

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

Microsoft’s new Windows Runtime

2011-09-20T00:07:00.002+05:30

Make no mistake: Microsoft has re-invented the Windows API in WinRT. Just to recap, WinRT is the API for Metro-style applications, the touch-centric, app-centric API for tablets and, one presumes, eventually for Windows Phone (though Microsoft has yet to admit it).

WinRT is only useable from Metro applications. You cannot call WinRT from a Win32 application, nor vice versa*. I think it is reasonable to assume that a future version of Windows which runs only WinRT is a possibility; and that Windows 8 on ARM will look a bit like that even though Win32 will still be there, but mainly out of sight; but I am speculating.

Does that mean Win32 is now legacy? In a way, but such a huge legacy that for the moment we should think of Windows 8 as two platforms side by side.

There is no inter-app communication in WinRT other than by the pre-defined contracts built into the system (though Lovell noted that you could always use the file system and polling for a crude inter-process communication).

There is no way to install a shared dynamic library. Apps can only use the system libraries together with what you install with the app. Each app lives in its own context and is isolated. In other words, WinRT is not extensible, other than within your app’s code*.

If you figure out a way to bypass limitations of WinRT by calling other Windows APIs, your app might work but the submission process for the Windows Store will prohibit it.

Versioning is built into WinRT. This means that when Windows 9 comes along, you will be able to code just against the Windows 8 versions of the classes, for compatibility, and your IDE can support this by only exposing the Windows 8 version of the API.

The CLR exists in the Metro environment, for use by .NET applications, complete with JIT (Just in time) compilation. However only a subset of the .NET Framework libraries are included. Microsoft aimed to include only what was necessary for Metro. I am not sure yet what is included and what is not, beyond the obvious (no Windows Forms, for example) but will be investigating what is documented. The native WinRT APIs look similar to a COM callable wrapper from the .NET side. That said, you do not normally need to care about WinRT interfaces, even though these are there in WinRT. Normally you interact with WinRT classes, making it more natural for .NET than working with COM.

WinRT is full of asynchronous calls. Lovell told us that Microsoft had seen in the past that if both synchronous and asynchronous APIs are available for the same function, then developers often use the synchronous version even when they should not, making applications less responsive. The new await keyword in C# makes this easy to code.

WinRT makes use of the ILDasm metadata format which is also used by .NET. This means you get rich metadata for IntelliSense and debugging, but note that the actual runtime is not .NET; they just borrowed the same metadata format.

WinRT objects are reference counted like COM for memory management, with weak references to avoid circularity. You should not have to worry about this; you can code according to the conventions of your language.

There are three ways to write WinRT applications. One is C++, in which case you write directly to the “projection” of WinRT into your language. The second is .NET, in which case your code goes via the CLR. The third is HTML and JavaScript, in which case your code goes via the “Chakra” JavaScript engine also used by Internet Explorer 9 and higher. Lovell assured me that there is little difference in performance in most cases, though there could be advantages for C++ in certain niche scenarios. Of course we heard that story for .NET as well, but from what I have seen it is more plausible in WinRT.

There is no message loop in WinRT. There is no GDI in WinRT. All graphics are via DirectX. XNA, the .NET games framework, is not supported. It seems that you will need to use C++ for fancy DirectX coding, though this is not confirmed. Of course your XAML or Canvas code will be rendered by DirectX under the covers.

It is fascinating to see how Microsoft has borrowed XAML and ILDasm from .NET, but that WinRT is native and not .NET at its core. My take on this is that Microsoft intended to preserve the productivity of .NET, but without any performance compromise.

Despite the inclusion of .NET though, the fact that only a subset of the Framework is available, and that interop to the Windows API will not work*, means that most existing apps will need considerable work to be ported to Metro.

*Updates

A few clarifications.

It has been shown that you can call WinRT from Win32 (the favoured word for Win32 seems to be “desktop applications”) though I’m not sure how useful it is.

Concerning P/Invoke (Platform Invocation) to Win32 APIs, apparently this does work for a certain specified, small subset of the Windows API. It also works for your own native code DLL, with the proviso that if your native code DLL calls a disallowed Win32 API it will raise an error.

WinRT is partially extensible. A Framework Extension is a library which you can reference as a dependency in your app’s manifest. When the app is deployed it will download this dependency from the Windows Store. An example is the C Runtime Library. An extension library installs into its own directory, and can be used by multiple WinRT apps provided each one also references it in their manifests. However, the caveat is that only Microsoft can create these extensions: there is no way to create your own shared extension for general distribution, though an enterprise can deploy a shared extension internally.

Cities of the future: Ahmedabad

2011-08-15T01:21:00.000+05:30

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

Najarna Jam Chhalkavine

2011-07-27T01:06:00.000+05:30

Najarna Jam Chhalkavine

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

Tesco: Homeplus Subway Virtual Store (Movie)

2011-07-15T09:39:00.000+05:30

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

ViewBag v/s ViewData

2011-07-12T03:01:00.001+05:30

Hi Friends,
If you go through ASP.NET MVC 3.0 framework then you will find two frequently used collection of data object which used to pass data between control and views and partial views. as both are doing similar functionality but has some difference in that , so today , I would like to put some difference of those and interoperability of that .

V/s

ViewData	ViewBag
It is dictionary of name/value pair collection	It is dynamic type object
This features exist since 1^st release of ASP.NET MVC	This features available from ASP.NET MVC 3.0
This will work in ASP.NET with .net 3.5 framework and above	This will work well with ASP.NET 4.0 with .net 4.0 framework and above
ViewData is faster compare to ViewBag	ViewBag is slower than ViewData
While retrieving data from viewData in to view pages , one need to do proper type casting	While retrieving data from viewbag in to view pages , one need not to do type casting
Hence it make code with lots of type casting fragments	Hence it make more clear code

How to decompile Android application to get sourcecode

2011-07-08T00:32:00.002+05:30

Hi Friends,
reverse engineering is everywhere. but reverse engineering is meant for code review of vulnerable application. so I hope you guys will not use this reverse engineering tricks to do any illegal things.
all android application are running on Dalvik , which is a Virtual Machine having register-base architecture and different from Java Virtual Machine by sun-microsystem (and now by oracle ) which is stack machine.
hence all android application is consist of Dalvik Executable (.dex). hence to convert those android application( *.apk) to source code we have to follow below steps

(Note : apk is packing of .dex file and other resources.)

step to decompile

1) convert .dex file format to .class file
2) convert .class file format to java code file

1) android application will come with .apk file format. which contains .dex file .
hence to convert .dex file in to .class file ( and those compress .class files are placed in .jar file)
one need to have .dex to .class file converter .(both are binary format)
you can download such tool from below link.

after downloading you need to extract them and it will have following files in you file system.

MVVM framework comparison sheet

2011-07-06T01:32:00.002+05:30

In this MVVM framework comparison sheet includes as many aspects as possible. However, it might be possible that some were missed. If you have features that are not included in the comparison sheet, or you find that information is incorrect, please let us know!

Below is short list of definitions:

Definition	Explanation
VM	View-Model

How to prevent from Cross-site scripting attacks on your ASP.NET website?

2011-07-03T19:38:00.004+05:30

Hi friends,
Security is major concern for our clients when they ask us to develop their website. Hence we have to take care of attacks like sql injection and cross-site scripting attacks.
today I come across with a very good library to prevent our website against cross-site scripting attacks.

Cross-site scripting (XSS) attacks occur when an attacker uses a web apps to inject malicious code(mainly scripting), generally in the form of a browser side script(means java script), to a different end user.

How to compress our websites..!!??

2011-07-01T01:12:00.003+05:30

Hi friends,

when you have website which has heavy pages( means all page are loaded with lots of html and css etc...) .It is recommended to compress your website pages while serving. This will decrease your network traffic at your server. To achieve such compression of your website pages while delivering to browser is done by two way.

1) By server setting

2) do custom coding in your web application

When your client will concern about his db password

2011-06-29T01:06:00.000+05:30

Hi friends,

When you get a client who is more technical ,then it accentuate on safety of his critical data. Recently I faced such type of client. When my client went through publish asp.net project on server and he found that our db password inside web.config ‘s connection string , and expressed his concern for it safety of db password. so he suggested me not to placed in web.config moreover he asked me to hardcoded that password in my asp.net code and obfuscate that dll..!!.

Atom v/s RSS

2011-06-27T23:23:00.001+05:30

Hi friends,
to follow's our favorite blogs or websites, usually we subscribe Atom or RSS feed provided by those blogs or websites. so one should know the difference and similarity between them

.: Forget '.com', are you ready for '.google', or '.b...

2011-06-27T19:46:00.000+05:30

.: Forget '.com', are you ready for '.google', or '.b...: "Think of it as a cyberspace land rush, as companies and others try to stake claims to websites ending with names like '.bank' Come next yea..."

compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

GUIDs (Globally Unique Identifiers) in .NET

2011-06-26T18:58:00.004+05:30

Validation in HTML5 without JavaScript

2011-06-25T18:41:00.000+05:30

Hi Friends,
any website or web page which allowed to fill data, should have client side as well as server side validation for those entered data. hence in any website client side validation is done by JavaScript only. but in HTML 5 now we can do validation without JavaScript.

you can have required filed by providing required attribute to those input type as shown below.

<input type="email" required/> where required will indicate that a value must be supplied

S
compile by
Divyang Panchasara
Sr. Programmer Analyst
Hitech OutSourcing

EB algorithm for Azure Database connection

2011-06-23T22:47:00.002+05:30

Hi Friends,

As cloud computing buzzing now days, so I spend my spare time to do some hand-on code for Window Azure using trial pass and reading related blogs for that

Then during my hand-on , once I face the problem of frequent connection failure due to my Azure db was unavailable for few seconds .