.NET Information center: Programming

Showing posts with label Programming. Show all posts

Monday, June 20, 2011

Developing a Simple HTTP Server in C#

This short video clip shows how to use the HttpListener class in order to develop a simple HTTP server in C#. This video clip was developed as part of the 'C# Fundamentals' course available for free personal usage at www.abelski.com.

Sunday, June 19, 2011

Help yourself in Debugging by using Call Stack and Immediate Window

Here I am going to show you the two important window of the Visual Studio which is useful when you debugging the project and to get the result on the fly during debug mode.

Call Stack Window

Most of the developer get confuse when they are debugging application “From which function call came from up to my debug point”, this happens when they are working the code design by some one else or debugging code of the dll.

Following is one common scenario which I notice number of time developer does.

In the three tier application developers always put the break point in presentation layer when the break point get hit they always check the data and the do wonder that which business layer method called >> database layer method get called by presentation layer to get this data.

The Solution is Call Stack Window which is part of the Visual Studio. Shortcut for it is

Ctrl + Alt + C or go to menu Debug >> Windows >> Call Stack

Using __arglist to send parameters to a Method

__arglist is used to send parameters to a method. Generally we used to send parameters to a function by having a list of arguments specified in the method head. If we want to pass a new set of arguments we need to have Method Overloading. Even when we want to send any number of arguments we might use param array.

Now why should we use __arglist.

In case of each of these methods, the problems are :

1. If we use Method Overloading, we might have to add new methods whenever a new set of argument list is thought to be sent.

2. If we use param array we need to have same type of arguments or need to have param array of objects.

__arglist reveals each of those. It can send any no of argument to a function. It might be of any type and we can parse each argument easily using simple steps.

Lets have a look at the Code :

public int paramLength(__arglist)

{

ArgIterator iterator = new ArgIterator(__arglist);

return iterator.GetRemainingCount();

}

Now if I call the function using this statement

int x = this.paramLength(__arglist(49,34,54,6,"asdfg")); // returns 5

The Basics of Securing Applications: Part 4 - Secure Architecture

In this post, we’re continuing our One on One with Visual Studio conversation from May 26 with Canadian Developer Security MVP Steve Syfuhs, The Basics of Securing Applications. If you’ve just joined us, the conversation builds on the previous post, so check that out (links below) and then join us back here. If you’ve already read the previous post, welcome!

Part 1: Development Security Basics

Part 2: Vulnerabilities

Part 3: Secure Design and Analysis in Visual Studio 2010 and Other Tools

Part 4: Secure Architecture (This Post)

In this session of our conversation, The Basics of Securing Applications, Steve provides us with great architectural guidance. As usual, when it comes to architecture, there is a lot to cover, and as such, today’s discussion is a bit longer, but, on the other hand, the security of your application is a big deal and doing it architecturally correct is worth the up front investment.

Steve, back to you.

Absolutely!

Before you start to build an application you need to start with it’s design. Previously, I stated that bugs that are introduced at this stage of the process are the most expensive to fix throughout the lifetime of the project. It is this reason that we need to have a good foundation for security, otherwise it'll be expensive (not to mention a pain) to fix. Keep in mind this isn't an agile vs. the world discussion because no matter what at some point you still need to have a design of the application.

Before we can design an application, we need to know that there are two basic types of code/modules:

That which is security related; e.g. authentication, crypto, etc.

That which is not security related (but should still be secure nonetheless); e.g. CRUD operations.

They can be described as privileged or unprivileged.

Privileged

Whenever a piece of code is written that deals with things like authentication or cryptography, we have be very careful with it because it should be part of the secure foundation of the application. Privileged code is the authoritative core of the application. Careless design here will render your application highly vulnerable. Needless to say, we don't want that. We want a foundation we can trust. So, we have three options:

Don't write secure code, and be plagued with potential security vulnerabilities. Less cost, but you cover the risk.

Write secure code, test it, have it verified by an outside source. More cost, you still cover the risk.

Make someone else write the secure code. Range of cost, but you don't cover the risk.

New Red Programming Language Gets Syllable Backend

There's a new REBOL like programming language in town. It's called Red, it's BSD licensed and contrary to REBOL and Boron, Red is a compiled language. The Syllable project is proud to announce that Red programs now run on Syllable Desktop. Here is a screenshot from a demo program. Syllable is the third Red target platform, after Windows and Linux.

Red was introduced at the REBOL & Boron conference in the Netherlands in February by its creator Nenad Rakocevic from Paris, previously of Cheyenne fame. The project is less than half a year old and has been public for a mere three months, but the first phase of the language, the design and implementation of the Red/System dialect is already nearing completion. It will be presented at the Cht'i RUG 2011 in Lille, France. If you are in time for the conference, you can follow it live on Twitter.

Red's name hints at its goal to offer a reduced REBOL dialect that is suitable for compilation, while still being as much like REBOL as possible. The new language is currently being bootstrapped in an ingenious way. The demo program is not written in Red yet, but in Red/System, yet another REBOL like dialect. Red/System is a low level language comparable to C, with similar capabilities. It will be used in the next phase to implement the higher level Red language.

Red was ported to Syllable in a collaboration with the REBOL community. Syllable Desktop has its own in-kernel ELF loader. Red has its own ELF executable format emitter. At first they didn't match, because both try to be lean and don't implement the full ELF specification. Syllable always generates its own program executables as Position Independent Code, as if they were shared libraries. As such, Syllable expects all binaries to have section headers. Red's backend doesn't support PIC yet and didn't strictly need section headers. Andreas Bolka implemented them for Syllable and for the coming PIC implementation in Red. He also implemented proper address alignment, which Syllable requires more strictly than the GNU loader on Linux. Finally, the starting address of the generated binaries was moved to Syllable's user address space, and an embedded kernel syscall was adapted.

KB: Google App Engine - Getting started

With App Engine, we can build web applications using the Python/Java programming language, and our application runs on Google's scalable infrastructure, and uses large-scale persistent storage and services.

The Python Runtime Environment

App Engine includes a simple web application framework, called webapp, to make it easy to get started.App Engine supports Python 2.5. Our app take advantage of the many libraries, tools and frameworks for Python.

The Development Environment

We can develop and upload Python applications for Google App Engine using the App Engine Python software development kit (SDK).

The Python SDK includes a web server application that simulates the App Engine environment, including a local version of the datastore, Google Accounts, and the ability to fetch URLs and send email directly from your computer using the App Engine APIs. The Python SDK runs on any computer with Python 2.5

Creating the first application

Create a directory named helloworld. All files for the sample application reside in this directory.

Creating the Configuration File

An App Engine application has a configuration file called app.yaml. Among other things, this file describes which handler scripts should be used for which URLs.

The contents of app.yaml file are as below

application: helloworld

version: 1

runtime: python

api_version: 1

handlers:

- url: .*

script: main.py

From top to bottom, this configuration file says the following about this application:

*The application identifier is helloworld. When we register our application with App Engine ,we will select a unique identifier, and update this value. This value can be anything during development. For now, leave it set to helloworld.

*This is version number 1 of this application's code. If we adjust this before uploading new versions of our application software, App Engine will retain previous versions, and let us roll back to a previous version using the administrative console.

*This code runs in the python runtime environment, version "1". Additional runtime environments and languages may be supported in the future.

*Every request to a URL whose path matches the regular expression /.* (all URLs) should be handled by the main.py script.

Working with webapp Framework

App Engine includes a simple web application framework of its own, called webapp. The webapp framework is already installed in the App Engine environment and in the SDK, so do not need to bundle it with our application code to use it.

Installing and Using the Kinect Sensor

Installing the Kinect for Windows SDK

Download the 32-bit or 64-bit version of the Kinect for Windows SDK at http://research.microsoft.com/kinectsdk

Kinect Hardware Basics

The Kinect Sensor consists of the following:

RGB Camera – A regular video camera that has a resolution of 640x480 at 30 frames per second

3D Depth Sensors – This is a combination of a depth projector (left reticule) and sensor (right reticule) to calculate distance. For more information, see the Tech behind Kinect video

Motorized Tilt – The motorized tilt enables you to adjust the camera up or down 27 degrees to ensure that the camera has the best possible view of you

Multi-Array Microphone – A four-microphone array that is mounted as a single microphone in Windows

Device manager

After installing the Kinect for Windows SDK and plugging in the Kinect to a USB port on your computer. Click Control Panel –> Device Manager. You should see Microsoft Kinect as shown below

Concurrent Programming Without Locks

KEIR FRASER

University of Cambridge Computer Laboratory

and

TIM HARRIS

Microsoft Research Cambridge

Mutual exclusion locks remain the de facto mechanism for concurrency control on shared-memory

data structures. However, their apparent simplicity is deceptive: It is hard to design scalable locking

strategies because locks can harbor problems such as priority inversion, deadlock, and convoying.

Furthermore, scalable lock-based systems are not readily composable when building compound

operations. In looking for solutions to these problems, interest has developed in nonblocking systems which have promised scalability and robustness by eschewing mutual exclusion while still

ensuring safety. However, existing techniques for building nonblocking systems are rarely suitable

for practical use, imposing substantial storage overheads, serializing nonconﬂicting operations, or

requiring instructions not readily available on today’s CPUs.

In this article we present three APIs which make it easier to develop nonblocking implementations of arbitrary data structures. The ﬁrst API is a multiword compare-and-swap operation

(MCAS) which atomically updates a set of memory locations. This can be used to advance a data

structure from one consistent state to another. The second API is a word-based software transactional memory (WSTM) which can allow sequential code to be reused more directly than with MCAS

and which provides better scalability when locations are being read rather than being updated.

The third API is an object-based software transactional memory (OSTM). OSTM allows a simpler

implementation than WSTM, but at the cost of reengineering the code to use OSTM objects.

We present practical implementations of all three of these APIs, built from operations available

across all of today’s major CPU families. We illustrate the use of these APIs by using them to build

highly concurrent skip lists and red-black trees. We compare the performance of the resulting

implementations against one another and against high-performance lock-based systems. These

results demonstrate that it is possible to build useful nonblocking data structures with performance

comparable to, or better than, sophisticated lock-based designs.

Categories and Subject Descriptors: D.4.1 [Operating Systems]: Process Management—Concurrency, mutual exclusion, synchronization

Daniel Moth: Blazing-fast code using GPUs and more, with C++ AMP

Herb Sutter recently announced C++ AMP at the AMD Fusion Developer Summit as part of his keynote. Here, Daniel Moth, a program manager on Microsoft's Parallel Computing Platform Team, digs deeper into C++ AMP with code samples and more. Please download the slides from the link below as the recording of this session doesn't do them justice.

Big thanks to AMD for providing Channel 9 with this excellent content!

To get full performance out of mainstream hardware, high-performance code needs to harness, not only multi-core CPUs, but also GPUs (whether discrete cards or integrated in the processor) and other compute accelerators to achieve orders-of-magnitude speed-up for data parallel algorithms. How can you as a C++ developer fully utilize all that heterogeneous hardware from your Visual Studio environment? How can your code benefit from this tremendous performance boost without sacrificing your developer productivity or the portability of your solution? The answers will be presented in this session that introduces a new technology from Microsoft.

Interceptor

Project Description

Interceptor is an open source library used to intercept managed methods. The library can be used whenever an hook of a managed method is necessary.

Currently Interceptor works only on 32 bit machine.

Example of interception:

public static void Main()

{

var hook = MethodHookFactory.Create();

var sayHelloMethod = typeof( Program ).GetMethod( "SayHello" );

var sayGoodbyeMethod = typeof( Program ).GetMethod( "SayGoodbye" );

hook.Initialize( sayHelloMethod, sayGoodbyeMethod );

hook.Hook();

Console.WriteLine( Program.SayHello() ); // print "Goodbye"

hook.UnHook();

Console.WriteLine( Program.SayHello() ); // print "Hello"

}

public static String SayHello()

{

return "Hello";

}

public static String SayGoodbye()

{

return "Goodbye";

}

The Minority Report Kinect SDK hacks begin

Mark the date. This is the beginning of what I can only imagine to be a long stream of Minority Report-inspired Kinect SDK experiments.

Barely two days after the Kinect for Windows SDK beta was released, .NET developer Kevin Connolly has already successfully implemented a primitive but inspiring demo that hooks into the Windows 7 Flip 3D window management functionality, activated by gestures not from the ones used in the movie. Granted, it didn’t work perfectly, but Rome wasn’t built in a day either.

It’s funny to think just how much influence a movie nearly a decade old has had and is still having on natural user interfaces. Luckily for us, the movie was set in 2054 which means the Kinect for Windows SDK just gave us a 43-year head start. In the words of this developer, “imagine what we’ll see in a few months”.

Kinect For Windows SDK BETA Now Available

It’s official! You can now start developing Windows applications that make use of Kinect! The live launch event is actually still on Channel 9 right now! Go check it out. If you’ve missed parts of the event (it started at 9:30 AM PST this morning), they’ll be available in the Channel 9 Live Events Area within 24 hours.

Want to jump right in and start playing with the SDK? Here’s what you need:

Download the SDK

Kinect Quick Starts

Installing and Using the Kinect Sensor

Setting Up Your Development Environment

Skeletal Tracking Fundamentals

Camera Fundamentals

Working with Depth Data

Audio Fundamentals

Kinect Project Gallery

Last but not least, here are some cool examples of using Kinect for Windows:

Coding4Fun Kinect Toolkit

Kinect Mouse Cursor

Kinect Paint

Thursday, June 16, 2011

Ten Caching Mistakes that Break your App

Introduction

Caching frequently used objects, that are expensive to fetch from the source, makes application perform faster under high load. It helps scale an application under concurrent requests. But some hard to notice mistakes can lead the application to suffer under high load, let alone making it perform better, especially when you are using distributed caching where there’s separate cache server or cache application that stores the items. Moreover, code that works fine using in-memory cache can fail when the cache is made out-of-process. Here I will show you some common distributed caching mistakes that will help you make better decisions when to cache and when not to cache.

Here are the top 10 mistakes I have seen:

Relying on .NET’s default serializer
Storing large objects in a single cache item
Using cache to share objects between threads
Assuming items will be in cache immediately after storing them
Storing entire collection with nested objects
Storing parent-child objects together and also separately
Caching Configuration settings
Caching Live Objects that have open handle to stream, file, registry, or network
Storing same item using multiple keys
Not updating or deleting items in cache after updating or deleting them on persistent storage

Let’s see what they are and how to avoid them.

I am assuming you have been using ASP.NET Cache or Enterprise Library Cache for a while, you are satisfied, now you need more scalability and have thus moved to an out-of-process or distributed cache like Velocity or Memcache. After that, things have started to fall apart and thus the common mistakes listed below apply to you.

Relying on .NET’s Default Serializer

When you use an out-of-process caching solution like Velocity or memcached, where items in cache are stored in a separate process than where your application runs; every time you add an item to the cache, it serializes the item into byte array and then sends the byte array to the cache server to store it. Similarly, when you get an item from the cache, the cache server sends back the byte array to your application and then the client library deserializes the byte array into the target object. Now .NET’s default serializer is not optimal since it relies on Reflection which is CPU intensive. As a result, storing items in cache and getting items from cache add high serialization and deserialization overhead that results in high CPU, especially if you are caching complex types. This high CPU usage happens on your application, not on the cache server. So, you should always use one of the better approaches shown in this article so that the CPU consumption in serialization and deserialization is minimized. I personally prefer the approach where you serialize and deserialize the properties all by yourself by implementing ISerializable interface and then implementing the deserialization constructor.

Open source projects used in LinkedIn

LinkedIn is a social network for professionals. It is built using open source products. They sponsored many projects to open source. Here are the list of open source products used by LinkedIn.

Programming language: LinkedIn uses C++, Java, Scala, Python and Ruby.

Hadoop is a framework for running applications on large clusters built of commodity hardware. http://hadoop.apache.org/

Azkaban is simple batch scheduler for constructing and running Hadoop jobs or other offline processes. It is a workflow system for Hadoop which allows a program to be built out of small reusable pieces that need not know about one another. By declaring dependencies, you can control sequencing. http://sna-projects.com/azkaban/

Pig is a high-level data-flow language and execution framework for parallel computation. http://pig.apache.org/

Zoie is a real-time search and indexing system built on Apache Lucene. http://sna-projects.com/zoie/

Bobo is a Faceted Search implementation in Java, an extension of Apache Lucene. http://sna-projects.com/bobo/

Sensei is a distributed, elastic, realtime, searchable database. It is designed to handle billions of rows. http://sna-projects.com/sensei/

Using Google Calendar in ASP.NET Website

Problem

Google Calendar is used to store concert dates of some famous Russian DJs. The task is to display these dates with titles on the ASP.NET website.

What is Google Calendar?

Google calendar is a free Google service for planning of meetings, events, affairs with a binding to a calendar. It is possible to set a time for a meeting, repetition, a reminder, to invite other participants (service sends the invitation by e-mail). It is possible to create several calendars, each with its own name.

Possible Ways to Solve the Problem

Google has Calendar Data API that allows you to view and update calendar events from your application.

The following Calendar Data API libraries are there:

.NET

Java

JavaScript

PHP

Python

We will use .NET library for our task, because we have ASP.NET application where we need to work with Google Calendar service.

Meaningful Statement of the Problem

Get an array of events from the Google Calendar, using the following information: "Google calendar name", "Google account name", "Google account password".

Display these events on the site.

Solution of the Problem

(1) Get an array of events from the Google Calendar, using the following information: "Google calendar name", "Google account name", "Google account password".

Consider the solution to this problem step by step:

Step 1: Download .NET library for Google data API

You can download the .NET library for Google data API from Google_Data_API_Setup_1.8.0.0.msi. Then, run the installer. The library will be installed into the following folder: C:\Program Files\Google\Google Data API SDK\Redist\.

Step 2: Copy the necessary files to the Web site

Copy the following files from C:\Program Files\Google\Google Data API SDK\Redist\ into Bin folder of the website: Google.GData.AccessControl.dll, Google.GData.Calendar.dll, Google.GData.Client.dll, Google.GData.Extensions.dll.

Next, add the References to these files in the website project.

Go to References-Add Reference-Browse, choose files and press OK.

Debugging Install Functions in Visual Studio 2010

Most of us have probably used or know of the System.Diagnostics.Debugger.Break(). For more information on Debugger.Break checkout this link http://msdn.microsoft.com/en-us/library/system.diagnostics.debugger.break.aspx

Online documentation states that if no debugger is already attached, user would be prompted to attach one to executing program when the break is hit. For some reason however, this didn’t work for us when our desired breakpoint was in an OnInstall() function of an installer class.

Further digging revealed that the comments decorating the Break() call differ a bit from the online documentation:

// Summary:

// Signals a breakpoint to an attached debugger.

// Exceptions:

// System.Security.SecurityException:

// The System.Security.Permissions.UIPermission is not set to break into the

// debugger.

[SecuritySafeCritical]

public static void Break();

Apparently, Break() only signals a breakpoint to an attached debugger as per the summary above.

Interprocess Communication

Summary

The article provides an overview about approaches for interprocess communication.

When you need to realize the communication between applications, usually you consider the following approaches.

File Transfer

Applications communicate via files. Producing applications write data to files and consuming applications read files to get data.

The advantage is that applications are loosely coupled. They do not have to know about internal implementations of each other. They just need to know the file format and a location of files.

On the other hand, writing and reading files is not so fast. Therefore, files cannot be updated very frequently (e.g. many times per second) but usually they are updated in intervals, e.g. hourly. However, this causes delays and applications reading the file must often deal with the fact that data is not up to date -> synchronization issues.

Database Storage

Applications communicate via shared data in a database. Shared data is written into the database from where it can be read by other applications.

The advantage is that the database provides a unified access to all data (e.g. via SQL). So applications do not have to deal with different file formats. In addition, the transaction mechanism helps to keep data consistent.

The drawback is that applications using the database depend on the data schema. Therefore, the change in the data structure (data schema) can cause changes in applications using the database.

Also the performance can be problematic - especially, if multiple applications frequently read and update the same data or the database is distributed across different locations.

Remote Procedure Call

Applications communicate via exposed functionality. Application providing the functionality uses a middleware (e.g. WCF) to hide the interprocess communication. The intention is that remote calls look like local calls. The communication is usually synchronous.

The advantage of this approach is that the application provides a specified functionality and encapsulates (hides) data.

The disadvantage is that the communicating applications are coupled. Example: The calling application assumes that the other side implements the particular interface. If you add a new method to the interface, then all client applications are affected and must be updated and recompiled.

Atomicity, volatility and immutability are different, part one

I get a fair number of questions about atomicity, volatility, thread safety, immutability and the like; the questions illustrate a lot of confusion on these topics. Let's take a step back and examine each of these ideas to see what the differences are between them.

First off, what do we mean by "atomic"? From the Greek ἄτομος, meaning "not divisible into smaller parts", an "atomic" operation is one which is always observed to be done or not done, but never halfway done. The C# specification clearly defines what operations are "atomic" in section 5.5. The atomic operations are reads and writes of variables of any reference type, or, effectively, any built-in value type that takes up four bytes or less, like int, short and so on. Reads and writes of variables of value types that take more than four bytes, like double, long and decimal, are not guaranteed to be atomic by the C# language.

What does it mean for a read and write of an int to be atomic? Suppose you have static variables of type int. X is 2, Y is 1, Z is 0. Then on one thread we say:

Z = X;

and on another thread:

X = Y

Each thread does one read and one write. Each read and write is itself atomic. What is the value of Z? Without any synchronization, the threads will race. If the first thread wins then Z will be 2. If the second thread wins then Z will be 1. But Z will definitely be one of those two values, you just can't say which.

David Corbin asks in a comment to my previous entry whether immutable structs are guaranteed to be written atomically regardless of their size. The short answer is no; why would they be? Consider:

struct MyLong

{

public readonly int low;

public readonly int high;

public MyLong(low, high)

{

this.low = low;

this.high = high;

}

Ignore for the moment the evil that is public fields. Suppose we have a fields Q, R and S of type MyLong initialized to (0x01234567, 0x0BADF00D), (0x0DEDBEEF, 0x0B0B0B0B) and (0, 0), respectively. On two threads we say:

S = Q;

and

Q = R;

We have two threads. Each thread does one read and one write, but the reads and writes are not atomic. They can be divided! This program is actually the same as if the two threads were:

S.low = Q.low;

S.high = Q.high;

and

Q.low = R.low;

Q.high = R.high;

Now, you can't do this because that's writing to a readonly field outside a constructor. But the CLR is the one enforcing that rule; it can break it! (We'll come back to this in the next episode; things are even weirder than you might think.) Value types are copied by value; that's why they're called value types. When copying a value type, the CLR doesn't call a constructor, it just moves the bytes over one atomic chunk at a time. In practice, maybe the jitter has special registers available that allow it to move bigger chunks around, but that's not a guarantee of the C# language. The C# language only goes so far as to guarantee that the chunks are not smaller than four bytes.

Posted via email from Jasper-Net

Building your own Continuous Integration with Mule Cloud Connect and iON

As you probably already heard we launched Mule iON this week. If you ask one of our marketing guys what iON is, he will tell you that is the first cloud-based integration platform. iON will enable you to integrate popular SaaS applications, cloud services, social media, and a lot more without requiring any infrastructure.

Of course, I’m not a marketing guy, I’m a software developer. So my description is: “iON is awesome. It’s Mule on the cloud, and you are totally going to dig it”. Also, since I’m a software developer, I will put my money were my mouth is and I will show you how to build something incredible in a couple of minutes. Thats right! A few minutes and thats taking into account your learning curve of Mule iON.

Continuous Integration

If you are a software developer you probably heard about continuous integration. Continuous integration is the process of continuously verifying the quality of a software product. That means that instead of waiting until you are done to actually test a product you actually continuously test the quality as you develop it.

That is exactly what we are going to be building today. A Mule iON application that will do continuous integration of Maven-based projects. The application will connect to a database hosted at MongoHQ which will contain the list of applications to continuously integrate, then it will connect to their GitHub repositories, perform a clone of them locally and then invoke maven to actually build them.

So, the integration will be between GitHub, Mongo and Maven. In order to simplify this, we are going to be using the following components:

* MongoDB Connector

* Git Connector

* Maven Connector

Except for the MongoDB (which uses the original connector model) everything else was developed using our Mule Cloud Connect dev kit, and you will see how incredible easy it makes for you (the integration developer) to use different cloud services.

Creating a Windows Sidebar gadget for a SQL Server Reporting Services Report walkthrough

By default, after installing Window7 operation, there are many powerful and handy little tools in Sidebar Gadget, you can also download some customized Sidebar Gadget, such as: MSDN forum helper. Currently, we have some stock reports to show the real-time status of stock market, we also want to integrate SQL Reporting Services - stock report into window7’s Sidebar Gadget rather than open the IE all the time.

This article will walk you through the processes of integrating SQL Server Reporting Services into Windows 7 Sidebar Gadget.

Posted via email from Jasper-Net