Archive
GridView: Findcontrol from HeaderTemplate/ItemTemplate
How to find item template control in GridView?
Dim chkHeader As CheckBox = DirectCast(gridView1.Row.FindControl(“chkHeader”), CheckBox)
How to find control from header template in grid view?
For example If you want to find checkbox available in header template of gridview
<asp:GridView ID=”gridView1″ runat=”server” AutoGenerateColumns=”False”><Columns>
<asp:TemplateField >
<HeaderTemplate>
<asp:CheckBox ID=”chkHeader” runat=”server” />
</HeaderTemplate>
</asp:TemplateField >
</Columns>
</asp:GridView>
Solution:
Find Header control using following line of code
VB.NET Code:
Dim chkHeader As CheckBox = DirectCast(gridView1.HeaderRow.FindControl(“chkHeader”), CheckBox)
C# Code:
CheckBox chkHeader = (CheckBox)gridView1.HeaderRow.FindControl(“chkHeader”);
Hope this is help !
Dependency Injection Pattern in C#
Simple Introduction to Dependency Injection
Scenario 1
You work in an organization where you and your colleagues tend to travel a lot. Generally you travel by air and every time you need to catch a flight, you arrange for a pickup by a cab. You are aware of the airline agency who does the flight bookings, and the cab agency which arranges for the cab to drop you off at the airport. You know the phone numbers of the agencies, you are aware of the typical conversational activities to conduct the necessary bookings.
Thus your typical travel planning routine might look like the following :
- Decide the destination, and desired arrival date and time
- Call up the airline agency and convey the necessary information to obtain a flight booking.
- Call up the cab agency, request for a cab to be able to catch a particular flight from say your residence (the cab agency in turn might need to communicate with the airline agency to obtain the flight departure schedule, the airport, compute the distance between your residence and the airport and compute the appropriate time at which to have the cab reach your residence)
- Pickup the tickets, catch the cab and be on your way
Now if your company suddenly changed the preferred agencies and their contact mechanisms, you would be subject to the following relearning scenarios
- The new agencies, and their new contact mechanisms (say the new agencies offer internet based services and the way to do the bookings is over the internet instead of over the phone)
- The typical conversational sequence through which the necessary bookings get done (Data instead of voice).
Its not just you, but probably many of your colleagues would need to adjust themselves to the new scenario. This could lead to a substantial amount of time getting spent in the readjustment process.
Scenario 2
Now lets say the protocol is a little bit different. You have an administration department. Whenever you needed to travel an administration department interactive telephony system simply calls you up (which in turn is hooked up to the agencies). Over the phone you simply state the destination, desired arrival date and time by responding to a programmed set of questions. The flight reservations are made for you, the cab gets scheduled for the appropriate time, and the tickets get delivered to you.
Now if the preferred agencies were changed, the administration department would become aware of a change, would perhaps readjust its workflow to be able to communicate with the agencies. The interactive telephony system could be reprogrammed to communicate with the agencies over the internet. However you and your colleagues would have no relearning required. You still continue to follow exactly the same protocol as earlier (since the administration department did all the necessary adaptation in a manner that you do not need to do anything differently).
Dependency Injection ?
In both the scenarios, you are the client and you are dependent upon the services provided by the agencies. However Scenario 2 has a few differences.
- You don’t need to know the contact numbers / contact points of the agencies – the administration department calls you when necessary.
- You don’t need to know the exact conversational sequence by which they conduct their activities (Voice / Data etc.) (though you are aware of a particular standardized conversational sequence with the administration department)
- The services you are dependent upon are provided to you in a manner that you do not need to readjust should the service providers change.
That is dependency injection in “real life”. This may not seem like a lot since you imagine a cost to yourself as a single person – but if you imagine a large organization the savings are likely to be substantial.
Sorry for long description above 😦 lets discuss what is Dependency Injection in a Software Context
Dependency Injection (DI) is a software design pattern that allow us to develop loosely coupled code. DI is a great way to reduce tight coupling between software components. DI also enables us to better manage future changes and other complexity in our software. The purpose of DI is to make code maintainable.
The Dependency Injection pattern uses a builder object to initialize objects and provide the required dependencies to the object means it allows you to “inject” a dependency from outside the class.
For example, Suppose your Client
class needs to use a Service
class component, then the best you can do is to make your Client
class aware of an IService
interface rather than a Service
class. In this way, you can change the implementation of the Service
class at any time (and for how many times you want) without breaking the host code.

We can modify this code by the DI different ways. We have following different ways to implement DI :
Constructor Injection
- This is the most common DI.
- Dependency Injection is done by supplying the DEPENDENCY through the class’s constructor when instantiating that class.
- Injected component can be used anywhere within the class.
- Should be used when the injected dependency is required for the class to function.
- It addresses the most common scenario where a class requires one or more dependencies.
public interface IService
{
void Serve();
}
public class Service : IService
{
public void Serve()
{
Console.WriteLine(“Service Called”);
//To Do: Some Stuff
}
}
public class Client
{
private IService _service;
public Client(IService service)
{
this._service = service;
}
public void Start()
{
Console.WriteLine(“Service Started”);
this._service.Serve();
//To Do: Some Stuff
}
}
class Program
{
static void Main(string[] args)
{
Client client = new Client(new Service());
client.Start();
Console.ReadKey();
}
}
The Injection happens in the constructor, by passing the Service that implements the IService-Interface. The dependencies are assembled by a “Builder” and Builder responsibilities are as follows:
- knowing the types of each IService
- according to the request, feed the abstract IService to the Client
Property injection
- Also called Setter injection.
- Used when a class has optional dependencies, or where the implementations may need to be swapped. Different logger implementations could be used this way.
- May require checking for a provided implementation throughout the class(need to check for null before using it).
- Does not require adding or modifying constructors.
public interface IService
{
void Serve();
}
public class Service : IService
{
public void Serve()
{
Console.WriteLine(“Service Called”);
//To Do: Some Stuff
}
}
public class Client
{
private IService _service;
public IService Service
{
set
{
this._service = value;
}
}
public void Start()
{
Console.WriteLine(“Service Started”);
this._service.Serve();
//To Do: Some Stuff
}
}
class Program
{
static void Main(string[] args)
{
Client client = new Client();
client.Service = new Service();
client.Start();
Console.ReadKey();
}
}
Method injection
- Inject the dependency into a single method, for use by that method.
- Could be useful where the whole class does not need the dependency, just the one method.
- Generally uncommon, usually used for edge cases.
public interface IService
{
void Serve();
}
public class Service : IService
{
public void Serve()
{
Console.WriteLine(“Service Called”);
//To Do: Some Stuff
}
}
public class Client
{
private IService _service;
public void Start(IService service)
{
this._service = service;
Console.WriteLine(“Service Started”);
this._service.Serve();
//To Do: Some Stuff
}
}
class Program
{
static void Main(string[] args)
{
Client client = new Client();
client.Start(new Service());
Console.ReadKey();
}
}
Key points about DI
- Reduces class coupling
- Increases code reusing
- Improves code maintainability
- Improves application testing
Updatepanel triggers another updatepanel
By default, every UpdatePanel
will be refreshed during every asynchronous post back.
Some important remarks about Update Panel
When an UpdatePanel control is not inside another UpdatePanel control, the panel is updated according to the settings of the UpdateMode and ChildrenAsTriggers properties, together with the collection of triggers. When an UpdatePanel control is inside another UpdatePanel control, the child panel is automatically updated when the parent panel is updated.
The content of an UpdatePanel control is updated in the following circumstances:
- If the UpdateMode property is set to Always, the UpdatePanel control’s content is updated on every postback that originates from anywhere on the page. This includes asynchronous postbacks from controls that are inside other UpdatePanel controls and postbacks from controls that are not inside UpdatePanel controls.
- If the UpdatePanel control is nested inside another UpdatePanel control and the parent update panel is updated.
- If the UpdateMode property is set to Conditional, and one of the following conditions occurs:
- You call the Update method of the UpdatePanel control explicitly.
- The postback is caused by a control that is defined as a trigger by using the Triggers property of the UpdatePanel control. In this scenario, the control explicitly triggers an update of the panel content. The control can be either inside or outside the UpdatePanelcontrol that defines the trigger.
- The ChildrenAsTriggers property is set to true and a child control of the UpdatePanel control causes a postback. A child control of a nested UpdatePanel control does not cause an update to the outer UpdatePanel control unless it is explicitly defined as a trigger.
Following is the example of code with UpdateMode
property set to Conditional
.
Hope it helps !
C# 7.0
C# History
In all previous versions of C# (with the exception of C# 6.0 maybe) new features have revolved around a specific theme:
- C# 2.0 introduced generics.
- C# 3.0 enabled LINQ by bringing extension methods, lambda expressions, anonymous types and other related features.
- C# 4.0 was all about interoperability with dynamic non-strongly typed languages.
- C# 5.0 simplified asynchronous programming with the async and await keywords.
- C# 6.0 had its compiler completely rewritten from scratch, and introduced a variety of small features and improvements that were easier to implement now.
C# 7.0 is no exception to this rule. The language designers were focusing on three main themes:
- Working with Data – Increased usage of web services is changing the way data is being modelled. Instead of designing the data models as a part of the application, their definition is becoming a part of web service contracts. While this is very convenient in functional languages, it can bring additional complexity to object oriented development. Several C# 7.0 features are targeted at making it easier to work with external data contracts.
- Improved Performance – Increased share of mobile devices is making performance an important consideration again. C# 7.0 introduces features that allow performance optimizations, which were previously not possible in the .NET framework.
- Code simplification – Several additional small changes built on the work done for C# 6.0 to allow further simplification of the code written.
Using the code
Tuples (with types and literals)
Return multiple values from a method is now a common practice, we generally use custom datatype, out parameters, Dynamic return type or a tuple object but here C# 7.0 brings tuple types and tuple literals for you it just return multiple values/ multiple type inform of tuple object. see below snippet
( string, string, string, string) getEmpInfo() { //read EmpInfo from database or any other source and just return them string strFirstName = "abc"; string strAddress = "Address"; string strCity= "City"; string strState= "State"; return (strFirstName, strAddress, strCity, strState); // tuple literal } //Just call above method and it will return multiple values var empInfo= getEmpInfo(); WriteLine("Emp info as {empInfo .Item1} {empInfo .Item2} {empInfo .Item3} {empInfo .Item4}.");
In above sample we can easily retrieve multiple values from tuples, but Item1, Item2 name are bit ir-relevant so let’s assign some meaningful names before return, see below sample
(string strFName, string strAdd, string strC, string strSt) getEmpInfo() { //code goes here } //Now when you call method get values with specific name as below var empInfo= getEmpInfo(); WriteLine("Emp info as {empInfo.strFName} {empInfo.strAdd} {empInfo.strC} {empInfo.strSt}.");
Additionally you can return their name directly in tuple literal as below
return (strFName: strFirstName, strAdd: strAddress, strCity: strC, strState: strSt);
Tuples are very useful thing where you can replace hash table or dictionary easily, even you can return multiple values for a single key, Additionally you can use it instead of List where you store multiple values at single position.
.NET also has a Tuple type (See here) but it is a reference type and that leads to performance issue, but C# 7.0 bring a Tuple with value type which is faster in performance and a mutable type.
Deconstruction
Most of the time we don’t want to access whole tuple bundle or we just need internal values then we can use Deconstruction features of C# 7.0, we can easily de-construct a tuple and fetch values that we need, following snippet will clear your doubt
( string strFName, string strAdd, string strC, string strSt) = getEmpInfo(); Console.WriteLine($"Address: { strAdd }, Country: { strC }");
Record Type
C# support record type, which is nothing but a container of a properties and variables, most of the time classes are full with properties and variables, we need lot of code to just declare them but with the help of Record Type you can reduce your effort, see below snippet
class studentInfo { string _strFName; string _strMName; string _strLName; studentInfo(string strFN, string strMN, string strLN){ this._strFName = strFN; this._strMName = strMN; this._strLName = strLN; } public string StudentFName {get{ return this._strFName;}} public string StudentMName {get{ return this._strMName;}} public string StudentLName {get{ return this._strLName;}} }
In above code we have a class with property, constructor and variable, so access and declare variable i need to write more code.
To avoid it i can use Record Type in C#, see below snippet
class studentInfo(string StudentFName, string StudentMName, string StudentLName);
That’s it and we have Done !
above snippet produce same output as earlier snippet.
Minimizing OUT
Out parameter is very popular when we want to return multiple values from method, By nature out parameters are ref type and works as an argument, we can use it easily but the only condition is out variable should be initialized before it passed. see below snippet
class SetOut { void AssignVal(out string strName) { strName = "I am from OUT"; } static void Main() { string strArgu; AssignVal(out strArgu); // here contents of strArgu is "I am from OUT" } }
C# 7.0 reduce your pain of writing extra code and you can just pass argument without initialize them, see below snippet
pat
static void Main() { AssignVal(out string szArgu); // here contents of szArgu is "I am from OUT" }
You can either use var as argument type instead to declare them.
Note that variable are used here, are in limited scope only, thus we can not use them outside method
Since we can define variable as argument directly, C# 7.0 gives us freedom to declare them as var also. so you don’t need to worry about datatype, see below snippet
static void Main() { AssignVal(out var szArgu); // here contents of szArgu is "I am from OUT" }
Non-‘NULL’ able reference type
Null reference is really a headache for all programmers, it is a million dollar exception. If you don’t check them you got runtime exception or if you check them for each object then your code goes long and long, To deal with this problem C# 7.0 come with non-nullable reference types
**I think syntax for it yet not fixed still they have release following syntax
‘?‘ is for nullable value-type and ‘!‘ is for non-nullable reference type
int objNullVal; //non-nullable value type int? objNotNullVal; //nullable value type string! objNotNullRef; //non-nullable reference type string objNullRef; //nullable reference type
Now look at the following complier effect after we run this snippet
MyClass objNullRef; // Nullable reference type MyClass! objNotNullRef; // Non-nullable reference type objNullRef = null; // this is nullable, so no problem in assigning objNotNullRef = null; // Error, as objNotNullRef is non-nullable objNotNullRef = objNullRef; // Error, as nullable object can not be refered WriteLine(objNotNullRef.ToString()); // Not null so can convert to tostring WriteLine(objNullRef.ToString()); // could be null if (objNullRef != null) { WriteLine(objNullRef.ToString); } // No error as we have already checked it WriteLine(objNullRef!.Length); // No error
Local Methods/Functions
Local methods and functions is already there in current version of C# (Yes, we can achieve them using Func and Action types, see here Func and Action), but still there are some limitations to local method, we can not have following features in it
- Generic
- out parameters
- Ref
- params
Now with C# 7.0 we can overcome this problems, see below snippet
private static void Main(string[] args) { int local_var = 100; int LocalFunction(int arg1) { return local_var * arg1; } Console.WriteLine(LocalFunction(100)); }
in above snippet we have define ‘LocalFunction’ as local function which is inside Main Function ‘Main’, here we can use out or ref in it.
Readability Improvement with Literals
Many times we use literals in code, if they are too long then we might loose Readability, to sort out such issues C# 7.0 comes with some improvement in Literals. Now C# allows ‘_‘ (underscore) in Literals for betterment of understand, it does not effect on its value. see below snippet
var lit1 = 478_1254_3698_44; var lit2 = ab0Xab_bc47at_XY; //C# also come with binary literal for bunary values var binLit = 1100_1011_0100_1010_1001;
**Literals are nothing but a constant value (hard-coded value) which may be with predefined meaning. (Litearls in C#)
Pattern matching
C# 7.0 allows user to use pattern in IS statement and with SWITCH statement, so we can match pattern with any datatype, patterns can be constant patterns, Type patterns, Var patterns. following sample snippet will clear your concepts, let’s start with IS pattern
public void Method1( object obj) { //following null is constant pattern if (obj is null) return; //datatype pattern, string is datatype that we check directly if (obj is string st) { //code goes here } else return; }
Switch pattern helps a lot as it uses any datatype for matching additionally ‘case’ clauses also can have its pattern so it bit flexible implementation
see below snippet
class Calculate(); class Add(int a, int b, int c) : Calculate; class Substract(int a, int b) : Calculate; class Multiply(int a, int b, int c) : Calculate; Calculate objCal = new Multiply(2, 3, 4); switch (objCal) { case Add(int a, int b, int c): //code goes here break; case Substract(int a, int b): //code goes here break; case Multiply(int a, int b, int c): //code goes here break; default: //default case break; }
in above sample switch case checks pattern and call ‘Multiply’ method
‘return’ by Ref
Have you tried to return your variable from method/function as Ref ? Yes, C# 7.0 allows you to do that. Infect you can pass a variable with Ref return them as Ref and also store them as Ref, isn’t it amazing.
see below snippet
ref string getFromList(string strVal, string[] Values) { foreach (string val1 in Values) { if (strVal == val1) return ref val1; //return location as ref not actual value } } string[] values = { "a", "b", "c", "d" }; ref string strSubstitute = ref getFromList("b", values); strSubstitute = "K"; // replaces 7 with 9 in the array System.Write(values[1]); // it prints "K"
In above sample we have find and replace a string, by return a Ref from method.
Throw Exception from Expression
You read it right, in C# 7.0 Now you can throw exception from your expression directly. see below snippet
public string getEmpInfo( string EmpName) { string[] empArr = EmpName.Split(","); return (empArr.Length > 0) ? empArr[0] : throw new Exception("Emp Info Not exist"); }
In above snippet we can directly throw exception from return statement, isn’t it really good !
Point to be Notice
All above features are expected to be a part of C# 7.0, yet Microsoft has release some of it with Visual studio 2015 Release 4.
Hope you enjoy these new features of C# 7.0.
Set focus on textbox
Using Jquery
$(function() {
$("#Box1").focus();
});
Using Javascript
window.onload = function() {
document.getElementById("Box1").focus();
};
HTML5
File Download code in vb.net
If Not String.IsNullOrEmpty(strURL) Then
Dim req As New WebClient()
Dim response As HttpResponse = HttpContext.Current.Response
response.Clear()
response.ClearContent()
response.ClearHeaders()
response.Buffer = True
response.AddHeader(“Content-Disposition”, “attachment;filename=””” + Server.MapPath(strURL) + “”””)
Dim data As Byte() = req.DownloadData(Server.MapPath(strURL))
response.BinaryWrite(data)
response.[End]()
End If
Hope it helps !
Comments