Showing posts with label Tools. Show all posts
Showing posts with label Tools. Show all posts

Monday, May 10, 2010

* SharePoint Designer 2010 available as free download

image

As SharePoint 2010 reaches RTM status, SharePoint Designer 2010 is now available for free download.

Both 32-bit and 64-bit versions are available.

Important Note : SharePoint Designer 2010 only connects to SharePoint 2010. To connect to SharePoint 2007 and earlier sites you must continue to use SharePoint Designer 2007. If you elect to install both applications side-by-side, you must download the 32-bit version of SharePoint Designer 2010, and install it after installing SharePoint Designer 2007. Please also note that 64 bit Office applications will not run if SharePoint Designer 2007 is installed; 64-bit Office 2010 applications should only be used if not connecting to SharePoint 2007 servers.

Download SharePoint Designer 2010 32-bit

Download SharePoint Designer 2010 64-bit

Wednesday, April 21, 2010

* Free folder size management tool – Folder Size

Having folder size not available in default view of Windows Explorer is always a challenge during investigation of disk space.

Here is a free tool which you can use to find out how your disk space is utilized.

image 

Download Folder Size tool

Thursday, April 15, 2010

* VSTS and VS 2010 launched with .NET 4.0

A big reason for developer community to smile and celebrate. Dev tools team at Microsoft has again done a great job. image 

Here are few important links :

Soma’s launch announcement

Watch Launch Keynote

Compare Various Editions

What's new in .NET Framework 4.0

What's new in Visual Studio 2010 - Rosario

Sunday, January 25, 2009

* MIX you should not miss

image

Some of the most exciting sessions :

What's New in Microsoft Silverlight 3

Hear about some of the new experience-oriented Silverlight 3 features, and see how to build applications for Silverlight 3 using Microsoft Expression Blend and Microsoft Visual Studio.

Building Microsoft Silverlight Applications with Eclipse

Come learn about plug-in support in Silverlight 2, and how to build a typical Silverlight-based application using the Silverlight tools for Eclipse.

Integrating Microsoft Expression Blend with Adobe Creative Suite

Explore how Expression Blend integrates with the design tools from Adobe's Creative Suite. Learn how to use content from Photoshop and Illustrator to efficiently create Windows Presentation Foundation (WPF) and Microsoft Silverlight-based applications, and see a range of useful tips and tricks from one of the core Expression Blend team members.

Mesh-Enabled Web Applications

Come learn how to extend your existing Web applications and get them to live and breathe within Live Mesh. See how Mesh-enabled Web applications can be accessed from anywhere through a Web browser as well as run locally (and offline) on a user's desktop. Also see how Web applications can take full advantage of value-add Mesh services such as a dedicated sandbox, online and offline synchronized storage, automatic application updates, identity, application catalogue, social computing, and more.

Microsoft Expression Web: No Platform Left Behind

Come learn how to use Expression Web to build resilient standards-based sites for use across a wide range of browsers and platforms. Hear about the current version of Expression Web and also some sneak peeks at future work that will make creating great sites even easier for designers. With a focus on workflow, you will also see how well Expression Web integrates with ASP.NET and PHP.

The Future of Microsoft Expression Blend

Hear about the future plans for Expression Blend. See how Expression Blend improves the productivity of visual designers, providing better access to data and enhanced tools for interactivity. Learn how designers can be deeply engaged and remain in control of the creative decisions while enjoying improved collaboration with developers throughout the project lifecycle.

Friday, August 03, 2007

* WCF Tool : WCF IIS Registration Tool (ServiceModelReg.exe)

Previous Post <<- WCF : Overview of Hosting in IIS

This tool is used to manage the registration of ServiceModel with IIS. ServiceModel is required for hosting WCF services in IIS.

Although if IIS is already present machine where .NET 3.0 is installed, the ServiceModel gets registered automatically but it case of issues this tool can be used for following :

  • Registration
  • Re-Registration
  • UnRegister
  • List all the components registered
  • Verification of registered components.

This tool can be found at following location : %windir%\Microsoft.NET\Framework\v3.0\Windows Communication Foundation

If you have installed pre-release versions of WCF, you will have to do some manual changes in  machine.config. Pls chk MSDN for same.

Next Post -> WCF : Hosting WCF service in IIS

Monday, May 21, 2007

* NDepend : A must in your toolbox

Code Analysis is one of the most important activity in development project lifecycle.

Its used mainly for following :

  • Analyzing coding standards
  • Understand Code Structure
  • Finding code performing badly
  • Refactoring
  • Viewing metadata of assemblies
  • Finding binding closures
  • Detecting circular dependencies

There are many tools like Visual Studio code analysis tool, FxCop, ildasm etc. which helps in achieving one or more of above but not all.

But there is one tool which helps in achieving all of them plus lot of other things like build comparisons.

NDepend is a very popular non-intrusive tool from C# MVP Patrick Smacchia used for code analysis and trial is available for free download. It can be integrated with your build process and has both GUI and command line interface.

It also introduces SQL - Like language called 'Code Query Language' for querying code based on attributes and constraints.

Other Posts

Monday, May 07, 2007

* Tool : Circular Dependency Checker

Recently while exploring the Microsoft.Cci dll which contains common compiler infrastructure i developed this simple tool for checking circular dependency amongst pre-built assemblies. I have uploaded the alpha release with source code to codeplex.

Circular Dependency Check

Cci can be used to read metadata of assemblies instead of Reflection technology provided by framework. Cci provides some advantages like multithreading support, does not lock assemblies and do not create instances.

You can use the source code as a starting point for your tool.

Other Posts

Wednesday, May 02, 2007

* Tool : VSProfiler - Analyze Performance of Managed Code

While Visual Studio 2005 has an integrated add-in for profiling managed code, VSProfiler is a stand-alone profiler for managed code.

It can be used to profile production systems or machines where Visual Studio can't be installed.

VSProfiler - vs_profiler.exe can be found on Visual Studio installation disc in wcu\profiler folder.

Executing the vs_profiler.exe installs required tools in Visual Studio installation folder like :

D:\Program Files\Microsoft Visual Studio 8\Team Tools\Performance Tools

VSProfiler supports two kinds of profiling :

  1. Sampling : Where the profiled application is analyzed and data is captured at fixed intervals e.g. after every 5 seconds performance data like CPU usage, memory usage, call graph, etc is gathered.
  2. Instrumentation/Trace : Application is profiled continuously through out the application lifetime. This is definitely more accurate but slows down the application performance during profiling and the size of output data is generally huge.

In this post i will demonstrate the steps to profile pre-built assemblies of asp.net web application using instrumentation.

  • Run VSPerfCLREnv /globaltraceon. This will setup the environment to load profiling infrastructure. Reboot is required after this.
  • Insert the instrumentation code in each of the assemblies you want to profile. Use the following command :

vsinstr <assembly name>    Make sure use the debug build for these assemblies and generate pdb files also.

  • Start the performance monitor using following command :

vsperfmon /TRACE /OUTPUT:[outputfile].vsp /USER:"[ASP.NET worker process user]"

  • An important tip here .. make sure the worker process is already not started else it won't get registered with profiler and no data will be collected.
  • Start using your web application. You will see a message on profiler windows regarding registration of worker process.
  • Once you are through with application navigation, start another command window and execute the following commands:

iisreset /stop

vsperfcmd -SHUTDOWN

  • A vsp file is created which contains all the data for analysis. While Visual Studio is required to view vsp file, following command generates two csv files using vsp file *Header.csv and Function_summary.csv which can be used for analysis without Visual Studio.

vsperfreport [outputfile].vsp /SUMMARY:FUNCTION /PACKSYMBOLS

  • Opening vsp file in VS2005 you will be able to see following :
    • Performance Report Summary showing Most called functions, Functions with most individual work, Functions taking longest.
    • How the various functions performed.
    • functions call graphs.
  • If you are through with profiling make sure to reset the environment for switching off profiling infrastructure by executing following command :

VSPerfCLREnv /globaloff

Reboot is required after this.

Other Posts

Monday, April 30, 2007

* Tool : FxCop - Managed Code Analysis

FxCop is a tool provided by Microsoft for managed code analysis. Its an excellent tool for doing a quality check on your code during and post development.

The documentation provided with FxCop is excellent for beginners so i will not demonstrate how to use the tool. I will list down some of the features of this tool to encourage you to start using this tool if you are not using it till now.

  • Its main objective is to check managed code for programming & design guidelines and report issues if there are any.
  • It is available both with GUI and as a command line tool to get integrated into automated build process. FxCop.exe is with GUi and FxCopCmd.exe is command line tool.
  • It comes by default with lot of best practices rules for programming and design in areas of Naming, performance, security etc.
  • Custom rules can be added and existing rules can be suppressed based on requirement.
  • It can be used to view IL stored in assemblies.
  • It can also be used for finding Managed & Full Binding closure of assemblies.
  • Can be used as an external command in Visual Studio
  • Some of the rules available by default are :
    • Validate Arguments of Public Methods
    • Mark assemblies with assembly version
    • Specify CultureInfo
    • Compound words should be cased correctly
    • Avoid unused parameters
  • With minimum of overhead this tool can bring lot of quality add to your application.

FxCop can be download from FxCop Team Page.

Other Posts

Wednesday, April 25, 2007

* Tool : CLRProfiler for .NET 2.0 released

CLR team at Microsoft has released the new version of CLRProfiler for .NET 2.0.

It can be downloaded from following location.

CLRProfiler is mainly used to study the memory usage behavior of managed applications.

Some of the graphs available as an output are :

  • Allocation Graph
  • Assembly Graph
  • Function Graph
  • Class Graph
  • Call Graph

Its an excellent tool for detecting memory leaks in managed code.

Other Posts

Monday, April 23, 2007

* Tool : MSIL Disassembler (Ildasm.exe)

Ildasm is one of the most frequently used tool by .NET community. It comes as part of the .net sdk since the very beginning.

The main purpose of this tool is to convert the portable executable (PE) file into readable and compilable MSIL code.

For beginners let me just explain few things :

  • MSIL : Microsoft Intermediate Language. When you compile your .net source code it gets converted to MSIL which is a platform independent language. The resultant exe or dll which you get contains the MSIL which gets compiled to native code at runtime.
  • PE File : The exe or dll file which you get after compilation of .net source code or MSIL code is called portable executable file which contains MSIL plus metadata about types and external dependencies which make PE an independent,self-describing entity and can be executed by runtime.

Ildasm supports both console and rich UI interface. The rich UI interface is the one most commonly used and is very useful for seeing following contents of an assembly :

  • Types in that assembly with full qualified names.
  • Methods and signatures available in various types.
  • Access modifiers of various types.
  • Version of that assembly.
  • Detecting if its strong named
  • External assemblies to which it references to including their version number.

In console mode Ildasm supports various other advanced options. The output in the console mode can be saved to a file in rtf , text or html format.

The other advanced options supported are :

  • /linenum : includes references to original source files
  • /source : show original source lines as comments
  • /html : produces output in html format.

The unrestricted output file containing MSIL generated by Ildasm can be given as input directly to MSIl Assembler Tool (Ilasm.exe) which will generate PE back again from which MSIL was generated.

Ildasm can also be used to check if the exe or dll file is managed or not. For unmanaged files it displays a message that no valid common language header found.

Add to : del.icio.us    Digg this    Technorati

Other Posts

Monday, April 16, 2007

* 'TOOLS' Section added

The various tools accompanying the framework are one of the strongest feature of Microsoft.NET technology.

I will be covering most of the tools here with sample usage. So, i have added a new section in right sidebar on tools.

Other Posts

Friday, April 13, 2007

* Tool : XML Schema Definition Tool (Xsd.exe)

XSD.exe which comes as part of .net framework is mainly used to generate XML schemas or .net classes based on XML schema.

Some of the generations possible with this tool are :

  • XDR -> XSD : generates xml schema based on xml data reduced schema
  • XML -> XSD : generates xml schema based on xml data file
  • XSD -> Dataset : generates code of dataset based class which can be used to read xml data compliant to input xsd using System.Data.DataSet.ReadXml
  • XSD -> Classes : generates code of classes which can be used to read and write xml data using System.Xml.Serialization.XmlSerializer
  • Classes -> XSD : generates xml schema for types in a runtime assembly

 Lets create a sample xml data file and work on it using xsd tool.

Consider the following xml data file EmployeeList.xml:

<EmployeeList>
<Company ID="1">
<Employee>Employee11</Employee>
<Employee>Employee12</Employee>
<Employee>Employee13</Employee>
</Company>
<Company ID="2">
<Employee>Employee21</Employee>
<Employee>Employee22</Employee>
<Employee>Employee23</Employee>
</Company>
<Company ID="3">
<Employee>Employee31</Employee>
<Employee>Employee32</Employee>
<Employee>Employee33</Employee>
<Employee>Employee34</Employee>
</Company>
</EmployeeList>


Execute XSD.exe on the xml data file:



> XSD EmployeeList.xml



The resultant xsd file EmployeeList.xsd will be :

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="EmployeeList" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xs:element name="EmployeeList" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="Company">
<xs:complexType>
<xs:sequence>
<xs:element name="Employee" nillable="true" minOccurs="0" maxOccurs="unbounded">
<xs:complexType>
<xs:simpleContent msdata:ColumnName="Employee_Text" msdata:Ordinal="0">
<xs:extension base="xs:string">
</xs:extension>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</xs:sequence>
<xs:attribute name="ID" type="xs:string" />
</xs:complexType>
</xs:element>
</xs:choice>
</xs:complexType>
</xs:element>
</xs:schema>


Now we can generate code of classes using the same tool and xsd generated which can be used to read and write xml data using System.Xml.Serialization.XmlSerializer.



>xsd EmployeeList.xsd /classes



The code generated is :

//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.42
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System.Xml.Serialization;

//
// This source code was auto-generated by xsd, Version=2.0.50727.42.
//


/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.42")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
[System.Xml.Serialization.XmlRootAttribute(Namespace="", IsNullable=false)]
public partial class EmployeeList {

private EmployeeListCompany[] itemsField;

/// <remarks/>
[System.Xml.Serialization.XmlElementAttribute("Company", Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
public EmployeeListCompany[] Items {
get {
return this.itemsField;
}
set {
this.itemsField = value;
}
}
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.42")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
public partial class EmployeeListCompany {

private EmployeeListCompanyEmployee[] employeeField;

private string idField;

/// <remarks/>
[System.Xml.Serialization.XmlElementAttribute("Employee", Form=System.Xml.Schema.XmlSchemaForm.Unqualified, IsNullable=true)]
public EmployeeListCompanyEmployee[] Employee {
get {
return this.employeeField;
}
set {
this.employeeField = value;
}
}

/// <remarks/>
[System.Xml.Serialization.XmlAttributeAttribute()]
public string ID {
get {
return this.idField;
}
set {
this.idField = value;
}
}
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("xsd", "2.0.50727.42")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
public partial class EmployeeListCompanyEmployee {

private string valueField;

/// <remarks/>
[System.Xml.Serialization.XmlTextAttribute()]
public string Value {
get {
return this.valueField;
}
set {
this.valueField = value;
}
}
}


The sample usage of this class can be as below:

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.IO;

namespace XSD_TOOL_SAMPLE
{
class Program
{
static void Main(string[] args)
{
EmployeeList empList;
XmlSerializer xs = new XmlSerializer(typeof(EmployeeList));
FileStream fs = new FileStream(@"D:\Vikas\vikas\tech\code\CSharp\XML\EmployeeList.xml",FileMode.Open);
empList = (EmployeeList)xs.Deserialize(fs);
Console.WriteLine(empList.Items[0].Employee[0].Value);
}
}
}


The output for this will be the value of first Employee element.



Output : Employee11



More detailed documentation on xsd tool can be found on msdn.



Other Posts



Monday, April 02, 2007

* Tool : XML Notepad

XML Notepad is a UI based XML browsing & editing tool built using .NET framework 2.0.

It is developed by XML tools team at Microsoft.

The main features of this tool are :

  • Tree View synchronized with Node Text View for quick editing of node names and values.
  • Real time XML schema validation with errors and warning shown.
  • Intellisense based on schema attached.
  • Mapping of Namespace URIs and file names containing schemas.
  • XML difference tool
  • XSLT transformation output.
  • Drag/Drop & Copy/Paste feature for nodes.

It can be downloaded from following location.

~tata & take care~

Other Posts

Monday, March 12, 2007

* Tool : SandCastle March 2007 CTP released

Microsoft has released the CTP of its next generation documentation tool code named 'SandCastle'.

It can be used to generate MSDN style documentation.

It can be downloaded from here.

~tata & take care~

Other Posts

Thursday, March 08, 2007

* Creating a context menu item for folders

I remember in .NET 1.0 sdk there used be a sample which demonstrated how to modify registry through CSharp. By doing so it used to add an item into the context menu of folders in windows explorer. The best thing about that item was that it can be used to open a command window directly into that folder which is very useful if you work with lot of console applications.

Well, i couldn't find it in .NET 3.0 sdk samples but managed to find how to write such a sample.

Here is the code which is very simple and demonstrate the power of CSharp.

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Win32;

namespace RegistryProgram
{
class Program
{
static void Main(string[] args)
{
try
{
Registry.ClassesRoot.CreateSubKey("Directory\\shell\\CmdWindow");
RegistryKey rk = Registry.ClassesRoot.CreateSubKey("Directory\\shell\\CmdWindow\\command");
rk.SetValue("","cmd \"%1\"");

}
catch(System.Exception ex)
{
Console.WriteLine(ex.StackTrace);
}
}
}
}






~tata & take care~



Other Posts



Tuesday, March 06, 2007

* Tools : ILMerge

Few important points to be noted before we get to the usage of this utility.

  • Its a utility which merges multiple .NET assemblies into a single assembly.
  • It will not work if assembly contains unmanaged code.
  • Its a console application but all its functionality is available programmatically also.
  • The type of first assembly in the list of input assemblies determines whether target assembly is exe or dll.
  • It supports strong named assemblies also.
  • Download : It can be downloaded from here.

To understand its usage lets create two libraries lib1 and lib2 with following source code :

Let Lib1 contain the following code :

using System;
using System.Collections.Generic;
using System.Text;

namespace Lib1
{
public class Class1
{
public void GetHello()
{
System.Console.WriteLine("Hello from Lib1");
}
}
}






Let Lib2 contain the following source code :

using System;
using System.Collections.Generic;
using System.Text;

namespace Lib2
{
public class Class1
{
public void GetHello()
{
System.Console.WriteLine("Hello from Lib2");
}
}
}






Build both the assemblies and run ILMerge tool to generate a new assembly called LibUnited.dll



Use the following command :



ilmerge   /out:LibUnited.dll     lib1.dll       lib2.dll



Investigate the new dll using ildasm and you will the contents of both the input dll into it. To confirm the merge lets build a console app which uses this new dll.



Create a console app with following code & add a reference to LibUnited and not Lib1 or Lib2.

using System;
using System.Collections.Generic;
using System.Text;
using Lib1;
using Lib2;

namespace UseLib
{
class Program
{
static void Main(string[] args)
{
Lib1.Class1 lc1 = new Lib1.Class1();
Lib2.Class1 lc2 = new Lib2.Class1();
lc1.GetHello();
lc2.GetHello();
}
}
}






The output you should get is :



Hello from Lib1
Hello from Lib2



The main advantage of this tool comes in the scenario where large number of application components are getting developed/tested by independent teams and during integration of those components instead of having so many assemblies, they can be merged into a single assembly.



~tata & take care~



Other Posts