asp.net

jQuery Limit text entry

Rajesh Pillai — Thu, 03 Dec 2009 12:10:31 GMT

Lets quickly have a look at how you can limit the entry to textbox and display the character input left to be keyed in.

First things first, the script.

<script type="text/javascript">
    $(function() {
        var limit = 250;
        $('#dvLimit').text('250 characters left');
        $('textarea[id$=txtDemoLimit]').keyup(function() {
            var len = $(this).val().length;
            if (len > limit) {
                this.value = this.value.substring(0, limit);
            }
            $("#dvLimit").text(limit - len + " characters left");
        });
    });
</script>

The $() function does the following things on startup.

1. Set a variable to a limit of 250 characters.

2. Assign a default value to the "div" element with id "dvLimit"

3. Find the control that contains the id "txtDemoLimit" and hook up the keyup event.

4. In the keyup event get the length of the current text.

5. If len is greater than the limit set, set the text value as a substring within the specified limit.

6. Update the div with the no. of characters left to be keyed in.

The HTML is shown below.

<div id="dvLimit"></div>
<div>
    <asp:TextBox ID="txtDemoLimit" TextMode="MultiLine" Columns = "40" Rows = "10" runat="server"></asp:TextBox>
</div>

The following is the application in action.

Modify this as per your requiement and enjoy jQuerying !!!

<a href="http://www.codeproject.com/script/Articles/BlogFeedList.aspx?amid=48141" style="display:none" rel="tag">CodeProject</a>

Tech Tips: C# 3.0 Partial Methods

Rajesh Pillai — Sat, 28 Nov 2009 06:11:04 GMT

c# 3.0 : Partial Method

You are all aware of “Partial Class” introduced in .net 2.0. Partial class is useful in situation where you need to split the definition of a class,
struct or an interface over two or more source files. Each source file contains a section of the type or method definition and all parts are
combined when the application is compiled.

There are several situations when splitting a class definition is desirable:

When working on large projects, spreading a class over separate files enables multiple programmers to work on it at the same time.

· When working with automatically generated source, code can be added to the class without having to recreate the source file. Visual Studio
uses this approach when it creates Windows Forms, Web service wrapper code, and so on. You can create code that uses these classes without
having to modify the file created by Visual Studio.

Partial Method (.net 3.0):

Partial methods are the code block which reside inside a partial type and gets executed only when it has definition. This gives us the extensibility
and if user wants to implement the rule, they can go ahead and define the body but if they do not want it will not. This improves the performance as
you are not loading/creating unwanted methods. Partial methods are especially useful as a way to customize generated code. They allow for a
method name and signature to be reserved, so that generated code can call the method but the developer can decide whether to implement the
method. Much like partial classes, partial methods enable code created by a code generator and code created by a human developer to work together
without run-time costs.

A partial method declaration consists of two parts: the definition, and the implementation. These may be in separate parts of a partial class, or in the
same part. If there is no implementation declaration, then the compiler optimizes away both the defining declaration and all calls to the method.

// Definition in file1.cs

partial void onNameChanged();

// Implementation in file2.cs

partial void onNameChanged()
{
// method body
}

Partial method declarations must begin with the contextual keyword partial and the method must return void.
Partial methods can have ref but not out parameters.
Partial methods are implicitly private, and therefore they cannot be virtual.
Partial methods cannot be extern, because the presence of the body determines whether they are defining or implementing.
Partial methods can have static and unsafe modifiers.
Partial methods can be generic. Constraints are put on the defining partial method declaration, and may optionally be repeated on the implementing one. Parameter and type parameter names do not have to be the same in the implementing declaration as in the defining one.
You can make a delegate to a partial method that has been defined and implemented, but not to a partial method that has only been defined.

The above knowledge may seem very miniscule but it opens up a whole new opportunity when you are designing your system.
For e.g. Microsoft Entity Framework uses this feature for notifying property changes.

But beware there are caveats to it.

How can this knowledge be applied? Say for e.g. you have a class called “Address” which is declared as follows

public partial class Address
{
      private string city;
      public string City
    {
             get { return this.city;}
             set
             {
                     // If this method is implemented then the actual code will be executed else this will be ignored.
                     this.OnCityChanging(value);     // This is partial method. No exception will be thrown if this method is not implemented.

this.city = value;

             }
      }

    partial void OnCityChanging (string city);
}

public partial class Address
{
      partial void OnCityChanging(string city)
      {
                // You can add business rules/validation or constraints here…
               If (city == “prohibited city”)
                      throw new InvalidArgumentException(“This city is not allowed”);
      }
}

Create an instance of Address…

Address add = new Address();
add.City = “prohibited city”; // exception will be thrown.

This is just a rudimentary example to wet up your appetite. Now, wear your “Thinking Hat” and ponder over when you get some time
as to where this can be applied.

Reference:

http://msdn.microsoft.com/en-us/library/wa80x488.aspx

http://community.bartdesmet.net/blogs/bart/archive/2007/07/28/c-3-0-partial-methods-what-why-and-how.aspx

In-Place-Edit with jQuery

Rajesh Pillai — Thu, 26 Nov 2009 07:24:42 GMT

Let's try a simple in-place edit with jquery. For demonstration purpose I am using the plain old HTML file. However,
if you, wish you could apply the same technique to asp.net, asp.net mvc or php or any other web application as well.

Here is the html that we will be using for the demo.

<body>
    <div style="line-height:3xm;background-color:skyblue">
        Double Click the below paragraph to edit.
    </div>
    </br></br>
    <div class="edit">
        Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio. Praesent libero.
        Sed cursus ante dapibus diam. Sed nisi. Nulla quis sem at nibh elementum imperdiet. Duis
        sagittis ipsum. Praesent mauris.
        Fusce nec tellus sed augue semper porta. Mauris massa. Vestibulum lacinia arcu eget nulla.
        Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
        Curabitur sodales ligula in libero. Sed dignissim lacinia nunc. Curabitur tortor.
    </div>
</body>

The element that needs to be made editable is given a class of "edit".

The following is the minimal CSS we will be using for this demo.

</style>

Let's add a reference to the jquery library

If you have a local copy then refer it as follows

<script src="scripts/jquery-1.3.2.min.js"></script>

The above assumes you have a copy of the jquery library in the scripts folder on your root directory.

Otherwise you can always grab the latest copy from google..

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>

Now let's setup the event handler to make the div editable.

The $() function is jquery's way of telling the browser to execte the function when the DOM is ready.

Here' is the setEditable function.

function trim(stringToTrim) {
return stringToTrim.replace(/^\s+|\s+$/g, "");
}

The above function essentially does three things.

Hook up the click event handler on the element with class ".edit".
Inside the function the following are the sequence that happens
1. Build the html for inserting a <textarea> for editing.
2. Build the html for inserting a "save" and "cancel" button.
3. Save the current value of the element.
4. Removes the current div (with class .edit) and inserts the above html.
5. Hooks up the events for "save" and "cancel" button.

Note: the jquery function after() inserts content after each of the matched elements.

The below function is called when you click "save" or "cancel" button

That's it. You can actually make an ajax request and send this data to the server for persistence. We will see
that in an another post.

ASP.NET Session Id getting lost

Rajesh Pillai — Wed, 25 Nov 2009 12:55:31 GMT

This typical problem is almost faced by all new developer working with asp.net.

This behaviour is by design as ASP.NET tries to be efficient in storing sessions for users. Remember
unless you store anything in session the session id value keep changing.

If you want to tell ASP.NET that you want it to track user sessions, you can do one of 2 things:

Store something in the session.
Simple handle the Session_Start event in your GLobal.asax. The presence of this method will
tell ASP.NET to track sessions , even if there is no data in the session..

// NOTE: There is no need to add any thing to session if you are doing this...

public void Session_Start(object sender, EventArgs e)
{
}

The related stackoverflow post can be read here
stackoverflow.com/questions/1533709/session-id-changing-randomly/1535573#1535573

This behavior had caused me much worry in the past :)