Technoart

How to Suppress / Disable Script Errors in WebBrowser Control

2011-01-13T05:10:00.000-08:00

If you want to suppress script errors in web browser control in .net just do two things

1> Set web browser control property ScriptErrorsSuppressed = True
2> set below option in IE
i) Disable Script Debugging (Internet Explorer) and
ii) Disable Script Debugging (Other).

HashSet VS SortedSet

2010-11-25T22:03:00.000-08:00

Today I come across a good article explaining the difference between HashSet VS SortedSet collections in .net

Below is the link of original article
http://msdn.microsoft.com/en-us/vcsharp/ee906600.aspx

The .NET 4.0 library includes an additional collection class: The SortedSet.
SortedSet will typically be faster than HashSet when the majority of your operations require enumerating the set in one particular order. If, instead, most of the operations are searching, you’ll find better performance using the HashSet. The frequency of insert operations also has an effect on which collection would be better. The more frequently insert operations occur, the more likely HashSet will be faster.

LINQ – In-Memory Collections

2010-11-08T02:18:00.000-08:00

LINQ – In-Memory Collections

In this article we will cover only the querying of in-memory collections.

This article has been designed to give you a core understanding of LINQ that we will rely heavily on in subsequent parts of this series.

Before diving into the code it is essential to define what LINQ actually is. LINQ is not C# 3.0, and vice versa. LINQ relies heavily on the new language enhancements introduced in C# 3.0; however, LINQ essentially is the composition of many standard query operators that allow you to work with data in a more intuitive way regardless of the data source.

The benefits of using LINQ are significant – queries are a first class citizen within the C# language, benefit from compile time checking of queries, and the ability to debug (step through) queries. We can expect the next Visual Studio IDE to take full advantage of these benefits – certainly the March 2007 CTP of Visual Studio Orcas does!

In-Memory Collections

The best way to teach new technologies is to just to show you an example and then explain what the heck is going on! – That will be my approach throughout this series; hopefully it is a wise decision.

For our first example we will compose a query to retrieve all the items in a generic List collection (Fig. 1).

Figure 1: Selecting all the items in a generic List collection

private static List<string> people = new List<string>()

  "Granville", "John", "Rachel", "Betty",

  "Chandler", "Ross", "Monica"

};

public static void Example1()

  IEnumerable<string> query = from p in people select p;

  foreach (string person in query)

    Console.WriteLine(person);

The code example given in Fig. 1 is very basic and its functionality could have been replicated easier by simply enumerating through the items in the List via a foreach loop.

In Fig.1 we compose a query that will return each of the items in the people List collection by aliasing the people collection with a variable p and then selecting p (p is of type string remember as the people List is a collection of immutable string objects).

You may notice that query is of type IEnumerable - this is because we know that query will hold an enumeration of type string. When we foreach through the query the GetEnumerator of query is invoked.

At this time it is beneficial to look at exactly what the compiler generated code looks like (Fig. 2).

Figure 2: Compiler generated code for Fig. 1

public static void Example1()

  IEnumerable<string> query = people.Select<string, string>(delegate (string p)

    return p;

});

  foreach (string person in query)

    Console.WriteLine(person);

Fig. 2 reveals that our query has actually been converted by the compiler to use an extension method (in this case just the Select extension method is used) taking a delegate as its argument.

You will find that queries and lambda expressions are simply a facade that we deal with in order to make our lives easier – under the covers the compiler is generating the appropriate code using delegates. Be aware of this internal compiler behavior!

Also be aware that a cached anonymous delegate method is generated at compile time as well (Fig. 3) – we will discuss this particular feature in future articles.

Figure 3: Compiler generated cached anonymous delegate method

[CompilerGenerated]

private static Func<string, string> <>9__CachedAnonymousMethodDelegate1;

We will now take a look at a more complex query of the same collection which retrieves a sequence of all strings in the List whose length is greater than 5(Fig. 4).

Figure 4: A more complex query

public static void Example2()

  IEnumerable<string> query = from p in people where p.Length > 5

  orderby p select p;

  foreach (string person in query)

    Console.WriteLine(person);

The example in Fig. 4 relies on the use of two other standard query operators – Where and orderby to achieve the desired results.

If we examine the code generated by the compiler for the Example2 method you will see that shown in Fig. 5 – notice as well that we now have another two cached anonymous delegate methods (Fig. 6) – each of which having the type signature of their corresponding delegates (Where delegate and orderby delegate).

Figure 5: Compiler generated code for Fig. 4

public static void Example2()

  IEnumerable<string> query = people.Where<string>(delegate (string p)

    return (p.Length > 5);

  }).OrderBy<string, string>(delegate (string p)

    return p;

});

  foreach (string person in query)

    Console.WriteLine(person);

Figure 6: Cached anonymous delegate methods for their respective Where and orderby delegates defined in Fig. 5

[CompilerGenerated]

private static Func<string, bool> <>9__CachedAnonymousMethodDelegate4;

[CompilerGenerated]

private static Func<string, string> <>9__CachedAnonymousMethodDelegate5;

The type signature of the Where delegate (Fig. 5) is Funcdelegate takes a string argument and returns a bool depending on whether the string was greater than 5 characters in length. Similarly the orderby delegate (Fig. 5) takes a string argument and returns a string.

Linq query operators :Part 3

2010-11-08T02:11:00.000-08:00

AsEnumerable Operator

I found the AsEnumerable operator to be really important in understanding where the query gets executed, meaning is it going to get converted to SQL and the query would be performed on SQL server or LINQ to objects would be used and query would be performed in memory. The ideal use I have found for AsEnumerable would be when I know that a certain functionality is not available in SQL server, I can perform part of the query using LINQ to SQL (Iqueryable) and the rest executed as LINQ to objects (IEnumerable<T>). Basically, AsEnumerable is a hint to perform this part of the execution using LINQ to objects. This is how the prototype looks:

public static IEnumerable AsEnumerable(

this IEnumerable source);

The prototype operates on the source of IEnumerable<T> and also returns an IEnumerable<T>. This is because standard query operators operate on IEnumerable<T>, whereas LINQ to SQL operates on IQueryable<T>, which also happens to implement IEnumerable<T>. So when you execute an operator like on an IQueryable <T> (domain objects), it uses a LINQ to SQL implementation for the where clause. As a result, the query gets executed on SQL Server. But what if we knew in advance that a certain operator would fail on SQL Server since SQL Server has no implementation for it. It's good to use the AsEnumerable operator to tell the query engine to perform this part of the query in memory using LINQ to objects. Let's see an example:

public static void AsEnumerableExample()

{

NorthwindDataContext db = new NorthwindDataContext();

var firstproduct = (from product in db.Products

where product.Category.CategoryName == "Beverages"

select product

).ElementAt(0);

Console.WriteLine(firstproduct.ProductName);

}

When you run this query, it would throw an exception saying that elementat is not supported because SQL Server does not know how to execute elementAt. In this case, when I add as enumerable, the query would execute fine as follows:

public static void AsEnumerableExample()

{

NorthwindDataContext db = new NorthwindDataContext();

var firstproduct = (from product in db.Products

where product.Category.CategoryName == "Beverages"

select product

).AsEnumerable().ElementAt(0);

Console.WriteLine(firstproduct.ProductName);

}

DefaultIfEmpty

The DefaultIfEmpty operator returns a default element if the input sequence is empty. If the input sequence is empty, the DefaultIfEmpty operator returns a sequence with a single element of default (T) which, for reference types, is null. Furthermore, the operator also allows you to specify the default operator that will be returned.

public static void DefaultIfEmptyExample()

{

string[] fruits = { "Apple", "pear", "grapes", "orange" };

string banana = fruits.Where(f => f.Equals("Banana")).First();

Console.WriteLine(banana);

}

The above example throws an exception because the first operator requires that sequence not be empty. Therefore if we were to use defaultifEmpty, this is how it would look:

public static void DefaultIfEmptyExample1()

{

string[] fruits = { "Apple", "pear", "grapes", "orange" };

string banana =

fruits.Where(f => f.Equals("Banana")).DefaultIfEmpty("Not Found").First();

Console.WriteLine(banana);

}

Another interesting use of DefaultIfEmpty is to perform a left outer join using GroupJoin. Here is an example that illustrates that:

public class Category

{

public string CategoryName { get; set; }

}

public class Product

{

public string ProductName { get; set; }

public string CategoryName { get; set; }

}

public static void LeftOuterJoin()

{

Category[] categories = {

new Category{CategoryName="Beverages"},

new Category{CategoryName="Condiments"},

new Category{CategoryName="Dairy Products"},

new Category{CategoryName="Grains/Cereals"}

};

Product[] products = {

new Product{ProductName="Chai",

CategoryName="Beverages"},

new Product{ProductName="Northwoods Cranberry Sauce",

CategoryName="Condiments"},

new Product{ProductName="Butter",

CategoryName="Dairy Products"},

};

var prodcategory =

categories.GroupJoin(

products,

c => c.CategoryName,

p => p.CategoryName,

(category, prodcat) => prodcat.DefaultIfEmpty()

.Select(pc => new { category.CategoryName,

ProductName = pc != null ? pc.ProductName : "No" })

).SelectMany(s => s);

foreach (var product in prodcategory)

{

Console.WriteLine("Category :{0}, Product = {1}", product.CategoryName,

product.ProductName);

}

In the example above, I am using left outer join to list all categories, regardless of whether they have any products or not.

Linq Query operators :part 2

2010-11-08T02:09:00.001-08:00

OrderBy Operators

The order operator allows collections to be ordered using orderby, orderbydescending, thenby and thenbydescending. Here is what the prototype looks like:

public static IOrderedEnumerable OrderBy(

this IEnumerable source,

Func keySelector)

where

K : IComparable

The operator takes an IEnumerable<T> and orders the collection based on the key selector that will return the key value for each element in the sequence. The only important point that is worth mentioning is that the sorting of orderby and orderbydescending is considered unstable, meaning that if two elements return the same key based on the key selector, the order of the output could be the maintained or could be different. You should never rely on the order of elements coming out of an orderby call other than the field specified in the orderby clause.

Another interesting point that I found was that orderby, orderbydescending and orderbyascending take as an input source IEnumerable, as you can see from the prototype. However, the return type is IORderedEnumerable. The problem with that is if you want to order by more than 1 column, you cannot pass IOrderedEnumerable since orderby takes IEnumerable. The solution to this is to use the ThenBy or ThenByDescending operators, which take IOrderedEnumerble. Let's proceed to an example:

public static void OrderByOperators()

        Book[] books =

            new Book{Title="ASP.NET 2.0 Website Programming: Problem -

                Design - Solution",

                Author="Marco Bellinaso"},

            new Book{Title="ASP.NET 2.0 Unleashed", Author="Stephen Walther"},

            new Book{Title="Pro ASP.NET 3.5 in C# 2008,  Second Edition",

                Author="MacDonald and Mario Szpuszta"},

            new Book{Title="ASP.NET 3.5 Unleashed ", Author="Stephen Walther"},

};

        IEnumerable orderedbooks =

              books.OrderBy(b => b.Author).ThenBy(b => b.Title);

In the above example, I make use of both orderby and thenby. Since orderby only works on IEnumerable<T>, I make use of the thenby extension method as well. The second prototype for orderby takes in Icomparable and does not require the return type of the keyselector delegate to return a Collection that implements IComparable. Here is what the prototype looks like:

public static IOrderedEnumerable OrderBy(

this IEnumerable source,

Func keySelector,

IComparer comparer);

interface IComparer {

int Compare(T x,  T y);

The compare method will return a greater int if the second argument is greater than the first, equal to zero if both arguments are equal and less than zero if the first argument is less than the second. Let's see an example of that:

public class LengthComparer : IComparer

    public int Compare(string title1,  string title2)

        if (title1.Length < class="code-keyword">return -1;

        else if (title1.Length > title2.Length) return 1;

        else return 0;

I have created a custom comparer which compares the book title based on the title's length. When the length of the first title is less than the second title's length, I return -1. If it's greater, I return 1. Otherwise, I return 0 for being equal. This is how I make use of the comparer in my LINQ query.

public static void OrderByUsingCustomComparer()

        Book[] books =

            new Book{Title="ASP.NET 2.0 Website Programming: Problem -

                 Design - Solution",

                Author="Marco Bellinaso"},

            new Book{Title="ASP.NET 2.0 Unleashed", Author="Stephen Walther"},

            new Book{Title="Pro ASP.NET 3.5 in C# 2008,  Second Edition",

                Author="MacDonald and Mario Szpuszta"},

            new Book{Title="ASP.NET 3.5 Unleashed ", Author="Stephen Walther"},

};

        IEnumerable orderedbooks = books.OrderBy(b => b.Title,

            new LengthComparer());

LINQ Query Operators

2010-11-08T01:33:00.000-08:00

Query operators such as SelectMany, Concat, Object Initializers, OrderBy,

AsEnumerable, defaultifempty and how to do left joins in LINQ to SQL.

Standard Query Operators

The list of standard query operators is huge. I will cover a few of them that I found interesting and that require a bit of understanding.

Select Many and Concat Operators

The SelectMany operator is used to create one to many projections. The SelectMany operator will return zero or more inputs for every input element. The prototype is as follows:

public static IEnumerable<s> SelectMany(

this IEnumerable source,

Func> selector);

The operator takes an input sequence of T and a selector delegate that takes an element of type T. It returns an IEnumerable of S, an intermediate output sequence. Let's see an example:

public static void SelectManyOperator()

{

string[] items = { "this", "is", "a", "test" };

IEnumerable characters = items.SelectMany(s => s.ToCharArray());

foreach (char character in characters)

{

Console.WriteLine(character);

}

public static void ConcatAndSelectManyOperator()

{

string[] books = {

"ASP.NET 2.0 Website Programming: Problem -

Design - Solution",

"Pro ASP.NET 3.5 in C# 2008, Second Edition",

"ASP.NET 2.0 Unleashed",

"ASP.NET 3.5 Unleashed "

};

IEnumerable concatbooks = books.Take(2).Concat(books.Skip(2));

IEnumerable selectmanybooks = new[]{

books.Take(2),

books.Skip(2)

}.SelectMany(b => b);

}

Using concat or selectmany would yield the same results, but the advantage of selectmany is that it allows you to merge more than two sequences to return a single sequence back.

Object Initializers

There is a C# language feature in the upcoming "Orcas" version known as object initializers. Object initializers basically allow the assignment of multiple properties or fields in a single expression. For example, a common pattern for object creation is:

Customer customer = new Customer();

customer.Name = “Roger”;

customer.Address = “1 Wilco Way”;

In this case, there is no constructor of Customer that takes a name and address; however, there are two properties, Name and Address, that can be set once an instance is created. Object initializers allow the same creation with the following syntax:

Customer customer = new Customer()

{ Name = “Roger”, Address = “1 Wilco Way” };

In our earlier CustomerTuple example, we created the CustomerTuple class by calling its constructor. We can achieve the same result via object initializers:

var locals =

customers

.Where(c => c.ZipCode == 91822)

.Select(c =>

new CustomerTuple { Name = c.Name, Address = c.Address });

Notice that object initializers allow the parentheses of the constructor to be omitted. In addition, both fields and settable properties can be assigned within the body of the object initializer.

We now have a succinct syntax for creating queries in C#. However, we also have an extensible way to add new operators (Distinct, OrderBy, Sum, and so on) through extension methods and a distinct set of language features useful in their own right.

The language design team now had several prototypes to get feedback on. So we organized a usability study with many participants who had experience with both C# and SQL. The feedback was almost universally positive, but it was clear there was something missing. In particular, it was difficult for the developers to apply their knowledge of SQL because the syntax we thought was ideal didn’t map very well to their domain expertise.

LINQ Cast & LINQ over Dataset: Part 2

2010-11-08T01:21:00.000-08:00

1. When to use OfType & Cast
2. What support C# provides to query over datasets and data tables (LINQ to dataset).
3. Implications of anonymous types.

OfType & Cast

public static void CastOperator()
{
ArrayList list = new ArrayList();
list.Add(1);
list.Add(2);
list.Add("ASP.NET 3.5 Unleashed");

IEnumerable numbers = list.Cast();
foreach (int number in numbers)
{
Console.WriteLine(number);
}
}

When you run the cast operator, you get an exception because the cast operator tries to cast every element in the collection to the specified type. If it does not cast, it will throw an exception. In contrast, the OfType operator will return objects that can be cast to the right type and skips the rest from the collection.

public static void OfTypeOperator()
{
ArrayList list = new ArrayList();
list.Add(1);
list.Add(2);
list.Add("ASP.NET 3.5 Unleashed");

IEnumerable numbers = list.OfType();
foreach (int number in numbers)
{
Console.WriteLine(number);
}
}

LINQ Over Dataset

Out-of-the-box, datasets, datatables and dataviews do not have the necessary infrastructure to work in a LINQ query. This is where Microsoft introduced the new extension called System.Data.DataSetExtensions.dll, which includes DataTable extensions, DataRow extensions and TypedTableBasedExtesions. To make a data table LINQ aware, you simply need to call the AsEnumerable extension, which will return an EnumerableRowCollection consisting of DataRows. Another very useful extension method is DataRowExtensions.Field(), which allows you to do safe casting in a LINQ query and helps prevent runtime exceptions. Once you apply the filter on a datatable using the LINQ query, the result is simply EnumerableRowCollection. In order to return back a table, we can use the new copytodatatable extension method on the result.

public static void DataSetExample(DataTable books)
{
var implicittype = from book in books.AsEnumerable()
where book.Field("Author") == "Stephen Walther"
select book;
var datatable = implicittype.CopyToDataTable();
}

Anonymous Types
The C# 3.0 language includes the ability to dynamically create new unnamed classes. This type of class is known as an anonymous type. An anonymous type has no name and is generated by the compiler based on the initialization of the object being instantiated. Since the class has no type name, any variable assigned to an object of an anonymous type must have some way to declare it. This is the purpose of the new C# 3.0 var keyword. Anonymous types allow you to define class on-the-fly using object initialization syntax and assigning to var keyword. At compile time, the C# compiler will generate a unique class which is not accessible from your code. All anonymous classes derive from System.Object and therefore inherit all the properties and methods of the object class. Anonymous classes are provided with overridden versions of Equals(), GetHashCode and ToString(). The ToString implementation for an anonymous book class would look something like this:

public class Book
{
public string Title { get; set; }
public string Author { get; set; }
}

public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.Append("{ BookTitle = ");
builder.Append(this.i__Field);
builder.Append(", BookAuthor = ");
builder.Append(this.i__Field);
builder.Append(" }");
return builder.ToString();
}

LINQ Execution

2010-11-08T01:09:00.000-08:00

How LINQ leverages differed execution and what benefits and impacts it can have to a developer.

Differed and Immediate Execution

By default, LINQ query expressions are not evaluated until you iterate over the contents. The benefit of this differed execution allows the same LINQ query to be executed multiple times, giving you the latest results. However, there would be times when differed execution behavior would not be acceptable due to performance reasons of the query being executed every time. To prevent this behavior, the .NET Framework defines a number of extension methods such as ToArray<T>(), ToDictionary<TSource, TKey>() and ToList<T>() to capture the results in a strongly typed container which would not reflect new changes made to the original collection. Here is an example:

public static void DifferedAndImmediateExecution()

        int[] numbers = { 1,  2,  3,  4,  5,  6 };

        var lessthan4 = from n in numbers

                        where n < 4

                        select n;

        Console.WriteLine("Original array with items less than 4");

        foreach (int n in lessthan4)

            Console.WriteLine("{0} <>, n);

        //differed execution

        numbers[2] = 7;//assigning new value

        Console.WriteLine(

            "Results based on differed execution after change number[2] = 7");

        foreach (int n in lessthan4)

            Console.WriteLine("{0} <>,  n);

        //immediate execution

        numbers = new int[] { 1,  2,  3,  4,  5,  6 };

        var lessthan4immediate = numbers.Where(n => n < 4).Select(n => n).ToArray();

        numbers[2] = 7;//assigning new value

        Console.WriteLine(

            "Results based on immediate execution after change number[2] = 7");

        foreach (int n in lessthan4immediate)

            Console.WriteLine("{0} <>,  n);

As you can see that, new changes are reflected on differed queries whereas new changes are not reflected on immediate execution because the results are cached in a strongly typed container. However, the query does not run until you iterate over the collection.

One of the downsides I have observed with differed execution is that bugs are harder to trace because enumerating the query could happen much further down in your code. This is where the exception would be thrown. However, you may forget that it is the original query that is the problem. So if differed execution is not the desired behavior you want, use the non-deferred extension methods like ToArray, ToList, ToDictionary or ToLookup to force the query to be executed. Let's see an example for that:

public static void DelayedExceptions()

        string[] blob = {"Resharper", "is", "great"};

        IEnumerable sentence = blob.Select(s => s.Substring(0,  5));

        foreach (string word in sentence)

            Console.WriteLine(word);

How to find Union of two string array in C#

2010-02-09T01:25:00.000-08:00

Linq Made our life easy.
It is too simple to find Union of two array in c#
Below is the code

string [] array1= new string [] {"JON","JEMIN","MATT"};
string[] array2 = new string[] { "JEMIN", "SUHAS", "MATT" };
array1 = array1.Union(array2).ToArray();

semaphore tell me your value

2008-12-01T03:20:00.000-08:00

Today in morning I was little bit free from my regular work hushh..... Those sales force cases.
So I decided to write small utility which will tell me how many messages are present in the queue from another application.
Queue in this application is synchronized by using semaphore. And any point of time semaphore value Represent message count in the queue. So my thinking was if I know the name of the semaphore and required Access permission on the semaphore I can easily get the message count. But hey it is not possible to get the Current value of semaphore in .net
I found this on the forum
http://www.informit.com/guides/content.aspx?g=dotnet&seqNum=606

An finally I have to wrap up my idea…………………………….

Managing Security with the .NET Configuration tool

2008-08-30T02:00:00.000-07:00

How to manage security with NET Configuration tool

1 Managing Security with the .NET Configuration tool
1.1 On the Test Machine, Start .NET Framework Configuration Tool

To run Mscorcfg.msc from the Start menu
On Windows 2000 Professional, click Start>Settings>Control Panel.>Double-click Administrative Tools.
In the Administrative Tools window, double-click Microsoft .NET Framework Configuration.
On Windows XP Professional, click Start>Control Panel>Performance and Maintenance, and click Administrative Tools.
In the Administrative Tools window, double-click Microsoft .NET Framework Configuration.
On Windows 2000 Server or Windows Server 2003 family, click Start>Programs, and point to Administrative Tools. Click Microsoft .NET Framework Configuration.
Note The command to start Mscorcfg.msc appears in the Start menu only if MMC version 1.2 or later is installed on the computer. A compatible version of MMC is included with Windows 2000 and Windows XP. If Windows 98, Windows Me, or Windows NT 4 is running on the computer, you must download and install MMC 1.2 from Microsoft.com.
To run Mscorcfg.msc from the command line
At the command line, type %Systemroot%\Microsoft.NET\Framework\versionNumber\Mscorcfg.msc
The user interface for the tool is displayed.

Click the Runtime Security Policy node of the console tree.

Click the Increase Assembly Trust link in the plane on the right.
The tool displays a corresponding wizard.

3. Select the option Make changes to this computer and then click the next button

4. Select the network path where the your exe is available.

5. Click the next button which will show the following window.

6. Adjust the scrollbar setting to Full trust position.
7. Click the next button.

8. Click the finish button.

India's First individual Gold Medal in Olympics

2008-08-11T00:51:00.000-07:00

Wow !!! Abhinav Bindra of India has won India its first Gold medal for 10 Meter Air Rifle.what a great moment for India .
This is the first individual Gold medal for India in Olympics. Abhinav you make us proud .

He score of (596+140.5) 700.5

In ten rounds, Bindra shot 10.7, 10.3, 10.4, 10.5, 10.5, 10.5, 10.6, 10.0, 10.2, 10.8 to clinch the first berth. China's Qinan Zhu won silver while Finland's Henri Hakkinen won bronze.

How to detect browser close event in IE7

2008-07-20T02:58:00.000-07:00

How to detect browser close event
I have written a code to detect the bowser close event in IE6 which looks like

This works well with IE6. Unfortunately, IE7 browser returns positive clientX value even if mouse pointer is out of client area.This means that the trick which I used in IE6 case will not work on IE7.

I searched solution for this problem on net but I didn't find any perfect solution.
So I tried myself to find out the solution. In the below sample code I tried to go closer to the solution of problem and tried to cover maximum number of condition such as atr+X ,Popup window ,mouse click on close button etc.

There is no “universal way” to determine if the browser has been closed. You can only determine if a browser window (web page) has been closed or navigated away from, provided you understand that the events illustrated below are generated not only when a user triggers the closing of a window, but the same events fire on a “refresh” too. So this fact probably defeats your purpose. Using the methodologies described, you can’t tell if the user clicked the “Red X” or the “Refresh” button, let alone the browser’s top right “X” or “File->Exit” menu item.

Note:Please replace "replace" keyword in the below code with "script"keyword .

<[[CDATA[



var alterffourflag=0;
var lastkey=0;
var refreshflag=0;
document.onkeydown = function ( event )
{
event = event window.event;
return window_onkeydown();
}


ie7=navigator.userAgent.toLowerCase().indexOf('msie 7')!=-1;
if(ie7==1)
{
if(window.document.referrer.toString()=="")//to detect popup window in the IE7
{
return;
}
var offset=0.0;
var width=0.0;
if( document.documentElement && ( document.documentElement.clientWidth ))
{
//IE 6+ in 'standards compliant mode'
width = document.documentElement.clientWidth;
}
else if( document.body && ( document.body.offsetWidth))
{
width=document.body.offsetWidth;
}
offset=18500/screen.width;
var diff =width-offset;
if (refreshflag!=1 && width!=0 && window.event.clientY <> (width - offset))alterffourflag==1)
{
if( window.opener == null)
{
if (window.XMLHttpRequest)
{
req=new XMLHttpRequest();
req.open("GET", "../ping.aspx" + "?t=" + new Date(), false);//page which removes session information
req.send(null);
}
else
{
if (window.ActiveXObject)
{
req = new ActiveXObject("Microsoft.XMLHTTP");
req.open("GET", "../ping.aspx" + "?t=" + new Date(), false);
req.send(null);
}
}
}
}
refreshflag=0;
}
else// IE6
{
if (self.screenTop > 10000 && event.clientY < opener ="=" req="new" t=" + new Date(), false); req.send(null); } else { if (window.ActiveXObject) { req = new ActiveXObject(" t="">

function window_onkeydown()
{
var keynum
var numcheck
e=window.event;
keynum = e.keyCode;
if(lastkey==18 && keynum==115)//(lastkey==17 && keynum==87))
{
alterffourflag=1;
}
if(keynum==116)
{
refreshflag=1;
}
lastkey=keynum;
}

]]>

Problem while loading the Assembly In web application

2008-07-09T06:04:00.000-07:00

Yesterday I came across a below problem in my web application. After lots of search on google I couldn't figure out the reason .After some investigation I found that this problem appeared after machine poweroff because of power cut .

After reinstalling my .net framework version below problem get resolved .

Could not load file or assembly 'myinterface or one of its dependecies .The Parameter is incorrect (Exception From HRresult : 0x80070057(E_INVALIDARG))

Could not load file or assembly 'myinterface, Version=4.0.0.9185, Culture=neutral, PublicKeyToken=null' or one of its dependencies. Access is denied. Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code. Exception Details: System.IO.FileLoadException: Could not load file or assembly 'myinterface, Version=4.0.0.9185, Culture=neutral, PublicKeyToken=null' or one of its dependencies. Access is denied.Source Error: An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below. Assembly Load Trace: The following information can be helpful to determine why the assembly 'myinterface, Version=4.0.0.9185, Culture=neutral, PublicKeyToken=null' could not be loaded.WRN: Assembly binding logging is turned OFF.To enable assembly bind failure logging, set the registry value [HKLM\Software\Microsoft\Fusion!EnableLog] (DWORD) to 1.Note: There is some performance penalty associated with assembly bind failure logging.To turn this feature off, remove the registry value [HKLM\Software\Microsoft\Fusion!EnableLog].Stack Trace: [FileLoadException: Could not load file or assembly 'myinterface, Version=4.0.0.9185, Culture=neutral, PublicKeyToken=null' or one of its dependencies. Access is denied.] mYWebsite..LOGINPage_Load(Object sender, EventArgs e) +0 System.Web.UI.Control.OnLoad(EventArgs e) +99 System.Web.UI.Control.LoadRecursive() +47 System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint) +1061--------------------------------------------------------------------------------Version Information: Microsoft .NET Framework Version:2.0.50727.42; ASP.NET Version:2.0.50727.42 --------------------------------------------------