DotNet-Good programming practices

Read this doc on Scribd: DotNet-Good programming practices

DOT NET in Samples

Read this doc on Scribd: DOTNETinSamples

DotNet faq

Read this doc on Scribd: DotNet faq

aspdotNET IQ

Read this doc on Scribd: aspdotNET IQ

SQL Common Interview Questions

Read this doc on Scribd: SQL FAQ

DotNet SQL Interview Questions

Read this doc on Scribd: DotNet SQL Interview Questions 007

Access Modifiers in C#

Class Modifiers

The class is one of the two basic encapsulation constructs in C# (the other being the struct). Every executable statement must be placed inside a class or struct. Classes define reference types that are the basic building blocks of C# programs, and they are the architectural blueprint for the "objects" in OOP.

A class can be...

abstract: An instance of the class cannot be created.Usually this means the class is intended to serve as a base class.

sealed: The class cannot serve as a base class for another class (it can't be derived from). A class cannot be both abstract and sealed.

internal: The class is only accessible from other classes in the same assembly. This is the default access for non-nested types. If no modifier is specified, the class has internal access.

new: Used only with nested classes. "New" indicates that the class hides an inherited member of the same name.

private: A nested class that can only be accessed inside the class in which it is defined.

public: Instances of this class are available to any class that wants to access it.

Constructor Modifiers

A class defines data members, methods and nested types. A constructor is a special method that is normally used to initialize the data members of a class, and its name is always the same as the name of the class. Constructors have no return value, and any number of constructors can be defined within a class. If no constructor is defined, the C# compiler provides a default constructor having no parameters.

Methods

Methods are always defined within the bounds of a class or struct. Methods can be instance (called as an instance of the type within which the method is defined) or static, where the method is associated with the type itself. Methods can be declared as virtual, abstract , or sealed. Methods can be overloaded, overridden and hidden.

Access Modifiers

Access modifiers are specified as part of the method declaration syntax and can be:

internal
private
protected
protected internal
public

If no modifier is specified, the method is given private access.

virtual methods can be overriden by a derived class using the override keyword.

abstract methods must be overriden in a derived class. If any method of a class is abstract, the entire class must be declared as abstract.

sealed methods are methods that override an inherited virtual method having the same signature. When a method is sealed, it cannot be overriden in a derived class.

Method Access Modifiers

public indicates the method is freely accessible inside and outside of the class in which it is defined.

internal means the method is only accessible to types defined in the same assembly.

protected means the method is accessible in the type in which it is defined, and in derived types of that type. This is used to give derived classes access to the methods in their base class.

protected internal means the method is accessible to types defined in the same assembly or to types in a derived assembly.

private methods are only accessible in the class in which they are defined.

Executing client report from web application

protected void Page_Load(object sender, EventArgs e)
{
DataSet1TableAdapters.authorsTableAdapter ds = new DataSet1TableAdapters.authorsTableAdapter();
ds.ClearBeforeFill = true;
DataSet1.authorsDataTable dt=new DataSet1.authorsDataTable();
ds.Fill(dt, "ca");
ReportViewer1.LocalReport.ReportPath = Server.MapPath("Pubs.rdlc");
ReportViewer1.LocalReport.SubreportProcessing += new Microsoft.Reporting.WebForms.SubreportProcessingEventHandler(subReports);
}
void subReports(object sender, SubreportProcessingEventArgs e)
{
if (e.ReportPath.Equals("ClientSubReport"))
{
if (e.Parameters.Count > 0)
{
DataSet2TableAdapters.employeeTableAdapter da = new DataSet2TableAdapters.employeeTableAdapter();
da.ClearBeforeFill = true;
DataSet2.employeeDataTable dt = new DataSet2.employeeDataTable();
da.Fill(dt);
e.DataSources.Add(new ReportDataSource("DataSet2_employee",dt));

}
}
}