.NET Deployment Questions and Answers
What do you know about .NET assemblies?
Assemblies are the smallest units of versioning and deployment in the .NET application. Assemblies are also the building blocks for programs such as Web services, Windows services, serviced components, and .NET remoting applications.
What’s the difference between private and shared assembly?
Private assembly is used inside an application only and does not have to be identified by a strong name. Shared assembly can be used by multiple applications and has to have a strong name.
What’s a strong name?
A strong name includes the name of the assembly, version number, culture identity, and a public key token.
How can you tell the application to look for assemblies at the locations other than its own install?
Use the
directive in the XML .config file for a given application.
should do the trick. Or you can add additional search paths in the Properties box of the deployed application.
How can you debug failed assembly binds?
Use the Assembly Binding Log Viewer (fuslogvw.exe) to find out the paths searched.
Where are shared assemblies stored?
Global assembly cache.
How can you create a strong name for a .NET assembly?
With the help of Strong Name tool (sn.exe).
Where’s global assembly cache located on the system?
Usually C:\winnt\assembly or C:\windows\assembly.
Can you have two files with the same file name in GAC?
Yes, remember that GAC is a very special folder, and while normally you would not be able to place two files with the same name into a Windows folder, GAC differentiates by version number as well, so it’s possible for MyApp.dll and MyApp.dll to co-exist in GAC if the first one is version 1.0.0.0 and the second one is 1.1.0.0.
So let’s say I have an application that uses MyApp.dll assembly, version 1.0.0.0. There is a security bug in that assembly, and I publish the patch, issuing it under name MyApp.dll 1.1.0.0. How do I tell the client applications that are already installed to start using this new MyApp.dll?
Use publisher policy. To configure a publisher policy, use the publisher policy configuration file, which uses a format similar app .config file. But unlike the app .config file, a publisher policy file needs to be compiled into an assembly and placed in the GAC.
What is delay signing?
Delay signing allows you to place a shared assembly in the GAC by signing the assembly with just the public key. This allows the assembly to be signed with the private key at a later stage, when the development process is complete and the component or assembly is ready to be deployed. This process enables developers to work with shared assemblies as if they were strongly named, and it secures the private key of the signature from being accessed at different stages of development.
.NET and COM Inteview Questions and Answers
Describe the advantages of writing a managed code application instead of unmanaged one. What’s involved in certain piece of code being managed?
The advantages include automatic garbage collection, memory management, support for versioning and security. These advantages are provided through .NET FCL and CLR, while with the unmanaged code similar capabilities had to be implemented through third-party libraries or as a part of the application itself.
Are COM objects managed or unmanaged?
Since COM objects were written before .NET, apparently they are unmanaged.
Any code not written in the Microsoft .NET framework environment is UNMANAGED. So naturally COM+ is unmanaged because it is written in Visual Basic 6.
So can a COM object talk to a .NET object?
Yes, through Runtime Callable Wrapper (RCW) or PInvoke.
How do you generate an RCW from a COM object?
Use the Type Library Import utility shipped with SDK. tlbimp COMobject.dll /out:.NETobject.dll or reference the COM library from Visual Studio in your project.
I can’t import the COM object that I have on my machine. Did you write that object?
You can only import your own objects. If you need to use a COM component from another developer, you should obtain a Primary Interop Assembly (PIA) from whoever authored the original object.
How do you call unmanaged methods from your .NET code through PInvoke?
Supply a DllImport attribute. Declare the methods in your .NET code as static extern. Do not implement the methods as they are implemented in your unmanaged code, you’re just providing declarations for method signatures.
Can you retrieve complex data types like structs from the PInvoke calls?
Yes, just make sure you re-declare that struct, so that managed code knows what to do with it.
I want to expose my .NET objects to COM objects. Is that possible?
Yes, but few things should be considered first. Classes should implement interfaces explicitly. Managed types must be public. Methods, properties, fields, and events that are exposed to COM must be public. Types must have a public default constructor with no arguments to be activated from COM. Types cannot be abstract.
Can you inherit a COM class in a .NET application?
The .NET Framework extends the COM model for reusability by adding implementation inheritance. Managed types can derive directly or indirectly from a COM coclass; more specifically, they can derive from the runtime callable wrapper generated by the runtime. The derived type can expose all the method and properties of the COM object as well as methods and properties implemented in managed code. The resulting object is partly implemented in managed code and partly implemented in unmanaged code.
Suppose I call a COM object from a .NET applicaiton, but COM object throws an error. What happens on the .NET end?
COM methods report errors by returning HRESULTs; .NET methods report them by throwing exceptions. The runtime handles the transition between the two. Each exception class in the .NET Framework maps to an HRESULT.
faqs-05
NET Interoperability
How can we use COM Components in .NET?
What is RCW ?
.NET components communicate with COM using RCW (Runtime Callable Wrapper). Following
are the ways with which you can generate RCW :-
√ Adding reference in Visual Studio.net. See figure below (Adding reference using VS.NET
2005). Wrapper class is generated and placed in the “BIN” directory.
√ Using Type library import tool. Tlbimp.exe yourname.dll.
√ Using interopservices.System.runtime.Interopservices namespace contains class
TypeLib Converter which provides methods to convert COM classes and interface in
to assembly metadata.
√ Make your custom wrappe rs.If your COM component does not have type library
then the only way to communicate is writing custom wrappers. That means
communicating directly with COM components.
Once I have developed the COM wrapper do I have to still register the
COM in registry?
Yes.
How can we use .NET components in COM?
Twist :- What is CCW (COM callable wrapper) ?
Twist :- How do we ensure that .NET components is compatible with COM ?
.NET components can not be used in straight forward way with COM. You will need to create
CCW in order that COM components communicate with .NET assemblies. Following are the
different approaches to implement it :-
√ Explicitly declare interfaces..
Public Interface ICustomer
Property CustomerName() As String
Property CustomerCode() As String
Sub AddCustomer()
End Interface
Public Class Customer
Implements ICustomer
Private PstrCustomerName As String
Private PstrCustomerCode As String
Public Sub AddCustomer() Implements ICustomer.AddCustomer
Try
‘ addin of database code can go here
Catch ex As Exception
Throw ex
End Try
End Sub
Public Property CustomerCode() As String Implements
ICustomer.CustomerCode
Get
Return PstrCustomerCode
End Get
Set(ByVal value As String)
PstrCustomerCode = value
End Set
End Property
Public Property CustomerName() As String Implements
ICustomer.CustomerName
Get
Return PstrCustomerName
End Get
Set(ByVal value As String)
PstrCustomerName = value
End Set
End Property
Public Sub New()
End Sub
End Class
Note :- Source code of this is provided in CD in SOURCECODE folder in
COMCALLABLEWRAPPER
The above customer class is going to be used by COM components so all the properties and
methods are declared in interface and implemented in the customer class. Customer Name.Customer
Code and AddCustomer are first declared in ICustomer and then implemented in Customer
Class. Also note that the class must have a default constructor.
Note :- All source code in this book is provided in VB.NET that does not mean that
author of the book does not like C#. In fact the main programming language of author is
C#. In order to keep things small I have only used one language. But the conversion is so
seamless that it is of least matter.
√ The second way to create CCW is by using InteropServices attributes. Here interfaces
are created automatically.
Following are different type of class attributes :
None:-No class interface is generated for the class. This is default setting when you do not specify
anything.
AutoDispatch :- Interface that supports IDispatch is created for the class. However, no type
information is produced.
AutoDual :- A dual interface is created for the class. Type information is produced and made
available in the type library.
Below in the source code we have used the third attribute.
Imports System.Runtime.InteropServices
Public Class ClsCompliant
End Class
Other than class attributes defined up there are other attributes with which you can govern other
part of assembly.Example “GuidAttribute” allows you to specify the GUID,
“ComVisibleAttribute” can be used to hide .NET types from COM etc. All attributes are not in
scope of the book as this is a interview questions book refer MSDN for more details.
√ Once .NET assembly is created using either interface or using interopservices method
we need to create a COM type library using Type library export tool.
Tlbexp (AssemblyName)
√ The final thing is registering the CCW in registry using regasm tool.
regasm AssemblyName [Options]
√ Finally refer the TLB in your COM IDE Below is figure showing VB6 IDE referencing
the DLL
Note :- DLL and TLB should be in same directory where the application is executed.
How can we make Windows API calls in .NET?
Windows API call are not COM based and they are invoked through Platform Invoke Services.
Declare StringConversionType (Function Sub) MethodName Lib "DllName" ([Args]) As Type
√ StringConversionType is for what type of conversion should take place. Either we
can specify Unicode to convert all strings to Unicode values, or Auto to convert
strings according to the .NET runtime rules.
√ MethodName is the name of the API to call.
√ DllName is the name of the DLL.
√ Args are any arguments to the API call.
√ Type is the return type of the API call.
Below is a sample code for VB.NET which uses Sleep windows API for delaying.
Public Class Form1
Declare Auto Sub Sleep Lib “kernel32.dll” (ByVal dwMilliseconds As Long)
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
MessageBox.Show(“ start sleeping for 5000 Milli seconds.....”)
Sleep(5000)
MessageBox.Show(“ end of sleeping.....”)
End Sub
End Class
In VB.NET we use declare keyword but in C# it goes little bit different, we use DLLIMPORT
here.
Note :- We have interopservices in this and EXTERN keyword.
#region Using directives
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
#endregion
namespace CSharpCode
{
partial class Form1 : Form
{
[DllImport(“Kernel32.dll”)]
static extern int Sleep(long dwMilliseconds);
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
105
{
MessageBox.Show(“Starting of 5000 ms...”);
Sleep(5000);
MessageBox.Show(“End of 5000 ms...”);
}
}
}
When we use windows API in .NET is it managed or unmanaged code
?
Windows API in .NET is unmanaged code.
Note:- Even though VB6 and V C++ has gone off still many people do ask these old
questions again and again. Still there are decent old application which are working with
COM very much fine. So interviewer still asks you these questions so that those
application’s can be ported to .NET. So let’s play some old music... By the way my
favourite music is Kishore, what’s yours???
(I)What is COM ?
Microsoft’s COM is a technology for component software development. It is a binary standard
which is language independent. DCOM is a distributed extension of COM.
(A) What is Reference counting in COM ?
Reference counting is a memory management technique used to count how many times an object
has a pointer referring to it. The first time it is created, the reference count is set to one. When the
last reference to the object is nulled, the reference count is set to zero and the object is deleted.
Care must be exercised to prevent a context switch from changing the reference count at the time
of deletion. In the methods that follow, the syntax is shortened to keep the scope of the discussion
brief and manageable.
(A) Can you describe IUKNOWN interface in short ?
Every COM object supports at least one interface, the IUnknown interface. All interfaces are
classes derived from the base class IUnknown. Each interface supports methods access data and
perform operations transparently to the programmer. For example, IUnknown supports three
methods, AddRef, Release(), and QueryInterface(). Suppose that pinterf is a pointer to an IUnknown.
pinterf->AddRef() increments the reference count. pinterf->Release() decrements the reference
count, deleting the object when the reference count reaches zero. pinterf->QueryInterface( IDesired, pDesired) checks to see if the current interface (IUnknown) supports another interface, IDesired,
creates an instance (via a call to CoCreateInstance()) of the object if the reference count is zero (the
object does not yet exist), and then calls pDesired->AddRef() to increment the reference count
(where pDesired is a pointer to IDesired) and returns the pointer to the caller.
(I)Can you explain what is DCOM ?
DCOM differs from COM in that it allows for creating objects distributed across a network, a
protocol for invoking that object’s methods, and secures access to the object. DCOM provides a
wrapper around COM, hence it is a backwards compatible extension. DCOM uses Remote
Procedural Calls (RPC) using Open Software Foundation’s Distributed Computing Environment.
These RPC are implemented over TCP/IP and named pipes. The protocol which is actually being
used is registered just prior to use, as opposed to being registered at initialization time. The reason
for this is that if a protocol is not being used, it will not be loaded.
In order to inform an object that the client is still alive, periodic pinging is used. Hence, when the
client has died and no ping has been received (to refresh it) before the expiration time, the server
object will perform some clean up tasks (including decrementing its reference count).
Since RPC across a network are typically slow (compared to processes residing on the same
machine), DCOM sends multiple requests in the same call. For example, in COM, the program
performs a QueryInterface, one interface at a time. In DCOM, multiple QueryInterfaces are all
clustered into one call.
This clustering optimization trick is also used when creating an instance of the object and serializing
it with data. Since these two operations usually occur together, DCOM allows one method which
will perform both operations in one call without waiting for an acknowledgment from the first
task before performing the second one.
Similarly, when a client pings its server object, he can do it in one call. Moreover, if there are
multiple clients sending pings to multiple servers, an optimization is made where the multiple
pings going to the same object are consolidated into just one ping. This is to cut down on the use
of precious bandwidth used only for pinging.
The client has the control to set the computer which will be responsible for the lifetime of the
object. That is to say, these objects are not created just somewhere where the system resources and
access privileges allow for it.
Call security is implemented in all four ways: authentication (to prevent false clients from
impersonating the true client), authorization (to insure that a client only does what it is authorized to do), data integrity (to insure that data was not tampered with during transit) and data privacy (to insure that only designated sources can read it). The security issues are handled as they are on operating systems. The client gives the server various access privileges to access memory or disk space
How do we create DCOM object in VB6?
Using the CreateObject method you can create a DCOM object. You have to put the server
name in the registry.
How to implement DTC in .NET ?
Following are the steps to implement COM + in .NET :-
√ “EnterpriseService” namespace has all the classes by which we can implement DTC
in .NET. You have to add reference “EnterpriseService” namespace.
√ You class must derive from “Serviced Component” object.
√ Then you have to define your class with the transaction attribute
(For all transaction attribute look the down question)
[ Transaction(TransactionOption.RequiresNew) ]
√ After the class level transaction type is defined. Its time to define at the method level
the AutoComplete attribute. Autocomplete attribute says that if no exception is thrown
then mark its part of the transaction as being okay. This helps cut down on the
amount of code required. If the implementation sets AutoComplete to false, or
omits it all together, then we would need to manage the transaction manually. To
manually control the transaction you will need to use the ContextUtil class and its static
members. Following is small snippet of ContextUtil: -
public void SampleFunction()
{
try
{
// Do something to a database
// ...
// Everything okay so far Commit the transaction
ContextUtil.SetComplete();
}
catch(Exception)
{
// Something went wrong Abort and Rollback the Transaction.
ContextUtil.SetAbort();
}
}
run under COM+.
√ Once the classes are compiled using the string name.Register the Component in COM+
services using
regsvcs c:\DllPath\TransactionComponent.dll
√ You can see that the component is registered using the COM+ explorer.
How many types of Transactions are there in COM + .NET ?
There are 5 transactions types that can be used with COM+. Whenever an object is registered with COM+ it has to abide either to these 5 transaction types.
Disabled: - There is no transaction. COM+ does not provide transaction support for this
component.
Not Supported: - Component does not support transactions. Hence even if the calling component in the hierarchy is transaction enabled this component will not participate in the transaction.
Supported: - Components with transaction type support will be a part of the transaction. This will be only if the calling component has an active transaction. If the calling component is not transaction enabled this component will not start a new transaction.
Required: - Components with this attribute require a transaction i.e. either the calling should have a transaction in place else this component will start a new transaction.
Required New: - Components enabled with this transaction type always require a new transaction. Components with required new transaction type instantiate a new transaction for themselves every time.
How do you do object pooling in .NET ?
COM+ reduces overhead by creating object from scratch. So in COM+ when object is activated
its activated from pool and when its deactivated it’s pushed back to the pool. Object pooling is
configures by using the “ObjectPoolingAttribute” to the class.
Note:- When a class is marked with objectpooling attribute it can not be inherited.
ObjectPooling(MinPoolSize := 2, MaxPoolSize := 5, CreationTimeout := 20000)> _
Public Class testingclass
Inherits ServicedComponent
Public Sub DoWork()
' Method contents go here.
End Sub
End Class
Above is a sample code which has the “ObjectPooling” attribute defined. Below is a sample code
which uses the class.
Public Class App
Overloads Public Shared Sub Main(args() As String)
Dim xyz As New TestObjectPooling()
xyz.doWork()
ServicedComponent.DisposeObject (xyz)
End Sub
End Class
Above is a sample code which uses the object pooled object. Note the DisposeObject() This
ensures its safe return to the object pool.
What are types of compatibility in VB6?
√ No Compatibility
√ Project Compatibility
√ Binary Compatibility
No Compatibility
With this setting, new class ID’s, new interface ID’s and a new type library ID will be generated by
VB each time the ActiveX component project is compiled. This will cause any compiled client
components to fail (with error 429!) and report a missing reference to the 'VB ActiveX Test
Component' when a client project is loaded in the VB IDE.
Note :- Use this setting to compile the initial release of a component to other developers.
Project Compatibility
With this setting, VB will generate new interface ID’s for classes whose interfaces have changed,
but will not change the class ID’s or the type library ID. This will still cause any compiled client
components to fail (with error 429!) but will not report a missing reference to the 'VB ActiveX
Test Component' when a client project is loaded in the VB IDE. Recompilation of client
components will restore them to working order again.
Note:- Use this setting during the initial development and testing of a component within
the IDE and before the component is released to other developers.
Binary Compatibility
VB makes it possible to extend an existing class or interface by adding new methods and properties
etc. and yet still retain binary compatibility. It can do this, because it silently creates a new interface
ID for the extended interface and adds registration code to register the original interface ID but
with a new Forward key containing the value of this new interface ID. COM will then substitute
calls having the old ID with the new ID and hence applications built against the old interface will
continue to work (assuming the inner workings of the component remain backward compatible!).
With this setting, VB will not change any of the existing class, interface or type library ID’s, however
in order that it can do so, VB requires the project to specify an existing compiled version that it can
compare against to ensure that existing interfaces have not been broken
What is equivalent for regsvr32 exe in .NET ?
Regasm
