Google for Advertisers has launched

I came to know from Google Adwords Blog that Google has launched Advertisement Solution with new site Launching. Google Centralizes Advertising Solutions On Microsite.

Read Some Words of Google Adwords Blog

Here are four ways to dive in and get the most from the site:

1. Read up on our various media platforms. This site gives straightforward descriptions of each of Google's platforms (like search, TV, the Content Network or mobile) and all of the supporting tools. You'll learn how to reach your audience in relevant and useful ways across devices, locations and languages.


2. Take a ride on 'The Marketing Cycle.' We put Google solutions in the context of how they can be applied across all the stages of building an effective advertising campaign -- ways to sculpt your strategy, creative development, media deployment, measurement and optimization -- which together help you better plan campaigns that make an impact and deliver strong ROI.


3. Stick it to a marketing objective. Explore a [very fictional] marketing example that illustrates how Google tools could come together to solve for a particular goal. We hope it inspires you, and offers a chuckle or two.


4. Build your personal 'toolkit.' As you browse the site and find Google tools that pique your interest, you can add them to your online toolkit. This way you can easily hone in on the solutions that are right for you and share them with your colleagues.

Google Sandbox

How To Play In Google's Sandbox

Theory:
There has been a theory floating around that Google is now imposing some kind of penalty on brand new web sites or sites that seem to acquire a large amount of links from other sites in a relatively short period of time. It is being discussed on all the search engine marketing forums. Many articles have been written about it. Even several live examples have been presented by frustrated web site owners and managers who can't seem to understand why their sites will not rank well in the Google search engine results pages (SERPs).

Play Sandbox?
So now that we have come to the conclusion that this sandbox, aging filter or whatever you want to call it, actually seems to exist, what can one do that has been affected by it? The answer is "absolutely nothing". That surely is not what many people want to hear and possibly even you the reader question the reasoning of writing an article on the subject if there are no solutions. But wait a minute, there is a solution! It is called patience. Sure that might not be a definite solution to getting one's self out of the sandbox or out from underneath an aging filter. However it will allow them to keep their sanity and in doing so, to look at some alternatives to marketing their sites until the time period lapses. Let us take a look at some of those alternatives.

Sandbox or Aging Filter?
So if a site is sent to the sandbox by Google either because it is new or it is participating in mass link building, what is the time frame that must pass before the site is allowed out of the box? Most search engine marketers that have been discussing and analyzing this say about 6-8 months. As for myself, I don't actually believe that Google is sending new sites to a "sandbox" but rather they may be applying some sort of aging filter.

Thanks to searchengineguide.com

Handling database exceptions in Dynamic Data

Posted by davidebb

This post was prompted from a forum thread in which the user wanted to display database errors in a Dynamic Data

page, instead of the default behavior that ends up with an unhandled exception (or an AJAX error with partial

rendering).

When using Linq To Sql, this can be done fairly easily in a couple different ways, by wrapping the exception in a

ValidationException. To do it globally for a DataContext, you can do something like this:

public override void SubmitChanges(System.Data.Linq.ConflictMode failureMode) {
try {
base.SubmitChanges(failureMode);
}
catch (Exception e) {
throw new ValidationException(null, e);
}
}
And to do it with more granularity, you can use one of the partial methods on the DataContext. e.g.

partial void DeleteCategory(Category instance) {
try {
ExecuteDynamicDelete(instance);
}
catch (Exception e) {
throw new ValidationException(null, e);
}
}
A few notes about this:

By passing null as the text, it uses the original exception’s text. You very well may want to use a custom error

message instead
Instead of doing it ‘blindly’, you may want to look at the database exception and selectively decide to wrap it or

not. If you don’t want to wrap it, just use the ‘throw;’ statement to rethrow it unchanged.
There is a small issue in the default templates that you need to fix if you want to handle DB exceptions happening

during a Delete: in both list.aspx and details.aspx, you’ll find CausesValidation="false". You need to either get

rid of it or set it to true (which is the default).
But now, let’s try to do the same thing with Entity Framework. Unfortunately, ObjectContext doesn’t have as many

useful hooks as Linq To Sql’s DataContext (this will change in the next version), so the techniques above are not

available.

However, there is a fairly easy workaround that can be used, which involves using a custom derived

DynamicValidator control. Here are the steps to do this (full sample attached at the end of this post).

First, let’s create the derived DynamicValidator, as follows. I’ll let the comments speak for themselves:

///

/// By default, Dynamic Data doesn't blindly display all exceptions in the page,
/// as some database exceptions may contain sensitive info. Instead, it only displays
/// ValidationExceptions.
/// However, in some cases you need to display other exceptions as well. This code
/// shows how to achieve this.
///

public class MyDynamicValidator : DynamicValidator {

protected override void ValidateException(Exception exception) {
// If it's not already an exception that DynamicValidator looks at
if (!(exception is IDynamicValidatorException) && !(exception is ValidationException)) {
// Find the most inner exception
while (exception.InnerException != null) {
exception = exception.InnerException;
}

// Wrap it in a ValidationException so the base code doesn't ignore it
if (ExceptionShouldBeDisplayedInPage(exception)) {
exception = new ValidationException(null, exception);
}
}

// Call the base on the (possibly) modified exception
base.ValidateException(exception);
}

private bool ExceptionShouldBeDisplayedInPage(Exception e) {
// This is where you may want to add logic that looks at the exception and
// decides whether it should indeed be shown in the page
return true;
}
}Then you need to make all the pages use it. The simplest way to do it is via a little know but powerful feature:

tag remapping. Here is what you need to have in web.config:






And then you also need to do the same as the 3rd bullet point above: get rid of CausesValidation="false" in the

pages.

And that’s all! You should now see the error messages directly in the page.

Overview of the Chart Control

Dundas charts is a popular charting tool that embeds pie, bar, line, and more charts into a web or windows applicatin. For the web, Dundas generates the charts on the server and serves up images to the client in the browser. This works well in the web environment, which relies upon the use of images being present (whereas the windows realm can display an image stream). Microsoft leased part of the Dundas controls to create the .NET chart control freely available to the community, making all these great innovations created by Dundas available to the public. Microsoft did not lease the entire product, but rather a subset of the product.


Everything begins with the Chart control; the chart control defines all of the parameters and methods required to show charts in a .NET application. Each chart can have one or more titles that appear at the top of the chart. It can also have one or more legends that make up the various information groups in the chart. There can be one or more legends, and the legend can be docked to the top, bottom, left, or right side of the chart.

Each chart has a chart area that defines the region to draw the chart in. This area has a variety of settings regarding the X or Y axis, 3D chart rendering, the inner position of the chart, and more. The ChartArea object is the key component that makes up the chart, because it tells the chart data where to live, so to speak.

The groupings of data, or information groups as I mentioned before, represents the Series object. The series is exactly that; a series of data elements that representsss one information group. I'll provide an example later, but know that a Series stores one or more DataPoint objects. The DataPoint class represents the X/Y values to show on the chart.

To give you an example of the coorelation between Series and DataPoints, imagine this. Suppose you wanted to create a coorelation between how well various products at a store sell in relation to each other. This coorelation tracks total net sales as compared to the year. So in a chart scenario, the Y axis running north would represent the net sales, and the X axis running east would represent the years.

In the chart control, each product would represent a series. A series would consist of multiple DataPoint objects, one per year, which would have its XValue property set to the year and its YValues property (there can be multiple values to accommodate certain kinds of charts) would reference the net sales. This is how the two objects coorelate.

Chart Example



Now its time to see an example of this. Take a look at the following chart.

Width="600px" Height="400px" Palette="Chocolate">

Text = "My Title" Enabled="True" />




So far, within this chart, we have the core Chart control that defines the width and height of the image. I'd highly recommend specifying these parameters, to ensure the chart image renders decently. In addition, there are four image types and this chart renders in Jpeg format, along with using the Chocolate palette (one of many color schemes that changes the color that the individual bars, lines, points, or pie slices use within the chart).

Chart Areas

Next, let's look at the setup of the charting area.


.
.















The charting area is setup by the ChartArea object. This chart contains the name of the charting region (important because there can be more than one charting areas and Series objects have to interrelate to the ChartArea). The chart area defines information about the charting area itself. First, the InnerPlotPosition specifies the region of the charting area to render itself in. This varies by type of chart, as pie charts render differently than bar charts, and each chart functions differently depending on its settings.

The LabelStyle object specifies settings to use for labels that appear within the chart. Font is just one of those properties that are customizable. The next two properties affect the rendering of the chart axis. The MajorGrid property specifies whether to draw a line for the major X or Y values. So for each item rendered in the list, the chart control specifies the details about the line, such as line color, width, style, etc. Currently its disabled, so no X/Y lines appear, but can be easily enabled by setting the value to true, and by at least specifying a line width. This is the same for the tick marks that appear by enabling MajorTickMark.

Major grid lines are represented by the major values in the grid. For instance, if the X axis shows years, it would most likely show one major grid line per year. With the Y axis being net sales, the chart control may create a major grid line every $20,000. The chart control automatically creates major values for you; however, you can override this feature to include whatever ranges you like.

Series and Data Points

Charting data itself is made up of series and data points; these series and data points represent the actual ranges of data. As I mentioned before in my previous example, a series represents and object of measurement (a product), while the data points contain the measurement value data (years and net sales) used to establish a trend.

This would appear in the chart like the following.



ChartArea="MainChart" ChartType="Bar">









This creates a typical bar chart with four bar lines, one for each of the years that shows the trend of net sales dollars.

Custom Labels
[ Back To Top ]


The .NET charting control provides the ability to create custom labels for the X or Y axis. This means that anyone has full control over the text that renders along the axis line. For example, take a look at the following example.



Text="Store Opening" />
Text="Current Year" />

Based upon this list of custom labels, the X axis value for the year 2005 will be transformed to the text "Store Opening", and the current year's axis value will be transformed to "Current Year".

You may be wondering why I use values like 2004.5. I tend to use half decimal points and search for a range. The reasoning is that the X and Y values are doubles, and sometimes even though a value is 16, it may really be 15.999999999999999999999 or 16.000000000000001, and thus searching for an exact value may not produce the actual result. This is one of the many tidbits of knowledge that I learned from reading Steve McConnell's Code Complete.

And so I tend to choose values I'm certain will be a match. I could have used 2004.9 and 2005.1 to fit within the range, which would have been perfectly fine; I just tend to use .5 for whatever reason that may be.

Conclusion
[ Back To Top ]


The free .NET chart control available from Microsoft contains a subset of components originally created by Dundas. This component is a full-fledged charting component rendering bar, line, pie, or statistical charts in a windows or web UI. The chart component has many features available to the user, so many that it's often hard to tell what each feature does.

The chart control uses Series and DataPoints to render a chart within a chart region defined by the ChartArea object. Charts can be 2D or 3D depending on the settings, and the developer has control over colors, borders, fonts, lines, rendering region, and other styling of the chart.

The final result of the markup above, with some added styles, produces the following chart.



The final charting markup looks like the following.

BackColor="LightBlue">














Text="Store Opening" />
Text="2006" />
Text="2007" />
Text="2008" />
Text="Current Year" />










BackGradientStyle="TopBottom" BackSecondaryColor="LightYellow">











Source by Brian Mains - aspalliance.com

Syndicating and Consuming RSS 1.0 (RDF) Feeds in ASP.NET 3.5

By Scott Mitchell

Introduction
Websites that produce new content on a regular basis should include a syndication feed, which is a specially formatted XML file that includes a summary of the most recently published items. Virtually all blogs, news sites, and social media sites have a syndication feed, and 4Guys is no exception. The 4GuysFromRolla.com syndication feed contains the most recent articles. Syndication feeds are meant to be consumed by computers. Sites like Technorati parse the syndication feeds from blogs and use that data to determine the topic du jour. Also, syndication feeds are commonly used by websites to display the latest headlines from related sites. For example, an ASP.NET community website could consume the 4GuysFromRolla.com syndication feed to display the latest 4Guys headlines.

Until recently, there was no built-in support for creating or consuming syndication feeds in the .NET Framework. That changed with the release of the .NET Framework version 3.5, which included a new namespace: System.ServiceModel.Syndication. This new namespace includes a handful of classes for working with syndication feeds. As aforementioned, syndication feeds are XML files, and for the syndication feed to be of any use it must conform to one of the popular syndication feed standards. The two most popular syndication feed standards are RSS 2.0 and Atom 1.0, and these are the standards supported by the classes in the System.ServiceModel.Syndication namespace. But there is a third format that, while not as popular as RSS 2.0 or Atom 1.0, is still used. That standard is RSS 1.0.

The good news is that with a little bit of work we can create a class that works with the RSS 1.0 standard and have this class used by the syndication feed-related classes in the .NET Framework 3.5 can be. This article introduces a free library, skmFeedFormatters, which you can use in an ASP.NET 3.5 application to create and consume RSS 1.0 feeds. (This same concept could be applied to creating and parsing Atom 0.3 feeds, as well.)


Brief History of Syndication Feed Standards
The idea of online syndication feeds was first proposed by Dave Winer back in 1997 as a way for exposing the content of his blog in a machine-readable format. Dave called his standard RSS for Really Simple Syndication. Over the years he continued fine tuning the standard until 2003, at which point the standard was frozen with the release of RSS 2.0. RSS 2.0 is a very popular syndication feed standard in large part because it is very simple and straightforward, making it easy to implement and parse. For example, the 4Guys syndication feed adheres to the RSS 2.0 standard.

Around the same time a group from Netscape set about crafting a syndication standard based on Resource Description Framework (RDF), a standard proposed by the W3C for representing information about resources on the web. To make things as confusing as possible, this new syndication feed standard was named RDF Site Summary, or RSS for short, resulting in two differing standards with the same acronym! Eventually, this work by Netscape (and later O'Reilly) became known as RSS 1.0 and Dave's standard as RSS 2.0, although sometimes the RSS 1.0 standard is referred to as RDF to help remove any ambiguity.

After the RSS 2.0 standard was frozen in 2003, Sam Ruby proposed a new standard to overcome RSS 2.0's shortcomings. This new standard was defined by the community and named Atom. The first major release was Atom 0.3. After some more changes, the final, standardized version was released as Atom 1.0. (Unfortunately, some sites still syndicate content using the Atom 0.3 standard.)

The two most widely used standards are RSS 2.0 and Atom 1.0. However, some sites still use RSS 1.0 or Atom 0.3. For example, the popular tech news and discussion site Slashdot.org syndicates its content using RSS 1.0.

Creating and Consuming Syndication Feeds in ASP.NET 3.5
The .NET Framework version 3.5 introduced a new namespace, System.ServiceModel.Syndication, with a number of classes for creating and consuming syndication feeds. These classes are divided into two categories: classes that model a syndication feed and the items in a feed, and classes that are responsible for transforming the classes that model syndication feeds into the appropriate XML and vice-a-versa.

Classes That Model Syndication Feeds and Items
SyndicationFeed - represents a syndication feed. Has properties like Title, Description, Links, and Items. The Items property represents the collection of content items expressed in the feed.
SyndicationItem - represents a specific syndication feed item and includes properties like Title, Summary, PublishDate, Authors, and so on.
Classes That Transform Syndication Feeds To/From XML
Rss20FeedFormatter - can take a SyndicationFeed object and turn it into XML that conforms to the RSS 2.0 specification. Also, can be used to consume a properly-formatted RSS 2.0 feed, turning the XML into a SyndicationFeed object with its properties set based on the data in the consumed XML.
Atom10FeedFormatter - same as the Rss20FeedFormatter, but uses the Atom 1.0 standard.
The .NET Framework 3.5 only ships with two feed formatter classes for the RSS 2.0 and Atom 1.0 specifications. Consequently, you cannot syndicate or consume RSS 1.0 or Atom 0.3 feeds out of the box. In his blog entry How to upgrade Atom 0.3 feeds on the fly with a custom XmlReader for use with WCF Syndication APIs, Daniel Cazzulino shows how you can use XSLT to transform Atom 0.3 markup to Atom 1.0-compliant markup on the fly.
A more formal approach, in my opinion, is to create your own feed formatter class. The Rss20FeedFormatter and Atom10FeedFormatter classes in the System.ServiceModel.Syndication namespace derive from the base class SyndicationFeedFormatter. We can create our own formatter class by extending this base class. For example, we could create an Atom03FeedFormatter class and use it to turn a SyndicationFeed object into conforming XML, or consume an Atom 0.3 XML feed and generate a corresponding SyndicationFeed object.

The download available for download at the end of this article includes a class named Rss10FeedFormatter, which can be used to create and consume RSS 1.0 feeds. The download also includes a demo website showing this class in action. The remainder of this article explores the Rss10FeedFormatter class. (You could take the concepts presented in this article to create an Atom03FeedFormatter class, or a class to work with other, more esoteric feed formats, should the need arise.)

Implementing Dynamic Web Interfaces Using XSLT

Web applications are dynamic- many requiring unique content and interfaces for each user. There are a myriad of ways to take user content out of a database and present it in a browser. This article is for IT management and development staff and it focuses on the different ways web applications can display dynamic content in ASP.Net, why we chose XSLT to for our own product, and finally a look at our technical implementation.

Planning for Dynamic Content

Whether you are in the process of building a new business web application or planning to build one, you most likely need to address how your web application will handle displaying different content for different users.

Considerations

When considering the different options for displaying dynamic content you generally need to take into account the following aspects:

Usability

Usability might be one of the most critical aspects in the success (or lack thereof) of your application.

Development Time

This includes the total amount of development time involved in satisfying your current application requirements.

Flexibility

Regardless of how comprehensive your current requirements are, applications tend to evolve over time. It’s important to evaluate the development effort and skill sets required to accommodate changes.

Support, Maintenance & Ongoing Enhancements

Commonly ignored by many when planning new development projects, it is generally responsible for a good chunk of the total cost of an application over the span of its life. This includes bug fixes, client customizations, minor application enhancements and of course, QA and testing.

The Options in ASP.Net

Generally web applications that use ASP.Net have two main options for displaying dynamic content:

Server Controls

With Binding – retrieving the relevant data and binding it to the appropriate ASP.Net server controls on a web form

In Code – populating the appropriate ASP.Net server controls in code

HTML

In Code – constructing the HTML to display in code based on the information retrieved from the database

Using XSLT – retrieving the database information in XML format and then transforming it into HTML with XSLT

A third option is Silverlight, a relatively young technology introduced as an option for web applications by Microsoft about a year ago. Silverlight provides a very rich GUI with the power of the .Net platform (a subset, actually) and tools that make web application development quite similar to the latest Windows application development (WDF).

Source by Gil Shabat - aspalliance.com

A B2B Portal for Importers, Exporters, Manufacturers and Suppliers

The B2B Trade Links Pvt.Ltd. is a business-to-business portal for serious people interested in Global business. Welcome to our b2btradeworld portal which gives you a platform to improve your company’s productivity in both the factors of revenue and growth. B2b trade world is a creative and an online B2B portal from India. Our company was established in 2007 and has attained the position of India’s biggest online B2B portal. B2B trade world portal is a great platform with latest features which carry out electronic business and manage significant parts of corporate business processes.

We are one of the India’s well-known and fast-growing B2B Trade Portal, perfect for suppliers and buyers from small and medium-sized businesses all over the India including manufacturers, importers, exporters, purchasing departments, procurement agents, trading companies, distributors, retailers etc. We are committed to providing effective and efficient services that meet or exceed the expectations of our members. Free memberships are available for buyers and suppliers, paid Premium Suppliers (Silver, Gold, and Platinum Suppliers) are also available.

Our emphasis has always been on quality of visitors rather than quantity.
b2btradeworld.com is one of the most data-rich portals in the world, hosting databases of millions of buyers, sellers, agents, distributors, retailers, wholesalers, trade leads, trade statistics, foreign trade documents, business news, tenders, projects, institutional procurement information etc. No other b2b portal in India can match the depth and quality of information available at b2btradeworld.com and overseas Visitors come in large number for this quality information.

SOME SPECIAL FEATURES TO HELP YOU BETTER:

• Supply Chain Management
• Revenue Growth
• Cost Savings
• Sales and support costs
• Inventory keeping costs
• Improve customer service
• Reduces time cycle
• Storefront for members
• Forum
• Directory of Companies
• Product Adding System

For more details,

Please visit www.b2btradeworld.com

B2B Trade Links Pvt Ltd
F-8, Krishana Tower,
Opp Sachin Tower, 100Ft Ring Road,
Satellite, Ahmedabad - 380015
Gujarat India

Or, email at info@b2btradeworld.com