C# and ASP.NET Question and Answers

• The cost of developing applications is much lower, since standard business languages can be used and device independent presentation tier logic can be written.
• The cost of running applications is much lower, since commodity hardware platforms (at 1/5 the cost of their Unix counterparts) can be used.
• The ability to scale up is much greater, with the proven ability to support at least ten times the number of clients any J2EE platform has shown itself able to support.
• Interoperability is much stronger, with industry standard eCollaboration built into the platform.

• Security
• Type Identity
• Reference Scope
• Versioning
• Deployment

1. Those that are directly supported by .NET (Pocket PCs, i-Mode phones, and WAP devices)
2. Those that are not (Palm OS and J2ME-powered devices).

• Public: Access is not restricted.
• Protected: Access is limited to the containing class or types derived from the containing class.
• Internal: Access is limited to the current assembly.
• Protected intetnal: Access is limited to the current assembly or types derived from the containing class.
• Private: Access is limited to the containing type.

20. What is value type and refernce type in .Net?.

Value Type: A variable of a value type always contains a value of that type. The assignment to a variable of a value type creates a copy of the assigned value, while the assignment to a variable of a reference type creates a copy of the reference but not of the referenced object. The value types consist of the following two main categories:

• Struct Type
• Enumeration Type

• Class
• Interface
• Delegate

• object
• string

22. What are namespaces?

A namespace is a logical naming scheme for group related types. Some class types that logically belong together can be put into a common namespace. They prevent namespace collisions and they provide scoping. They are imported as "using" in C# or "Imports" in Visual Basic. It seems as if these directives specify a specific assembly, but they don't. A namespace can span multiple assemblies, and an assembly can define multiple namespaces. When the compiler needs the definition for a class type, it tracks through each of the various imported namespaces to the type name and searches each referenced assembly until it is found. Namespaces can be nested. This is very similar to packages in Java as far as scoping is concerned. 23. How do you create shared assemblies?

Just look through the definition of Assemblies..

• An Assembly is a logical unit of code
• Assembly physically exist as DLLs or EXEs
• One assembly can contain one or more files
• The constituent files can include any file types like image files, text files and so on. along with DLLs or EXEs
• When you compile your source code by default the exe/DLL generated is actually an assembly
• Unless your code is bundled as assembly it can not be used in any other application
• When you talk about version of a component you are actually talking about version of the assembly to which the component belongs.
• Every assembly file contains information about itself. This information is called as Assembly Manifest.
• Following steps are involved in creating shared assemblies:
• Create your DLL/EXE source code
• Generate unique assembly name using SN utility
• Sign your DLL/EXE with the private key by modifying AssemblyInfo file
• Compile your DLL/EXE
• Place the resultant DLL/EXE in Global Assembly Cache using AL utility

• Use an installer designed to work with the Global Assembly Cache. This is the preferred option for installing assemblies into the Global Assembly Cache.
• Use a developer tool called the Global Assembly Cache tool (Gacutil.exe), provided by the .NET Framework SDK.
• Use Windows Explorer to drag assemblies into the cache.

This case-sensitive attribute "debug tells ASP.NET to generate symbols for dynamically generated files and enables the debugger to attach to the ASP.NET application. ASP.NET will detect this change automatically, without the need to restart the server. Debug Mode for ASP.NET Webservices, Debugging an XML Web service created with ASP.NET is similar to the debugging an ASP.NET Web application. 29. What is the property available to check if the page posted or not?

The Page_Load event handler in the page checks for IsPostBack property value, to ascertain whether the page is posted. The Page.IsPostBack gets a value indicating whether the page is being loaded in response to the client postback, or it is for the first time. The value of Page.IsPostBack is True, if the page is being loaded in response to the client postback; while its value is False, when the page is loaded for the first time. The Page.IsPostBack property facilitates execution of certain routine in Page_Load, only once (for for example in Page load, we need to set default value in controls, when page is loaded for the first time. On post-back, we check for true value for IsPostback value and then invoke server-side code to update data). 30. What are the abstract classes available under system.xml namespace?

The System.XML namespace provides XML related processing ability in .NET framework. XmlReader and XMLWriter are the two abstract classes at the core of .NET Framework XML classes:

1. XmlReader provides a fast, forward-only, read-only cursor for processing an XML document stream.
2. XmlWriter provides an interface for producing XML document streams that conform to the W3C's XML standards.

1. XmlTextReader
2. XmlNodeReader
3. XmlValidatingReader

1. XmlTextWriter
2. XmlNodeWriter

1. Detect and redirect
2. Run-time adjustment
3. Using Satellite assemblies.

A GUID is a 128-bit integer (16 bytes) that can be used across all computers and networks wherever a unique identifier is required. Such an identifier has a very low probability of being duplicated. Visual Studio .NET IDE has a utility under the tools menu to generate GUIDs. 40. Why do you need to serialize.?

We need to serialize the object,if you want to object from one computer/application domain to another.Process of converting complex objects into stream of bytes that can be persisted or transported.Namespace for serialization is System.Runtime.Serialization.The ISerializable interface allows you to make any class Serializable..NET framework features 2 serializing method. 44. Can a nested object be used in Serialization ?

Yes. If a class that is to be serialized contains references to objects of other classes, and if those classes have been marked as serializable, then their objects are serialized too. 45. Difference between int and int32 ?

Both are same. System.Int32 is a .NET class. Int is an alias name for System.Int32. 46. Describe the difference between a Thread and a Process?

A Process is an instance of an running application. And a thread is the Execution stream of the Process. A process can have multiple Thread. When a process starts a specific memory area is allocated to it. When there is multiple thread in a process, each thread gets a memory for storing the variables in it and plus they can access to the global variables that is common for all the thread. Eg.A Microsoft Word is a Application. When you open a Word file,an instance of the Word starts and a process is allocated to this instance that has one thread. 47. What is the difference between an EXE and a DLL?

You can create an objects of DLL but not of the EXE. DLL is an In-Process Component whereas EXE is an OUt-Process Component. Exe is for single use whereas you can use DLL for multiple use. Exe can be started as standalone where DLL cannot be. 48. What is strong-typing versus weak-typing? Which is preferred? Why?

Strong typing implies that the types of variables involved in operations are associated to the variable, checked at compile-time, and require explicit conversion; weak typing implies that they are associated to the value, checked at run-time, and are implicitly converted as required. (Which is preferred is a disputable point, but I personally prefer strong typing because I like my errors to be found as soon as possible.) 49. What is a PID? How is it useful when troubleshooting a system?

PID is the process Id of the application in Windows. Whenever a process starts running in the Windows environment, it is associated with an individual process Id or PID. The PID (Process ID) a unique number for each item on the Process Tab, Image Name list. How do you get the PID to appear? In Task Manger, select the View menu, then select columns and check PID (Process Identifier). In Linux, PID is used to debug a process explicitly. However we cannot do this in a windows environment. Microsoft has launched a SDK called as Microsoft Operations Management (MOM). This uses the PID to determine which DLL's have been loaded by a process in the memory. This is essentially helpful in situations where the Process that has a memory leak is to be traced to a erring DLL. Personally I have never used a PID, our Windows debugger does the things required to determine. 50. What is the GAC? What problem does it solve?

Each computer where the Common Language Runtime is installed has a machine-wide code cache called the Global Assembly Cache. The Global Assembly Cache stores assemblies that are to be shared by several applications on the computer. This area is typically the folder under windows or winnt in the machine. All the assemblies that need to be shared across applications need to be done through the Global Assembly Cache only. However it is not necessary to install assemblies into the Global Assembly Cache to make them accessible to COM interop or unmanaged code. There are several ways to deploy an assembly into the Global Assembly Cache:

• Use an installer designed to work with the Global Assembly Cache. This is the preferred option for installing assemblies into the Global Assembly Cache.
• Use a developer tool called the Global Assembly Cache tool (Gacutil.exe), provided by the .NET Framework SDK.
• Use Windows Explorer to drag assemblies into the cache.

• Interface should not have any implementation.
• Interface can not create any instance.
• Interface should provide high level abstraction from the implementation.
• Interface can have multiple inheritances.
• Default access level of the interface is public.

• Name uniqueness. Shared assemblies must have names that are globally unique.
• Prevent name spoofing. Developers don't want someone else releasing a subsequent version of one of your assemblies and falsely claim it came from you, either by accident or intentionally.
• Provide identity on reference. When resolving a reference to an assembly, strong names are used to guarantee the assembly that is loaded came from the expected publisher.

This three alongwith name of the assembly provide a strong name or fully qualified name to the assembly. When a assebly is referenced with all three. PublicKeyToken: Each assembly can have a public key embedded in its manifest that identifies the developer. This ensures that once the assembly ships, no one can modify the code or other resources contained in the assembly. Culture: Specifies which culture the assembly supports Version: The version number of the assembly.It is of the following form major.minor.build.revision. Explain the differences between public, protected, private and internal. These all are access modifier and they governs the access level. They can be applied to class, methods, fields. Public: Allows class, methods, fields to be accessible from anywhere in other words within and outside an assembly. Private: When applied to field and method allows to be accessible within a class. Protected: Similar to private but can be accessed by members of derived class also. Internal: They are public within the assembly in other words they can be accessed by anyone within an assembly but outside assembly they are not visible. 68. What is the difference between typeof(foo) and myFoo.GetType()?

Typeof is operator that applied to a object returns System.Type object. Typeof cannot be overloaded white GetType has lot of overloads.GetType is a method that also returns System.Type of an object. GetType is used to get the runtime type of the object. Example from MSDN showing Gettype used to retrive type at untime: No "This" cannot be used in a static method. As only static variables/methods can be used in a static method. What is the purpose of XML Namespaces? An XML Namespace is a collection of element types and attribute names. It consists of 2 parts:

1. The first part is the URI used to identify the namespace
2. The second part is the element type or attribute name itself.

1. Combine fragments from various documents without any naming conflicts. (See example below.).
2. Write reusable code modules that can be invoked for specific elements and attributes. Universally unique names guarantee that such modules are invoked only for the correct elements and attributes.
3. Define elements and attributes that can be reused in other schemas or instance documents without fear of name collisions. For example, you might use XHTML elements in a parts catalog to provide part descriptions. Or you might use the nil attribute defined in XML Schemas to indicate a missing value.

70. What is difference between MetaData and Manifest ?

Metadata and Manifest forms an integral part of an assembly( DLL / exe ) in .net framework Out of which Metadata is a mandatory component , which as the name suggests gives the details about various components of IL code viz: Methods , properties , fields , class and so on. Essentially Metadata maintains details in form of tables like Methods Metadata tables , Properties Metadata tables , that maintains the list of given type and other details like access specifier , return type and so on. Now Manifest is a part of metadata only , fully called as "manifest metadata tables" , it contains the details of the references needed by the assembly of any other external assembly / type , it could be a custom assembly or standard System namespace. Now for an assembly that can independently exists and used in the .Net world both the things ( Metadata with Manifest ) are mandatory , so that it can be fully described assembly and can be ported anywhere without any system dependency . Essentially .Net framework can read all assembly related information from assembly itself at runtime. But for .Net modules , that can't be used independently , until they are being packaged as a part of an assembly , they don't contain Manifest but their complete structure is defined by their respective metadata. Ultimately . .Net modules use Manifest Metadata tables of parent assembly that contain them. 71. What is the use of Internal keyword?

Internal keyword is one of the access specifier available in .Net framework , that makes a type visible in a given assembly , for e.g: a single DLL can contain multiple modules , essentially a multi file assembly , but it forms a single binary component , so any type with internal keyword will be visible throughout the assembly and can be used in any of the modules. 72. What actually happes when you add a something to arraylistcollection ?

Following things will happen: Arraylist is a dynamic array class in C# in System.Collections namespace derived from interfaces – ICollection , IList , ICloneable , IConvertible . It terms of in memory structure following is the implementation.

1. Check up the total space if there's any free space on the declared list.
2. If yes add the new item and increase count by 1 .
3. If No Copy the entire thing to a temporary Array of Last Max. Size.
4. Create new Array with size ( Last Array Size + Increase Value )
5. Copy back values from temp and reference this new array as original array.
6. Must doing Method updates too , need to check it up.

1. .NET class should be implement its functionality through interface. First define interface in code, then have the class to imlpement it. This way, it prevents breaking of COM client, if/when .NET component changes.
2. Secondly, .NET class, that is to be visible to COM clients must be declared public. The tools that create the CCW only define types based on public classes. The same rule applies to methods, properties, and events that will be used by COM clients.

1. Generate type library of .NET component, using TLBExporter utility. A type library is the COM equivalent of the metadata contained within
   a .NET assembly. Type libraries are generally contained in files with the extension .tlb. A type library contains the necessary information to allow a COM client to determine which classes are located in a specific server, as well as the methods, properties, and events supported by those classes.
   
2. Secondly, use Assembly Registration tool (regasm) to create the type library and register it.
3. Lastly install .NET assembly in GAC, so it is available as shared assembly.

<DataInstance> The name of this element, DataInstance, is used for explanation purposes in this documentation. A DataInstance element represents a DataSet or a row of a DataTable. Instead of DataInstance, the element would contain the name of the DataSet or DataTable. This block of the DiffGram format contains the current data, whether it has been modified or not. An element, or row, that has been modified is identified with the diffgr:hasChanges annotation. <diffgr:before>

This block of the DiffGram format contains the original version of a row. Elements in this block are matched to elements in the DataInstance block using the diffgr:id annotation. <diffgr:errors> This block of the DiffGram format contains error information for a specific row in the DataInstance block. Elements in this block are matched to elements in the DataInstance block using the diffgr:id annotation. 2. Which method do you invoke on the DataAdapter control to load your generated dataset with data?

You must use the Fill method of the DataAdapter control and the dataset object as an argument to load the generated data. 3. Can you edit data in the Repeater control?

NO. 4. Which are the various IsolationLevels ?

Following are the various IsolationLevels:

• Serialized Data read by a current transaction cannot be changed by another transaction until the current transaction finishes. No new data can be inserted that would affect the current transaction. This is the safest isolation level and is the default.
• Repeatable Read Data read by a current transaction cannot be changed by another transaction until the current transaction finishes. Any type of new data can be inserted during a transaction.
• Read Committed A transaction cannot read data that is being modified by another transaction that has not committed. This is the default isolation level in Microsoft® SQL Server.
• Read Uncommitted A transaction can read any data, even if it is being modified by another transaction. This is the least safe isolation level but allows the highest concurrency.
• Any Any isolation level is supported. This setting is most commonly used by downstream components to avoid conflicts. This setting is useful because any downstream component must be configured with an isolation level that is equal to or less than the isolation level of its immediate upstream component. Therefore, a downstream component that has its isolation level configured as Any always uses the same isolation level that its immediate upstream component uses. If the root object in a transaction has its isolation level configured to Any, its isolation level becomes Serialized.

• Connection: Establishes a connection to a specific data source
• Command: Executes a command against a data source. Exposes Parameters and can execute within the scope of a Transaction from a Connection.
• DataReader: Reads a forward-only, read-only stream of data from a data source.
• DataAdapter: Populates a DataSet and resolves updates with the data source.

1. Table Collection: ADO Recordset provides the ability to navigate through a single table of information. That table would have been formed with a join of multiple tables and returning columns from multiple tables. ADO.NET DataSet is capable of holding instances of multiple tables. It has got a Table Collection, that holds multiple tables in it. If the tables are having a relation, then it can be manipulated on a Parent-Child relationship. It has the ability to support multiple tables with keys, constraints and interconnected relationships. With this ability the DataSet can be considered as a small, in-memory relational database cache.
2. Navigation: Navigation in ADO Recordset is based on the cursor mode. Even though it is specified to be a client-side Recordset, still the navigation pointer will move from one location to another on cursor model only. ADO.NET DataSet is an entirely offline, in-memory, and cache of data. All of its data is available all the time. At any time, we can retrieve any row or column, constraints or relation simply by accessing it either ordinarily or by retrieving it from a name-based collection.
3. Connectivity Model: The ADO Recordset was originally designed without the ability to operate in a disconnected environment. ADO.NET DataSet is specifically designed to be a disconnected in-memory database. ADO.NET DataSet follows a pure disconnected connectivity model and this gives it much more scalability and versatility in the amount of things it can do and how easily it can do that.
4. Marshalling and Serialization: In COM, through Marshalling, we can data from 1 COM component to another component at any time. Marshalling involves copying and processing data so that a complex type can appear to the receiving component the same as it appeared to the sending component. Marshalling is an expensive operation. ADO.NET Dataset and DataTable components support Remoting in the form of XML serialization. Rather than doing expensive Marshalling, it uses XML and sent data across boundaries.
5. Firewalls and DCOM and Remoting: Those who have worked with DCOM know that how difficult it is to marshal a DCOM component across a router. People generally came up with workarounds to solve this issue. ADO.NET DataSet uses Remoting, through which a DataSet / DataTable component can be serialized into XML, sent across the wire to a new AppDomain, and then Desterilized back to a fully functional DataSet. As the DataSet is completely disconnected, and it has no dependency, we lose absolutely nothing by serializing and transferring it through Remoting.

The output parameter has its sourcecolumn and sourceversion arguments set to point the output parameter's return value back to the current value of the LastUpdateDateTime column of the DataSet. This way the updated DATETIME value is retrieved and can be returned to the user's .aspx page. Contd.... Saving Changes

Now that the Employees table has the tracking field (LastUpdateDateTime) and the Stored Procedure has been created to use both the primary key and the tracking field in the WHERE clause of the UPDATE statement, let's have a look at the role of ADO.NET. In order to trap the event when the user changes the values in the textboxes, I created an event handler for the TextChanged event for each TextBox control: The Page_Load event grabs the row from the DataSet in the Session object; the TextChanged events update the DataRow with the new values; and the btnSave_Click event attempts to save the record to the database. The btnSave_Click event calls the SaveEmployee method (shown in Figure 3) and es it a bLastInWins value of false since we want to attempt a standard save first. If the SaveEmployee method detects that changes were made to the row (using the HasChanges method on the DataSet, or alternatively using the RowState property on the row), it creates an instance of the Employee class and es the DataSet to its SaveEmployee method. The Employee class could live in a logical or physical middle tier. (I wanted to make this a separate class so it would be easy to pull the code out and separate it from the presentation logic.) Notice that I did not use the GetChanges method to pull out only the modified rows and them to the Employee object's Save method. I skipped this step here since there is only one row. However, if there were multiple rows in the DataSet's DataTable, it would be better to use the GetChanges method to create a DataSet that contains only the modified rows. If the save succeeds, the Employee.SaveEmployee method returns a DataSet containing the modified row and its newly updated row version flag (in this case, the LastUpdateDateTime field's value). This DataSet is then merged into the original DataSet so that the LastUpdateDateTime field's value can be updated in the original DataSet. This must be done because if the user wants to make more changes she will need the current values from the database merged back into the local DataSet and shown on screen. This includes the LastUpdateDateTime value that is used in the WHERE clause. Without this field's current value, a false concurrency violation would occur. Reporting Violations

If a concurrency violation occurs, it will bubble up and be caught by the exception handler shown in Figure 3 in the catch block for DBConcurrencyException. This block calls the FillConcurrencyValues method, that displays both the original values in the DataSet that were attempted to be saved to the database and the values currently in the database. This method is used merely to show the user why the violation occurred. Notice that the exDBC variable is ed to the FillConcurrencyValues method. This instance of the special database concurrency exception class (DBConcurrencyException) contains the row where the violation occurred. When a concurrency violation occurs, the screen is updated to look like Figure 1. The DataSet not only stores the schema and the current data, it also tracks changes that have been made to its data. It knows which rows and columns have been modified and it keeps track of the before and after versions of these values. When accessing a column's value via the DataRow's indexer, in addition to the column index you can also specify a value using the DataRowVersion enumerator. For example, after a user changes the value of the last name of an employee, the following lines of C# code will retrieve the original and current values stored in the LastName column: string sLastName_Before = oEmpRow["LastName", DataRowVersion.Original]; string sLastName_After = oEmpRow["LastName", DataRowVersion.Current]; The FillConcurrencyValues method uses the row from the DBConcurrencyException and gets a fresh copy of the same row from the database. It then displays the values using the DataRowVersion enumerators to show the original value of the row before the update and the value in the database alongside the current values in the textboxes. User's Choice

Once the user has been notified of the concurrency issue, you could leave it up to her to decide how to handle it. Another alternative is to code a specific way to deal with concurrency, such as always handling the exception to let the user know (but refreshing the data from the database). In this sample application I let the user decide what to do next. She can either cancel changes, cancel and reload from the database, save changes, or save anyway. The option to cancel changes simply calls the RejectChanges method of the DataSet and rebinds the DataSet to the controls in the ASP.NET page. The RejectChanges method reverts the changes that the user made back to its original state by setting all of the current field values to the original field values. The option to cancel changes and reload the data from the database also rejects the changes but additionally goes back to the database via the Employee class in order to get a fresh copy of the data before rebinding to the control on the ASP.NET page. The option to save changes attempts to save the changes but will fail if a concurrency violation is encountered. Finally, I included a "save anyway" option. This option takes the values the user attempted to save and uses the last-in wins technique, overwriting whatever is in the database. It does this by calling a different command object associated with a Stored Procedure that only uses the primary key field (EmployeeID) in the WHERE clause of the UPDATE statement. This technique should be used with caution as it will overwrite the record. If you want a more automatic way of dealing with the changes, you could get a fresh copy from the database. Then overwrite just the fields that the current user modified, such as the Extension field. That way, in the example I used the proper LastName would not be overwritten. Use this with caution as well, however, because if the same field was modified by both users, you may want to just back out or ask the user what to do next. What is obvious here is that there are several ways to deal with concurrency violations, each of which must be carefully weighed before you decide on the one you will use in your application. Wrapping It Up

Setting the SqlDataAdapter's ContinueUpdateOnError property tells the SqlDataAdapter to either throw an exception when a concurrency violation occurs or to skip the row that caused the violation and to continue with the remaining updates. By setting this property to false (its default value), it will throw an exception when it encounters a concurrency violation. This technique is ideal when only saving a single row or when you are attempting to save multiple rows and want them all to commit or all to fail. I have split the topic of concurrency violation management into two parts. Next time I will focus on what to do when multiple rows could cause concurrency violations. I will also discuss how the DataViewRowState enumerators can be used to show what changes have been made to a DataSet. 13. How you will set the datarelation between two columns?

ADO.NET provides DataRelation object to set relation between two columns.It helps to enforce the following constraints,a unique constraint, that guarantees that a column in the table contains no duplicates and a foreign-key constraint,that can be used to maintain referential integrity.A unique constraint is implemented either by simply setting the Unique property of a data column to true, or by adding an instance of the UniqueConstraint class to the DataRelation object's ParentKeyConstraint. As part of the foreign-key constraint, you can specify referential integrity rules that are applied at three points,when a parent record is updated,when a parent record is deleted and when a change is accepted or rejected. WebServices And Windows Services

Can you give an example of when it would be appropriate to use a web service as opposed to non-serviced .NET component Web service is one of main component in Service Oriented Architecture. You could use web services when your clients and servers are running on different networks and also different platforms. This provides a loosely coupled system. And also if the client is behind the firewall it would be easy to use web service since it runs on port 80 (by default) instead of having some thing else in Service Oriented Architecture applications. 14. What is the standard you use to wrap up a call to a Web service

"SOAP." 15. What is the transport protocol you use to call a Web service SOAP

HTTP with SOAP 16. What does WSDL stand for?

"WSDL stands for Web Services Dsescription Langauge. There is WSDL.exe that creates a .wsdl Files that defines how an XML Web service behaves and instructs clients as to how to interact with the service. eg: wsdl http://LocalHost/WebServiceName.asmx" 17. Where on the Internet would you look for Web Services?

www.uddi.org 18. What does WSDL stand for?

Web Services Description Language 19. True or False: To test a Web service you must create a windows application or Web application to consume this service?

False. 20. What are the various ways of accessing a web service ?

1. Asynchronous Call

Application can make a call to the Webservice and then continue todo watever oit wants to do.When the service is ready it will notify the application.Application can use BEGIN and END method to make asynchronous call to the webmethod.We can use either a WaitHandle or a Delegate object when making asynchronous call. The WaitHandle class share resources between several objects. It provides several methods that will wait for the resources to become available The easiest and most powerful way to to implement an asynchronous call is using a delegate object. A delegate object wraps up a callback function. The idea is to a method in the invocation of the web method. When the webmethod has finished it will call this callback function to process the result 2. Synchronous Call

Application has to wait until execution has completed. Note: Few of the references are taken from other sites/sources 21. What are VSDISCO files?

VSDISCO files are DISCO files that support dynamic discovery of Web services. If you place the following VSDISCO file in a directory on your Web server, for example, it returns references to all ASMX and DISCO files in the host directory and any subdirectories not noted in <EXCLUDE>elements: 22. How does dynamic discovery work?

ASP.NET maps the file name extension VSDISCO to an HTTP handler that scans the host directory and subdirectories for ASMX and DISCO files and returns a dynamically generated DISCO document. A client who requests a VSDISCO file gets back what appears to be a static DISCO document. Note that VSDISCO files are disabled in the release version of ASP.NET. You can reenable them by uncommenting the line in the <HTTPHANDLERS>section of Machine.config that maps *.vsdisco to System.Web.Services.Discovery.DiscoveryRequestHandler and granting the ASPNET user account permission to read the IIS metabase. However, Microsoft is actively discouraging the use of VSDISCO files because they could represent a threat to Web server security. 23. Is it possible to prevent a browser from caching an ASPX page?

Just call SetNoStore on the HttpCachePolicy object exposed through the Response object's Cache property, as demonstrated here: <%@ Page Language="C#" %> <% Response.Cache.SetNoStore (); Response.Write (DateTime.Now.ToLongTimeString ()); %> SetNoStore works by returning a Cache-Control: private, no-store header in the HTTP response. In this example, it prevents caching of a Web page that shows the current time. 24. What does AspCompat="true" mean and when should I use it?

AspCompat is an aid in migrating ASP pages to ASPX pages. It defaults to false but should be set to true in any ASPX file that creates apartment-threaded COM objects--that is, COM objects registered ThreadingModel=Apartment. That includes all COM objects written with Visual Basic 6.0. AspCompat should also be set to true (regardless of threading model) if the page creates COM objects that access intrinsic ASP objects such as Request and Response. The following directive sets AspCompat to true: <%@ Page AspCompat="true" %> Setting AspCompat to true does two things. First, it makes intrinsic ASP objects available to the COM components by placing unmanaged wrappers around the equivalent ASP.NET objects. Second, it improves the performance of calls that the page places to apartment- threaded COM objects by ensuring that the page (actually, the thread that processes the request for the page) and the COM objects it creates share an apartment. AspCompat="true" forces ASP.NET request threads into single-threaded apartments (STAs). If those threads create COM objects marked ThreadingModel=Apartment, then the objects are created in the same STAs as the threads that created them. Without AspCompat="true," request threads run in a multithreaded apartment (MTA) and each call to an STA-based COM object incurs a performance hit when it's marshaled across apartment boundaries. Do not set AspCompat to true if your page uses no COM objects or if it uses COM objects that don't access ASP intrinsic objects and that are registered ThreadingModel=Free or ThreadingModel=Both. 25. Can two different programming languages be mixed in a single ASMX file?

No. 26. What namespaces are imported by default in ASMX files?

The following namespaces are imported by default. Other namespaces must be imported manually.• System, System.Collections,System.ComponentModel,System.Data, System.Diagnostics,System.Web,System.Web.Services 27. How do I provide information to the Web Service when the information is required as a SOAP Header?

The key here is the Web Service proxy you created using wsdl.exe or through Visual Studio .NET's Add Web Reference menu option. If you happen to download a WSDL file for a Web Service that requires a SOAP header, .NET will create a SoapHeader class in the proxy source file. Using the previous Example: Service1 objSvc = new Service1(); processingobjSvc.AuthTokenValue = new AuthToken(); objSvc.AuthTokenValue.Token = <ACTUAL token value>; Web Servicestring strResult = objSvc.MyBillableWebMethod(); 28. What is WSDL?

WSDL is the Web Service Description Language, and it is implemented as a specific XML vocabulary. While it's very much more complex than what can be described here, there are two important aspects to WSDL with which you should be aware. First, WSDL provides instructions to consumers of Web Services to describe the layout and contents of the SOAP packets the Web Service intends to issue. It's an interface description document, of sorts. And second, it isn't intended that you read and interpret the WSDL. Rather, WSDL should be processed by machine, typically to generate proxy source code (.NET) or create dynamic proxies on the fly (the SOAP Toolkit or Web Service Behavior). 29. What is a Windows Service and how does its lifecycle differ from a "standard" EXE?

Windows service is a application that runs in the background. It is equivalent to a NT service. The executable created is not a Windows application, and hence you can't just click and run it . it needs to be installed as a service, VB.Net has a facility where we can add an installer to our program and then use a utility to install the service. Where as this is not the case with standard exe 30. How can a win service developed in .NET be installed or used in Win98?

Windows service cannot be installed on Win9x machines even though the .NET framework runs on machine. 31. Can you debug a Windows Service? How ?

Yes we can debug a Windows Service. Attach the WinDbg debugger to a service after the service starts This method is similar to the method that you can use to attach a debugger to a process and then debug a process. Use the process ID of the process that hosts the service that you want to debug. 1. To determine the process ID (PID) of the process that hosts the service that you want to debug, use one of the following methods. Method 1: Use the Task Manager

• Right-click the Taskbar, and then click Task Manager. The Windows Task Manager dialog box appears.
• Click the Processes tab of the Windows Task Manager dialog box.
• Under Image Name, click the image name of the process that hosts the service that you want to debug. Note the process ID of this process as specified by the value of the corresponding PID field.

• Click Start, and then click Run. The Run dialog box appears.
• In the Open box, type cmd, and then click OK.
• At the command prompt, change the directory path to reflect the location of the tlist.exe file on your computer

  Note: The tlist.exe file is typically located in the following directory: C:\Program Files\Debugging Tools for Windows
• d. At the command prompt, type tlist to list the image names and the process IDs of all processes that are currently running on your computer.

1. Click Start, and then click Run. The Run dialog box appears.
2. In the Open box, type cmd, and then click OK to open a command prompt.
3. At the command prompt, change the directory path to reflect the location of the windbg.exe file on your computer.

1. Start Windows Explorer.
2. Locate the windbg.exe file on your computer.

   Note: The windbg.exe file is typically located in the following directory: C:\Program Files\Debugging Tools for Windows.
3. Run the windbg.exe file to start the WinDbg debugger.
4. On the File menu, click Attach to a Process to display the Attach to Process dialog box.
5. Click to select the node that corresponds to the process that hosts the service that you want to debug, and then click OK.
6. In the dialog box that appears, click Yes to save base workspace information. Notice that you can now debug the disassembled code of your service.

• Start Windows Explorer.
• Locate the gflags.exe file on your computer.

  Note: The gflags.exe file is typically located in the following directory: C:\Program Files\Debugging Tools for Windows.
• Run the gflags.exe file to start the Global Flags Editor.
• In the Image File Name text box, type the image name of the process that hosts the service that you want to debug. For example, if you want to debug a service that is hosted by a process that has MyService.exe as the image name, type MyService.exe.
• Under Destination, click to select the Image File Options option.
• Under Image Debugger Options, click to select the Debugger check box.
• In the Debugger text box, type the full path of the debugger that you want to use. For example, if you want to use the WinDbg debugger to debug a service, you can type a full path that is similar to the following: C:\Program Files\Debugging Tools for Windows\windbg.exe
• Click Apply, and then click OK to quit the Global Flags Editor.

• Click Start, and then click Run. The Run dialog box appears.
• In the Open box, type regedit, and then click OK to start Registry Editor.
• Warning If you use Registry Editor incorrectly, you may cause serious problems that may require you to reinstall your operating system. Microsoft cannot guarantee that you can solve problems that result from using Registry Editor incorrectly. Use Registry Editor at your own risk.

  In Registry Editor, locate, and then right-click the following registry subkey:

  HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options
• Point to New, and then click Key. In the left pane of Registry Editor, notice that New Key #1 (the name of a new registry subkey) is selected for editing.
• Type ImageName to replace New Key #1, and then press ENTER.

  Note ImageName is a placeholder for the image name of the process that hosts the service that you want to debug. For example, if you want to debug a service that is hosted by a process that has MyService.exe as the image name, type MyService.exe.
• Right-click the registry subkey that you created in step e.
• Point to New, and then click String Value. In the right pane of Registry Editor, notice that New Value #1, the name of a new registry entry, is selected for editing.
• Replace New Value #1 with Debugger, and then press ENTER.
• Right-click the Debugger registry entry that you created in step h, and then click Modify. The Edit String dialog box appears.
• In the Value data text box, type DebuggerPath, and then click OK.

  Note: DebuggerPath is a placeholder for the full path of the debugger that you want to use. For example, if you want to use the WinDbg debugger to debug a service, you can type a full path that is similar to the following: C:\Program Files\Debugging Tools for Windows\windbg.exe

• Click Start, and then point to Programs.
• On the Programs menu, point to Administrative Tools, and then click Services. The Services console appears.
• In the right pane of the Services console, right-click ServiceName, and then click Properties.

  Note: ServiceName is a placeholder for the name of the service that you want to debug.
• On the Log On tab, click to select the Allow service to interact with Desktop check box under Local System account, and then click OK.

• In Registry Editor, locate, and then click the following registry subkey:

  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ServiceName

  Note Replace ServiceName with the name of the service that you want to debug. For example, if you want to debug a service named MyService, locate and then click the following registry key:

  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\MyService
• Under the Name field in the right pane of Registry Editor, right-click Type, and then click Modify. The Edit DWORD Value dialog box appears.
• Change the text in the Value data text box to the result of the binary OR operation with the binary value of the current text and the binary value, 0x00000100, as the two operands. The binary value, 0x00000100, corresponds to the SERVICE_INTERACTIVE_PROCESS constant that is defined in the WinNT.h header file on your computer. This constant specifies that a service is interactive in nature.

• In Registry Editor, locate, and then right-click the following registry subkey:

  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control
• Point to New, and then click DWORD Value. In the right pane of Registry Editor, notice that New Value #1 (the name of a new registry entry) is selected for editing.
• Type ServicesPipeTimeout to replace New Value #1, and then press ENTER.
• Right-click the ServicesPipeTimeout registry entry that you created in step c, and then click Modify. The Edit DWORD Value dialog box appears.
• In the Value data text box, type TimeoutPeriod, and then click OK

  Note:

  TimeoutPeriod is a placeholder for the value of the time-out period (in milliseconds) that you want to set for the service. For example, if you want to set the time-out period to 24 hours (86400000 milliseconds), type 86400000.
• Restart the computer. You must restart the computer for Service Control Manager to apply this change.

• Click Start, and then point to Programs.
• On the Programs menu, point to Administrative Tools, and then click Services. The Services console appears.
• In the right pane of the Services console, right-click ServiceName, and then click Start.

  Note: ServiceName is a placeholder for the name of the service that you want to debug.