shadowing, overloading, and overriding

shadowing, overloading, and overriding

Shadowing, similar to Overloads, allows you to define a method that has the same name as another method in a base class, but without having to ensure a different signature.

You can also shadow a method that is defined in the same class using the Shadows keyword and a different signature, however this has the similar effect of overloading a method and can be used when your intent is to overload and protect your methods at the same time. And since the Shadows keyword is the default, declaring multiple methods with the same name and different signatures without using either keyword is enough to ensure they are both overloaded and shadowed (I never said this was simple!).

Primary Key Vs Unique Key

Primary Key :

1) Clustered index

2) It doesn't allow duplicates & NULL values.

Unique Key:

1) Non-clustered Index

2) It doesn't allow duplicates but it allows only one NULL value.

Clustered Index :

1) It store the directly value in a B-Tree Format.

2) A table contain only one Clusted Index

Non-Clustered Index:

1) It store the Address of the value in a B-Tree Format.

2) A table contain more than one Non-clustered Index

OOPS Concepts

Operator overloading :

C# operator definitions are class members that define or redefine the behavior of basic C# operators (called implicitly or explicitly) on instances of the class:

public class Complex
{
private double re, im;

public double Real
{
get { return re; }
set { re = value; }
}

public double Imaginary
{
get { return im; }
set { im = value; }
}

// binary operator overloading
public static Complex operator +(Complex c1, Complex c2)
{
return new Complex() { Real = c1.Real + c2.Real, Imaginary = c1.Imaginary + c2.Imaginary };
}

// unary operator overloading
public static Complex operator -(Complex c)
{
return new Complex() { Real = -c.Real, Imaginary = -c.Imaginary };
}

// cast operator overloading (both implicit and explicit)
public static implicit operator double(Complex c)
{
// return the modulus - sqrt(x^2 + y^2)
return Math.Sqrt(Math.Pow(c.Real, 2) + Math.Pow(c.Imaginary, 2));
}

public static explicit operator string(Complex c)
{
// we should be overloading the ToString() method, but this is just a demonstration
return c.Real.ToString() + " + " + c.Imaginary.ToString() + "i";
}
}

public class StaticDemo
{
public static void Main()
{
Complex number1 = new Complex() { Real = 1, Imaginary = 2 };
Complex number2 = new Complex() { Real = 4, Imaginary = 10 };
Complex number3 = number1 + number2; // number3 now has Real = 5, Imaginary = 12

number3 = -number3; // number3 now has Real = -5, Imaginary = -12
double testNumber = number3; // testNumber will be set to the absolute value of number3
Console.WriteLine((string)number3); // This will print "-5 + -12i".
// The cast to string was needed because that was an explicit cast operator.
}
}

ASP.NET Interview Questions for 3+ years Experience

ASP.NET Interview questions for 3+ years Experience

• 
  
• From constructor to destructor (taking into consideration Dispose() and the concept of non-deterministic finalization), what the are events fired as part of the ASP.NET System.Web.UI.Page lifecycle. Why are they important? What interesting things can you do at each?
• What are ASHX files? What are HttpHandlers? Where can they be configured?
• What is needed to configure a new extension for use in ASP.NET? For example, what if I wanted my system to serve ASPX files with a *.jsp extension?
• What events fire when binding data to a data grid? What are they good for?
• Explain how PostBacks work, on both the client-side and server-side. How do I chain my own JavaScript into the client side without losing PostBack functionality?
• How does ViewState work and why is it either useful or evil?
• What is the OO relationship between an ASPX page and its CS/VB code behind file in ASP.NET 1.1? in 2.0?
• What happens from the point an HTTP request is received on a TCP/IP port up until the Page fires the On_Load event?
• How does IIS communicate at runtime with ASP.NET? Where is ASP.NET at runtime in IIS5? IIS6?
• What is an assembly binding redirect? Where are the places an administrator or developer can affect how assembly binding policy is applied?
• Compare and contrast LoadLibrary(), CoCreateInstance(), CreateObject() and Assembly.Load().

Interview Questions Part 2

Q 1)From constructor to destructor (taking into consideration Dispose() and the concept of non-deterministic finalization), what the are events fired as part of the ASP.NET System.Web.UI.Page lifecycle. Why are they important? What interesting things can you do at each?

Ans)
From constructor to destructor :

The .NET Framework's garbage collector manages the allocation and release of memory for our application. Each time we use the new operator to create an object(calls the "constructor"), the runtime allocates memory for the object from the managed heap. As long as address space is available in the managed heap, the runtime continues to allocate space for new objects. However, memory is not infinite. Eventually the garbage collector must perform a collection in order to free some memory(calls finalizer/destructor). The garbage collector's optimizing engine determines the best time to perform a collection, based upon the allocations being made. When the garbage collector performs a collection, it checks for objects in the managed heap that are no longer being used by the application and performs the necessary operations to reclaim their memory.

what the are events fired as part of the ASP.NET System.Web.UI.Page lifecycle. Why are they important?

• PreInit Event
  • Called at the very beginning of page initialization, this event has several practical uses in your code behind pages. A few of these uses are: Checking the IsPostBack property, dynamically setting a master page or theme property, dynamically creating controls, and reading or setting property values. If you were so inclined, you could set a master page dynamically in the PreInit event as such:
• Init Event
• Called after the PreInit event and after all controls have been initialized and any skin settings have been applied, this event is very useful for initializing control properties before the page loads.
• InitComplete Event
• Like the name implies, this event is called after the Init event is completed. I’m at a bit of a loss for thinking up useful and/or interesting things to do with this event, but if there were any tasks that needed to be completed once the controls were initialized, this would be the place to do it.
• PreLoad Event
• This event is called immediately before the Page.Load event and after all postback data has been processed.
• Load Event
• Probably the most familiar since it comes for free whenever you switch to the code-behind (or hit F7) on an aspx page in Visual Studio. This event is useful for setting control properties and establishing database connections (both of which could be used to populate a drop-down from the database, for example).
• LoadComplete Event
• What else could possibly follow up the Load event? This event is useful for doing any processing that requires that all controls on the page first be loaded.
• PreRender Event
• This event is useful for making any final changes to the page or the controls before the output is rendered to the browser.
• PreRenderComplete Event
• Called after PreRender is completed. This is the last event to be called before the viewstate is saved.
• SaveStateComplete Event
• Called once the viewstate has been saved. Use this for any processing that requires the viewstate to be saved but that doesn’t affect the rendering of the controls.
• Render
• While not technically an event, this method gets called for every control on the page. When creating a custom control (that requires custom markup), you could override this method to provide your own markup.
• Unload Event
• Use this event to do any final cleanup work on the page. Any controls on the page will also have an unload event that can be used to do cleanup on the controls themselves.
• Disposed Event
• This is the last event called for a control when it is released from memory on the server. The is the last stage of the ASP.NET lifecycle when a page is requested.

**************************************************************************

Q 2)Does machine.config overrides the configurations mentioned in web.config?

Ans) NO, because machine.config is use for Server configuration, where as web.config is used to setup the Website configuration.

**************************************************************************

Q 3) Does web.config overrides the configurations mentioned in machine.config?

Ans) Yes, we can override the machine.config with web.config.

In some cases we have to override the machine.config with the web.config according to the Application(website) requirement's.

**************************************************************************

Q 4) How can you compress a viewstate?

Ans).NET also provides the GZipStream or DeflateStream to compress viewstate.

**************************************************************************

Nested Selects in LINQ to SQL

Consider the following diagram to track the votes in a contest. Each voter can register only one vote (a score from 1 to 4) for each contest entry.

For any given voter, you'll want to present a screen showing every entry in the competition, along with the score assigned to the entry by the voter (if a score exists). To fetch the data with SQL, I'd write something like:

SELECT E.EntryID, E.EntryName, E.EntryDescription, @VoterID AS VoterID,
(SELECT V.Score
FROM Votes AS V
WHERE (V.VoterID = @VoterID) AND (V.EntryID = E.EntryID)) AS Score
FROM Entries AS E

The query should yield a resultset like the following:
...
EntryID EntryName VoterID Score

13 EntryA 1 4
14 EntryB 1 2
15 EntryC 1 NULL
...

I thought the query would be difficult to express in LINQ, but I stumbled into a solution just by keeping a "SQL" mindset:

var q = from e in Entries
select new
{
EntryID = e.EntryID,
EntryName = e.EntryName,
EntryDescription = e.EntryDescription,
VoterID = voterID,
Score = (int?)(from v in e.Votes
where v.VoterID == voterID
select v.Score).FirstOrDefault()
};

The LINQ generated SQL looks amazingly similar to the hand generated SQL, which is a comforting sight!