Converting a Memory Stream to String:

memstream.Flush();
      memstream.Position = 0;
      StreamReader sreader = new StreamReader(memstream);
string str = sreader .ReadToEnd();

I was of the opinion that the messages that are received and sent from the WCF services validate the messages against the schemas since we see the message directly in the implementation classes.

But I was so wrong, the only validation that occurs in WCF messages by default is the serialization validation – i.e. the structure correctness of the messages. They are not strictly validated against the schemas.

Hence my requirement was this – validate the messages against the schemas that are used to generate the contract files.

The answer is – Message Inspectors

You create  a message inspector by implementing the IClientMessageInspector and the IDispatchMessageInspector interfaces.

Then extend the EndPointBehaviour by extending the IEndpointBehavior interface.

Though there are some very good blogs that tell you how to do that, I couldn’t find enough help to solve my problem. I create the endpoints in the code and host services dynamically using reflection.

Some good starting resources:

• Message Inspectors on MSDN
• MSDN
• CodePlex
• Good Resource on adding the Behaviour dynamically.

It’s so implicit that you create your own control when you do not get enough features in an out-of-the-box control.

I needed to add a ToolStripTextBox to my tool bar and wanted to resize the control when the parent control is resized.

I don’t understand why MSFT does not allow us to do that as we do for a normal out-of.the-box Text Box.

The only option I was left is to create my own ToolStripTextBox. After writing 70% of the code for my custom control, I noticed that MSDN already had this readymade code to offer. So, I did what an intelligent person would do – use it

Here is the link in MSDN

There are some things which are seemingly simple but are difficult to get done for the first time at least. This is one of them.

The other day I had to get a Stream from the String I had. Though it was apparently easy, it took me quite a while to figure it out. Nevertheless here’s what I did:

MemoryStream myStream = new MemoryStream(ASCIIEncoding.Default.GetBytes("My String"));

Recently I had a requirement where I had to create an XML file without any definitive structure but from a Class file. I had to write a tag for each class and a child property for each property.

Then instead of going for a primitive method of using the XML Document class, I went for LINQ to XML. The XElement makes life very easy when writing an XML. I just had to write 2 recursive methods to write the entire XML file.

This article helped a lot.

This is Links collection post for Microsoft Word Programming.

Visual Studio Tools for the Microsoft Office System – MSDN

Word Object Model Overview – MSDN

Understanding the Word Object Model from a .NET Developer’s Perspective

We do not have a built in split button in .net Framework. The work around is use tool strip split button which is not that useful in aesthetic perspective.

This is very good article where the author extended the standard Button control and modified it into a split button.

A Good link for a beginner in WCF.

Windows Communication Foundation – A beginner’s guide

Conceptual Overview in MSDN

What is Windows Communication Foundation on MSDN

ABC’s of Windows Communication Foundation – I like this

Modifying a Type at runtime is always difficult.

Requirement: Object must be assigned to a PropertyGrid. To expand the nested complex types in the Object, TypeConvertor attributes should be added to the properties of the type. Type should be modified not be modified at design time.

Solution: The PropertyGrid does not expand the nested complex types of an object assigned to it, if the complex type is a user-defined object. We need to add TypeConverterAttribute(typeof(ExpandableObjectConverter) to the user-defined types. Since I cannot modify the user-defined type at design time, it was not a feasible option. That leaves me with two alternatives:

Alternative 1: Tweak the Property Grid to show the nested Complex types. Given the Complexity of Property Grid and the time constraint to solve the problem, I had to go to the second alternative.

Alternative 2: After searching  lot on the internet, I stumbled here. The way to achieve the task is to bluff the Property Grid. Before you create the object, add the attributes to the properties of the type at runtime using COM (not Reflection). What you do is tell the Property Grid that the Type you used has the Attributes required for the former display the nested complex types.

The Code goes something like this:

AttributeCollection oldAttributes = TypeDescriptor.GetAttributes(type); 

Attribute[] newAttributes = new Attribute[oldAttributes.Count + 1]; 

oldAttributes.CopyTo(newAttributes, 0); 

newAttributes[oldAttributes.Count] = new TypeConverterAttribute(typeof(ExpandableObjectConverter)); 

TypeDescriptor.AddAttributes(type, newAttributes);

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Every application has a configuration file and you want to have some keys in that file which are

• application specific
• easily accessible in the application
• have read and write operations

Read the keys with the following code:

System.Configuration.ConfigurationSettings.AppSettings["keyname"];