Event Driven Programming

📖 Theory

જવાબ આપતું page

તમારી VB.NET desktop apps સીધી ચાલીને અટકી જતી નહોતી. એ રાહ જોતી અને જવાબ આપતી: વપરાશકારે button દબાવ્યું અને તમારો click નો code ચાલ્યો. એ જ છે event-driven programming, અને ASP.NET Web Forms વેબ પર એ જ રીતે કામ કરે છે.

FestConnect નું page એક વાર દેખાઈને બેસી રહેતું નથી. એ જવાબ આપે છે: page load થાય ત્યારે થોડો code ચાલે છે; વિદ્યાર્થી Register પર click કરે ત્યારે તમારો registration નો code ચાલે છે. તમે handlers કહેવાતી નાની methods લખો છો, દરેક કોઈ એક ઘટના સાથે બંધાયેલી, અને એ ઘટના બને ત્યારે ASP.NET સાચો handler બોલાવે છે. આ પાઠ એ કઈ રીતે થાય તે બતાવે છે, અને વેબ જે એક વળાંક ઉમેરે છે તેની ઓળખાણ કરાવે છે: postback.

📖 Theory

Events અને handlers

બે પ્રકારની ઘટનાઓ અગત્યની છે. Page events page પોતાનામાંથી આવે છે, જેમાં સૌથી અગત્યનું છે Page_Load, જે page ની દરેક પ્રક્રિયા વખતે ચાલે છે. Control events વપરાશકાર જેની સાથે આપલે કરે છે તે controls માંથી આવે છે, જેમ કે Button નું Click.

તમને જે ઘટના મહત્વની લાગે તે દરેક માટે તમે એક handler લખો છો: એટલે કે સામાન્ય C# method જેને ઘટના બને ત્યારે ASP.NET ચલાવે છે. આ methods તમે જાતે બોલાવતા નથી; framework જ સાચી ક્ષણે એમને બોલાવે છે. તમારું કામ ફક્ત શું થવું જોઈએ એ લખવાનું છે.

⌨️ Practical

Page ની ઘટના અને button ના click માટેના handlers

public partial class Register : System.Web.UI.Page
{
    // Page event: runs every time the page is processed
    protected void Page_Load(object sender, EventArgs e)
    {
        lblTitle.Text = "Register for an Event";
    }

    // Control event: runs when the Register button is clicked
    protected void btnRegister_Click(object sender, EventArgs e)
    {
        lblStatus.Text = "Thanks, " + txtName.Text + "! You are registered.";
    }
}

✏️ Formula

Postback: page પોતાની જ સાથે વાત કરે છે

વેબ વાળો વળાંક આ રહ્યો. વિદ્યાર્થી Register પર click કરે ત્યારે browser આખું form server પરના એ જ page પર પાછું મોકલે છે. આ ફેરાને postback કહે છે.

Server પર ASP.NET page ફરી load કરે છે, Page_Load ચલાવે છે, પછી button નો Click handler ચલાવે છે, તાજું HTML બનાવે છે અને પાછું મોકલે છે. એટલે click browser માં સંભાળાતો નથી; એ server સુધીનો અને પાછો આવવાનો ફેરો છે. દરેક button click, એટલે કે દરેક postback, પહેલાં Page_Load ફરી ચલાવે છે.

📖 Theory

પહેલો load સામે postback: IsPostBack

Page_Load દરેક postback પર ચાલે છે, એટલે સૌથી પહેલી મુલાકાતને પછીના button clicks થી જુદી પાડવાની કોઈ રીત જોઈએ. Page.IsPostBack એ જ કામ માટે છે.

Page માટેના પહેલા request વખતે IsPostBack false હોય છે. એ પછીના દરેક postback પર (દાખલા તરીકે button click પર) એ true હોય છે. પહેલી વારની તૈયારી ફક્ત એક જ વાર ચલાવવા તમે એને if (!IsPostBack) માં વીંટીને વાપરો છો. પહેલી વારની સામાન્ય તૈયારી: database માંથી events નું drop-down list ભરવું. આ રખેવાળી વગર તમે એ list દરેક click પર ફરી ભરી નાખો અને વપરાશકારની પસંદગી ભૂંસાઈ જાય.

⌨️ Practical

તૈયારી ફક્ત પહેલા load પર ચલાવવી

protected void Page_Load(object sender, EventArgs e)
{
    if (!IsPostBack)
    {
        // Runs ONCE, on the first visit only
        LoadEventList();       // fill the drop-down from the database
    }
    // Code here (outside the guard) runs on every load and every postback
}

🧩 Quiz

વિદ્યાર્થી પહેલાં Register.aspx ખોલે છે, પછી Register button પર એક વાર click કરે છે. Page_Load કેટલી વાર ચાલે છે, અને દર વખતે IsPostBack શું હોય છે?

1. કુલ એક જ વાર; IsPostBack હંમેશા false હોય છે
2. બે વાર: પહેલા load પર (IsPostBack false), પછી button-click ના postback પર ફરી (IsPostBack true)
3. એક જ વાર, ફક્ત button દબાય ત્યારે; IsPostBack true હોય છે
4. તમે જાતે ન બોલાવો ત્યાં સુધી Page_Load ચાલતું જ નથી

💭 Think first

તૈયારીની રખેવાળી if (!IsPostBack) થી શા માટે કરવી?

જો તમે event નું drop-down Page_Load માં if (!IsPostBack) ની તપાસ વગર ભરો, તો ખરેખર શું ખોટું થાય? વિચારીને પછી tap કરો.

⚠️ Watch out

Event-model ના ફાંદા

Page_Load ફરી ચાલે છે એ ભૂલી જવું: એ દરેક postback પર ચાલે છે, ફક્ત પહેલી મુલાકાત વખતે નહીં; એક વારની તૈયારીની રખેવાળી if (!IsPostBack) થી કરો.

દરેક postback પર controls ફરી બનાવવાં: શરત વગર lists ફરી load કરવાથી વપરાશકારની પસંદગી ભૂંસાઈ જાય છે.

Clicks browser માં ચાલશે એવી અપેક્ષા: Button નો Click postback પછી SERVER પર સંભાળાય છે, page માં તરત નહીં.

Handlers જાતે બોલાવવા: Page_Load અને event handlers ને framework બોલાવે છે; તમારે ફક્ત એ લખવાના છે.

✅ Summary

Key takeaways

• ASP.NET Web Forms VB.NET desktop apps ની જેમ event-driven છે: code ઘટનાઓના જવાબમાં ચાલે છે, ઉપરથી નીચે એક વાર નહીં.
• Page events (Page_Load) page માંથી આવે છે; control events (Button Click) વપરાશકારની આપલેમાંથી આવે છે.
• તમે handler methods લખો છો; framework એમને સાચા સમયે બોલાવે છે.
• Button click જેવી વપરાશકારની આપલેથી postback થાય છે: page server પરના એ જ page પર મોકલાય છે, જે ફરી ચાલે છે અને ફરી render થાય છે.
• Page_Load દરેક પ્રક્રિયા વખતે ચાલે છે, દરેક postback સહિત; Page.IsPostBack પહેલા load પર false અને postbacks પર true હોય છે.
• એક વારની તૈયારીની રખેવાળી if (!IsPostBack) થી કરો જેથી એ એક જ વાર ચાલે અને પછીના clicks પર વપરાશકારે ભરેલું ભૂંસાય નહીં.
• યાદ રાખવાની કડી: click -> postback -> Page_Load -> તમારો handler -> નવું HTML.