Caught In A Web

My blog was forward to Microsoft (MS Israel Community)

2008-06-25T17:32:00.002+03:00

Hi All,
I forward my blog to MS Israel Community.

My new blog URL is: Rotem Bloom's Blog.

I want to say many thanks to Guy Burstein that helps me open the new blog.

Assembly Information work under .NET 2.0

2008-06-18T09:57:00.000+03:00

Hi All,
The Assembly Information tool is now also work under .NET 2.0.

You can download the setup from codeplex on the link below:
Assembly Information work under .NET 2.0

WCF Practices: Single point for WCF proxy calls

2008-06-17T09:11:00.000+03:00

Hi All,
Let's say you want that all your WCF proxy calls will come from one function. This could be very useful and save a lot of code.
For example you can write your proxy exception handling in one place.

Here is the code example that work on .NET framework 3.5 only:

// The public function that execute the WCF proxy call
public void WCFProxyCall()
{
CreateConferenceRequest r = new CreateConferenceRequest();

Func createFunc = a =>
proxy.CreateConference(a);

CreateConferenceResponse ci = ProxyWrapperOperation(createFunc, r);
}

// This is the single point function for the entire WCF proxy calls
// Here you can write code for all your WCF proxy calls.
private TResult ProxyWrapperOperation(Func operation, T parameter)
{
TResult result;
try
{
result = operation(parameter);
}
catch (TimeoutException timeProblem)
{
proxy.Abort();
throw;
}
catch (FaultException unknownFault)
{
throw;
}
catch (CommunicationException commProblem)
{
proxy.Abort();
throw;
}

return result;
}

.NET Assembly Information Tool is now on codeplex

2008-06-15T10:33:00.000+03:00

Hi All,
I wrote a nice .NET tool that display .net assembly information like:
1) Compilation mode Debug\Release.
2) .NET Assembly full name
3) .NET Assembly references

You must have .NET framework 3.5 install in order to work with .NET Assembly Information tool.

How to use:
After the installation you can point on any .NET Assembly (DLL), press right click and press on the new menu called: "Assembly Information".
A popup window with useful information on your Assembly will pops.

You can find it under:
.NET Assembly Information

svcutil with /r does not work for MessageContract

2008-05-12T18:29:00.000+03:00

Hi,
I was trying to generate WCF proxy (Client) using svcutil.exe from Visual Studio 2008. I also need to use the /r parameter of the svcutil.exe so the generated proxy code will not include the objetcs from my other internal assemblies.
The command I use is something like:
svcutil.exe /async http://localhost:8080/MyService /r:"C:\My.dll" /tcv:Version35 /out:MyClient.cs

I saw that if my .NET MessageContract objects on My.dll still exists on my generated proxy, so I have to change these objects to DataContract objects and then the generated proxy was correct.

You also need to remember that if your internal objects (on My.dll) contain objects form other internal assembly, You have to include this dll also in your svcutil command. So you new command will look like:
svcutil.exe /async http://localhost:8080/MyService /r:"C:\My.dll" /r:"C:\MyOtherObjects.dll" /tcv:Version35 /out:MyClient.cs

Your,
Rotem

Increasing WCF Client Applications Performance

2008-05-05T16:43:00.000+03:00

Some times your WCF client object are created on the Middle-Tier of the application.
This scenario leads for creating many WCF client objects quickly and, as a result, experience increased initialization requirements.

There are two main approaches to increasing the performance of middle-tier applications when calling services:
1. Cache the WCF client object and reuse it for subsequent calls where possible.
2. Create a ChannelFactory object and then use that object to create new WCF client channel objects for each call.

Issues to consider when using these approaches include:

- If the service is maintaining a client-specific state by using a session, then you cannot reuse the middle-tier WCF client with multiple-client tier requests because the service's state is tied to that of the middle-tier client.

- If the service must perform authentication on a per-client basis, you must create a new client for each incoming request on the middle tier instead of reusing the middle-tier WCF client (or WCF client channel object) because the client credentials of the middle tier cannot be modified after the WCF client (or ChannelFactory) has been created.

- While channels and clients created by the channels are thread-safe, they might not support writing more than one message to the wire concurrently. If you are sending large messages, particularly if streaming, the send operation might block waiting for another send to complete. This causes two sorts of problems: a lack of concurrency and the possibility of deadlock if the flow of control returns to the service reusing the channel (that is, the shared client calls a service whose code path results in a callback to the shared client). This is true regardless of the type of WCF client you reuse.

- You must handle faulted channels regardless of whether you share the channel. When channels are reused, however, a faulting channel can take down more than one pending request or send.

Link to MS article:
Middle-Tier Client Applications

Best Practices: How to Dispose WCF clients

2008-05-05T16:15:00.000+03:00

Use of the using statement (Using in Visual Basic) is not recommended for Dispose WCF clients. This is because the end of the using statement can cause exceptions that can mask other exceptions you may need to know about.

using (CalculatorClient client = new CalculatorClient())
{
...
} // <-- this line might throw
Console.WriteLine("Hope this code wasn't important, because it might not happen.");

The correct way to do it is:
try
{
...
client.Close();
}
catch (CommunicationException e)
{
...
client.Abort();
}
catch (TimeoutException e)
{
...
client.Abort();
}
catch (Exception e)
{
...
client.Abort();
throw;
}

How to add custom http header in WCF

2008-04-17T15:54:00.000+03:00

If you want to add custom http header web service calls, there is a simple way to do it in WCF. Here is the code:

MessageHeader header
= MessageHeader.CreateHeader(
"My-CustomHeader",
"http://myurl",
"Custom Header."
);

using (Service1Client client = new Service1Client())
{
using (OperationContextScope scope = new OperationContextScope(client.InnerChannel))
{
OperationContext.Current.OutgoingMessageHeaders.Add(header);

HttpRequestMessageProperty httpRequestProperty = new HttpRequestMessageProperty();
httpRequestProperty.Headers.Add("myCustomHeader", "Custom Happy Value.");
httpRequestProperty.Headers.Add(HttpRequestHeader.UserAgent, "my user agent");
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpRequestProperty;

}
}

ReaderWriterLockSlim Performance - Is it really so slim??!!!

2008-04-15T17:54:00.000+03:00

Hi,
On the .NET 3.5 Microsoft came up with new object named ReaderWriterLockSlim in order to achieve synchronised access to shared resources and also to improve the profermance issues that the old object (System.Threading.ReaderWriterLock) has.

Pedram Rezaei's wrote on his blog great post on Performance Comparison of ReaderWriterLockSlim.
On his performance tests he found that ReaderWriterLockSlim object is slower then the Monitor object.

Pedram Rezaei's conclusion:
"A reader-writer lock allows for multiple concurrent reads to enter a read-lock all at the same time and depending on the scenario, it can significantly improve the overall performance of your application when used instead of a mutual exclusive lock. A read-lock takes a shared lock and a write-lock takes an exclusive lock.

The new ReaderWriterLockSlim correctly gives priority to write requests therefore only use when reads are frequent and writes are less common."

You can take a look on his post here: A Performance Comparison of ReaderWriterLockSlim with ReaderWriterLock

Open VSS 2005 client without enter user name and password

2008-04-14T16:48:00.000+03:00

Hi,
If you want to set VSS (Visual Source Safe) 2005 client default user name and password without type them all the time, you have to do the following steps:
1) right click on VSS 2005 client icon
2) select properties
3) on the "target" at the end add your desire user name and pssword as follow:
-Y,
So you target shuold look like something like:
"C:\Program Files\Microsoft Visual SourceSafe\ssexp.exe" -YMyUser,123456.

This will open your source safe client with current user without opening the user password screen.

LINQ to SQL Visual LINQ Query Builder Visual Studio 2008 Add-In

2008-04-13T09:47:00.000+03:00

Visual LINQ Query Builder is an add-in to Visual Studio 2008 Designer that helps you visually build LINQ to SQL queries. Functionally it provides the same experience as, for instance the Microsoft Access Query Builder, but in the LINQ domain.
You can read more here:
LINQ to SQL Visual LINQ Query Builder

.NET Reflector add-ins

2008-02-03T07:56:00.000+02:00

.NET Reflector has a lot of useful add-ins. The list of all the add-ins can be found in CodePlex under the link below:
.NET Reflector add-ins

Stored Procs performance are better then Dynamic SQL. Is it A myth?

2007-11-04T22:22:00.000+02:00

People still thinks Stored Procedures are faster, even if there is much evidence that shows otherwise.

Andres Aguiar's wrote is his blog that: "Fortunately, when they go and ask the LinQ for SQL/Entities team they get the same answer than they get from me. They are not.
"

To add more evidence, a couple of weeks ago he was in Redmond in a meeting with the ADO.NET team, and a Tech Lead from that team wrote the code below and said 'this is the fastest way to execute this SQL sentence with the .NET framework today'.

SqlCommand cmd = sqlConnection.CreateCommand();
cmd.CommandText = @"
SELECT Sales PersonId, FirstName, HireDate
FROM SalesPerson as sp
INNER JOIN Employee AS e ON sp.SalesPersonID = e.EmployeeID
INNER JOIN Contact AS c ON e.EmployeeID = c.ContactID
WHERE e.HireDate < @date";
cmd.Parameters.AddWithValue("@date", date");

DbDataReader r = cmd.ExecuteReader();

Why is this _faster_ than a stored procedure? Because the SQL Server engine could select a better execution plan depending on the value of the @date parameter.

Even in that room there was people that were surprised.

So here are some points why not using stored procedures:
1. Stored Procedures are written in big iron database "languages" like PL/SQL (Oracle) or T-SQL (Microsoft). These so-called languages are archaic, and full of the crazy, incoherent design choices that always result from the torturous evolution of ten years of backwards compatibility. You really don't want to be writing a lot of code in this stuff. For context, JavaScript is a giant step up from PL/SQL or T-SQL.

2. Stored Procedures typically cannot be debugged in the same IDE you write your UI. Every time I isolate an exception in the procs, I have to stop what I am doing, bust out my copy of Toad, and load up the database packages to see what's going wrong. Frequently transitioning between two totally different IDEs, with completely different interfaces and languages, is not exactly productive.

3. Stored Procedures don't provide much feedback when things go wrong. Unless the proc is coded interally with weird T-SQL or PL/SQL exception handling, we get cryptic 'errors' returned based on the particular line inside the proc that failed, such as Table has no rows. Uh, ok?

4. Stored Procedures can't pass objects. So, if you're not careful, you can end up with a zillion parameters. If you have to populate a table row with 20+ fields using a proc, say hello to 20+ parameters. Worst of all, if I pass a bad parameter-- either too many, not enough, or bad datatypes-- I get a generic "bad call" error. Oracle can't tell me which parameters are in error! So I have to pore over 20 parameters, by hand, to figure out which one is the culprit.

5. Stored Procedures hide business logic. I have no idea what a proc is doing, or what kind of cursor (DataSet) or values it will return to me. I can't view the source code to the proc (at least, without resorting to #2 if I have appropriate access) to verify that it is actually doing what I think it is-- or what the designer intended it to do. Inline SQL may not be pretty, but at least I can see it in context, alongside the other business logic.

So why use Stored Procedures at all? Conventional wisdom says we do it because:
1. Stored procedures generally result in improved performance because the database can optimize the data access plan used by the procedure and cache it for subsequent reuse.

2. Stored procedures can be individually secured within the database. A client can be granted permissions to execute a stored procedure without having any permissions on the underlying tables.

3. Stored procedures result in easier maintenance because it is generally easier to modify a stored procedure than it is to change a hard-coded SQL statement within a deployed component.

4. Stored procedures add an extra level of abstraction from the underlying database schema. The client of the stored procedure is isolated from the implementation details of the stored procedure and from the underlying schema.

5. Stored procedures can reduce network traffic, because SQL statements can be executed in batches rather than sending multiple requests from the client.

one more interesting fact on Stored Procs:
Everyone who thinks stored procedures are pre-compiled, say "Aye!". Whoa, what a noise! For all of you who said "Aye!" a few seconds ago: open SqlServer's Books Online (v7 or v2000, doesn't matter), search for "cache execution plan". You'll find fine articles like "Execution Plan Caching and Reuse" and "SQL Stored Procedures". Let me just quote some lines from the "SQL Stored Procedures" article:

SQL Server 2000 and SQL Server version 7.0 incorporate a number of changes to statement processing that extend many of the performance benefits of stored procedures to all SQL statements. SQL Server 2000 and SQL Server 7.0 do not save a partially compiled plan for stored procedures when they are created. A stored procedure is compiled at execution time, like any other Transact-SQL statement. SQL Server 2000 and SQL Server 7.0 retain execution plans for all SQL statements in the procedure cache, not just stored procedure execution plans.

So what do you think? Is it a myth? :-)

.NET goodie #2: High Performance C# Code

2007-11-04T22:02:00.000+02:00

This article presents helpful tips for writing in-process .NET managed code that performs well. It's assumed that basic programming skills such as factoring control structures, pulling work outside of loops whenever possible, caching variables for reuse, use of the switch statement, and the like are known to the average reader.

Working with Objects and Value Types
Objects: A Double Whammy
Objects are expensive to use, partly because of the overhead involved in allocating memory from the heap (which is actually well-optimized in .NET) and partly because every created object must eventually be destroyed. The destruction of an object may take longer than its creation and initialization, especially if the class contains a custom finalization routine. Also, the garbage collector runs in an indeterministic way; there's no guarantee that an object's memory will be immediately reclaimed when it goes out of scope, and until it's collected, this wasted memory can adversely affect performance

The Garbage Collector in a Nutshell
It's necessary to understand garbage collection to appreciate the full impact of using objects. The single most important fact to know about the garbage collector is that it divides objects into three "generations": 0, 1, and 2. Every object starts out in generation 0; if it survives (if at least one reference is maintained) long enough, it goes to 1; much later, it transitions to 2. The cost of collecting an object increases with each generation. For this reason, it's important to avoid creating unnecessary objects, and to destroy each reference as quickly as possible. The objects that are left will often be long-lived and won't be destroyed until application shutdown.

Lazy Instantiation/Initialization
The Singleton design pattern is often used to provide a single global instance of a class. Sometimes it's the case that a particular singleton won't be needed during an application run. It's generally good practice to delay the creation of any object until it's needed, unless there's a specific need to the contrary - for instance, to pre-cache slow-initializing objects such as database connections. The "double-checked locking" pattern is useful in these situations, as a way to avoid synchronization and still ensure that a needed action is only performed once. Lazy initialization is a technique that can enhance the performance of an entire application through object reduction.

Avoiding Use of Class Destructors
Class destructors (implemented as the Finalize() method in VB.NET) cause extra overhead for the garbage collector, because it must track which objects have been finalized before their memory can be reclaimed. I've never had a need for finalizers in a purely managed application.

Casting and Boxing/Unboxing Overhead
Casting is the dynamic conversion of a type at runtime to another, and boxing is the creation of a reference wrapper for a value type (unboxing being the conversion back to the wrapped value type). The overhead of both is most heavily felt in collections classes, as they all - with the exception of certain specialized ones like StringDictionary - store each value as an Object. For instance, when you store an Int32 in an ArrayList, it is first boxed (wrapped in an object) when it is inserted; each time the value is read, it is unboxed before it is returned to the calling code. You can use generics to avoid Boxing/Unboxing.

Trusting the Garbage Collector
Programmers new to .NET sometimes worry about memory allocation to the point that they explicitly invoke System.GC.Collect(). Garbage collection is a fairly expensive process, and it usually works best when left to its own devices. The .NET garbage collection scheme can intentionally delay reclamation of objects until memory is available, and in particular longer-lived objects (those that make it to generation 1 or 2) may not be reclaimed for an extended period. Even a simple "Hello, world!" console application may allocate 15 MB or more of memory for its "working set." My advice: don't call GC.Collect() unless you really know what you're doing.

Properties, Methods, and Delegates
Avoiding Overuse of Property Getters and Setters
Most people don't realize that property getters and setters are similar to methods when it comes to overhead; it's mainly syntax that differentiates them. A non-virtual property getter or setter that contains no instructions other than the field access will be inlined by the compiler, but in many other cases, this isn't possible. You should carefully consider your use of properties; from inside a class, access fields directly (if possible), and never blindly call properties repeatedly without storing the value in a variable. All that said, this doesn't mean that you should use public fields!

About Delegates
Delegates are slower to execute than interface methods. Delegates are often used to introduce a level of indirection in code, but in almost all cases interfaces allow a cleaner design. Of course, it's impossible to completely shun delegates; the entire event-handling paradigm in .NET is based on them. Example 2 compares the performance of delegates and direct method calls.

Minimizing Method Calls
The .NET compiler is capable of performing many optimizations for release builds. One of them is called "method inlining." If method A calls method B and certain other conditions are met, such as the code in method B being small enough, the code from B will be copied into A during compilation. However, .NET won't or can't inline certain types of methods, such as virtual methods or methods over a certain size. Each method invocation/property access entails significant overhead, such as the allocation of a stack frame, etc. Of course, you should never repeatedly call a method for the same result on purpose, but you should also be mindful of the impact of method calls in general.

Using the 'Sealed' Keyword
Wherever extensibility is not required, you should use the sealed keyword. This makes your design easier to understand, as someone can tell at a glance if a certain class or method isn't meant to be extended or overridden. It also increases the chances that the compiler will inline code.

Working with Collections
Avoid Overuse of Collections
This might sound strange, but I'm not advocating working without data structures. The fact is, I've seen collections used many times when they don't actually simplify the code or provide any benefit at all. The single biggest avoidable use of collections is the use of an ArrayList when a simple array would suffice. It should be obvious that there's no way that calling a collection method - which may do significant work under the covers - can compare to something as simple as an array access for performance.

for vs foreach
The rumor abounds that the foreach loop is bad for performance. The truth is actually a little more complicated. Basically, foreach involves no performance penalty when used against arrays. However, when used against lists it involves the same overhead as creating an enumerator and using it within a try/catch block! Ildasm.exe may come in handy here to see what's going on. This isn't a complete killer, but if you do enough list access you may want to avoid it.

Enumerators: Don't Go Overboard
Just because the possibility exists for the enumerating of a collection doesn't mean you have to do it. For instance, the ArrayList class is useful as an array replacement; one of its best features is indexed element access. By using an enumerator with ArrayList, you hide its most useful features and introduce needless overhead.

Avoid Overuse of Collection Wrappers
A peek at the code in classes such as ArrayList shows that, to implement synchronized, fixed-size, and read-only versions of these, methods such as Synchronized() actually create a new wrapper list around the original one (this scheme was copied from Java). While this is nice from certain design standpoints, it degrades performance; the method-call overhead for each operation is multiplied. For a fixed-size, synchronized ArrayList, this overhead is tripled! Chances are, if you're working with a collection and need synchronization, the code using the collection is already synchronized. In any case, simply locking on the collection itself around every access turns out to be faster than using a synchronized wrapper.

Working With Strings
Don't Use String.Format() to Concatenate Strings
While string-formatting routines built into .NET are very useful for globalization and other tasks, they're not meant to be used for appending strings to each other.

Use StringBuilder to Build Strings Inside Loops
The StringBuilder class is basically an array list for string fragments; the StringBuilder takes care of expanding its internal char array, hiding this from the user. The use of this class is also specially optimized by the .NET compiler, making it impossible to duplicate this functionality with equivalent performance (for instance, by manipulating char arrays directly and converting to a string afterwards).

Don't Use StringBuilder to Concatenate Small Numbers of Strings
Many .NET developers who consider themselves well-versed in performance matters advocate the use of the StringBuilder class whenever possible. However, it's not the fastest approach for concatenating small numbers of strings. Actually, any number can be combined in a single statement, although the performance benefit tends to dwindle above five or six substrings. This is due to instantiation and destruction overhead for the StringBuilder instance, as well as method-call overhead involved in calling Append() once for every added substring and ToString() once the string is built. What are the alternatives? Plus-sign concatenation and the String.Concat() method are equivalent; I prefer plus signs for readability. Note that this cannot be used across loops because the entire concatenation must occur within a single statement.

Don't Be Afraid to Use String Literals
Many developers incorrectly assume that a new object is created for every string literal, and, therefore, avoid their use. In some cases, using string literals directly in your code is a better approach than using string constants! It can make the code easier to understand and has no adverse impact on performance. This is due to the use of the .NET interned string table; this table maintains a String instance for every known string and reuses this instance whenever the same character sequence is used as a literal. See the documentation of the String.Intern() method for more details.

Threading
In itself, this is a huge topic. Most easy-to-apply, synchronization-related optimizations focus on minimizing the amount of code executing inside synchronized blocks, which may involve moving some code from inside to outside such blocks. In some cases, thoughtful programming may allow elimination of synchronization entirely from a class (see "Immutable Objects").

Performing a multithreaded micro-benchmark is more complicated than running a simple loop. In the simplest method, multiple threads are spawned, each looping over the benchmarked code; the reading is not started until all threads are successfully executing the code, and is terminated before the threads are shut down.

Thread Reuse
Newbie programmers make the common mistake of spawning a new thread for every request or other action. This can result in worse performance than using a single-threaded approach; the relative performance degradation is worse the quicker the individual requests can be serviced.

Writing Your Own Threading Code
Even better than the .NET thread pool, with its dependence on delegates, is to write your own threading code. Instead of using QueueUserWorkItem(), you typically write your own queueing code to coordinate work items. This also allows other benefits such as priority-based queueing.

Immutable Objects
Immutable objects are objects in which the data cannot be changed. In most cases, this is achieved by setting all fields in constructor methods and providing only property getters and/or methods that retrieve data from the object, without any mutator logic whatsoever. Many classes in the .NET Common Type System are immutable: System.String, System. Drawing.Font, etc. In addition, care should be taken that any values returned from property accessors, etc. are immutable as well. Otherwise, this data may be copied to insure the integrity of the object itself.

Data Copying
This flies in the face of the advice given earlier, to minimize the use of objects. However, it's really the other side of the coin from immutable objects. Object copying allows you to use the data in a non-immutable object, but in a way that still completely avoids synchronization. The more highly multithreaded the environment, the more strategies like this make sense.

Read-Write Locks
Synchronization issues in managed code mirror those in databases. In some situations, optimistic concurrency strategies can be used; in some dirty reads are acceptable, etc. For situations in which a structure is seldom updated and often read, the ReaderWriterLock class can give significant performance benefits over simple synchronization. It allows either multiple read access or single write access at once.

Minimizing Synchronized Blocks
The use of the [MethodImpl Attribute(MethodImplOptions.Synchronized)]attribute should be avoided, as it always locks an entire method and is also non-standard C# usage. Instead, the lock keyword or one of the System.Threading classes should be used. Wherever possible, adjust the start of a synchronized section forward and the end backward. Do whatever you can to decrease the number of synchronized operations.

Hope you find this article interesting. I think it really important to understand and know how to right efficient C# code.

Yours,
Rock Rotem Bloom

.NET goodie #1: Declaring variables inside or outside of a loop impact performance?

2007-11-01T16:32:00.000+02:00

Did you ever wonder......
Is there any difference in terms of performance between declaring a variable outside of a loop like this...

string str = "";

for (int i = 0; i < 10; i++)

{

str = "hello";
}

...versus declaring the variable within a loop and using it like this:

for (int i = 0; i < 10; i++)

{

string str = "hello";
}

So what do you think???!!! The asnwer in this case will be:

The first example is actually slower, because it causes one more string allocation to occur. In c# the "creation" of variables is always moved to the top of methods in the compiled IL. Therefore your second example is exactly the same performace as:

string str;

for (int i = 0; i < 10; i++)

{

str = "hello";
}

Notice this does not assign an initial value to str of "".

SQL Formatter, beautified SQL statements

2007-11-01T15:50:00.000+02:00

Hi,
There is a free SQL formatter that supports several databases like:
oracle, mssql, db2, mysql etc...

You can take a large SQL statement with parameters and the "SQL Formatter" will beautified the SQL statement for you. It will add line breaks and more.

You can found the cool SQL Formatter here.

Great tool for SQL debugging.

Cross site Ajax plugin for Prototype

2007-10-30T10:11:00.000+02:00

Thierry Schellenbach has implemented a Prototype plugin that allows you to do cross site remoting using the dynamic script tag method that other frameworks such as Dojo and jQuery have supported for awhile.

You can implement this by simply setting crossSite: true as a config parameter to Ajax.Request.

Code example:

new Ajax.Request('myurl', {
method: 'GET',
crossSite: true,
parameters: Form.serialize(obj),
onLoading: function() {
//things to do at the start
},
onSuccess: function(transport) {
//things to do when everything goes well
},
onFailure: function(transport) {
//things to do when we encounter a failure
}
});
the full information can be found on Thierry Schellenbach blog.

JavaScript Image effect library

2007-08-07T12:00:00.000+03:00

Christian Effenberger wrote nice JavaScript library that let you apply an image mask (in the form of another image) to any image via unobtrusive CSS.

You can take a peek:
http://www.netzgesta.de/corner/

JavaScript accordion component

2007-07-17T12:44:00.000+03:00

Kevin Miller wrote nice accordion component that use protoype.js.
The component work both ways horizontal and vertical.

Information can be found on the link below:
accordion component

Tooltip effect using Script.aculo.us

2007-07-11T10:57:00.000+03:00

Nick Stakenburg has written a nice simple tooltip built on Script.aculo.us called Effect.Tooltip

Cool and very simple to use

DP_Debug JavaScript Debugging Extensions

2007-06-24T15:15:00.000+03:00

Jim Davis has released a simple little JavaScript dumping library, DP_Debug, that supports circular and recursive references, most system objects and specifies certain otherwise ambiguous conditions.

In addition the library allows for simple access to Query String and Cookie values and provides basic logging, code timing support and program integration support.

Full information can be found:
http://www.depressedpress.com/Content/Development/JavaScript/Extensions/DP_DeBug/
:-)

Jayrock JSON and JSON-RPC for .NET

2007-05-04T18:45:00.000+03:00

Jayrock is a modest and an open source implementation of JSON and JSON-RPC for the Microsoft .NET Framework, including ASP.NET. What's so modest about it? Well, modest as in plain and basic and no work of genius.

A developer creates a helloworld.ashx that contains your server side logic:

C#:

namespace JayrockWeb
{
using System;
using System.Web;
using Jayrock.Json;
using Jayrock.JsonRpc;
using Jayrock.JsonRpc.Web;

public class HelloWorld : JsonRpcHandler
{
[ JsonRpcMethod("greetings") ]
public string Greetings()
{
return "Welcome to Jayrock!";
}
}
}

Then you can access the file asking for a proxy via helloworld.ashx?proxy and you will see a test page. From code you can now:

JavaScript:

var s = new HelloWorld();

alert("sync:" + s.greetings());

s.greetings(function(response) {
alert("async:" + response.result) });

Validators inside UpdatePanel won't work as expected

2007-04-26T17:48:00.000+03:00

Hi,
If you work with controls such as .NET Validators placed inside an UpdatePanel you probably know they won't work as expected.

Until Microsoft will solve this issue you can use the "ASP.NET AJAX Validators" that can be download from here:
1) Site 1: http://blogs.msdn.com/mattgi/attachment/1516974.ashx
2) Site 2: http://forums.asp.net/forums/storage/1007/1545781/Validators.zip

More information on asp.net forums

I hope it helps :-)
Bye Rotem

Controls that Are Not Compatible with UpdatePanel Controls

2007-04-26T17:43:00.000+03:00

Hi All,

The following ASP.NET controls are not compatible with partial-page updates, and are therefore not supported inside an UpdatePanel control:

TreeView and Menu controls.

Web Parts controls. For more information, see ASP.NET Web Parts Controls.

FileUpload controls when they are used to upload files as part of an asynchronous postback.

GridView and DetailsView controls when their EnableSortingAndPagingCallbacks property is set to true. The default is false.

Login, PasswordRecovery, ChangePassword, and CreateUserWizard controls whose contents have not been converted to editable templates.

The Substitution control.

Validation controls, which includes the BaseCompareValidator, BaseValidator, CompareValidator, CustomValidator, RangeValidator, RegularExpressionValidator, RequiredFieldValidator, and ValidationSummary control.

Controls that are incompatible with partial-page rendering can still be used on a page outside UpdatePanel
controls. Additionally, in some cases you can use the controls in a
specific way to make them compatible with partial-page updates. For
example, you can use the Login, ChangePassword, or PasswordRecovery controls inside an UpdatePanel
control if you can convert their contents to templates. (If you are
using Visual Studio, in Design view you can convert the controls by
using smart-tag menu commands such as Convert to Template or Customize Create User Step.)
When you convert these controls into editable templates, the validation
controls that are used in the control are defined declaratively by
using markup in the page. To make the validators compatible with an UpdatePanel control, set the EnableClientScript property of the validators to false.
This disables the client script that would ordinarily be used to
perform validation in the browser. As a result, during an asynchronous
postback, the validators perform validation on the server. However,
because only the content of the UpdatePanel is refreshed, the validators can provide the kind of immediate feedback that is ordinarily provided by client script.

To use a FileUpload control inside an UpdatePanel control, set the postback control that submits the file to be a PostBackTrigger control for the panel.

All other controls work inside UpdatePanel controls. However, in some circumstances, a control might not work as expected inside an UpdatePanel control. These circumstances include the following:

Registering script by calling registration methods of the ClientScriptManager control.

Rendering script or markup directly during control rendering, such as by calling the Write(String) method.

If the control calls script registration methods of the ClientScriptManager control, you could use corresponding script registration methods of the ScriptManager control instead. In that case, the control can work inside an UpdatePanel control.

Prototype Library that helps store JSON data in cookies

2007-04-14T14:14:00.000+03:00

Lalit Patel wrote JavaScript Library that helps to use JSON to store data in cookies.
The nice library is built on top of Prototype and gives you a simple API to put and get JSON values into cookies.

Full information and download:
Yummy JSON Cookies (using Prototype)

Code Example:
var jar = new CookieJar({
expires:3600, // seconds
path: '/'
});

var dog = {name: 'Jacky', breed: 'Alsatian', age:5};

jar.put('mydog', dog);
mydog = jar.get('mydog');

alert("My dog's name is " + mydog.name);
alert("He is " + mydog.age + " years old");
alert("He is an " + mydog.breed);

Enjoy :-)

Rules For JavaScript Library Authors

2007-03-28T16:21:00.000+02:00

Dean Edwards wrote a nice article on "Rules For JavaScript Library Authors".
His main points are:
1) Be unobtrusive:
My HTML doesn’t want to know about your JavaScript

2) Object.prototype is verboten!
This is so important that it needs a rule all to itself. Objects are the basic building blocks of JavaScript functionality. Don’t mess with them

3) Do Not Over-extend
The less you extend JavaScript’s built-in objects the better. Don’t get me wrong. Native JavaScript objects are a little sparse on useful methods. You will feel obliged to add one or two of your own. But “one or two” is not enough for the creative (library) programmer. Stop! Just add what you need. The less you extend JavaScript’s built-in objects the less you will clash with other libraries.

4) Follow Standards
As a library writer you are defining patterns of JavaScript code. Patterns are signs of weakness in programming languages. Remember, JavaScript and the DOM are continually being specified. If you are going to “fix” something then look to see if it has not already been fixed. Consider available solutions. If you follow standards, then follow them closely (e.g. don’t skip a parameter on a forEach method).

5) Or Follow The Leader
Mozilla leads the way in JavaScript. The creator of the language, Brendan Eich, continues to develop it. New language features are available in Mozilla browsers before any other. If you are going to add language features to JavaScript then look to Mozilla standards first. For example, if you want to extend Array to allow an enumeration method, then call that method forEach instead of each. If you do provide missing language features then follow existing standards closely.

6) Be Flexible
What if I want to modify behaviour without changing the source code of your library? How easy is that? Not easy enough. Make it easier.

7) Manage Memory
People care about memory leaks. Do your job

8) Eliminate Browser Sniffing
It seems that browser vendors will forever compete by adding new features. As a library author you must keep up with the latest fashions. It is not good enough to browse Ajaxian occasionally. You must slavishly read every blog to find the next hack. Browser sniffing can be addictive

9) Small is Better
JavaScript libraries have come of age. Some of them now power premier sites. But we are not all on 2MBit DSL lines. So keep your library small. Better yet, provide a build page that allows me to efficiently build my library according to my needs.

10) The Tenth Rule
Good ol’ tenth rule. You can always rely on the tenth rule. The tenth rule is: be predictable. I should be able to guess what your methods do. And if I don’t know what a method is called then I should be able to guess that too.

11) Bonus Rules
* Documentation. Annoying but true.
* The more namespacing you use, the less likely I am to remember your phone number.
* Remember that potentially millions of people will be executing your code.

The article is a must read for web 2.0 programmers.

The full article:
Rules For JavaScript Library

Control.Modal: Great CSS Modal Windows and Lightboxes in one package

2007-03-28T15:27:00.000+02:00

Ryan Johnson has created Control.Modal (CSS modal window based on the Prototype library).

It weighs in at around 8K and hit a sweet spot for some functionality. The Prototype
window class was overkill, and he needed more than just a lightbox

Example and source code can be found here: Control.Modal

Efficient looping in Javascript

2007-03-19T15:34:00.000+02:00

Hi Guys,
I read a great article that talk about the Efficient looping in Javascript.
If you are a big fan of Javascript Libraries like Prototype and Mootools, this article will show you the performance problems of some of these Libraries Iterating like:
Array.each()
Native For-Loop
Native For-In-Loop
Prototype Each-Loop

etc.....

Efficient looping in Javascript

Cross Browser Keyboard Support

2007-03-19T15:23:00.000+02:00

First here is an excellant article on keystroke detection keystroke detection

Here is the code in order to support Cross Browser Keyboard:


document.onkeydown = function(e) {handleKeys(e)}
document.onkeypress = function(e) {handleKeys(e)}
var nonChar = false;

function handleKeys(e) {
    var char;
    var evt = (e) ? e : window.event;       //IE reports window.event not arg
    if (evt.type == "keydown") {
        char = evt.keycode;
        if (char < 16 ||                    // non printables
            (char > 16 && char < 32) ||     // avoid shift
            (char > 32 && char < 41) ||     // navigation keys
            char == 46) {                   // Delete Key (Add to these if you need)
            handleNonChar(char);            // function to handle non Characters
            nonChar = true;
        } else
            nonChar = false;
    } else {                                // This is keypress
        if (nonChar) return;                // Already Handled on keydown
        char = (evt.charCode) ?
                   evt.charCode : evt.keyCode;
        if (char > 31 && char < 256)        // safari and opera
            handleChar(char);               //
    }
    if (e)                                  // Non IE
        Event.stop(evt);                    // Using prototype
    else if (evt.keyCode == 8)              // Catch IE backspace
        evt.returnValue = false;            // and stop it!
}

CSS+Javascript Fancy menu

2007-03-19T15:16:00.000+02:00

If you are looking for cool javascript+CSS menu, you can found one right here on link below:
devthought.com

I found it when I was surfing and looking for cool javascript and CSS stuff.

Cache Manager plug-in for ASP.NET

2007-03-11T18:54:00.000+02:00

Hi Guys,
Steven Smith wrote Cache Manager for an ASP.NET application.
"Cache Manager is an ASP.NET plug-in which can be added to any ASP.NET website with no code, no recompile, a single DLL, and a single entry in web.config. It allows web administrators to monitor and manage the ASP.NET Cache object for their ASP.NET applications."

More information and download:
Cache Manager

Hope it will be useful :-)

Compressed versions of Prototype

2007-03-11T17:59:00.000+02:00

John-David Dalton Compressed some prototype version like:
1.4, 1.5rc0, 1.5rc1, 1.5 final.
His package can be download from:
Compressed prototype

He managed to get it down to 14.4kb.

ASP.NET JavaScript IntelliSense

2007-03-07T20:11:00.000+02:00

A new release of Visual Studio “Orcas” shows off the intellisense features nicely, including:
1) Proactive Completion List: No more waiting for ‘.’
2) Keywords in Completion List: fun your way to function
3) ASP.NET AJAX Concepts in Completion List: Direct support for Atlas
4) IntelliSense from Script Libraries for ASPX Pages: Now you can see objects that exist in other external script files.

This comes along with the release of an updated Ajax Control Toolkit.

more information:
blogs.msdn.com

How work with multiple versions of IE on your PC

2007-02-18T18:53:00.000+02:00

Hi,
Ever wanted to test your website in various versions of Internet Explorer?
As a web developer I often want to work with multiple versions of IE on one machine.

It is possible to run Internet Explorer in standalone mode without having to over-write previous versions thanks to Joe Maddalone

Full in formation and download can be found on:
TredoSoft web site.

Compressing http traffic

2007-02-18T18:47:00.000+02:00

Some nice articles explain about Compressing HTTP traffic:
10 Tips for Writing High-Performance Web Applications look for Tip 9

MSDN article on how to configure Internet Information Services (IIS) 5.0 to compress .aspx pages

another article about turning on the compression built into IIS6 (over Win 2003).

JavaScript Performance Validator

2007-02-18T18:33:00.000+02:00

Hi,
There is great "JavaScript Performance Validator" tool that provides automatic source code performance analysis (profiling) of applications as they run.
Currently the tool works with Mozilla Firefox 1.0.6, Mozilla Firefox 1.5 and Flock 0.7. At present they cannot support Internet Explorer, although they want to support Internet Explorer.

More information can be found on the company (software verify) web site:
JavaScript Performance Validator

Even if you work with Internet Explorer and your application can also run with Mozilla this tool can help you, because often the performance problems are the same in both browsers.

Microsoft announces the ASP.NET Ajax 1.0 Release

2007-01-24T01:33:00.000+02:00

Microsoft has announced the final 1.0 release of ASP.NET Ajax (a.k.a. Atlas).

ASP.NET AJAX Control Toolkit
In addition to the fully-supported ASP.NET AJAX 1.0 release, you can use the more than 30 free ASP.NET AJAX enabled controls available within the ASP.NET AJAX Control Toolkit

HttpUtility.HtmlEncode and Server. HtmlEncode do not prevent Cross Site Scripting

2007-01-11T17:07:00.000+02:00

Do not use: HttpUtility.HtmlEncode or Server.HtmlEncode because this functions only encodes <>"& characters. This is not sufficient to protect against all possible attacks.
For instance, the following ASP.NET code would be vulnerable:

<br />' src='/image.gif' /><br /><br />An attacker could inject client-side script here by setting userId to:' onload=alert('xss') alt='<br />

In order to be fully protected use the method: HtmlEncode of Microsoft Anti-Cross Site Scripting Library.

Tutorial that shows you how to use the Microsoft Anti-Cross Site Scripting Library:
http://msdn2.microsoft.com/en-us/library/aa973813.aspx

Forum:
http://forums.asp.net/1107/ShowForum.aspx.

moo.fx javascript effects library for prototype.js or mootools framework.

2006-12-14T15:57:00.000+02:00

moo.fx is a superlightweight, ultratiny, megasmall javascript effects library, to be used with prototype.js or the mootools framework.
It's very easy to use, blazing fast, cross-browser, standards compliant, provides controls to modify any CSS property of any HTML element, including colors, with builtin checks that won't let a user break the effect with multiple, crazy clicks. Optimized to make you write the lesser code possible, the new moo.fx is so modular you can create any kind of effect with it.

more information on moo.fx:
http://moofx.mad4milk.net/

Terminals the right answer for Remote Desktop Connection

2006-12-12T10:36:00.000+02:00

2 friends of mine Dudu shmaya and Eyal Post wrote a great tool "Terminals".
"Terminals is a multi tab terminal services/remote desktop client. It uses Terminal Services ActiveX Client (mstscax.dll).The project started from the need of controlling multiple connection simultaneously."

Download:
http://www.codeplex.com/Terminals/Release/ProjectReleases.aspx

Dudu's Not So Smart Builder Blog:
http://notsosmartbuilder.blogspot.com/

Eyal's Blog:
http://www.epocalipse.com/blog/

Prototype Event Extension: Event.wheel(e)

2006-12-07T11:41:00.000+02:00

Frank Monnerjahn created a Prototype Event extension which makes it trivial to use the mouse wheel in Prototype with Event.observe(..).
The demo shows this in action.
The Code:

/*
* Orginal: http://adomas.org/javascript-mouse-wheel/
* prototype extension by "Frank Monnerjahn" themonnie @gmail.com
*/

extend(Event, {

wheel:function (event){

var delta = 0;

if (!event) event = window.event;

if (event.wheelDelta) {

delta = event.wheelDelta/120;

if (window.opera) delta = -delta;

} else if (event.detail) { delta = -event.detail/3; }

return Math.round(delta); //Safari Round

}

});

/*

* end of extension

*/

var counterSite=0;

function handleSite(e) {

counterSite += Event.wheel(e);

$('delta').innerHTML = counterSite +'#'+ Event.wheel(e) + ": " + (Event.wheel(e) <0 ? 'down' : 'up' );

}

var counterDIV=0;

function handleDIV(e) {

counterDIV += Event.wheel(e);

$('divdelta').innerHTML = counterDIV +'#'+ Event.wheel(e) + ": " + (Event.wheel(e) <0 ? 'down' : 'up' );

}

Usage:
Event.observe(document, "mousewheel", handleSite, false);

Event.observe(document, "DOMMouseScroll", handleSite, false); // Firefox

Event.observe($('divdelta'), "mousewheel", handleDIV, false);

Event.observe($('divdelta'), "DOMMouseScroll", handleDIV, false); // Firefox

W3C DOM vs. innerHTML performance

2006-12-03T17:37:00.000+02:00

On of the most important issue developer has to think of when he writes WEB 2.0, AJAX application is JavaScript and browser performance.
I found great test page that intended to find out which method of generating large amounts of content is fastest in the browsers. Of course the results differ significantly from browser to browser.
W3C DOM vs. innerHTML
I hope this link will help improve your client code performance.

More information on JavaScript performance can be on:
The Microsoft Internet Explorer Weblog

Unlocker the tool for you

2006-12-03T17:34:00.000+02:00

Cannot delete file: Access is denied
There has been a sharing violation.
The source or destination file may be in use.
The file is in use by another program or user.
Make sure the disk is not full or write-protected and that the file is not currently in use.

Unlocker is the solution for you
Download and information:
Unlocker

Tools and Software Components for the .NET Framework

2006-12-03T17:14:00.000+02:00

Every developer loves Tools and Software Components that make his life easier.
On of the most updated list of tools, that also explain each on of them, can be found under:
http://www.dotnetframework.de/dotnet/produkte/tools.aspx?t=tools&kat=

Enjoy :-)

Understanding and Solving Internet Explorer Leak

2006-12-03T17:03:00.000+02:00

Hi,
Web 2.0 application use a lot of JavaScript code, so it's really important to understand how to write your JavaScript code in order to avoid browser memory leaks.
Great MSDN article on this issue can be found:
http://msdn2.microsoft.com/en-us/library/aa701095.aspx

More information can be found:
http://simon.incutio.com/slides/2006/etech/javascript/js-reintroduction-notes.html#memoryleaks

Drip is a nice tool that help find IE memory leaks:
http://outofhanwell.com/ieleak/index.php?title=Main_Page

Developer Notes for prototype.js

2006-12-03T16:58:00.000+02:00

Hi,
Here is a great link that have full explanation on prototype.js, can used as Developer Notes.
http://www.sergiopereira.com/articles/prototype.js.html

JavaScript AJAX framework prototype dissected

2006-12-03T16:42:00.000+02:00

Detail every method and property that was available on prototype AJAX framwork:
http://snook.ca/archives/javascript/prototype_disse/

How to add JavaScript and CSS file declaration in ASP.NET 2.0 head tag

2006-11-28T17:04:00.000+02:00

Code example in C# that show how to add JavaScript and CSS file declaration to ASP.NET runat server tag:

private const string JavaScriptIncludeTemplate = "script language='JavaScript' src='{0}' type='text/javascript' /script";

string includeLocation;
includeLocation = System.Web.VirtualPathUtility.ToAbsolute("~/JS/Test.js");

// Check that we have header runat=server on page
if ((System.Web.UI.HtmlControls.HtmlHead)Page.Header != null)
{
// Look if file declaration not already exist in page
if (((System.Web.UI.HtmlControls.HtmlHead)Page.Header).FindControl(key) == null)
{
LiteralControl include = new LiteralControl(String.Format(JavaScriptIncludeTemplate, includeLocation));
include.ID = key;

// Add the file declaration to page
// You can also use Controls.AddAt(addAt, include) to control the order of the JS file registration.
((System.Web.UI.HtmlControls.HtmlHead)Page.Header).Controls.Add(include);
}
}

JavaScript actsAsAspect

2006-11-28T16:27:00.000+02:00

The idea is that you run actsAsAspect() on any JavaScript object,
and then your object receives 3 extra methods:

before()
after()
around()

You then can use those methods to setup the callbacks you need.

The Code:
function actsAsAspect(object) {
object.yield = null;
object.rv = { };
object.before = function(method, f)
{
var original = eval("this." + method);
this[method] = function()
{
this.rv[method] = f.apply(this, arguments);
if (this.rv[method] == false)
return false;
return original.apply(this, arguments);
};
};
object.after = function(method, f)
{
var original = eval("this." + method);
this[method] = function()
{
this.rv[method] = original.apply(this, arguments);
return f.apply(this, arguments);
}
};
object.around = function(method, f)
{
var original = eval("this." + method);
this[method] = function() {
this.yield = original;
return f.apply(this, arguments);
}
};
}

Example: Applying actsAsAspect() to window

actsAsAspect(window);
function haha() { return "HA Ha ha ha..."; }
after('haha', function() { alert(this.rv['haha']); });
haha();

Full information can be found:

http://beppu.lbox.org/articles/2006/09/06/actsasaspect