Difference between Const, Readonly and Static Keywords in C#

Constant and ReadOnly keyword are used to make a field constant which value cannot be modified. Static keyword is used to make members static that can be shared by all the class objects. In this article, I am going to explain the difference among these three.

Constant

Constant fields or local variables must be assigned a value at the time of declaration and after that they cannot be modified. By default constant are static, hence you cannot define a constant type as static.

public const int X = 10;

A const field is a compile-time constant. A constant field or local variable can be initialized with a constant expression which must be fully evaluated at compile time.

1. void Calculate(int Z)
2. {
3. const int X = 10, X1 = 50;
4. const int Y = X + X1; //no error, since its evaluated a compile time
5. const int Y1 = X + Z; //gives error, since its evaluated at run time
6. }

You can apply const keyword to built-in value types (byte, short, int, long, char, float, double, decimal, bool), enum, a string literal, or a reference type which can be assigned with a value null.

1. const MyClass obj1 = null;//no error, since its evaluated a compile time
2. const MyClass obj2 = new MyClass();//gives error, since its evaluated at run time

Constants can be marked as public, private, protected, internal, or protected internal access modifiers.

Use the const modifier when you sure that the value a field or local variable would not be changed.

ReadOnly

A readonly field can be initialized either at the time of declaration or with in the constructor of same class. Therefore, readonly fields can be used for run-time constants.

1. class MyClass
2. {
3. readonly int X = 10; // initialized at the time of declaration
4. readonly int X1;
5.  
6. public MyClass(int x1)
7. {
8. X1 = x1; // initialized at run time
9. }
10. }
11. 
    
12. Explicitly, you can specify a readonly field as static since, like constant by default it is not static. Readonly keyword can be apply to value type and reference type (which initialized by using the new keyword) both. Also, delegate and event could not be readonly.
    Use the readonly modifier when you want to make a field constant at run time.

Static

The static keyword is used to specify a static member, which means static members are common to all the objects and they do not tied to a specific object. This keyword can be used with classes, fields, methods, properties, operators, events, and constructors, but it cannot be used with indexers, destructors, or types other than classes.

1. class MyClass
2. {
3. static int X = 10;
4. int Y = 20;
5. public static void Show()
6. {
7. Console.WriteLine(X);
8. Console.WriteLine(Y); //error, since you can access only static members
9. }
10. }

Key points about Static keyword

1. If the static keyword is applied to a class, all the members of the class must be static.
2. Static methods can only access static members of same class. Static properties are used to get or set the value of static fields of a class.
3. Static constructor can't be parameterized. Access modifiers can not be applied on Static constructor, it is always a public default constructor which is used to initialize static fields of the class.

What do you think?

I hope you will enjoy the tips while programming with C#. I would like to have feedback from my blog readers. Your valuable feedback, question, or comments about this article are always welcome.

The Perfect Real Time Example of Interface in OOPS

 The Perfect Real Time Example of Interface in OOPS

Suppose your parents gives you a list of items to purchase,
that list is an Interface that you will implement at the time of purchasing.....
Means Before implementing any thing , you list out what you have to do that will be an interface......

Now Lets implement it in programming way:-

//Here Parent gives list of Items to purchase.So we listed out the Items

        interface IPurchaseItem

        {

            void PurchaseBook();

        }

        //Implementation while Purchasing.

        class Person1Purchasing:IPurchaseItem

        {

            public void PurchaseBook()

            {

                Console.WriteLine("Hey! I purchased C Sharp Book");

            }

            //other code here

        }

        class Person2Purchasing : IPurchaseItem

        {

            //Different Implementation

            public void PurchaseBook()

            {

                Console.WriteLine("Hey! I purchased Java Programming Book");

            }

            //other code here

        }

Description:-
Here we have one interface having PurchaseBook() method so now it depends on classes how they implement it. So here Person1 purchased C Sharp book and Person2 purchased Java Programming book.

I hope now you have a clear vision about Interface.

Note:-Its my own understanding on Interface.So Please correct me if i am wrong. Write your comments into the Comments section below.

LAG and LEAD Analytical Functions in Sql Server with Real Time Examples

LAG and LEAD Analytical Functions in Sql Server with Real Time Examples

Hello folks, Today I am going to share LAG and LEAD Analytical Functions in Sql Server. After reading this article you will be able to Understand and work with both the Analytical Functions.

1.   LAG Function:-

In SQL Server (Transact-SQL), the LAG function is an analytic function that lets you query more than one row in a table at a time without having to join the table to itself. It returns values from a previous row in the table. 

Syntax

LAG( expression [, offset [, default] ]) 

OVER ( [query_partition_clause ] order_by_clause )

Arguments Description:-

expression

 An expression that can contain other built-in functions, but can not contain any analytic functions.

offset
Optional. It is the physical offset from the current row in the table. If this parameter is omitted, the default is 1.

default 

Optional. It is the value that is returned if the offset goes out of the bounds of the table. If this parameter is omitted, the default is null.

query_partition_clause 

Optional. It is used to partition the results into groups based on one or more expressions.

order_by_clause 

Optional. It is used to order the data within each partition.

Applies To

The LAG function can be used in the following versions of SQL Server (Transact-SQL):

SQL Server 2014, SQL Server 2012

Example:-

Lets take an Example we have following Student data.

And we want to know the previous mark like this.

Another Example would be like we have Customer data with their order date so we want to know the Order Date along with Previous Order date so we would know what was the Previous Order date.

So now to achieve this data we will use LAG function as follow.

SELECT studentName, Mark,

LAG(Mark) OVER( ORDER BY Mark) AS PrevMark

FROM Exam order by Mark

So now it would return above result.

In this example, the LAG function will sort in ascending order all of the Mark values in the Student table.

2.   LEAD Function:-

Accesses data from a subsequent row in the same result set without the use of a self-join in SQL Server 2016. LEAD provides access to a row at a given physical offset that follows the current row. Use this analytic function in a SELECT statement to compare values in the current row with values in a following row.

Syntax

LEAD ( scalar_expression [ ,offset ] , [ default ] )  

    OVER ( [ partition_by_clause ] order_by_clause ) 

Arguments Description:-

scalar_expression

The value to be returned based on the specified offset. It is an expression of any type that returns a single (scalar) value. scalar_expression cannot be an analytic function.

offset
The number of rows forward from the current row from which to obtain a value. If not specified, the default is 1. offset can be a column, subquery, or other expression that evaluates to a positive integer or can be implicitly converted to bigint. offset cannot be a negative value or an analytic function.

default
The value to return when scalar_expression at offset is NULL. If a default value is not specified, NULL is returned. default can be a column, subquery, or other expression, but it cannot be an analytic function. default must be type-compatible with scalar_expression.

OVER ( [ partition_by_clause ] order_by_clause)
partition_by_clause divides the result set produced by the FROM clause into partitions to which the function is applied. If not specified, the function treats all rows of the query result set as a single group. order_by_clause determines the order of the data before the function is applied. When partition_by_clause is specified, it determines the order of the data in each partition. The order_by_clause is required.

Examples:-

Compare values between years

The query uses the LEAD function to return the difference in sales quotas for a specific employee over subsequent years. Notice that because there is no lead value available for the last row, the default of zero (0) is returned.

Conclusion

In this article I discussed how you can use LAG and LEAD analytical function to access or query data from previous or subsequent rows without writing  self-join query. Write your queries into the comments section.

what are the access modifiers

what are the access modifiers in c#

Access modifiers (or access specifiers) are keywords in object-oriented languages that set the accessibility of classes, methods, member function, member variables etc. Access modifiers are a specific part of programming language syntax used to facilitate the encapsulation of components, It defines the accessibility of the specific type (e.g class, struct), data member etc.
In c# there are five type of access modifiers -

• Public
• Private
• Protected
• Internal
• Protected Internal

Accessibility of access modifies in c#

Access Modifiers	Inside Assembly		Outside Assembly
	With Inheritance	With Type	With Inheritance	With Type
Public	ü	ü	ü	ü
Private	X	X	X	X
Protected	ü	X	ü	X
Internal	ü	ü	X	X
Protected Internal	ü	ü	ü	X

Explanation of Public, Protected, Private, Internal And Protected Internal Access Modifiers In C#

Public: - Public members are accessible anywhere, inside the type (e.g. - class), outside the type, inside the assembly, outside the assembly, through the inheritance or with the type (e.g. instance of class, with type of class in case of static).

Private: - Private members are only accessible within the own type (Own class).

Protected: - Protected members are accessible only with its derived types whether it is inside the assembly or outside the assembly.

Internal: - Internal members are accessible only within the assembly by inheritance (its derived type) or by instance of class.

Protected Internal: - Protected internal is type of access modifier contains protected member properties as well as internal member properties, means protected internal member accessible inside the assembly in its derived class or with the instance of the class and accessible outside the class only in its derived class.

The Various Ways of Binding MVC DropDownList

To Bind a DropDownListFor or DropDown in asp.net MVC from database, from enum or from hard coded values, most people suggest to add a property in the model with IEnumarable or IList. We can use it but not very helpful because after every postback we will need to fill the list again otherwise it will be null. So using ViewBag is not a bad idea, we will use it in our article.

What we will see in this discussion:

1. Bind DropDown with hard coded values
2. Bind DropDown with records from database
3. Bind DropDown with Enum
4. Bind DropDown on change of other DropDown's value

1. Bind DropDown with hard coded values

We will try to write both controller code and view in every case, so let's see our first example by using hard coded value

    public ActionResult Index()
    {       
        ViewBag.Active = new List<SelectListItem> {                  
                 new SelectListItem { Text = "Yes", Value = "1"},                   
                 new SelectListItem { Text = "No", Value = "0"}
             };
        var model = new ProductModel();
        return View(model);
    }

In the view, I am not going to show all the label and other model detail. Here IsActie is the model value which will come from database for existing records otherwise null or default value from the model, I used the class name from bootstrap.

@Html.DropDownListFor(model => model.IsActive,
   new SelectList(ViewBag.Active, "Value", "Text"), 
   "Select status",
    new { @class = "form-control" })

If it is hard coded values and is a big list then we can create a separate method to create the list otherwise directly we can declare it in view rather than passing from controller view as we did in our above example, see how

@Html.DropDownListFor(model => model.Category,
    new SelectList(new List<SelectListItem> {                  
             new SelectListItem { Text = "Yes", Value = "1"},                   
             new SelectListItem { Text = "No", Value = "0"}
         }, "Value", "Text"), 
    "Select status",
     new { @class = "form-control" })

It doesn't looks good but good thing is that we don't need to create the list again and again on postback, which we will see latter.

---

2. Bind DropDown with records from database

If you will explore a little bit, you will found most of the people suggest to convert the record into SelectList in controller or in model before passing to view. Is that really required or is a good practice? I cannot say about others but for me, it is really frustrating to convert my table into SelectList every time. If not then is there any way to directly bind the dropdown from a table records, yes, we will see it in this example:

I have a table category which we will use in this example, here is the table structure:

public partial class Category
{
    public int CategoryId { get; set; }
    public string CategoryName { get; set; }
    public bool IsActive { get; set; }
}

Controller code:

// GET: Products
public ActionResult Create()
{
    var db = new MyDBEntities();
    ViewBag.Categories = db.Categories.Where(x => x.IsActive);
    var model = new ProductModel();
    return View(model);
}   


// POST: Create Product
public ActionResult Create(ProductModel model)
{
    var db = new MyDBEntities();
    if (ModelState.IsValid)
    {
        // code to save record  and redirect to listing page
    }
    // If model is not valid then reload categories from database
    ViewBag.Categories = db.Categories.Where(x => x.IsActive);
    return View(model);
}

In our GET action we are fetching all active categories from database and passing to view by using ViewBag. In POST action we try to validate the posted data by using ModelState.IsValid method, if valid, save data and redirect user to your desired page otherwise, re-populate the the categories before returning the user to page to fix the issue. Now we will see our view html

@Html.DropDownListFor(model => model.Category,
    new SelectList(ViewBag.Categories, "CategoryID", "CategoryName"), 
    "Select Category",
    new { @class = "form-control" })

As you noticed, we directly pass the table records to view after fetching from database without converting to Select List and converted into Select List directly into the view, which is easy and save time. If we will do the same in controller then we need to convert the list in both GET as well as POST action.

---

3. Bind DropDown with Enum

There are two ways to bind and save the records, and it's all depends on requirement, whether we want to save the number or text value of the enum, we will try both. Let's first create an enum say Language, I am adding those language which I read write and speak

public enum Language
{
    Arabic,
    English,
    Hindi,
    Spanish,
    Urdu
}

If we need to save the text or say bind with text then

// In controller
ViewBag.Languages = Enum.GetValues(typeof(Language)).Cast<Language>();


// In View
@Html.DropDownListFor(model => model.Language,
        new SelectList(ViewBag.Languages),
        "Select language",
        new { @class = "form-control" })

As in most cases we want to use value and text, so we need to create a structure or class and create the list of it from enum which we will use in this example:

We will create a structure which we can use for entire application

public struct DDL
{
    public int Value { get; set; }
    public String Text { get; set; }
}

Now create the list of DLL by using Language enum foreach, and assign to ViewBag.Languages

var languages = new List<DDL>();
foreach (Language lang in Enum.GetValues(typeof(Language)))
    languages.Add(new DDL { Value = (int)lang, Text= lang.ToString() });


ViewBag.Languages = languages;

In view, binding is same as earlier:

@Html.DropDownListFor(model => model.Language,
      new SelectList(ViewBag.Languages, "Value", "Text"),
      "Select status",
      new { @class = "form-control" })

Now when we will post the page, it will post the language Id not the text.

4. Bind DropDown on change of other DropDown's value

we will try to bind child Dropdown on selection change of parent Dropdown, say Country to State or Sate to City, by using jQuery which will call an action in controller and return JSON for selected id, and with the help of jQuery append values to child Dropdown. We will try to create page to add new employee and state and city will be used as parent and child Dropdown.

Let's see the tables we are going to use:

public partial class State
{
    public int StateId { get; set; }
    public string StateName { get; set; }
    public string Abbr { get; set; }
} 
public partial class City
{
    public int CityId { get; set; }
    public string CityName { get; set; }
    public int StateId { get; set; }
}

Employee Model:

public class Employees
{
    [Key]
    public int EmployeeId { get; set; }


    [Required, Display(Name="Employee Name")]
    public string EmployeeName { get; set; }


    [Required, Display(Name = "Address")]
    public String Address { get; set; }


    [Required, Display(Name = "State")]
    public int State { get; set; }


    [Required, Display(Name = "City")]
    public int City { get; set; }


    [Display(Name = "Zip Code")]
    public String ZipCode { get; set; }


    [Required, Display(Name = "Phone #")]
    public String Phone { get; set; }
}

As you can see, I have not added anything in our model for list of states or cities because we are using Code first, which will create the database tables, we will try to get data from database and pass to view by using ViewBag, here is our HttpGet and HttpPost action method:

[HttpGet]
public ActionResult Create()
{
    ViewBag.StateList = db.States;
    var model = new Employees();
    return View(model);
}
[HttpPost]
public ActionResult Create(Employees model)
{
    if (ModelState.IsValid)
    {
        // code to save record  and redirect to listing page
    }
    ViewBag.StateList = db.States;
    return View(model);
}

HTML code for both state and city dropdown:

<div class="form-group">
    @Html.LabelFor(m => m.State,  new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.DropDownListFor(m => m.State,
              new SelectList(ViewBag.StateList, "StateId", "StateName"),
              "Select state",
              new { @class = "form-control", @onchange="FillCity()" })
        @Html.ValidationMessageFor(m => m.State, "", new { @class = "text-danger" })
    </div>
</div>


<div class="form-group">
    @Html.LabelFor(m => m.City, new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.DropDownListFor(m => m.City,
       new SelectList(Enumerable.Empty<SelectListItem>(), "CityId", "CityName"),
              "Select city",
              new { @class = "form-control" })
        @Html.ValidationMessageFor(m => m.City, "", new { @class = "text-danger" })
    </div>
</div>

As you can notice we used @onchange="FillCity()" in our State dropdown so we need a JavaScript function which will be call on change of state. If you are from asp.net background then forgot about the postback, in mvc there is no postback concept so we don't need viewstate of controls so the pages are light weight. Here is our FillCity function:

@section Scripts {
<script>
  function FillCity() {
    var stateId = $('#State').val();
    $.ajax({
        url: '/Employees/FillCity',
        type: "GET",
        dataType: "JSON",
        data: { State: stateId},
        success: function (cities) {                    
            $("#City").html(""); // clear before appending new list 
            $.each(cities, function (i, city) {
                $("#City").append(
                    $('<option></option>').val(city.CityId).html(city.CityName));
            });
        }
    });
  }
</script>
}

Here we used $.each to loop the items and add item by item to city dropdown. We used to call FillCity action method in our Employees controller.We need a separate action method which can return cities on the basis of selection change and return JSON string.

public ActionResult FillCity(int state)
{
    var cities = db.Cities.Where(c => c.StateId == state);
    return Json(cities, JsonRequestBehavior.AllowGet);
}

See how we can return json from any action method in our controller. If you want to see the complete html of the page then it is here.

@model MyApp.Models.Employees
@{
    ViewBag.Title = "Index";
    Layout = "~/Views/Shared/_Layout.cshtml";
}
<h2>Index</h2>
@using (Html.BeginForm()) 
{
@Html.AntiForgeryToken()


<div class="form-horizontal">
    <h4>New Employee</h4>      
    <div class="form-group">
        @Html.LabelFor(m => m.EmployeeName, new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.TextBoxFor(m => m.EmployeeName, new { @class = "form-control" })
            @Html.ValidationMessageFor(m => m.EmployeeName, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        @Html.LabelFor(m => m.Address, new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.TextBoxFor(m => m.Address, new { @class = "form-control" })
            @Html.ValidationMessageFor(m => m.Address, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        @Html.LabelFor(m => m.State,  new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.DropDownListFor(m => m.State,
                  new SelectList(ViewBag.StateList, "StateId", "StateName"),
                  "Select state",
                  new { @class = "form-control", @onchange="FillCity()" })
            @Html.ValidationMessageFor(m => m.State, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        @Html.LabelFor(m => m.City, new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.DropDownListFor(m => m.City,
           new SelectList(Enumerable.Empty<SelectListItem>(), "CityId", "CityName"),
                  "Select city",
                  new { @class = "form-control" })
            @Html.ValidationMessageFor(m => m.City, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        @Html.LabelFor(m => m.ZipCode, htmlAttributes: new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.TextBoxFor(m => m.ZipCode,  new { @class = "form-control" })
            @Html.ValidationMessageFor(m => m.ZipCode, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        @Html.LabelFor(m => m.Phone, new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.TextBoxFor(m => m.Phone, new { @class = "form-control" })
            @Html.ValidationMessageFor(m => m.Phone, "", new { @class = "text-danger" })
        </div>
    </div>
    <div class="form-group">
        <div class="col-md-offset-2 col-md-10">
            <input type="submit" value="Create" class="btn btn-success" />
            <a href="/Employees" class="btn btn-warning" >Cancel</a>
        </div>
    </div>
</div>
}

If you want to add more column value into dropdown text you can concatenate them easily, say we want to show both Id and text in city drop down then we simmply show it like this:

$('<option></option>').
   val(city.CityId).html(city.CityId + " - " + city.CityName)); 

Whatever we see here is not complete to maintain the selected value if we found the model invalid in our post method and return back to the view then current selected state's cities will be lost same will happen when we need to fill and select the value in city dropdown for a saved records. We need to add one more JavaScript method to check on document.ready if there is any value already selected in state dropdown then call the FillCity method and fill our city dropdown and selected the city value which we get from the model.

I am leaving it for you so you can do a little bit practice, hope you will easily complete it, best of luck.