Westwind.Web
No Form data is posted (but there may still be some post state)
No POST data is posted back to the server
Only standard POST data is posted back - ASP.NET Post stuff left out
Posts back POST data but skips ViewState and EventTargets
Posts only the method parameters and nothing else
Causes the Javascript code to be embedded into the page on every
generation. Fully self-contained.
Enumeration JavaScriptCodeLocationTypes
Keeps the .js file as an external file in the Web application. If this is
set you should set the <<%= TopicLink([ScriptLocation],[_1Q01F9K4D])
%>> Property to point at the location of the file.
This option requires that you deploy the .js file with your application.
Enumeration JavaScriptCodeLocationTypes
ASP.NET 2.0 option to generate a WebResource.axd call that feeds the .js
file to the client.
Enumeration JavaScriptCodeLocationTypes
Don't include any script - assume the page owner will handle it all
The proxy is generated inline of the page.
No proxy is generated at all
Works only with CallbackHandler implementations
that run as handlers at a distinct URL.
JsonCallbacks.ashx/jsdebug
Special return type that can be used to return messages to the
caller directly rather than throwing an exception.
Special exception type used to indicate that an exception was
fired on the server for a JSON callback. This exception is captured
by the CallbackHandler and serialized into CallbackErrorResponse
to the client in a consistent format.
Also used in various MVC related AJAX error handlers
(BaseController and JsonCallback
Additional Error Detail to assign to this error instance
Mimicks the CallbackException class except this is not based on an Exception.
Ideal for passing back as an error result from a failed serialization request
in an API or other service interface.
Additional Error Detail to assign to this error instance
CallbackHandler is an Http Handler base class that allows you to create a
class with methods marked up with a [CallbackMethod] attribute which are
then exposed for remote execution. The handler routes the to the methods
and executes the call and returns the results - or any errors - as JSON
strings.
To use this service you need to create an HttpHandler (either .ASHX or a
class registered in web.config's httpHandler section) and then add methods
with the [CallbackMethod] attribute and that's it. The service accepts
inputs via query string and POST data.
If you use the AjaxMethodCallbackControl the process of calling service
methods is fully automated including automatic client proxy creation and
you can call methods with individual parameters mapped from client to server.
Alternately you can also use plain REST calls that pass either no parameters
and purely access POST data, or pass a single JSON object that can act as
a single input parameter.
The service can be accessed with:
MyHandler.ashx?CallbackMethod=MethodToCall
POST data can then be passed in to act as parameters:
<<ul>>
<<li>> <<b>>Raw Post Buffer<</b>>
You simply pass raw POST data that you can access with Request.Form in the
handler
<<li>> <<b>>JSON value or object
string<</b>>
Alternately you can set the content type to application/json and pass a
JSON string of a value or object which calls the server method with a
single parameter of matching type.
<</ul>>
For more information on how to call these handlers see
Using CallbackHandler with REST Calls.
Shortcut to the ASP.NET Response object.
Allows easy access to the ASP.NET Response object to allow formatting of
the response. Note that CallbackHandler will set default content types and
encoding for a request which can be overridden in your code if necessary.
<<code lang="C#">>[CallbackMethod(RouteUrl="stocks/{symbol}")]
public StockQuote GetStockQuote(string symbol)
{
Response.Cache.SetExpires(DateTime.UtcNow.Add(new TimeSpan(0, 2, 0)));
StockServer server = new StockServer();
return server.GetStockQuote(symbol);
}<</code>>
Class CallbackHandler
Shortcut reference to active ASP.NET Request object
Shortcut to the current HttpContext instance
This handler is not thread-safe
Optionally store RouteData on this handler
so we can access it internally
Handle the actual callback by deferring to JsonCallbackMethodProcessor()
Route handler that can create instances of CallbackHandler derived
callback classes. The route handler tracks the method name and
creates an instance of the service in a predictable manner
CallbackHandler type
Method name that is to be called on this route.
Set by the automatically generated RegisterRoutes
invokatio.n
The type of the handler we're going to instantiate.
Needed so we can semi-generically instantiate the
handler and call the method on it.
Constructor to pass in the two required components we
need to create an instance of our handler.
Retrieves an Http Handler based on the type specified in the constructor
Generic method to register all routes from a CallbackHandler
that have RouteUrls defined on the [CallbackMethod] attribute
Marker Attribute to be used on Callback methods. Signals
parser that the method is allowed to be executed remotely
Allows specification of an ASP.NET style route URL to
a Service Method.
Parameterized route fragments ( {parameter} ) should match
parameter names.
products/{id}
products/add
products/add/{sku}
service/helloworld/{name}/{company}
Applies only to CallbackHandler based handlers.
Doesn't have any effect on Page methods called with AjaxMethodCallback
Routes need to *uniquely* identify a method in a CallbackHandler.
Make sure you don't have the same route or same partially parameterized
route pointing at multiple methods - in which case you may end up with
routing mismatches.
stocks/{symbol}
stocks/{symbollist}
Content Type used for results that are returned as Stream
or raw string values. Same as setting Response.ContentType
but more clear in the attribute
Allows specifying of the HTTP Verb that is accepted for the called method.
The default is HttpVerbs.All.
Requests that fail to access the endpoint with the right HTTP Verb will not
get called and return a 405 error along with an error object (JSON/XML) that
details the error in the body.
Class CallbackMethodAttribute
<<code lang="C#">>// Allow both GET and POST
operations
[CallbackMethod(AllowedHttpVerbs=HttpVerbs.GET | HttpVerbs.POST),
RouteUrl="stocks/{symbol}"]
public StockQuote GetStockQuote(string symbol)
{ ... }<</code>>
When set to true indicates that a string result returned to the
client should not be encoded in anw way. This can be more efficient for
large string results passed back to the client when returning
HTML or other plain text and avoids extra encoding and decoding.
The client can also specify format=string on the querystring to
return string values as raw strings.
Default Constructor for CallbackMethodAttribute. No functionality added
This class provides helper services to the CallbackProcessor classes with
the generic services that deal with method execution and parsing POST
parameters which should be independent of the specific implementation
(JSON, XML etc.).
Extracted here so other Callback Processors can be created more easily
later on, using other request formats (Xml etc.)
Executes the requested method.
to the proper types for execution.
An array of the string json parameters to
The object to call the method on
An array of json Strings that make up the parameters for the method call. This value can be null in which case parms are parsed out of GET QueryString or POST values
An optional instance of an CallbackAttribute that is set by this method
the result of the method execution
A generic Callback/Service Response message object
Inteface that defines the Callback operations for handling method callbacks
on the server.
This interface serves as an abstraction for potentially different implementations
that use XML instead of JSON.
Generic method that handles processing a Callback request by routing to
a method in a provided target object.
The target object that is to be called. If null this is used
Returns an error response to the client from a callback. Code
should exit after this call.
This is the core implementation of the JSON callback method handler that
picks up POST data from the request and uses it to call the actual callback
method on the specified object and return the results back as JSON.
This processor is generic and can be used easily from anywhere that needs
to feed back JSON data from a method callback, simply calling the
ProcessCallbackMethod() with an object that contains methods that are
marked up with the [CallbackMethod] attribute.
For example, wwCallbackHandler simply forwards all processing like this:
<<code lang="C#">>public void ProcessRequest(HttpContext
context)
{
// Pass off to the worker Callback Processor
ICallbackMethodProcessor processor = new JsonCallbackMethodProcessor();
// Process the inbound request and execute it on this
// Http Handler's methods
processor.ProcessCallbackMethodCall(this);
}<</code>>
This processor is expected to execute in an environment where
HttpContext.Current is available and where POST data is available to
describe the incoming parameter data and method to call.
JSONP method parameter value if provided
Generic method that handles processing a Callback request by routing to
a method in a provided target object.
The target object that is to be called. If null this is used
This method handles special return types from callback methods
by examining the return type or the ResultFormat query string.
Checks are performed for:
Stream, Bitmap, byte[] and raw string output
Generic method that handles processing a Callback request by routing to
a method in a provided target object.
This version doesn't pass in the method name but retrieves it from the
POST data or query string.
Returns an error response to the client from a callback. Code
should exit after this call.
This is the core implementation of the JSON callback method handler that
picks up POST data from the request and uses it to call the actual callback
method on the specified object and return the results back as JSON.
This processor is generic and can be used easily from anywhere that needs
to feed back JSON data from a method callback, simply calling the
ProcessCallbackMethod() with an object that contains methods that are
marked up with the [CallbackMethod] attribute.
For example, wwCallbackHandler simply forwards all processing like this:
<<code lang="C#">>public void ProcessRequest(HttpContext
context)
{
// Pass off to the worker Callback Processor
ICallbackMethodProcessor processor = new JsonCallbackMethodProcessor();
// Process the inbound request and execute it on this
// Http Handler's methods
processor.ProcessCallbackMethodCall(this);
}<</code>>
This processor is expected to execute in an environment where
HttpContext.Current is available and where POST data is available to
describe the incoming parameter data and method to call.
Implemented only for compatibility
Generic method that handles processing a Callback request by routing to
a method in a provided target object.
The target object that is to be called. If null this is used
This method handles special return types from callback methods
by examining the return type or the ResultFormat query string.
Checks are performed for:
Stream, Bitmap, byte[] and raw string output
Generic method that handles processing a Callback request by routing to
a method in a provided target object.
This version doesn't pass in the method name but retrieves it from the
POST data or query string.
Returns an error response to the client from a callback. Code
should exit after this call.
Master instance of the JSONSerializer that the user interacts with
Used to read option properties
Encodes Dates as a JSON string value that is compatible
with MS AJAX and is safe for JSON validators. If false
serializes dates as new Date() expression instead.
The default is true.
Determines if there are line breaks inserted into the
JSON to make it more easily human readable.
Force a master Serializer to be passed for settings
More text is a basic JSON serializer and deserializer that
deals with standard .NET types. Unlike the MS Ajax JSONSerializer
parser this parser support serialization and deserialization without
explicit type markup in the JSON resulting in a simpler two-way model.
The inbound model for complex types is based on Reflection parsing
of properties.
Master instance of the JSONSerializer that the user interacts with
Used to read option properties
ISO or MSAJAX serialization modes. Not supported with JSON.NET
Determines if there are line breaks inserted into the
JSON to make it more easily human readable.
Force a master Serializer to be passed for settings
Serializes a .NET object reference into a JSON string.
The serializer supports:
<<ul>>
<<li>> All simple types
<<li>> POCO objects and hierarchical POCO objects
<<li>> Arrays
<<li>> IList based collections
<<li>> DataSet
<<li>> DataTable
<<li>> DataRow
<</ul>>
The serializer works off any .NET type - types don't have to be explicitly
serializable.
DataSet/DataTable/DataRow parse into a special format that is essentially
array based of just the data. These objects can be serialized but cannot be
passed back in via deserialization.
Class JSONSerializer
The strongly typed value to parse
Takes a JSON string and attempts to create a .NET object from this
structure. An input type is required and any type that is serialized to
must support a parameterless constructor.
The de-serializer instantiates each object and runs through the properties
The deserializer supports <<ul>> <<li>> All simple
types <<li>> Most POCO objects and Hierarchical POCO objects
<<li>> Arrays and Object Arrays <<li>> IList based
collections <</ul>>
Note that the deserializer doesn't support DataSets/Tables/Rows like the
serializer as there's no type information available from the client to
create these objects on the fly.
Class JSONSerializer
A string of JSON text passed from the client.
The type of the object that is to be created from the JSON text.
The high level JSON Serializer wrapper that provides
serialization and deserialization services to the application.
This class merely defers operation to the specified JSON parsing implementation
to allow for pluggable JSON serializers to be used.
Supported parsers include:
* West Wind Native that's built-in (no dependencies) (This is the default)
* JavaScriptSerializer (ASP.NET JavaScript Serializer)
* JSON.NET (requires JSON.NET assembly to be included and JSONNET_REFERENCE global Define
This property determines the default parser that is created when
using the default constructor. This is also the default serializer
used when using the AjaxMethodCallback control.
This property should be set only once at application startup typically
in Application_Start of a Web app.
Determines whether fields are serialized. Supported only for the West Wind JSON Serializer
Determines the date serialization mode supported
for the Westwind and Json.NET parsers (not the JavaScript JSON Serializer)
Determines if there are line breaks inserted into the
JSON to make it more easily human readable.
By default if running in DebugMode this flag will be set to true
Default Constructor - assigns default
Default - West Wind JSON parser.
NewtonSoft JSON.NET JSON Parser
The ASP.NET JavaScript Serializer
Enumeration that determines how JavaScript dates are
generated in JSON output
More text is a basic JSON serializer and deserializer that
deals with standard .NET types. Unlike the MS Ajax JSONSerializer
parser this parser support serialization and deserialization without
explicit type markup in the JSON resulting in a simpler two-way model.
The inbound model for complex types is based on Reflection parsing
of properties.
More text is a basic JSON serializer and deserializer that
deals with standard .NET types. Unlike the MS Ajax JSONSerializer
parser this parser support serialization and deserialization without
explicit type markup in the JSON resulting in a simpler two-way model.
The inbound model for complex types is based on Reflection parsing
of properties.
The JavaScript base date on which all date time values
in JavaScript are based. Offsets are given in milliseconds
(ie. new Date(99990123) where the number is the offset in ms
from the base date)
Master instance of the JSONSerializer that the user interacts with
Used to read option properties
White space checking for char values
Internally held set of types traversed. Circular references are
not serialized and return null
Encodes Dates as a JSON string value that is compatible
with MS AJAX and is safe for JSON validators. If false
serializes dates as new Date() expression instead.
The default is true.
Determines if there are line breaks inserted into the
JSON to make it more easily human readable.
Determines whether fields are serialized
Force a master Serializer to be passed for settings
Master Serializer contructor is preferred
Serializes a .NET object reference into a JSON string.
The serializer supports:
<<ul>>
<<li>> All simple types
<<li>> POCO objects and hierarchical POCO objects
<<li>> Arrays
<<li>> IList based collections
<<li>> DataSet
<<li>> DataTable
<<li>> DataRow
<</ul>>
The serializer works off any .NET type - types don't have to be explicitly
serializable.
DataSet/DataTable/DataRow parse into a special format that is essentially
array based of just the data. These objects can be serialized but cannot be
passed back in via deserialization.
Class JSONSerializer
The strongly typed value to parse
Takes a JSON string and attempts to create a .NET object from this
structure. An input type is required and any type that is serialized to
must support a parameterless constructor.
The de-serializer instantiates each object and runs through the properties
The deserializer supports <<ul>> <<li>> All simple
types <<li>> Most POCO objects and Hierarchical POCO objects
<<li>> Arrays and Object Arrays <<li>> IList based
collections <</ul>>
Note that the deserializer doesn't support DataSets/Tables/Rows like the
serializer as there's no type information available from the client to
create these objects on the fly.
Class JSONSerializer
A string of JSON text passed from the client.
The type of the object that is to be created from the JSON text.
Deserializes JSON string into a specified type value.
Serialization routine that takes any value and serializes
it into JSON.
Date formatting follows Microsoft ASP.NET AJAX format which
represents dates as strings in the format of: "\/Date(231231231)\/"
This code is based originally on Jason Diamond's JSON code
in Anthem.NET although heavy modifications have been made.
Writes a string as a JSON string
Writes a date out as a JSON string into the string builder.
Data format is set based serialized based on the DateSerializationMode.
Outputs any dictionary type that has a string key.
Non string keys will cause an exception.
Unescapes string encoded Unicode character in the format of \u03AF
High level parsing method that takes a JSON string and tries to
convert it to the appropriate type.
Parses a JSON string into a string value
Parses Date Time values. Supports parsing values in various formats:
new Date()
MS Ajax Date Form (\/Date(xxxx)\/)
ISO Date Format
Parsing routine specific to parsing an object. Note the recursive flag which
allows skipping over prefix information.
Parses a array and IList subtype
Supports only Objects as array items
Parses a JSON array string to its underlying array type.
Requires:
- Array must be of a single element type (ie. an object, or string or decimal)
Re-written by Joe McLain with modifications by Rick Strahl
06/01/2008
Returns the type of item type of the array/collection
Strips a comma off a string builder. In Format mode
,\r\n are stripped
This is a proxy object for the Page.ClientScript and MS Ajax ScriptManager
object that can operate when MS Ajax when present otherwise falling back to
Page.ClientScript. Because MS Ajax may not be available accessing the
methods directly is not possible and we are required to indirectly
reference client script methods through this class.
This class should be invoked at the Control's start up and be used to
replace all calls Page.ClientScript. Scriptmanager calls are made through
Reflection indirectly so there's no dependency on the script manager.
This class also provides a few additional page injection helpers like the
abillity to load scripts in the page header (rather than in the body) and
to use script compression using wwScriptCompressionModule without using MS
Ajax.
Determines the default script rendering mode that is uses if no script rendering mode
is explicitly provided on the control.
This setting is global and should be set only once in Appplication_Start or
a static constructor.
Internal global static that gets set when IsMsAjax() is
called. The result is cached once per application so
we don't have keep making reflection calls for each access
Flag that determines whether check was previously done
Cached value to see whether the script manager is
on the page. This value caches here once per page.
Current instance of this class which should always be used to
access this object. There are no public constructors to
ensure the reference is used as a Singleton to further
ensure that all scripts are written to the same clientscript
manager.
No public constructor - use ClientScriptProxy.Current to
get an instance to ensure you once have one instance per
page active.
Clears all the request specific context items which are script references
and the script placement index.
Checks to see if MS Ajax is registered with the current
Web application.
Note: Method is static so it can be directly accessed from
anywhere. If you use the IsMsAjax property to check the
value this method fires only once per application.
Checks to see if a script manager is on the page
High level helper function that is used to load script resources for various AJAX controls
Loads a script resource based on the following scriptLocation values:
* WebResource
Loads the Web Resource specified out of ControlResources. Specify the resource
that applied in the resourceName parameter
* Url/RelativeUrl
loads the url with ResolveUrl applied
* empty string (no value)
No action is taken and nothing is embedded into the page. Use this if you manually
want to load resources
The control instance for which the resource is to be loaded
WebResource, a virtual path or a full Url. Empty to not embed any script refs (ie. user loads script herself)
The name of the resource when WebResource is used for scriptLocation null otherwise
Determines if scripts are loaded into the header whether they load at the top or bottom
Returns a WebResource or ScriptResource URL for script resources that are to be
embedded as script includes.
Any control
A type in assembly where resources are located
Name of the resource to load
Determines where in the document the link is rendered
Registers a script include tag into the page for an external script url.
This version embeds only in the body of the HTML document - ie. underneath the form tag
Registers a client script reference into the page with the option to specify
the script location in the page
Any control instance - typically page
Type that acts as qualifier (uniqueness)
the Url to the script resource
Determines where the script is rendered
Registers a CSS Web Resource in the page
Keep track of keys that were written
Registers a CSS stylesheet in the page header and if that's not accessible inside of the form tag.
Registers a client script block in the page.
Renders client script block with the option of rendering the script block in
the Html header
For this to work Header must be defined as runat="server"
any control that instance typically page
Type that identifies this rendering
unique script block id
The script code to render
Ignored for header rendering used for all other insertions
Where the block is rendered
Registers a startup code snippet that gets placed at the bottom of the page
Returns a WebResource URL for non script resources
Returns a WebResource URL for non script resources
Works like GetWebResourceUrl but can be used with javascript resources
to allow using of resource compression (if the Script Compression Module is loaded).
Works like GetWebResourceUrl but can be used with javascript resources
to allow using of resource compression (if the module is loaded).
Injects a hidden field into the page
Determines how scripts are included into the page
Inherits the setting from the control or from the ClientScript.DefaultScriptRenderMode
Renders the script include into the bottom of the header of the page
Renders the script include into the top of the header of the page
Uses ClientScript or ScriptManager to embed the script include to
provide standard ASP.NET style rendering in the HTML body.
Renders script at the bottom of the page before the last Page.Controls
literal control. Note this may result in unexpected behavior
if /body and /html are not the last thing in the markup page.
An alias/shortcut resource name
The name of the script file that this resource maps to. Should be just
the filename (ie. jquery.js or ww.jquery.js) as well as min.js versions
if those files are loaded as well
The full resource name to the resourceToFileItem
Any type in the assembly that contains the script resource
If null looks in the current executing assembly.
JsonVariables provides an easy way to embed server side objects and values
as JSON into client side JavaScript code.
You can use the dynamic Add() method to add properties to an object
with each added value becoming a property on the rendered JSON object.
Pass simple values, or complex objects and lists to easily push server
side static data into client side JavaScript code.
The static ToJsonString() and ToJsonHtmlString() methods also provide
easy self contained JSON serialization for any object.
This component produces either straight string or HtmlString output when used directly
using the ToString() or HtmlString() methods for use in ASP.NET MVC or Web Pages,
or can be used as WebForms control that automatically handles embedding of
the script and deserialization of return values on the server.
This component supports:<<ul>>
<<li>> Creating individual client side variables
<<li>> Dynamic values that are 'evaluated' in OnPreRender to
pick up a value
<<li>> Creating properties of ClientIDs for a given container
<<li>> Changing the object values and POSTing them back on
Postback
<</ul>>
You create a script variables instance and add new keys to it:
<<code lang="C#">>
var scriptVars = new JsonVariables("scriptVars");
// Simple value
scriptVars.Add("userToken", UserToken);
var book = new AmazonBook();
book.Entered = DateTime.Now;
// Complex value marshalled
scriptVars.Add("emptyBook", book);
In client code you can then access these variables:
<<code lang="JavaScript">>$( function() {
alert(scriptVars.book.Author);
alert(scriptVars.author);
alert( $("#" + scriptVars.txtAmazonUrlId).val() );
});<</code>>
Edit
Internally holds all script variables declared
The name of the object generated in client script code
Internal instance of the Json Serializer used to serialize
the object and deserialize the updateable fields
Full constructor that receives an instance of any control object
and the client name of the generated script object that contains
the specified properties.
Internal routine to create serializer instance
Adds a property and value to the client side object to be rendered into
JavaScript code. VariableName becomes a property on the object and the
value will be properly converted into JavaScript Compatible JSON text.
Class ScriptVariables
The name of the property created on the client object.
The value that is to be assigned. Can be any simple type and most complex
objects that can be serialized into JSON.
<<code
lang="C#">>ScriptVariables scriptVars = new
ScriptVariables(this,"serverVars");
// Add simple values
scriptVars.Add("name","Rick");
scriptVars.Add("pageLoadTime",DateTime.Now);
// Add objects
AmazonBook amazon = new AmazonBook();
bookEntity book = amazon.New();
scripVars.Add("book",book);
<</code>>
Adds an entire dictionary of values
Serialization helper that can be used to easily embed
JSON values into ASP.NET pages.
For Razor page embedding use ToJsonHtmlString instead.
value or object to serialize
JSON string
Serialization helper that can be used to easily
embed JSON values into Razor pages. Returns
an HTML string that doesn't require @Html.Raw()
value or object to serialize
JSON string that is not reencoded by Razor
Creates a JSON dictionary where the top level properties
are created from the dictionary's keys.
Returns the rendered JavaScript for the generated object and name.
Note this method returns only the generated object, not the
related code to save updates.
You can use this method with MVC Views to embedd generated JavaScript
into the the View page.
Returns the script as an HTML string. Use this version
with AsP.NET MVC to force raw unencoded output in Razor:
@scriptVars.ToHtmlString()
Outputs the variable data as a raw JSON object
Outputs the the dictionary as a JSON string for MVC
JavaScript minifier strips white space and comments from JavaScript
code. Based on Douglas Crockford's JavaScript Minifier with some modification
to support string and StreamReader conversions.
This class can minify strings in memory or files and entire directories of
disk files.
The MinifyDirectory() method can be used in the build process for VS or
can easily be used at application startup to automatically create minified
script files for an application.
Minifies a source file into a target file.
Source file that is to be compressed
Target file that is to contain the compressed output
Minifies a JavaScript code string into a minified string.
Input Javascript string to be minified
Minifies all JavaScript files in a given directory and writes out the
minified files to a new file extensions (.min.js for example).
This method can be integrated into the build process, or as part of an
application's startup to always create new minified scripts as needed.
Scripts are only minified if the minified files don't already exist and are
older than the corresponding JavaScript file.
A common usage scenario is to call this static method from
Application_Start:
<<code lang="C#">>void Application_Start(object sender,
EventArgs e)
{
// creates minify scripts if don't exist or are changed
// NOTE: REQUIRES that IIS/ASP.NET Account has writes to write
here!
Westwind.Web.Controls.JavaScriptMinifier.MinifyDirectory(Server.MapPath("~/
scripts"), ".min.js", true);
}<</code>>
to always ensure minified files are in sync with corresponding JavaScript
files.
Class JavaScriptMinifier
The path where files are to be minfied
The extension for the minified files (ie. .min.js). Include leading dot!
Determines whether nested directories are also included
Note that if you use this script from within an ASP.NET application it's
best to hook it to a Application_Start or a static constructor so it only
fires once.
When called from ASP.NET this routine REQUIRES that the server account that
ASP.NET/IIS AppPool runs under (NETWORK SERVICE by default) has rights to
write out the file to the folder specified. Otherwise an exception occurs.
A strongly-typed resource class, for looking up localized strings, etc.
Returns the cached ResourceManager instance used by this class.
Overrides the current thread's CurrentUICulture property for all
resource lookups using this strongly typed resource class.
Looks up a localized string similar to An error occurred in your Application.
Looks up a localized string similar to Bitmap output returned must specify a Content type. For example: [CallbackMethod(ContentType="image/png")].
Looks up a localized string similar to Can't get values if AllowUpdates is not set to true.
Looks up a localized string similar to Can't retrieve items in update mode .
Looks up a localized string similar to In order to call a Wcf or ASMX service you have to specify ClientProxyTargetType of the Web Service instance..
Looks up a localized string similar to Invalid JSON string input..
Looks up a localized string similar to Only one ScriptContainer is allowed per page..
Looks up a localized string similar to ScriptContainer.Current only works with Page based handlers..
Looks up a localized string similar to Unable to convert content type {0} to ImageFormat.
Looks up a localized string similar to Unable to convert ImageFormat {0} to ContentType.
Looks up a localized string similar to Invalid BindingSource.
Looks up a localized string similar to Invalid Control.
Looks up a localized string similar to Invalid Control Id.
Looks up a localized string similar to Invalid Server Method..
Looks up a localized string similar to Invalid URL: Virtual path relative URL (~) not allowed when HttpContext not available..
Looks up a localized string similar to Not allowed. Method expects {0}..
Looks up a localized string similar to Server method is not accessible due to missing CallbackMethod attribute.
Looks up a localized string similar to Unsupported JSON Serializer specified. Json.Net and System.Web.Extensions must be explicitly compiled in..
Looks up a localized string similar to WebResource not available for jQuery UI.
Class is used as to consolidate access to resources
* Icon Resource Strings */
Returns a string resource from a given assembly.
Assembly reference (ie. typeof(ControlResources).Assembly)
Name of the resource to retrieve
Returns a string resource from the from the ControlResources Assembly
Class that handles embedding of common script files like jQuery into
a page or return complete script tags for insertion into a ViewPage as a string.
Determines what location jQuery is loaded from
jQuery CDN Url on Google
Fallback Url if CDN can't be reached.
jQuery CDN Url on Google
jQuery UI fallback Url if CDN is unavailable or WebResource is used
Note: The file needs to exist and hold the minimized version of jQuery ui
The url the jQuery UI *base* CSS theme. Used in jQueryUiCssLink. Should point
at the jQuery UI base theme - the theme is replaced either explicitly or from
the jQueryUiTheme property value.soap
The theme that is applied to the jQueryUiCssBaseUrl
Internally used Page instance so we can get access to
a Page instance when no Page might be available. To Access ClientScript etc.
Loads jQuery depending on configuration settings (CDN, WebResource or site url)
and injects the full script link into the page.
Optional url to jQuery as a virtual or absolute server path
Inserts a script link to load jQuery into the page based on the jQueryLoadModes settings
of this class. Default load is by CDN plus WebResource fallback
An optional explicit URL to load jQuery from. Url is resolved.
When specified no fallback is applied
full script tag and fallback script for jQuery to load
Inserts a script link to load jQuery into the page based on the jQueryLoadModes settings
of this class. Default load is by CDN plus WebResource fallback
An optional explicit URL to load jQuery from. Url is resolved.
When specified no fallback is applied
full script tag and fallback script for jQuery to load
Returns the global jQuery UI Url and theme set on this class
Returns a fully qualified script tag for loading ww.jquery.js
Loads the jQuery component uniquely into the page
Optional Url to the jQuery Library. NOTE: Should also have a .min version in place
Loads the ww.jquery.js library from Resources at the end of the Html Header (if available)
Loads the appropriate jScript library out of the scripts directory and
injects into a WebForms page.
Optional url to jQuery as a virtual or absolute server path
The location from which jQuery and jQuery UI are loaded
in Release mode.
Default error display mode uses ASP.NET default
behavior: Yellow screen of death or ASP.NET
error display configured.
An application specific error message meant to
be seen by end users. Typically this mode display
only a fixed error message and no or limited
error details.
Display the application specific error message
but also adds additional developer information
that provides debugging information to a developer
while the app is running in production.
User information container that can easily 'serialize'
to a string and back. Meant to hold basic logon information
to avoid trips to the database for common information required
by an app to validate and display user info.
I use this class a lot to attach as Forms Authentication
Ticket data to keep basic user data without having to
hit the database
The display name for the userId
The user's email address or login acount
The user's user Id as a string
The users admin status
Returns the User Id as an int if convertiable
A unique id created for this entry that can be used to
identify the user outside of the UserState context
Exports a short string list of Id, Email, Name separated by |
Imports Id, Email and Name from a | separated string
Creates an instance of a userstate object from serialized
data.
IsEmpty() will return true if data was not loaded. A
UserData object is always returned.
Creates an instance of a userstate object from serialized
data.
IsEmpty() will return true if data was not loaded. A
UserData object is always returned.
Creates a UserState object from authentication information in the
Forms Authentication ticket.
IsEmpty() will return false if no data was loaded but
a Userdata object is always returned
Creates a UserState object from authentication information in the
Forms Authentication ticket.
IsEmpty() will return false if no data was loaded but
a Userdata object is always returned
Determines whether UserState instance
holds user information.
Module that handles compression of JavaScript resources using GZip and
script optimization that strips comments and extra whitespace.
This module should be used in conjunction with
ClientScriptProxy.RegisterClientScriptResource which sets up the proper URL
formatting required for this module to handle requests. Format is:
wwSc.axd?r=ResourceName&t=FullAssemblyName
The type parameter can be omitted if the resource lives in this assembly.
To configure the module in web.config (for pre-IIS7):
<<code lang="XML">><system.web>
<httpModules>
<add name="ScriptCompressionModule"
type="Westwind.Web.ScriptCompressionModule,Westwind.Web"/>
</httpModules>
</system.web><</code>>
For IIS 7 Integrated mode:
<<code lang="XML">><system.webServer>
<validation validateIntegratedModeConfiguration="false"/>
<modules>
<add name="ScriptCompressionModule"
type="Westwind.Web.ScriptCompressionModule,Westwind.Web"/>
</modules>
</system.webServer><</code>>
Stores resource names and their associated content types for lookup
Global flag that is set when the module is first loaded by ASP.NET and
allows code to check whether the module is loaded.
Used by ClientScriptProxy to determine if the module is active and
available in the ASP.NET Pipeline.
Returns an error response to the client. Generates a 404 error
Sends the output to the client using appropriate cache settings.
Content should be already encoded and ready to be sent as binary.
Very basic script optimization to reduce size:
Remove any leading white space and any lines starting
with //.
Finds an assembly in the current loaded assembly list
Takes a binary input buffer and GZip encodes the input
Takes a string input and GZip encodes the input
Embeds a link to a script resource into the page including the
script tags. Uses Page.ClientScript so the link is embedded into
the page content rather than the header.
Preferrably use ClientScriptProxy.RegisterClientScriptInclude instead
as it provides more options (including placement in header)
Works like GetWebResourceUrl but can be used with javascript resources
to allow using of resource compression (if the module is loaded).
Item stored in the cache
Implements the Gravatar API for retrieving a Gravatar image to display
Returns a Gravatar image url for an email address
Email address to display Gravatar for
Size in pixels (square image) (80)
Parental Guidance rating of image (PG)
Url to image if no match is found.
If not passed gravatar provides default image
Returns a Gravatar Image Tag that can be directly embedded into
an HTML document.
Email address to display Gravatar for
Size in pixels (square image) (80)
Parental Guidance rating of image (PG)
Any extra attributes to stick on the img tag
Url to image if no match is found.
If not passed gravatar provides default image
Class that holds a few static string definitions for
embedding Share on Google+ and Twitter
Places a Google+ +1 and Share button in the page
The Url to share. If not provided the current page is used
small,medium,standard,tall
Inserts a Tweet button to share tweet on Twitter with an image link
The text to present
This class provides a holding container for BindingErrors. BindingErrors
occur during binding and unbinding of controls and any errors are stored in
this collection. This class is used extensively for checking for
validation errors and then displaying them with the ToString() or ToHtml()
methods.
Formats all the BindingErrors into a rich list of error messages. The error
messages are marked up with links to the appropriate controls. Format of
the list is a <ul> style list ready to display in an HTML page.
Class BindingErrors
an Html string of the errors
Renders a link with the error message that attempts to find the control on the
page and highlights it.
Formats an Binding Errors collection as a string with carriage returns
Error object used to return error information during databinding.
The ClientID of the control the error occurred on. This value is used to
provide the hot linking to the control.
Class BindingError
The error message that is displayed for the Binding error.
Class BindingError
The raw Exception error message. Not used at the moment.
Class BindingError
A generic Web Cookie handler class that can be used for a single 'UserId' in an
application. This class manages all aspects of retrieving and setting of a cookie
consistently. Typically all you'll need to do is call the GetId() method which
both returns existing cookies and ensures that the cookie gets set.
All methods of this class are static which is the reason why only a single Cookie
can be managed at a time. The idea is that you can use this single cookie as an
application global Cookie to track a user and then retrieve additional storage
information from other locations (like a database or session).
Writes the cookie into the response stream with the value passed. The value
is always the UserId.
Class WebStoreCookie
Writes a value into the specified cookie.
Void
Writes the cookie into the response stream with the value passed. The value
is always the UserId.
Class WebStoreCookie
Writes a value into the specified cookie.
Void
Removes the cookie by clearing it out and expiring it immediately.
Class WebStoreCookie
Void
Determines whether the cookie exists
Sets the Cookie Path
A generic Cookie class that manages an individual Cookie by localizing the
cookie management into a single class. This means the Cookie's name and
and timing is abstracted.
The GetId() method is the key method here which retrieves a Cookie Id.
If the cookie exists it returns the value, otherwise it generates a new
Id and creates the cookie with the specs of the class and
It's recommended you store this class as a static member off another
object to have
The name of the Cookie that is used. This value should always be set or
overridden via the constructor.
Class wwCookie
The timeout of a persistent cookie.
Class wwCookie
Writes the cookie into the response stream with the value passed. The value
is always the UserId.
Class WebStoreCookie
Void
Writes the cookie into the response stream with the value passed. The value
is always the UserId.
Class WebStoreCookie
Void
Removes the cookie by clearing it out and expiring it immediately.
Class WebStoreCookie
Void
This is the key method of this class that retrieves the value of the
cookie. This method is meant as retrieving an ID value. If the value
doesn't exist it is created and the cookie set and the value returned. If
the Cookie exists the value is retrieved and returned.
Class wwCookie
String
Method that generates the ID stored in the cookie. You can override
this method in a subclass to handle custom or specific Id creation.
Determines whether the cookie exists
Class wwCookie
Boolean
Generic routine to create a cookie consistently and with the
proper HTTP settings applied
Sets the Cookie Path
The class that provides FormVariable to Model binding by matching
FormVariable names to the model's properties including child
properties. You can specify a
The base behavior is similar to ASP.NET MVC's ModelBinder's
binding operation minus the validation features.
Note on Child Property Separators:
WebForms doesn't support '.' characters in ID= values so
you will need to specify a FormVarPropertySeparator. A good
value to use is '__' (two underscores) to allow for underscores
in actual properties. If you know your properties don't have underscores
then a single '_' will also work. The separator is converted to . when
parsing for child property names.
An object to bind to
The character used as a separator in the HTML form for child properties
(ie. Address.Street or Address.Phone.Home)
Default value is a .
An optional prefix on form variables to unbind.
Can also specify multiple prefixes separated by commas.
List of exceptions that aren't to be bound. Uses the Form variable name.
Binding Errors that occur on unbining into the model
The object to unbind to
Comma seperated list of properties to exclude
Unbinds form variables into the specified target object
Unbinds form variable data into a model object.
Object to unbind to
Properties to skip
Form Variable prefixes to include. Prefix is stripped. (txtName maps to Name)
A semi-generic Stream implementation to use with Response.Filter.
Uses an event based interface for handling Content capture and
transformations with several variations of events that can
capture the entire output and transform it or work on actual
Response Write() chunks individually.
The key operational interface to this class is via exposed via Events
More information on how this class works:
http://www.west-wind.com/weblog/posts/72596.aspx
ResponseFilterStream filter = new ResponseFilterStream(Response.Filter);
filter.TransformStream += filter_TransformStream;
Response.Filter = filter;
The original stream
Current position in the original stream
Stream that original content is read into
and then passed to TransformStream function
Internal pointer that that keeps track of the size
of the cacheStream
Determines whether the stream is captured
Determines whether the Write method is outputting data immediately
or delaying output until Flush() is fired.
Event that captures Response output and makes it available
as a MemoryStream instance. Output is captured but won't
affect Response output.
This routine captures Response output in a MemoryStream.
Use with care on large content.
Event that captures Response output and makes it available
as a string. Output is captured but won't affect Response output.
This routine captures Response output in a MemoryStream.
Use with care on large content.
Event that allows you transform the stream as each chunk of
the output is written in the Write() operation of the stream.
This means that that it's possible/likely that the input
buffer will not contain the full response output but only
one of potentially many chunks.
This event is called as part of the filter stream's Write()
operation. It does not cache output.
Event that allows you to transform the response stream as
each chunk of bytep[] output is written during the stream's write
operation. This means it's possibly/likely that the string
passed to the handler only contains a portion of the full
output. Typical buffer chunks are around 16k a piece.
This event is called as part of the stream's Write operation.
It does not cache output.
This event allows capturing and transformation of the entire
output stream by caching all write operations and delaying final
response output until Flush() is called on the stream.
This routine captures Response output in a MemoryStream.
Use with care on large content.
Event that can be hooked up to handle Response.Filter
Transformation. Passed a string that you can modify and
return back as a return value. The modified content
will become the final output.
This routine captures Response output in a MemoryStream.
Use with care on large content.
Allows transforming of strings
Note this handler is internal and not meant to be overridden
as the TransformString Event has to be hooked up in order
for this handler to even fire to avoid the overhead of string
conversion on every pass through.
Wrapper method form OnTransformString that handles
stream to string and vice versa conversions
Override flush by writing out the cached stream data
Overriden to capture output written by ASP.NET and captured
into a cached stream that is written out later when Flush()
is called.
Application Error Module that can be used to handle
errors. Uses WebErrorHandler to collect error and
request information in a single place, and abstracts
the error handling to OnLogError and OnDisplayError
hooks to manage only the parts that we are typically
interested in in error processing.
Determines the error handling mode -
if you want to customize this value override it
in your application's startup code or from a configuration
value by overriding the Init().
Hook up Application.Error event
Override this method to set the error handling mode
which is configured when the appplication starts.
Override this method to handle displaying of error information.
You can write to the HTTP output stream. If using MVC you can
use the Westwind.Web.ViewRenderer class to easily display an
MVC view.
Contains error and request information
Model that contains a few simple properties like title and message
as well as an instance of the errorHandler object passed in to allow
for error pages that can provide a wealth of detail if desired.
Override this method to handle logging of errors. Gets passed
the WebErrorHandler instance that is fully parsed and filled
with the error and Http request data.
Contains formatted error and request information
The original exception that caused the error
Class that can be used to parse ASP.NET and exception error information
into an object. This class is ideal for capturing information for logging,
notification and display of detailed error information.
Also supports complete Application_Error handling with the HandleError
method which works off an exception and provides a complete handler for
processing error information with hooks for logging and displaying
of an error page.
The last exception that the error parsing uses
for creating the error properties when calling
Parse().
If true returns only the error message and URL.
Determines whether the routines attempt to retrieve Source Code lines.
The runtime error message thrown by the application.
The raw Web relative URL that caused this exception to occur.
Example: /WebStore/Item.aspx?sku=WWHELP
The completely qualified Url to this request.
Example: http://www.west-wind.com/webstore/item.aspx?sku=WWSTOREDOTNET
Stack trace listing as available from the runtime compiler
The source code if available for the error that occurred. The code will include the 5 surrounding lines before and after.
Source code is available only in Debug mode and if the source files are available on the server. Some errors that occur
inside of the .Net runtime itself or in ASP.Net pages also do not show the error.
Retrieves the source file if available
Method where the error occurred
Line Number if available
The client's IP address
The username of the user attached if the user is authenticated.
The client's browser string.
The referring Url that was used to access the current page that caused the error.
Content of the POST buffer if the page was posted. The size is limited to 2k. Larger buffers are stripped.
The size of the POST buffer if data was posted.
The complete querystring.
The Locale string returned by the browser
The time the error was logged.
List of all server variables
Gets the HTTP Status Code
Public constructor requires that an exception is passed in. Generally you'll want to do this is in Application_Error
and pass in in the InnerException of the error:
WebErrorHandler Handler = new WebErrorHandler(Server.GetLastError().InnerException);
The Exception to log
Parses the Exception into properties of this object. Called internally
by LogError, but can also be called externally to get easier information
about the error through the property interface.
Parses all ServerVariables into a string
Parses source code related properties
Semi generic Application_Error handler method that can be used
to handle errors without additional code. You should implement
the DisplayError event and LogError Event methods to display
a message when ErrorHandlingModes is not Default
Fired when all error information has been collected and
the information is ready for logging.
Allows overriding for logging error information in a subclass
Fired when at the end of the error handling process when an error page
needs to be displayed
Allows overriding of DisplayError
Summary description for wwWebUtils.
Returns a site relative HTTP path from a partial path starting out with a ~.
Same syntax that ASP.Net internally supports but this method can be used
outside of the Page framework.
Works like Control.ResolveUrl including support for ~ syntax
but returns an absolute URL.
Any Url including those starting with ~ for virtual base path replacement
relative url
Returns the path as relative of current location (ie. ./link.htm) if
HttpContext is not available. Note that this may result in some scenarios where
an invalid URL is returned if HttpContext is not present, but it allows for test
scenarios.
This method returns a fully qualified absolute server Url which includes
the protocol, server, port in addition to the server relative Url.
Works like Control.ResolveUrl including support for ~ syntax
but returns an absolute URL.
Any Url, either App relative (~/default.aspx)
or fully qualified
if true forces the url to use https
This method returns a fully qualified absolute server Url which includes
the protocol, server, port in addition to the server relative Url.
It work like Page.ResolveUrl, but adds these to the beginning.
This method is useful for generating Urls for AJAX methods
Any Url, either App relative or fully qualified
Returns the Application Path as a full Url with scheme
Returns the executing ASPX, ASCX, MASTER page for a control instance.
Path is returned app relative without a leading slash
Returns just the Path of a full Url. Strips off the filename and querystring
Translates an ASP.NET path like /myapp/subdir/page.aspx
into an application relative path: subdir/page.aspx. The
path returned is based of the application base and
starts either with a subdirectory or page name (ie. no ~)
The path is turned into all lower case.
A logical, server root relative path (ie. /myapp/subdir/page.aspx)
Application relative path (ie. subdir/page.aspx)
Translates the current ASP.NET path
into an application relative path: subdir/page.aspx. The
path returned is based of the application base and
starts either with a subdirectory or page name (ie. no ~)
This version uses the current ASP.NET path of the request
that is active and internally uses AppRelativeCurrentExecutionFilePath
Inserts a <script> source link into the page.
Includes carriage return at end.
The url to the script to load. Url is resolved
full script tag
Inserts a CSS <link> tag into the page.
Includes carriage return at end.
The url to the CSS file to load. Url is resolved
full CSS link tag
Creates the headers required to force the current request to not go into
the client side cache, forcing a reload of the page.
This method can be called anywhere as part of the Response processing to
modify the headers. Use this for any non POST pages that should never be
cached.
Class WebUtils
Void
Checks to see if a form variable exists in the
HttpContext. Only works in System.Web based applications
Retrieves a value by key from a UrlEncoded string.
UrlEncoded String
Key to retrieve value for
returns the value or "" if the key is not found or the value is blank
Returns a request value parsed into an integer. If the value is not found
or not a number null is returned.
The request key to retrieve
parsed integer or null on failure
Returns a request value parsed into an integer with an optional
default value set if the conversion fails.
defaults to -1
Returns the content of the POST buffer as string
Returns the result from an ASPX 'template' page in the /templates directory of this application.
This method uses an HTTP client to call into the Web server and retrieve the result as a string.
The name of a page (ASPX, HTM etc.) to retrieve plus the querystring
Examples: webform1.aspx, subfolder/WebForm1.aspx, ~/WebForm1.aspx,/myVirtual/WebForm1.aspx
If this method returns null this message will contain the error info
Merged Text or null if an HTTP error occurs - note: could also return an Error page HTML result if the template page has an error.
Sanitizes HTML to some of the most of
This provides rudimentary HTML sanitation catching the most obvious
XSS script attack vectors. For mroe complete HTML Sanitation please look into
a dedicated HTML Sanitizer.
input html
A list of HTML tags that are stripped.
Sanitized HTML
Parses a Carriage Return based into a <ul> style HTML list by
splitting each carriage return separated line.
Class WebUtils
The carriage return separated text list
string
Renders a control to a string - useful for AJAX return values
Renders a control dynamically by creating a new Page and Form
control and then adding the control to be rendered to it.
This routine works to render most Postback controls but it
has a bit of overhead as it creates a separate Page instance
The control that is to be rendered
if true forces a Page to be created
Html or empty
Renders a user control into a string into a string.
Instance of the page that is hosting the control
If false renders using RenderControl, otherwise uses Server.Execute() constructing a new form.
Optional Data parameter that can be passed to the User Control IF the user control has a Data property.
Renders a user control into a string into a string.
virtual path for the user control
If false renders using RenderControl, otherwise uses Server.Execute() constructing a new form.
Optional Data parameter that can be passed to the User Control IF the user control has a Data property.
Finds a Control recursively. Note finds the first match and exits
The top level container to start searching from
The ID of the control to find
If true uses FindControl to check for hte primary Id which is slower, but finds dynamically generated control ids inside of INamingContainers
Converts an ImageFormat value to a Web Content Type
Returns an image format from an HTTP content type string
Content Type like image/jpeg
Corresponding image format
Determines if GZip is supported
Sets up the current page or handler to use GZip through a Response.Filter
IMPORTANT:
You have to call this method before any output is generated!
Returns the IIS version for the given Operating System.
Note this routine doesn't check to see if IIS is installed
it just returns the version of IIS that should run on the OS.
Returns the value from Request.ServerVariables["Server_Software"]
if available. Otherwise uses OS sniffing to determine OS version
and returns IIS version instead.
version number or -1
Attempts to restart the active Web Application
Requires either Full Trust (HttpRuntime.UnloadAppDomain) or
or Write access to web.config otherwise the operation
will fail and return false.
Returns an encrypted string based on the local machine key of the local machine.
Can be used to create machine specific seed values that cannot be tracked via code
Optional - If no data is passed in a default seed value is used.
Encoded string
Applies only to ASP.NET Web applications
Encodes a string to be represented as a string literal. The format
is essentially a JSON string that is returned in double quotes.
The string returned includes outer quotes:
"Hello \"Rick\"!\r\nRock on"
Parses a JSON string into a string value
JSON string
unencoded string
Converts a .NET date to a JavaScript JSON date value.
.Net Date
Matchevaluated to unescape string encoded Unicode character in the format of \u03AF
Sets the culture and UI culture to a specific culture. Allows overriding of currency
and optionally disallows setting the UI culture.
You can also limit the locales that are allowed in order to minimize
resource access for locales that aren't implemented at all.
2 or 5 letter ietf string code for the Culture to set.
Examples: en-US or en
ietf string code for UiCulture to set
Override the currency symbol on the culture
if uiCulture is not set but setUiCulture is true
it's set to the same as main culture
Names of 2 or 5 letter ietf locale codes you want to allow
separated by commas. If two letter codes are used any
specific version (ie. en-US, en-GB for en) are accepted.
Any other locales revert to the machine's default locale.
Useful reducing overhead in looking up resource sets that
don't exist and using unsupported culture settings .
Example: de,fr,it,en-US
Sets a user's Locale based on the browser's Locale setting. If no setting
is provided the default Locale is used.
If not null overrides the currency symbol for the culture.
Use to force a specify currency when multiple currencies are not supported by the application
if true sets the UI culture in addition to core culture
Returns a JavaScript Encoded string from a Global Resource
Defaults to the "Resources" resource set.
Returns a resource string. Shortcut for HttpContext.GetGlobalResourceObject.
Resource Set Id (ie. name of the file or 'resource set')
The key in the resource set
Returns a resource string. Shortcut for HttpContext.GetGlobalResourceObject.
This version defaults to Resources as the resource set it.
Defaults to "Resources" as the ResourceSet (ie. Resources.xx.resx)
Key in the Resources resource set
Returns a JavaScript Encoded string from a Global Resource
Returns a local resource from the resource set of the current active request
local resource.
The resourceId of the item in the local resourceSet file to retrieve
Returns a local resource for the given resource set that you specify explicitly.
Use this method only if you need to retrieve resources from a local resource not
specific to the current request.
The resourceset specified as: subdir/page.aspx or page.aspx or as a virtual path (~/subdir/page.aspx)
The resource ID to retrieve from the resourceset
Returns a local resource properly encoded as a JavaScript string
including the quote characters.
HttpRequest Extension methods to facilitate various input retrieval tasks tasks
Determines whether a form variable exists
Returns a value via Params[] and attempts
to convert it to an integer.
Returns a value via Params[] and attempts
to convert it to a decimal value.
HttpResponse Extension methods to facilitate various output tasks
Writes output as an HTML 'line' by appending a <br /> and linefeed at the end
String to output
Writes formatted output as an HTML 'line' by appending a <br /> and linefeed at the end
HttpResponse object
format string
format string arguments
Writes formatted output into the Response
HttpResponse object
format string
format string arguments