Techno Scatter

Network Class Librar in 4.0

2009-07-21T10:04:00.002+05:30

Came across this interesting post on the changes in the NCL.
http://blogs.msdn.com/ncl/archive/2009/07/20/new-ncl-features-in-net-4-0-beta-2.aspx

DLL HELL

2009-07-17T11:35:00.003+05:30

Faced DLL hell issues after a real long time.
In the dev env, we compiled the VB6 dll and tested it and it worked fine.
But the minute we put it in test, it started off giving the CLSID errors.
We then registered, unregistered quite a few times. Turned out that there were multiple registrations of the same DLL. So we uninstalled all the versions, took the latest from VSS, compiled the DLL again, regsitered it and it finally worked.
Took around 2 whole days for it!!

My First Look at Moblin

2009-07-13T15:42:00.000+05:30

Not a valid assembly (Add Reference failure)

2009-06-30T16:28:00.001+05:30

When trying to add a reference to a VB DLL, you may receive the following error popup: A reference to

'assemblyname.exe' could not be added. This is not a valid assembly or COM

component. Please make sure that the file is accessible, and that it is a

valid assembly or COM component.

WorkAround:-
There were some on the net, but I registered the DLL using regsvr and added it from the COM components tab and it worked fine.

Session on Continuous Integration

2008-12-05T19:04:00.001+05:30

I'm planning on giving a session on Continuous Integration using CruiseControl and nAnt. Started prearing my notes for it. Hope it goes on well.
I will upload my PPT and notes if any once I'm done with it.

Session on Continuous Integration

2008-12-05T19:04:00.000+05:30

Search for Objects in DB

2008-12-02T11:40:00.000+05:30

Came across this article. I'll dig into it later.

SQL Server Central

Performance Tuning in ASP.NET

2008-11-26T15:37:00.001+05:30

I have a situation here.
We have a search criteria which returns about 70K + records. We have paging and the option to export to Excel. The earlier design was using caching which I promptly got it removed. Caching is not on a per user basis. So if there are two users trying to get the same report with different search criteria, one of them is surely in for a rude shock!
I ran the perf mon and saw that the large object heap size was going in GB's. The Gen 2 heap size was also huge.

So after reading this post from Tess i came to this conclusion.
Solutions:-
Option I- Session
The primary concern is disposing the objects after usage. If we run the perfmon, we see that the data gets moved to the Gen2. This is not good. The large object heap size also goes in GB's.

Option II - Cache
This seems to be the better solution under the circumstances. The advantages of using caching is that we can set the expiry to say 20 minutes. IN order to use the cache for each user, we can use the cache key as "Session.SessionID". This will be unique for each user.
This also moves the the object to Gen2 but from what I have seen, ASP.NET takes care of disposing the cached objects as and when it faces memory issues OR "memory pressures".
Additionally in the Session End event in Global.asax, we can remove the cache item.

Option II still has some issues to be resolved.

Meeting Jeff

2008-11-24T17:56:00.002+05:30

I went to the Wintellect site the other day and got on Jeff's blog.
To my pleasant surprise, I saw that Jeff would actually be here in hyderabad. I immediately put in a note requesting him to meet me for a while. He replied back and said he would let me know. I was thrilled beyond words. When I came to know that I would be meeting him on Friday, I was so excited that everyone at my place knew that I was meeting him.
I waited outside the MS gate and there he was. With a very pleasant smile and a sore that :) we spoke for some time on a lot of topics. I was a little disappointed that I couldnt get to spend the whole afternoon (talk about wishful thinking eh :)) but it was awesome getting insights from the man himself!
We also did have a quick photo session! I did learn one thing though.. humility was at its best that day. I am now a bigger fan of the Wintellect team and I do hope to see them more often!

Workflow Versioning

2008-05-22T17:28:00.000+05:30

One of my assignments required me to build a state machine workflow. I started going through the Workflow foundation and built the workflow definition. I must say that working with WF was amazing. I think its one of the best things that MS has done! Yes it still needs some work but hey ... who says life is perfect!
Anyways I used the external data service to pass parameters to the WF from the host. we now had this requirement to change the WF definition. I was under the impression that his will not lead to any issues. I thought that as long as I was not adding a new state, the existing data which was created using the old WF definition should work fine. Turns out.. it does not!
Which is fine, considering the security point of view, data built using one version of the dll should not work with another version. But what is the solution.
The solution it seemed was to go for versioning. There are quite a few posts which talks about that so i'll not get into the details here. So we tried to getthe versioning to work but unfortunately we hit a dead end there. We then came to know through reliable sources(I'm not at a liberty to mention who) that for versioning to work with External data services, we may need to use a concept called correlations. Remember that serialization has to be enables for this. Now I looked around for some samples and found that it looked like a pretty simple task (though understanding it is not!) and i tried the same with my workflow. Surprise surprise... it didnt work at all. I did see some posts about how getting correlation to work with a state machine workflow is not an easy if not impossible task. I have still not been able to solve it (pressed for time) and we had a workaround. We built a small appllication which would take all the workflow data which was built using the version 1 of the workflow, use the new version of the workflow and recreate them. In the process, we had to sensure that all the workflows were in the same state as before. Our workaround was aided since our application database was also holding the WFGUID's. WE have done some testing and it seems to be working fine.
In the meanwhile I'll need to get back to the original problem and see if I can actually get this to work with a state machine workflow.

My reliable source also mentioned that the instance state table stores the version of the dll in the binary data. Hence if you ever get this error "System.IndexOutOfRangeException: Index was outside the bounds of the array. ", this is a versioning problem and then when you try to fix it using correlation or whatever is the right solution, you may get this error
"System.Workflow.Activities.EventDeliveryFailedException: Event "CRApproval" on interface type ", and if you do get this error ....
"Run to the Hills....
Run for your lives .... "

A tribute to one of the greatest bands ever :)

Who is an Architect

2008-03-28T10:58:00.000+05:30

I have been playing the role of a Technical Lead for over 2+ years now.
A couple of weeks back, I had an interview for an architect's role.
It was a very interesting interview and it showed that I still have some way to go before I'm ready to be an architect.
From the Arch Journals that I was reading, Arvindra SehmiArchitect, Developer and Platform Evangelism Group, Microsoft EMEA says that a typical architect will have the following responsibilities
" Support business visioning and scoping activities.
Translate between business and IT requirements.
Communicate with stakeholders, both within business and IT.
Weigh different interests.
Determine solution alternatives.
Create a viable and feasible design.
Choose solutions.
Manage quality.
Manage complexity.
Mitigate risks.
Communicate.

This requires a diverse range of skills, including knowledge of architecture
design, workgroup and communications skills, and consultancy skills. "

Ram, another Architect from MS, has these interesting things to say about an Architect.
http://blogs.msdn.com/ramkoth/archive/tags/Architecture/default.aspx

SaaS, SOA , Software + Services

2008-03-27T13:49:00.002+05:30

The above terms are something that you will hear on a regular basis these days. I am going to go on a hunt. A hunt to find out what are these terms, what do they mean, and what impact do they have on the industry in the coming years. This is going to involve some amount of research so I will be updating this on a regular basis.
Till then ... time for a treasure hunt!

Update on 27 Mar 08
Found this image on the architecture journal article
http://msdn2.microsoft.com/en-us/arcjournal/bb906061.aspx

It gives a nice picture.

So far what I have think is
Software + Services is a Microsoft initiative. Talks about Software + cloud serices. I need to find out what is this cloud services.
SaaS is basically some applications that are ready to be used and are consumed over the internet. Now how is this different from WS..?
finding out...

Authentication in Web Services

2008-03-06T12:53:00.001+05:30

Ismail and me were sitting and having a coffee the other day and Ismail asked me about security in Web Services. Though it was quite a while since I had worked on it, I remembered that we need to send some tokens. I quickly did a search and came across this article that kind of covers it well.
http://www.codeproject.com/KB/webservices/WS-Security.aspx

Structural Patterns

2007-07-26T11:45:00.001+05:30

Reference: http://home.earthlink.net/~huston2/dp/structural_rules.html

Got some usefull info here ..

Rules of thumb

1. Adapter makes things work after they're designed; Bridge makes them work before they are. [GOF, p219]

2. Bridge is designed up-front to let the abstraction and the implementation vary independently. Adapter is retrofitted to make unrelated classes work together. [GOF, p161]

3. Adapter provides a different interface to its subject. Proxy provides the same interface. Decorator provides an enhanced interface. [GOF, p216]

4. Adapter changes an object's interface, Decorator enhances an object's responsibilities. Decorator is thus more transparent to the client. As a consequence, Decorator supports recursive composition, which isn't possible with pure Adapters. [GOF, p149]

5. Composite and Decorator have similar structure diagrams, reflecting the fact that both rely on recursive composition to organize an open-ended number of objects. [GOF, p219]

6. Composite can be traversed with Iterator. Visitor can apply an operation over a Composite. Composite could use Chain of Responsibility to let components access global properties through their parent. It could also use Decorator to override these properties on parts of the composition. It could use Observer to tie one object structure to another and State to let a component change its behavior as its state changes. [GOF, pp173,349]

7. Composite can let you compose a Mediator out of smaller pieces through recursive composition. [Vlissides, Apr96, p18]

8. Decorator lets you change the skin of an object. Strategy lets you change the guts. [GOF, p184]

9. Decorator is designed to let you add responsibilities to objects without subclassing. Composite's focus is not on embellishment but on representation. These intents are distinct but complementary. Consequently, Composite and Decorator are often used in concert. [GOF, p220]

10. Decorator and Proxy have different purposes but similar structures. Both describe how to provide a level of indirection to another object, and the implementations keep a reference to the object to which they forward requests. [GOF, p220]

11. Facade defines a new interface, whereas Adapter reuses an old interface. Remember that Adapter makes two existing interfaces work together as opposed to defining an entirely new one. [GOF, p219]

12. Facade objects are often Singletons because only one Facade object is required. [GOF, p193]

13. Mediator is similar to Facade in that it abstracts functionality of existing classes. Mediator abstracts/centralizes arbitrary communication between colleague objects, it routinely "adds value", and it is known/referenced by the colleague objects. In contrast, Facade defines a simpler interface to a subsystem, it doesn't add new functionality, and it is not known by the subsystem classes. [GOF, p193]

14. Abstract Factory can be used as an alternative to Facade to hide platform-specific classes. [GOF, p193]

15. Whereas Flyweight shows how to make lots of little objects, Facade shows how to make a single object represent an entire subsystem. [GOF, p138]

16. Flyweight is often combined with Composite to implement shared leaf nodes. [GOF, p206]

17. Flyweight explains when and how State objects can be shared. [GOF, p313]

- Soni

I'm back!!

2007-06-12T21:35:00.000+05:30

After weeks or rather months of not knowing where my blog disappeared, I finally managed to track it down.
To give a quick brief update, I'm currently working on a POC using Workflow foundation. So you can expect some posts here w.r.t that.
Oterwise watched some good movies, read some good fiction ...
and listening to some good music .. been hectic .. need a break i guess ..

ASP.NET 2.0

2006-02-15T20:39:00.000+05:30

I happened to attend a good session on ASP.NET 2.0 today at the Taj.
Started off with Janikaram giving a good peep into some of the fancy new controls in ASP.NET 2.0. He didnt have time to cover Deployement though. Some of the controls that he covered were the Login Control, the Create User Control etc.
Nikhil then started off on extensibility. I should say that the session was a tough one to catch up with since some of the concepts that were being covered were a lil deep and the demo couldnt have been coded on the fly. Hence I got a lil lost there.

MSCOREE.DLL

2005-07-15T11:45:00.000+05:30

From Nikhilesh ..

Microsoft Component Object Runtime Execution Engine

This DLL holds the definition of _CORDLLMAIN and _COREXEMAIN methods. These methods will always be placed in a managed assembly.
These methods are used to load the managed environment if the assembly is called from unmanaged environment.

Schedule

2005-06-22T18:18:00.000+05:30

So this is what I need to do eh ..?

Lets see how far I go with this one .. :)

Still havent got the schedule up adn running but atleast

after listing these down I feel a lot better. Now I know I am doomed :)

UML
	Diagrams
	Views
Patterns
	Categorisation of Patterns
SDLC/Processes
	Processes
	Phases
Project Management
	Estimation
	Requirement Elicitation
	Requirement Management
	Planning and Scheduling
	Risk management
	Config Management
	etc
OOPS

OOAD
	Object Modelling
	OOAD with UML
COM/COM+
	MTS
	Deployment and management
	Diff between MTS and COM+
DCOM
	Creation
	Deployment and management
VB/ASP
	Migration techniques to .NET
	Interop
	VB - MultiThreading
.NET Framework/Internals
	CLR
	Assemblies
	etc.
C#
	Diff between C# and VB.NET
	Multithreading
Web Services
	Security
	Transaction
	SOA
	Comparison between Remoring and Webservices
Remoting
	Comparison between CORBA, RMI and COM/DCOM with Remoting
	Transaction
Serviced Components
SQL Server
	Usage of XML in SQL
	Security in SQL
	Performance Tuning
	Data Modeling
Whidbey/Indigo
Biztalk

Speech SDK

SPPS

XML
	XPATH
	XSLT
	DTD vs Schema
	XSL
ASP.NET
	State maintenance between ASP and ASP.NET
	Perf. Max. - all techniques

Soni

Interface or Class?

2005-06-22T16:25:00.000+05:30

Some more info that i got on the net...

Interfaces, like classes, define a set of properties, methods, and events. But unlike classes, interfaces do not provide implementation. They are implemented by classes, and defined as separate entities from classes. Even though class inheritance allows your classes to inherit implementation from a base class, it also forces you to make most of your design decisions when the class is first published.

Abstract classes are useful when creating components because they allow you specify an invariant level of functionality in some methods, but leave the implementation of other methods until a specific implementation of that class is needed. They also version well, because if additional functionality is needed in derived classes, it can be added to the base class without breaking code.

Interfaces vs. Abstract Classes
Feature	Interface	Abstract class
Multiple inheritance	A class may implement several interfaces.	A class may extend only one abstract class.
Default implementation	An interface cannot provide any code at all, much less default code.	An abstract class can provide complete code, default code, and/or just stubs that have to be overridden.
Constants	Static final constants only, can use them without qualification in classes that implement the interface. On the other paw, these unqualified names pollute the namespace. You can use them and it is not obvious where they are coming from since the qualification is optional.	Both instance and static constants are possible. Both static and instance intialiser code are also possible to compute the constants.
Third party convenience	An interface implementation may be added to any existing third party class.	A third party class must be rewritten to extend only from the abstract class.
is-a vs -able or can-do	Interfaces are often used to describe the peripheral abilities of a class, not its central identity, e.g. an Automobile class might implement the Recyclable interface, which could apply to many otherwise totally unrelated objects.	An abstract class defines the core identity of its descendants. If you defined a Dog abstract class then Damamation descendants are Dogs, they are not merely dogable. Implemented interfaces enumerate the general things a class can do, not the things a class is.
Plug-in	You can write a new replacement module for an interface that contains not one stick of code in common with the existing implementations. When you implement the interface, you start from scratch without any default implementation. You have to obtain your tools from other classes; nothing comes with the interface other than a few constants. This gives you freedom to implement a radically different internal design.	You must use the abstract class as-is for the code base, with all its attendant baggage, good or bad. The abstract class author has imposed structure on you. Depending on the cleverness of the author of the abstract class, this may be good or bad. Another issue that's important is what I call "heterogeneous vs. homogeneous." If implementors/subclasses are homogeneous, tend towards an abstract base class. If they are heterogeneous, use an interface. (Now all I have to do is come up with a good definition of hetero/homogeneous in this context.) If the various objects are all of-a-kind, and share a common state and behavior, then tend towards a common base class. If all they share is a set of method signatures, then tend towards an interface.
Homogeneity	If all the various implementations share is the method signatures, then an interface works best.	If the various implementations are all of a kind and share a common status and behavior, usually an abstract class works best.
Maintenance	If your client code talks only in terms of an interface, you can easily change the concrete implementation behind it, using a factory method.	Just like an interface, if your client code talks only in terms of an abstract class, you can easily change the concrete implementation behind it, using a factory method.
Speed	Slow, requires extra indirection to find the corresponding method in the actual class. Modern JVMs are discovering ways to reduce this speed penalty.	Fast
Terseness	The constant declarations in an interface are all presumed public static final, so you may leave that part out. You can't call any methods to compute the initial values of your constants. You need not declare individual methods of an interface abstract. They are all presumed so.	You can put shared code into an abstract class, where you cannot into an interface. If interfaces want to share code, you will have to write other bubblegum to arrange that. You may use methods to compute the initial values of your constants and variables, both instance and static. You must declare all the individual methods of an abstract class abstract.
Adding functionality	If you add a new method to an interface, you must track down all implementations of that interface in the universe and provide them with a concrete implementation of that method.	If you add a new method to an abstract class, you have the option of providing a default implementation of it. Then all existing code will continue to work without change.

Here are some recommendations to help you to decide whether to use an interface or an abstract class to provide polymorphism for your components.

If you anticipate creating multiple versions of your component, create an abstract class. Abstract classes provide a simple and easy way to version your components. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface.
If the functionality you are creating will be useful across a wide range of disparate objects, use an interface. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes.
If you are designing small, concise bits of functionality, use interfaces. If you are designing large functional units, use an abstract class.
If you want to provide common, implemented functionality among all implementations of your component, use an abstract class. Abstract classes allow you to partially implement your class, whereas interfaces contain no implementation for any members.

Soni

"Programs must be written for people to read, and only incidentally for machines to execute"

Abelson & Sussman, SICP, preface to the first edition

Structures in Detail

2005-06-22T16:16:00.000+05:30

A struct type is a value type that can contain constructors, constants, fields, methods, properties, indexers, operators, events, and nested types.

The struct type is suitable for representing lightweight objects such as Point, Rectangle, and Color. Although it is possible to represent a point as a class, a struct is more efficient in some scenarios. For example, if you declare an array of 1000 Point objects, you will allocate additional memory for referencing each object. In this case, the struct is less expensive.
It is an error to declare a default (parameterless) constructor for a struct. A default constructor is always provided to initialize the struct members to their default values.

It is an error to initialize an instance field in a struct.
When you create a struct object using the new operator, it gets created and the appropriate constructor is called. Unlike classes, structs can be instantiated without using the new operator. If you do not use new, the fields will remain unassigned and the object cannot be used until all of the fields are initialized.

There is no inheritance for structs as there is for classes. A struct cannot inherit from another struct or class, and it cannot be the base of a class. Structs, however, inherit from the base class Object. A struct can implement interfaces, and it does that exactly as classes do.
Unlike C++, you cannot declare a class using the keyword struct. In C#, classes and structs are semantically different. A struct is a value type, while a class is a reference type. For more information on the features of value types, see Value Types.

Unless you need reference type semantics, a class that is smaller than 16 bytes may be more efficiently handled by the system as a struct.

More info here http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vcwlkstructstutorial.asp

What is the difference between a Struct and a Class?
· The struct type is suitable for representing lightweight objects such as Point, Rectangle, and Color. Although it is possible to represent a point as a class, a struct is more efficient in some scenarios. For example, if you declare an array of 1000 Point objects, you will allocate additional memory for referencing each object. In this case, the struct is less expensive.
· When you create a struct object using the new operator, it gets created and the appropriate constructor is called. Unlike classes, structs can be instantiated without using the new operator. If you do not use new, the fields will remain unassigned and the object cannot be used until all of the fields are initialized.
· It is an error to declare a default (parameterless) constructor for a struct. A default constructor is always provided to initialize the struct members to their default values.
· It is an error to initialize an instance field in a struct.
· There is no inheritance for structs as there is for classes. A struct cannot inherit from another struct or class, and it cannot be the base of a class. Structs, however, inherit from the base class Object. A struct can implement interfaces, and it does that exactly as classes do.
· A struct is a value type, while a class is a reference type.

Also,
There is no inheritance for structs as there is for classes. A struct cannot inherit from another struct or class, and it cannot be the base of a class. Structs, however, inherit from the base class Object. A struct can implement interfaces, and it does that exactly as classes do.

Some stuff from Nasar

2005-06-22T13:46:00.000+05:30

The Five Components of Function Points

Data Functions

Internal Logical Files
External Interface Files
Transactional Functions

External Inputs
External Outputs
External Inquiries

Worst Practices - To Avoid!
Make it unclear who is responsible for tasks; don't trust anyone with clear ownership, but ask several people to get the job done.

Keep yourself very busy, so team members will see how valuable you are, even if you have no time to supervise their assignments, solve problems, or monitor work methods.

Assign new team members to tasks without adequate task definitions, guidance or training; use the sink or swim method for work assignments.

Let poor performers continue without comment, and ignore gossip and dissension among project team members.

Reward your excellent performers by giving them an impossible workload; let them be the heroes to carry the project on their backs.

I'm not trying to be negative or sarcastic here, but it is sometimes helpful to describe negative behaviors we want to avoid to help us recognize them and not fall into the traps.

Webservices - How to expose a Type from a webmethod which is not a .NET generic type

Whats the base namespace when you define a .NET class

What is an Architecture?

Can you parse XML data in SQL server. If so how?

Soni

How to Share Session State

2005-06-20T13:43:00.000+05:30

Interesting article in MSDN ...

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnaspp/html/converttoaspnet.asp

http://searchvb.techtarget.com/vsnetTip/1,293823,sid8_gci951935_tax293033,00.html

Maintaining Transactions in Web Services

2005-06-20T13:22:00.001+05:30

The TransactionOption Property
If you've ever programmed MTS or COM+ components, you're probably comfortable with the idea of developing transaction-based services. A transaction can be thought of as any set of procedures (e.g., events, function calls) that collectively result in a change of state such as a success or failure. One example is a credit card processing system that authenticates a credit card number, charges the card, and triggers a fulfillment process. If any of these three steps fails (e.g., the card is declined), the transaction as a whole will fail, and each of the individual processes must be returned to its original state (e.g., cancel a fulfillment process if it has been started). All three steps are part of a transaction.

Microsoft includes support in the .NET platform for MTS or COM+ style transactions through the System.EnterpriseServices namespace. We're not going to get into the details of developing transacted services in this book; however, it is important to understand the difference between .NET-style transactions and what we'll call distributed web service transactions.

.NET transaction support is set through the TransactionOption property of the WebMethod attribute. The five possible settings for this property are:

Disabled

NotSupported

Supported

Required

RequiresNew

By default, transactions are disabled. If you decide to use .NET transactions, your web method will be able to participate only as the root object in a transaction. This means that your web method may call other transaction-enabled objects, but may not itself be called as part of a transaction started by another object. This limitation is due to the stateless nature of the HTTP protocol. As a result, the Required and RequiresNew values for TransactionOption are equivalent (and both declare a RequiresNew method that will start a new transaction). Disabled, NotSupported, and Supported all disable transactions for the web method, despite what their names imply.

Soni

"Programs must be written for people to read, and only incidentally for machines to execute"

Abelson & Sussman, SICP, preface to the first edition

Access Modifiers

2005-06-17T17:58:00.000+05:30

http://weblogs.asp.net/cnagel/archive/2004/12/27/332733.aspx

The December version of Visual Studio 2005 / C++ now has an internal access modifier instead of using public private. This is different from my previous post. The access modifiers public protected and protected private are still the same as before:

C++	C#	VB	IL
public	public	Public	public
protected	protected	Protected	family
private	private	Private	private
internal	internal	Friend	assembly
public protected	internal protected	Protected Friend	famorassem
protected private	not possible	not possible	famandassem

public public is no longer supported, too. public is good enough ;-)

http://builder.com.com/5100-6373-1027680.html

Q: I'm confused about what some of the .NET access modifiers mean and when I should use them. Can you help me sort them out?

A: Well, I'll certainly try. The allowed access modifiers in .NET are public, private, protected, internal, and protected internal. These keywords control the visibility of class members (and other things), defining the circumstances under which a member may be accessed—hence their collective name as access modifiers. With the exception of the last, protected internal, it's illegal to combine two access modifiers. Let's look at what each of these mean in turn when used in a .NET class.

Access modifiers illustrated
Public means just that: public and visible to everyone and everything. A public member can be accessed using an instance of a class, by a class's internal code, and by any descendants of a class. This is illustrated in Figure A.

Figure A

A public class member

Private is also intuitively understood, meaning hidden and usable only by the class itself. No code using a class instance can successfully access a private member and neither can a descendant class, as illustrated in Figure B. Information or functionality that will not be needed or has no meaning outside of the context of a specific class should be made private.

Figure B

A private class member

Protected members are similar to private ones in that they are accessible only by the containing class. However, protected members also may be used by a descendant class. So members that are likely to be needed by a descendant class should be marked protected, as Figure C shows.

Figure C

A protected class member

Members marked as internal are public to the entire application but private to any outside applications. Internal is useful when you want to allow a class to be used by other applications but reserve special functionality for the application that contains the class. Figure D illustrates internal in action.

Figure D

An internal class member

Finally, we have the only compound access modifier allowed in .NET, protected internal, which is shown in Figure E. Members marked as protected internal may be accessed only by a descendant class that's contained in the same application as its base class. You use protected internal in situations where you want to deny access to parts of a class' functionality to any descendant classes found in other applications.

Figure E

A protected internal class member

Not limited to controlling class access
As I mentioned before, access modifiers aren't limited to use on class members but can be applied to a few other code constructs. The rules defining when modifiers may be legally assigned to a construct are dependant on the construct's container:

Interface and enumeration members are always public and no access modifiers are needed (or allowed).
Classes in namespaces are internal by default and may be either internal or public, while namespaces themselves are always public.
Members of a struct are private by default and may be given public, internal, or private access modifiers.

In all cases, however, the modifier's meaning remains the same.

Soni

"Programs must be written for people to read, and only incidentally for machines to execute"

Abelson & Sussman, SICP, preface to the first edition

"How can I avoid turning into a pointy-haired boss?"

2005-06-16T18:29:00.000+05:30

Read this somewhere .. guess we all need to decide at one point of time or the other.

"The pointy-haired boss is a manager who doesn't program. So the surest way to avoid becoming him is to stay a programmer. What tempts programmers to become managers are companies with old-fashioned corporate structure, where the only way to advance in salary and prestige is to go into management. So if you want to avoid becoming a PHB, avoid such companies, and work for (or start) startups.

I never had to manage anyone in our startup, even though I was the president. The other hackers were my peers, and would have given me the raspberry if I'd tried to "manage" them. We operated by consensus. And the rest of the company reported to our experienced COO, who was also more of a peer.

Why be a manager when you could be a founder or early employee at a startup?"

Inputs from Nikhilesh

2005-06-16T18:17:00.000+05:30

To support the CLR, Microsoft has extended the PE/COFF file format to include metadata and IL code. The CLR uses metadata to determine how to load classes and uses the IL code to turn it into native code for execution. The extensions that Microsoft has added to the normal PE format include the CLR header and CLR data. The CLR header mainly stores relative virtual addresses (RVA) to locations that hold pertinent information to help the CLR manage program execution. The CLR data portion contains metadata and IL code, both of which determine how the program will be executed. Compilers that target the CLR must emit both the CLR header and data information into the generated PE file, otherwise the resulting PE file will not run under the CLR.

Looking at this text dump of a .NET PE file, you can see that a PE file starts off with the MS-DOS/COFF header, which all Windows programs must include. Following this header, you will find the PE header that supports Windows 32-bit programs. Immediately after the PE headers, you can find the code section for this program. The raw data (RAW DATA #1) of this section stores the CLR header, as follows:
RAW DATA #1 . . . clr Header: /* CLR HEADER */ 48 cb 2.00 runtime version 207C [ 214] RVA [size] of MetaData Directory 1 flags 6000001 entry point token 0 [ 0] RVA [size] of Resources Directory 0 [ 0] RVA [size] of StrongNameSignature Directory 0 [ 0] RVA [size] of CodeManagerTable Directory 0 [ 0] RVA [size] of VTableFixups Directory 0 [ 0] RVA [size] of ExportAddressTableJumps Directory
Section contains the following imports: mscoree.dll . . . 0 _CorExeMain . . .As mentioned earlier, the CLR header holds a number of pertinent details required by the runtime, including:
Runtime version Indicates the runtime version that is required to run this program
MetaData directory Is important because it indicates the location of the metadata needed by the CLR at runtime
Entry point token Is even more important because, for a single file assembly, this is the token that signifies the entry point, such as Main( ), that the CLR executes
Below the CLR Header, note that there is an imported function called _CorExeMain, which is implemented by mscoree.dll, the core execution engine of the CLR.[2] At the time of this writing, Windows 98, 2000, and Me have an OS loader that knows how to load standard PE files. To prevent massive changes to these operating systems and still allow .NET applications to run on them, Microsoft has updated the OS loaders for all these platforms. The updated loaders know how to check for the CLR header, and, if this header exists, it executes _CorExeMain, thus not only jumpstarting the CLR but also surrendering to it. You can then guess that the CLR will call Main( ), since it can find the entry point token within the CLR header.[3]

The common language runtime can either run garbage collection concurrently on a separate thread or on the same thread as the application. Use the element to specify how the runtime should run garbage collection. For example:
By default, the runtime runs garbage collection concurrently, which reduces performance. If your application is single-threaded and involves heavy user interaction, leave concurrent garbage collection enabled so the application does not pause to perform garbage collection. If your application is an ASP.NET server application, you do not need to alter the default value of the element.

A delegate is a data structure that refers to a static method or to an object instance and an instance method ofthat object.

A component container is a specialized class that acts as a means of organizing and containing components. Through a container you can track your components, communicate with them via the Site that hosts the component, and provide a means of common disposal after they are no longer needed.

What are ASHX Files

2005-06-15T13:16:00.000+05:30

ASHX files contain HTTP handlers.
HTTP Handlers are nothing but software modules that handle raw HTTP requests received by ASP.NET
With .ASHX files one can easily deploy HTTP Handlers without modifying IIS metabase.

Soni

"Programs must be written for people to read, and only incidentally for machines to execute"

Abelson & Sussman, SICP, preface to the first edition

What is the maximum amount of memory any single process on Windows can address

2005-06-15T12:41:00.000+05:30

Any process running under Windows gets a Virtual Address Space of 4 GB, no matter how much RAM is actually installed on the computer.
Actually, this is essentially the same for all operating systems running on 32 bit hardware that implement Virtual memory.
The only way to increase the size of the virtual address space beyond 4 GB is by using 64 bit hardware with an operating system and application built for that hardware.
In the normal, default Windows OS configuration, 2 GB of this address space are allocated to the process's private use and the other 2 GB are allocated to shared and operating system use.
The nub of it is, that no matter how much physical RAM is in the computer,the amount of memory available in the application's private part of thevirtual address space in 32 bit Windows implementations is limited to:
1. 2 GB - without the /3GB switch - this is the normal, default maximumprivate virtual address space or
2. 3GB with the /3GB switch AND a special application modification (more details below) or 3. any physical RAM not used by the OS and other applications by modifyingthe application to use the AWE (Address Windowing Extensions) API

More on address & memory allocation:
There seems to be a lot of confusion in the industry about what's commonly called the Windows “4GB memory limit.” When talking about performance tuning and server sizing, people are quick to mention the fact that an application on a 32-bit Windows system can only access 4GB of memory. But what exactly does this mean?
By definition, a 32-bit processor uses 32 bits to refer to the location of each byte of memory. 2^32 = 4.2 billion, which means a memory address that's 32 bits long can only refer to 4.2 billion unique locations (i.e. 4 GB).
In the 32-bit Windows world, each application has its own “virtual” 4GB memory space. (This means that each application functions as if it has a flat 4GB of memory, and the system's memory manager keeps track of memory mapping, which applications are using which memory, page file management, and so on.)
This 4GB space is evenly divided into two parts, with 2GB dedicated for kernel usage, and 2GB left for application usage. Each application gets its own 2GB, but all applications have to share the same 2GB kernel space.
This can cause problems in Terminal Server environments. On Terminal Servers with a lot of users running a lot of applications, quite a bit of information from all the users has to be crammed into the shared 2GB of kernel memory. In fact, this is why no Windows 2000-based Terminal Server can support more than about 200 users—the 2GB of kernel memory gets full—even if the server has 16GB of memory and eight 3GHz processors. This is simply an architectural limitation of 32-bit Windows.
Windows 2003 is a little bit better in that it allows you to more finely tune how the 2GB kernel memory space is used. However, you still can't escape the fact that the thousands of processes from hundreds of users will all have to share the common 2GB kernel space.
Using the /3GB (for Windows 2000) or the /4GT (for Windows 2003) boot.ini switches is even worse in Terminal Server environments because those switches change the partition between the application memory space and kernel memory space. These switches gives each application 3GB of memory, which in turn only leaves 1GB for the kernel—a disaster in Terminal Server environments!
People who are unfamiliar with the real meaning behind the 4GB Windows memory limit often point out that certain versions of Windows (such as Enterprise or Datacenter editions) can actually support more than 4GB of physical memory. However, adding more than 4GB of physical memory to a server still doesn't change the fact that it's a 32-bit processor accessing a 32-bit memory space. Even when more than 4GB of memory is present, each process still has the normal 2GB virtual address space, and the kernel address space is still 2GB, just as on a normal non-PAE system.
However, systems booted /PAE can support up to 64GB physical memory. A 32-bit process can "use" large amounts of memory via AWE (address windowing extension) functions. This means that they must map views of the physical memory they allocate into their 2GB virtual address space. Essentially, they can only use 2GB of memory at a time.