Partho's Weblog

Visual Debugger for MSBuild Projects

2007-12-01T17:16:26Z

Folks, Hi! A recent feature poll on the MSBuild blog seems to indicate that a debugger for MSBuild projects is the #1 vNext request from you. Lot of other folks (such as here and here ) have explicitly blogged about this requirement. Over the last week I put together a Visual Debugger for MSBuild Projects. The v1 alpha feature list looks like: v1 Feature Set: Load project and arbitrary target files Set/View build environment Step-Into tasks and targets (F11), Run (F5), Break execution, Step into...(read more)

Model-View-Controller Design Pattern...

2007-11-06T12:41:24Z

This post is really to update my blog so that is doesn't get deleted due to massive levels of inactivity. I am also experimenting with Windows Live Writer - it totally kicks ass! Anyways getting back to the point... This particular diagram conveys pretty much everything about M-V-C: Some additional links on M-V-C (Yes, yes... Google can give this information - but I am trying to save my blog really) http://weblogs.asp.net/scottgu/archive/2007/10/14/asp-net-mvc-framework.aspx http://java.sun.com/blueprints/patterns/MVC-detailed.html...(read more)

MEDC India 2006, Bangalore

2006-04-12T18:56:00Z

MEDC-India 2006. Thanks you for attending it. We loved talking to you and hearing from you......(read more)

Destination SQL Server 2005 (Mobile Edition)

2006-01-07T13:26:00Z

Pushing SQL Server Mobile database file from a desktop application developed in VS2005 to the mobile device...(read more)

Understanding the TypeDescriptor: A Metadata Engine for Designtime Code

2006-01-04T10:31:00Z

A dump of my understanding of the TypeDescriptor: A Metadata Engine for Designtime Code......(read more)

Writing .NET CF 2.0 Designtime Code – I: An Overview…

2005-10-27T20:27:00Z

Hi Folks... I am back and it’d have been sooner if not for ELDS :( Never mind that. As many of you have already noted , with Visual Studio 2005 there have been radical changes in the way designtime code is written for .NET Desktop/CF 2.0. These changes in the .NET CF Designtime architecture do break backward compatibility: .NET CF 1.0 Designtime code will refuse to even compile as .NET CF 2.0 Designtime code. But at the same time we believe these changes will: Improve the experience of the designtime...(read more)

Generics Terminology in .NET Framework

2005-10-21T18:30:00Z

Hi Folks...

The other day I was investigating an issue that finally boiled down to incorrect usage of System.Reflection & System.Reflection.Emit APIs (SR & SRE hereafter) to analyze Generic types. We were using Type.IsGenericParameter instead of using Type.IsGenericType. During investigation, what made things worse is that each time I went through the first paragraph of their respective help pages, I got more confused. Then I decided to read the Remarks section of the help pages and I was hopelessly lost because it seemed to be written in a dialect of English that I didn’t speak!

Do you know the difference between Type.IsGenericParameter and Type.IsGenericType? The difference between Generic Type Parameter and Generic Type Argument perhaps? How about Closed Constructed Generic Method and Open Constructed Generic Method? These are a part of some subtle terminology introduced into .NET Framework with Generics. Using SR & SRE without a clear understanding this terminology is only going to land you into trouble. You are going to introduce bugs into your code and you will have a really hard time debugging your own code! Just like me!

It is all there in MSDN but it is highly confusing at the first glance! So I decided to get done with this for good. I spent a good 3 hours going over Generics terminology in .NET Framework in MSDN. This is a gist of my understanding. I am all clear now. You should be too before you begin using SR and SRE.

Basic Terminology

Generics:
- They are classes/structs/interfaces/methods (CSIM hereafter) that have placeholders for one or more of the types they store and/or use.
Generic Type:
- Union of the set of all Generic Type Definitions and Constructed Types.
- A System.Type object represents a Generic Type iff its IsGenericType property is true
Generic Method:
- Must have a non-empty list of Generic Type Parameters.
- A method being a Generic Method doesn’t have anything to do with the enclosing type being Generic Type or not
- Union of the set of all Generic Method Definitions and Constructed Methods.
- Generic Type Parameters can appear as the return type or as the types of the formal parameters
- A System.Reflection.MethodInfo object represents a Generic Method iff its IsGenericMethod property is true
Generic Type Definition:
- A CSI declaration that serves as a template, with placeholders for the types it can contain or use.
- A System.Type object represents a Generic Type Definition iff its IsGenericTypeDefinition property is true
Generic Method Definition:
- A method with two parameter lists: A non-empty list of placeholder types and a list of formal parameters
- A System.Reflection.MethodInfo object represents a Generic Method Definition iff its IsGenericMethodDefinition property is true
Generic Type Parameter:
- It is the placeholder type in a Generic Type/Method Definition.
- It is represented using a System.Type object in SR and SRE.
- A System.Type object represents a Generic Type Parameter iff its IsGenericParameter property is true
- Example: Is T in Dictionary<T, int> in "class C<T> : Dictionary<T, int>" a Generic Type Parameter? Yes!
Generic Type Argument:
- It is any type that is substituted for a Generic Type Parameter. It could be another Generic Type Parameter.
- IsGenericParameter is false
- A System.Type object represents a Generic Type Argument iff its IsGenericParameter property is false
Constructed Generic Type/Method:
- A new type/method constructed as a result of specifying actual types for one or more of the Generic Type Parameters of a Generic Type/Method Definition.
- Example: Is A<B<, >, > a Constructed Generic Type? Yes!
Closed/Open Constructed Generic Type:
- A Closed Constructed Generic Type is the result of specifying Generic Type Arguments for all Generic Type Parameters of a Generic Type/Method Definition. An Open Constructed Generic Type otherwise.
- A System.Type object represents a Closed Constructed Generic Type iff its ContainsGenericParameters property is false. Otherwise it is an Open Constructed Generic Type.
- Only a Closed Constructed Generic Type can be instantiated
- Is A<B<T, string>, int>.C a Closed Constructed Generic Type? No!
Closed/Open Constructed Generic Method:
- A Closed Constructed Generic Method has no unassigned Generic Type Parameters *and* the containing type is a Closed Constructed Generic Type *and* all the Generic Type Arguments are Closed Constructed Generic Types. An Open Constructed Generic Method otherwise.
- A System.Reflection.MethodInfo object represents a Closed Constructed Generic Method iff its ContainsGenericParameters property is false. Otherwise it is an Open Constructed Generic Method
Constraints:
- They are limits placed on Generic Type Parameters.
- The GenericParameterAttributes property of a System.Type object representing a Generic Type Parameter gets a combination of System.Reflection.GenericParameterAttributes flags that describe its covariance and special constraints
- The GetGenericParameterConstraints() method of a System.Type object representing a Generic Type Parameter returns an array of System.Type objects that represent its constraints.

A few points to note

If a nested types doesn't have Generic Type Parameters of its own, the enclosing type determines the above for it.
Generic Type Parameters and Generic Type Arguments have the same relation as the parameters and arguments of a function.
typeof(Dictionary<, >).MakeArrayType() returns a System.Type object that is not a Generic Type but is an Open Constructed Generic Type. Same for pointers
In SR & SRE:
- Generic Type Parameters are represented by System.Type
- A Type/MethodInfo object representing a Generic Type/Method has an array of types containing the Generic Type Parameters and Generic Type Arguments

Examples to consolidate our understanding

Consider the followign code snippet. The invariant conditions are shown in the comments below it.

public class Base<T, U>
{
public static T M1Base(U u) { return default(T); }
}

public class Derived<V> : Base<string, V>
{
public G<Derived<V>> F;

public class Nested
{
void M1Nested() { }
}

public static void M1Derived<W>() { }
}

public class G<T> { }

/*
Type: Derived<V>
   IsGenericType: True
   IsGenericTypeDefinition: True
   ContainsGenericParameters: True
IsGenericParameter: False

Type: Base<string, V>
   IsGenericType: True
IsGenericTypeDefinition: False
ContainsGenericParameters: True
IsGenericParameter: False

Type: Array of Derived<int>
   IsGenericType: False
IsGenericTypeDefinition: False
   ContainsGenericParameters: False
IsGenericParameter: False

Type: Type parameter T in Base<T>
   IsGenericType: False
   IsGenericTypeDefinition: False
   ContainsGenericParameters: True
IsGenericParameter: True

Type: Field Derived<V>.F
   IsGenericType: True
   IsGenericTypeDefinition: False
   ContainsGenericParameters: True
IsGenericParameter: False

Type: Nested
   IsGenericType: True
   IsGenericTypeDefinition: True
   ContainsGenericParameters: True
IsGenericParameter: False

Method: T Base<T, U>.M1Base(U u)
   IsGenericMethod: False
   IsGenericMethodDefinition: False
   ContainsGenericParameters: True

Method: void Derived<V>.M1Derived<W>()
   IsGenericMethod: True
   IsGenericMethodDefinition: True
   ContainsGenericParameters: True

Method: void Derived<V>.M1Derived<int>();
   IsGenericMethod: True
   IsGenericMethodDefinition: False
   ContainsGenericParameters: True

Method: void Derived<string>.M1Derived<int>()
   IsGenericMethod: True
   IsGenericMethodDefinition: False
   ContainsGenericParameters: False
*/

Some of the System.Reflection API for Generics

System.Type.*Generic* members:
- [P] ContainsGenericParameters: True if the type is an Open Constructed Generic Type. False otherwise.
- [P] GenericParameterAttributes: Gets a combination of System.Reflection.GenericParameterAttributes flags that describe the covariance and special Constraints of a Generic Type Parameter
- [P] GenericParameterPosition: Gets the position of the Generic Type Parameter in the Generic Type Parameter list of the Generic Type/Method that declared the parameter.
- [P] IsGenericParameter: True if the type represents a Generic Type Parameter. False otherwise.
- [P] IsGenericType: True if the type represents a Generic Type. False otherwise.
- [P] IsGenericTypeDefinition: True if the type represents a Generic Type Definition. False otherwise.
- [M] GetGenericArguments: Get the array of types representing Generic Type Parameter/Arguments of the type.
- [M] GetGenericParameterConstraints: Returns an array of System.Type objects that represent the Constraints of a Generic Type.
- [M] GetGenericTypeDefinition: Gets the Generic Type Definition corresponding to the Generic Type.
- [M] MakeGenericType: Construct Closed/Open Constructed Generic Type from the Generic Type Definition
System.Reflection.MethodInfo.*Generic* members:
- [P] ContainsGenericParameters: True if the type is an Open Constructed Generic Method. False otherwise.
- [P] IsGenericMethod: True if the MethodInfo represents a Generic Method. False otherwise.
- [P] IsGenericMethodDefinition: True if the MethodInfo represents a Generic Method Definition. False otherwise.
- [M] GetGenericArguments: Get the array of types representing Generic Type Parameter/Arguments of the MethodInfo
- [M] GetGenericMethodDefinition: Gets the Generic Method Definition corresponding to the Generic Method
- [M] MakeGenericMethod: Construct Closed/Open Constructed Generic Method from the Generic Method Definition

References

If you want to learn more about Reflection & Generics in .NET Framework here are some references:

Overview of Generics in the .NET Framework clears up basic terminology
Overview of Reflection and Generics explains the how to analyze generics usign SR & SRE APIs.
Type.IsGenericType Property & MethodInfo.IsGenericMethod Property describes and has examples of various combinations
How to: Examine and Instantiate Generic Types with Reflection provides some walkthroughs for using SR & SRE for Generic Types/Methods
How to: Define a Generic Type with Reflection Emit gives examples on how to emit generic types using SRE.

Finally as an exercise:

Type.IsGenericType Property help page contains an error in the Example-Invariants table. Armed with the above knowledge find it out and let me know! :)

That's all for now... See you in my next post!

.NET Framework Designtime – I: An Introduction...

2005-10-10T14:07:00Z

Hi Folks... For a while now, I have been studying the .NET Framework Designtime Infrastructure. Not only because I now own the VSD WinForms and Data designers. But also because the design & architecture of this piece is quiet fascinating… What is the .NET Framework Designtime Infrastructure.? It is the guts of the Visual Studio designer that lets you rapidly design and build rich Windows Forms UI. In this series, I will dump my understanding of the .NET Framework Designtime. We will also progressively...(read more)

Object Test Bench – IV: Please send us your feedback and vNext wish list...

2005-10-06T10:50:00Z

Requesting feedback on Object Test Bench from the community......(read more)

Object Test Bench – III: Exploring Framework APIs...

2005-05-08T15:18:00Z

Exploring Framework APIs......(read more)

Object Test Bench – II: A User’s Manual…

2005-05-04T23:14:00Z

Object Test Bench – II: A User’s Manual…...(read more)

Visual J# on MSDN TV

2005-04-12T08:52:00Z

Pratap Lakshman introduces various enhancements to Visual J# 2005 and discusses themes such as, providing language level support for common programming idioms, making it easier to write better and correct code, and enabling new scenarios through enhanced security and integration....(read more)

Object Test Bench – I: Debugging unplugged!!!

2005-02-09T20:34:00Z

Hi folks…

As you may have seen from the various blogs and articles floating around on the internet, Visual Studio 2005 will ship with a new feature called the Object Test Bench (OTB, here after). My super cool test lead, Gopinath, suggested that I should give you guys a tour of this feature so you can start working on it as soon as Beta 2 hits the stands! So – here I am, doing just that.

What is OTB?

OTB is a rich GUI front end to the VS Debugger in design mode. It provides a graphical visualization ⁽¹⁾of the objects created at design time from within the IDE and the GUI to interact with these objects. It also provides a GUI to interact with the classes in the Class View (CV, here after) & Class Designer (CD, here after).

OTB was designed with the following in mind, which make it pretty interesting:

1. Design time debugging (?!?): Users create and interact with objects at design time and *without* having to write driver code and/or starting a debugging session. These objects are instances of either the classes the users has just written or the classes from the referenced assemblies.

2. It provides rich GUI: Users are guided by a rich wizard type GUI in all their tasks viz. instantiating class, calling methods, inspecting objects, and a lot of other activities.

3. It is language agnostic: OTB respects the user’s individuality (J, in terms of choice of coding language) by performing its tasks, irrespective of whether it is a J#, C# or VB project – yup, OTB Beta 2 supports VB! ⁽²⁾

Who/what is OTB meant for?

OTB is intended to simplify the debugging & testing the functionality of classes & their methods within a VS project or any of its references.

In other words, it could be used to shorten the design-code-debug loop for almost all classes & their methods you write. E.g. say you are writing a class library that provides utility classes/methods – you could use OTB to quickly test your code. The alternative is to create a console application as a driver for your code and then step through the driver application as it calls your code.

A corollary to the above is that OTB helps you to explore the functionality provided by the classes in a 3^rd party or .NET FX assembly. E.g. say you were banging your head on the wall with a question like:

Umm… What was that function again? The one in System.Environment that returned all the process environment variables in the current process? What exactly does it return?

Well with OTB around, the good news is you don’t have to create a console application and write code to call System.Environment.GetEnvironmentVariables, store its return value in a System.Collections.IDictionary reference and then step through the driver application to examine the return value. Using OTB all you have to do is create the bare bones zero impact J# console application, navigate to System.Environment in the CV and invoke the System.Environment.GetEnvironmentVariables method using a GUI and save the return value on the test bench. Once the return value is in the test bench, you can simply use the Enhanced Debugger Datatips to do pretty much anything you want with it.

While on the subject of survey and exploration, I have to confess that I have myself used the OTB at times to quickly verify whether some of OTB’s internal classes were indeed working the way I wanted them to.

Another thing to note is that OTB with its rich GUI and its language agnostic behavior along with the CD will probably attract the new timers ⁽³⁾, who are comfortable with GUIs and all but not so comfortable with debugging yet. They are trying to build a strong foundation in Computer Science by first learning the basics of OOP amongst other concepts. They should not have to delve deep into language syntax/semantics and other language idiosyncrasies. I mean, from within a class, why would a beginner care how to call the instance methods? He doesn’t need to know that you have to do a this.GetType() in J# or me.GetType() in VB, well not just yet, at least!

Hmm… OK, enough ranting for a day! Let’s proceed! J

Who/what is OTB not meant for?

OTB is designed/developed to provide a tool for the academia to help teachers/students for teaching/learning various concepts of software engineering. A hobbyist developer can also use it to explore the various 3^rd party class libraries written for .NET FX. Although, theoretically anyone can use it during development and testing of complex software projects, OTB, depending on the code will probably not scale up adequately for large projects!

Specifically OTB is an unlikely tool:

1. For folks involved in large/complex or distributed projects.

2. For doing unit testing on a given piece of code.

3. For extending/automating via DTE and other automation interfaces.

4. For Just-in-Time or post mortem debugging.

5. To be used in the break/run modes of the Visual Studio 2005 IDE.

Where/how/when is OTB available?

Here is a conversation we might just have at this point of time:

Me: You have done well, going through this huge pile of blog. And now I sense that you wish to continue your search for young OTB.

You: Yes, my master!

Me: Patience, my friend, in time he will seek you out and when he does, you must bring him before me. He has grown strong. Only together can we turn him to the unplugged side of debugging.

You: As you wish, my master!

Me: Everything is proceeding as I have foreseen.

Me: <laugh type="evil">eh eh eh he he</laugh>

Well the good news is that you can play with this Visual Studio 2005 Beta 2. As always, if you need more information you can contact me and I will put you through to someone who can answers your questions.

And finally…

In my next set of blogs, I will walk you through the OTB functionality. Basically what you can do and how! I will also present a few use cases that illustrate how OTB can be used. These won’t be the canonical cat.Meow()/dog.Bark() type examples, but something more realistic.

Finally the ever so clichéd: Hope you enjoy working with OTB as much as we have enjoyed designing/developing/testing it for you!

Please note that my blogs aren’t the official documentation on OTB or any other feature or component that write about – if you do see any discrepancy between my blogs and the product – then it is me goofing up big time! You are most welcome to contact me to get things clarified. Please also refer to the disclaimer on the left.

Here is the official OTB documentation on MSDN. This is based on the Beta 1 bits. So you will have to wait a while for the Beta 2 docs to appear at this link.

(To be continued…)

Notes:

1. ⁽¹⁾Not to be confused with Debugger Visualizers.

2. ⁽²⁾Party time for Elvis and Mort! Einstein will probably have to wait for v2! Sorry about that! :)

3. ⁽³⁾I was a new-timer w.r.t. computer programming in my 10^th grade… Nowadays, the new timers are from what? The 2^nd grade? 3^rd? 4^th? Ummm… I don’t know…

Some of the coolest articles on Visual J#...

2005-02-06T06:07:00Z

Hello everyone... The entire division has been really really busy over the last few weeks! We have just about begun the final phase of the Visual Studio 2005 Beta 2 release. And personally I haven’t much time for anything else – totally absolutely heads down on bug fixing! Well, what better job in the world that to write code, debug and fix bugs? And what better place in the world to work than in Microsoft Corporation? Visual J# rocks!!! Visual Studio rocks!!! Microsoft Corporation rocks!!! Anyways...(read more)

Visual J#: What is it?

2005-02-04T07:10:00Z

Sometime back the following question came up on an internal discussion:

"How to call method written in x lanuage from C#. In particular, I have several Java-language classes that I don't want to rewrite them in C#. How can I call them from C#. I understand that I can call a C/C++ dll from C# and load jvm within the c/c++ code. But is there anything more efficient?"

The answer to this question pretty much explains why Visual J# exists. Here is what I replied to the above question:

Apart from the load-jvm-and-execute option, you do have a few sleeker options:

1. If you have compiled .class binaries only and you don’t have access to the Java-language sources, you can use JBImp.exe (part of .NET SDK) to convert the .class files to managed assemblies.

JBImp will convert all compiled code that meets certain conditions.

Once you have managed assemblies – you can pretty much use it from any managed language – J#, C#, VB, MC++, etc.

2. If you have access to the J++ project and associated Java-language sources and you want to continue coding in the same language, you should run your sources through the J++ to J# Upgrade Wizard (part the VS IDE). This upgrade wizard will generate an upgrade report that lists all compatibility issues etc. and gives you suggestions/workarounds on how to modify them so that they can be compiled for the .NET platform.

Once the upgrade wizard is done you will get J# code that can be compiled (with the modifications suggested in the upgrade report) into managed assemblies using the J# complier.

(Note that if you do not have access to only the Java-language sources and not the J++ project, you may not be able to run J# Upgrade Wizard. Nevertheless you can simply compile the sources and as long as these conditions are met)

3. If you are keen on moving into .NET completely, C# should be your choice of language.

In that case you will need to run your sources through the Java Language Conversion Assistant (part of VS IDE).

The JLCA will basically convert your Java-language sources to C# sources and C# compiler will do the rest for you.

(Please see the foot note on JLCA)

Having said that, J# is the solution for Java-language developers on .NET platform.

The Visual J# tool comes with its compiler, a Java binary importer (JBImp above) and complete java-language support subject to this. Visual J# is also integrated into the VS IDE – you create/manage projects (and migrate J++ projects), use a number RAD tools for a super coding experience, use a rich visual debugger, build deployment solutions, etc.

For more information please visit the Visual J# home page. There you can get the latest information, articles, documentation, downloads, etc.

In my next post I will talk about Visual J# 2005 features and which of those I work on.

Please note:

1. JLCA is a very powerful tool and is shipped by a sister team of Visual J#, internally called the NetStep Team. TBright is a Program Manager in that team.

2. Microsoft Visual J# .NET is not a tool for developing applications intended to run on a Java virtual machine. Applications and services built with Visual J# .NET will run only in the .NET Framework; they will not run on any Java virtual machine. Visual J# .NET has been independently developed by Microsoft. It is neither endorsed nor approved by Sun Microsystems, Inc.