Customizing Fiddler for Omniture scripts

 

 

One of the best ways to investigate your Omniture implementation is to watch the actual traffic that is being sent by your site. To assist with this, Omniture provides a JavaScript debugger (search “Debugger” in the SiteCatalyst Knowledge Base). But sometimes, you need to break out the good ol’ packet sniffer to watch the actual traffic being sent.

The trouble with Fiddler is that it will watch all of your requests, making it difficult to isolate the Omniture requests that you’re looking for.

Fortunately, you can configure a custom filter in Fiddler, which will exclude non-Omniture calls. This makes is more convenient to use Fiddler to look at server requests sent to Omniture. Creating the filter is a little bit geeky, but very easy to do. Here’s how you do it:

1. Open Fiddler

2. From the Main Menu, select Rules > Customize Rules…

 

3. Add the following code to the class handlers. This adds the menu item, and turns it on by default.

public static RulesOption("&Omniture Only")
var m_OmnitureOnly: boolean = true;

4. Add the following code to the static function OnBeforeRequest. This is the logic for the filter. It tells Fiddler to only include requests that match the pattern 2o7.net. You can change the filter value by changing the value of var re.

if (m_OmnitureOnly){
  var re = /2o7.net/;
    if (!re.test(oSession.host)){ 
         }
}

5. Fiddler will now show you only Omniture requests, as long as the “Omniture Only” rule is selected in the Rules menu.

Once you have configured Fiddler to show you the Omniture server requests, be sure to check out the Debugger white paper in the SiteCatalyst knowledge base for more information on what the different parameters mean.

Cool Fire Fox Addons:

 

Web Developer

The Web Developer extension adds a menu and a toolbar to the browser with various web developer tools

https://addons.mozilla.org/en-US/firefox/addon/60

 

Firebug

• Inspect HTML and modify style and layout in real-time
• Use the most advanced JavaScript debugger available for any browser
• Accurately analyze network usage and performance
• Extend Firebug and add features to make Firebug even more powerful
• Get the information you need to get it done with Firebug.

https://addons.mozilla.org/en-US/firefox/addon/1843

DOM Inspector

Inspects the structure and properties of a window and its contents with a variety of views.

https://addons.mozilla.org/en-US/firefox/addon/6622

Auto-Implemented Properties in VB.Net

 

Auto-implemented properties enable you to quickly specify a property of a class without having to write code to Get and Set the property. When you write code for an auto-implemented property, the Visual Basic compiler automatically creates a private field to store the property variable in addition to creating the associated Get and Set procedures.

With auto-implemented properties, a property, including a default value, can be declared in a single line. The following example shows three property declarations.

 

Public Property Name As String
Public Property Owner As String = "DefaultName"
Public Property Items As New List(Of String) From {"M", "T", "W"}
Public Property ID As New Guid()

An auto-implemented property is equivalent to a property for which the property value is stored in a private field. The following code example shows an auto-implemented property.

 

Property Prop2 As String = "Empty"

The following code example shows the equivalent code for the previous auto-implemented property example.

 

Private _Prop2 As String = "Empty"
Property Prop2 As String
    Get
        Return _Prop2
    End Get
    Set(ByVal value As String)
        _Prop2 = value
    End Set
End Property

Backing Field

---

When you declare an auto-implemented property, Visual Basic automatically creates a hidden private field called the backing field to contain the property value. The backing field name is the auto-implemented property name preceded by an underscore (_). For example, if you declare an auto-implemented property named ID, the backing field is named _ID. If you include a member of your class that is also named _ID, you produce a naming conflict and Visual Basic reports a compiler error.

The backing field also has the following characteristics:

• 
  

  The access modifier for the backing field is always Private, even when the property itself has a different access level, such as Public.

  
  
• 
  

  If the property is marked as Shared, the backing field also is shared.

  
  
• 
  

  Attributes specified for the property do not apply to the backing field.

  
  
• 
  

  The backing field can be accessed from code within the class and from debugging tools such as the Watch window. However, the backing field does not show in an IntelliSense word completion list.

Initializing an Auto-Implemented Property

---

Any expression that can be used to initialize a field is valid for initializing an auto-implemented property. When you initialize an auto-implemented property, the expression is evaluated and passed to the Set procedure for the property. The following code examples show some auto-implemented properties that include initial values.

 

Property FirstName As String = "James"
Property PartNo As Integer = 44302
Property Orders As New List(Of Order)(500)

You cannot initialize an auto-implemented property that is a member of an Interface, or one that is marked MustOverride.

When you declare an auto-implemented property as a member of a Structure, you can only initialize the auto-implemented property if it is marked as Shared.

When you declare an auto-implemented property as an array, you cannot specify explicit array bounds. However, you can supply a value by using an array initializer, as shown in the following examples.

 

Property Grades As Integer() = {90, 73}
Property Temperatures As Integer() = New Integer() {68, 54, 71}

Pagination Query with SQL Server 2005

 

Pagination can be done more easier through SQL queries.

CREATE Procedure Paging  @startIndex int , @endIndex int
AS
Begin
-- create the Common Table Expression, which is a table called "pagination"
with pagination as
(
    -- your normal query goes here, but you put your ORDER BY clause in the rowNo declaration
    select
        row_number() over (order by department, employee) as rowNo,
        -- a list of the column you want to retrieve
        employeeId, employee, department
    from
        Employee
    where
        disabled = 0
)
-- we now query the CTE table
select
    -- add an additional column which contains the total number of records in the query
    *, (select count(*) from pagination) as totalResults
from
    pagination
where
    RowNo between @startIndex and @endIndex
order by
    rowNo

End

If we want to see 50 to 60 records using paging query , just execute exec Paging  5,6 --> will return rows from 50 to 60.

Advantages : we doesn’t need to keep all records in memory by means of datasources , we can hold records corresponding to a particular page.

Silverlight 4.0 released with a bunch of new features

New features:

* XAP Signing : User cannot unpack zap files any more !!
* Custom window chrome for trusted applications
* Pinned full-screen mode : can view application in full screen mode , even if it is hosted in a browser.
* WCF RIA Services Toolkit
* ContextMenu control : right click and do the thing you want :-)
* SLLauncher silent installs

Enhanced features:
* RichTextBox improvements
* WebBrowser control
* Printing API enhancements
* Native automation (COM interop)
* Language/Script support
* Networking and Sockets
* User consent dialog on webcam/clipboard/etc.

more information available @ http://www.microsoft.com/silverlight/

Data Caching in ASP.Net

Cached Data Reference Pattern

Whenever an attempt is made to access data from the cache, it should be with the assumption that the data might not be there any more. Thus, the following pattern should be universally applied to your access of cached data. In this case, we're going to assume the object that has been cached is a DataTable.

public DataTable GetCustomers(bool BypassCache)
{
  string cacheKey = "CustomersDataTable";
  object cacheItem = Cache[cacheKey] as DataTable;
  if((BypassCache) || (cacheItem == null))
  {
     cacheItem = GetCustomersFromDataSource();
     Cache.Insert(cacheKey, cacheItem, null,
     DateTime.Now.AddSeconds(GetCacheSecondsFromConfig(cacheKey),
     TimeSpan.Zero);
  }
  return (DataTable)cacheItem;
}

There are several points I'd like to make about this pattern:

• Values, like cacheKey, cacheItem and the cache duration, are defined once and only once.
• The cache can be bypassed as needed—for example, after registering a new customer and redirecting to a list of customers, it would probably be best to bypass the cache and repopulate it with the latest data, which would include the newly inserted customer.
• Cache is only accessed once. This has performance benefits and ensures that NullReferenceExceptions don't occur because the item was present the first time it was checked but had expired before the second check.
• The pattern uses strong type checking. The "as" operator in C# will attempt to cast an object to a type and will simply return null if it fails or if the object is null.
• The duration is stored in a configuration file. All cache dependencies, whether file-based, time-based, or otherwise, should ideally be stored in a configuration file so that changes can be made and performance measured easily. I also recommend that a default cache duration be specified, and that the GetCacheSecondsFromConfig() method uses the default if no duration is specified for the cacheKey being used.