Have you ever wished to modify the way Visual Studio imported a COM Class. Well finally you can.
The Managed, Native, and COM Interop Team (wow what a name). It looks like the name of that goverment office in the Ironman movie.
Well this fine group of men, have release the source code of the TLBIMP tool. I'm more that happy for this.
I can know finally get why are some things imported the way they are.
http://www.codeplex.com/clrinterop
You can dowload also the P/Invoke assistant. This assistant has a library of signatures so you can invoke any Windows API.
The WebBrowser control for .NET is just a wrapper for the IE ActiveX control. However this wrapper does not expose all the events that the IE ActiveX control exposes.
For example the ActiveX control has a NewWindow2 that you can use to intercept when a new window is gonna be created and you can even use the ppDisp variable to give a pointer to an IE ActiveX instance where you want the new window to be displayed.
So, our solution was to extend the WebBrowser control to make some of those events public.
In general the solution is the following:
- Create a new Class for your Event that extend any of the basic EventArgs classes.
- Add constructors and property accessor to the class
- Look at the IE Activex info and add the DWebBrowserEvents2 and IWebBrowser2 COM interfaces. We need them to make our hooks.
- Create a WebBrowserExtendedEvents extending System.Runtime.InteropServices.StandardOleMarshalObject and DWebBrowserEvents2. We need this class to intercept the ActiveX events. Add methos for all the events that you want to intercept.
- Extend the WebBrowser control overriding the CreateSink and DetachSink methods, here is where the WebBrowserExtendedEvents class is used to make the conneciton.
- Add EventHandler for all the events.
And thats all.Here is the code. Just add it to a file like ExtendedWebBrowser.cs
using System;
using System.Windows.Forms;
using System.ComponentModel;
using System.Runtime.InteropServices;
//First define a new EventArgs class to contain the newly exposed data
public class NewWindow2EventArgs : CancelEventArgs
{
object ppDisp;
public object PPDisp
{
get { return ppDisp; }
set { ppDisp = value; }
}
public NewWindow2EventArgs(ref object ppDisp, ref bool cancel)
: base()
{
this.ppDisp = ppDisp;
this.Cancel = cancel;
}
}
public class DocumentCompleteEventArgs : EventArgs
{
private object ppDisp;
private object url;
public object PPDisp
{
get { return ppDisp; }
set { ppDisp = value; }
}
public object Url
{
get { return url; }
set { url = value; }
}
public DocumentCompleteEventArgs(object ppDisp,object url)
{
this.ppDisp = ppDisp;
this.url = url;
}
}
public class CommandStateChangeEventArgs : EventArgs
{
private long command;
private bool enable;
public CommandStateChangeEventArgs(long command, ref bool enable)
{
this.command = command;
this.enable = enable;
}
public long Command
{
get { return command; }
set { command = value; }
}
public bool Enable
{
get { return enable; }
set { enable = value; }
}
}
//Extend the WebBrowser control
public class ExtendedWebBrowser : WebBrowser
{
AxHost.ConnectionPointCookie cookie;
WebBrowserExtendedEvents events;
//This method will be called to give you a chance to create your own event sink
protected override void CreateSink()
{
//MAKE SURE TO CALL THE BASE or the normal events won't fire
base.CreateSink();
events = new WebBrowserExtendedEvents(this);
cookie = new AxHost.ConnectionPointCookie(this.ActiveXInstance, events, typeof(DWebBrowserEvents2));
}
public object Application
{
get
{
IWebBrowser2 axWebBrowser = this.ActiveXInstance as IWebBrowser2;
if (axWebBrowser != null)
{
return axWebBrowser.Application;
}
else
return null;
}
}
protected override void DetachSink()
{
if (null != cookie)
{
cookie.Disconnect();
cookie = null;
}
base.DetachSink();
}
//This new event will fire for the NewWindow2
public event EventHandler<NewWindow2EventArgs> NewWindow2;
protected void OnNewWindow2(ref object ppDisp, ref bool cancel)
{
EventHandler<NewWindow2EventArgs> h = NewWindow2;
NewWindow2EventArgs args = new NewWindow2EventArgs(ref ppDisp, ref cancel);
if (null != h)
{
h(this, args);
}
//Pass the cancellation chosen back out to the events
//Pass the ppDisp chosen back out to the events
cancel = args.Cancel;
ppDisp = args.PPDisp;
}
//This new event will fire for the DocumentComplete
public event EventHandler<DocumentCompleteEventArgs> DocumentComplete;
protected void OnDocumentComplete(object ppDisp, object url)
{
EventHandler<DocumentCompleteEventArgs> h = DocumentComplete;
DocumentCompleteEventArgs args = new DocumentCompleteEventArgs( ppDisp, url);
if (null != h)
{
h(this, args);
}
//Pass the ppDisp chosen back out to the events
ppDisp = args.PPDisp;
//I think url is readonly
}
//This new event will fire for the DocumentComplete
public event EventHandler<CommandStateChangeEventArgs> CommandStateChange;
protected void OnCommandStateChange(long command, ref bool enable)
{
EventHandler<CommandStateChangeEventArgs> h = CommandStateChange;
CommandStateChangeEventArgs args = new CommandStateChangeEventArgs(command, ref enable);
if (null != h)
{
h(this, args);
}
}
//This class will capture events from the WebBrowser
public class WebBrowserExtendedEvents : System.Runtime.InteropServices.StandardOleMarshalObject, DWebBrowserEvents2
{
ExtendedWebBrowser _Browser;
public WebBrowserExtendedEvents(ExtendedWebBrowser browser)
{ _Browser = browser; }
//Implement whichever events you wish
public void NewWindow2(ref object pDisp, ref bool cancel)
{
_Browser.OnNewWindow2(ref pDisp, ref cancel);
}
//Implement whichever events you wish
public void DocumentComplete(object pDisp,ref object url)
{
_Browser.OnDocumentComplete( pDisp, url);
}
//Implement whichever events you wish
public void CommandStateChange(long command, bool enable)
{
_Browser.OnCommandStateChange( command, ref enable);
}
}
[ComImport, Guid("34A715A0-6587-11D0-924A-0020AFC7AC4D"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch), TypeLibType(TypeLibTypeFlags.FHidden)]
public interface DWebBrowserEvents2
{
[DispId(0x69)]
void CommandStateChange([In] long command, [In] bool enable);
[DispId(0x103)]
void DocumentComplete([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp, [In] ref object URL);
[DispId(0xfb)]
void NewWindow2([In, Out, MarshalAs(UnmanagedType.IDispatch)] ref object pDisp, [In, Out] ref bool cancel);
}
[ComImport, Guid("D30C1661-CDAF-11d0-8A3E-00C04FC9E26E"), TypeLibType(TypeLibTypeFlags.FOleAutomation | TypeLibTypeFlags.FDual | TypeLibTypeFlags.FHidden)]
public interface IWebBrowser2
{
[DispId(100)]
void GoBack();
[DispId(0x65)]
void GoForward();
[DispId(0x66)]
void GoHome();
[DispId(0x67)]
void GoSearch();
[DispId(0x68)]
void Navigate([In] string Url, [In] ref object flags, [In] ref object targetFrameName, [In] ref object postData, [In] ref object headers);
[DispId(-550)]
void Refresh();
[DispId(0x69)]
void Refresh2([In] ref object level);
[DispId(0x6a)]
void Stop();
[DispId(200)]
object Application { [return: MarshalAs(UnmanagedType.IDispatch)] get; }
[DispId(0xc9)]
object Parent { [return: MarshalAs(UnmanagedType.IDispatch)] get; }
[DispId(0xca)]
object Container { [return: MarshalAs(UnmanagedType.IDispatch)] get; }
[DispId(0xcb)]
object Document { [return: MarshalAs(UnmanagedType.IDispatch)] get; }
[DispId(0xcc)]
bool TopLevelContainer { get; }
[DispId(0xcd)]
string Type { get; }
[DispId(0xce)]
int Left { get; set; }
[DispId(0xcf)]
int Top { get; set; }
[DispId(0xd0)]
int Width { get; set; }
[DispId(0xd1)]
int Height { get; set; }
[DispId(210)]
string LocationName { get; }
[DispId(0xd3)]
string LocationURL { get; }
[DispId(0xd4)]
bool Busy { get; }
[DispId(300)]
void Quit();
[DispId(0x12d)]
void ClientToWindow(out int pcx, out int pcy);
[DispId(0x12e)]
void PutProperty([In] string property, [In] object vtValue);
[DispId(0x12f)]
object GetProperty([In] string property);
[DispId(0)]
string Name { get; }
[DispId(-515)]
int HWND { get; }
[DispId(400)]
string FullName { get; }
[DispId(0x191)]
string Path { get; }
[DispId(0x192)]
bool Visible { get; set; }
[DispId(0x193)]
bool StatusBar { get; set; }
[DispId(0x194)]
string StatusText { get; set; }
[DispId(0x195)]
int ToolBar { get; set; }
[DispId(0x196)]
bool MenuBar { get; set; }
[DispId(0x197)]
bool FullScreen { get; set; }
[DispId(500)]
void Navigate2([In] ref object URL, [In] ref object flags, [In] ref object targetFrameName, [In] ref object postData, [In] ref object headers);
[DispId(0x1f7)]
void ShowBrowserBar([In] ref object pvaClsid, [In] ref object pvarShow, [In] ref object pvarSize);
[DispId(-525)]
WebBrowserReadyState ReadyState { get; }
[DispId(550)]
bool Offline { get; set; }
[DispId(0x227)]
bool Silent { get; set; }
[DispId(0x228)]
bool RegisterAsBrowser { get; set; }
[DispId(0x229)]
bool RegisterAsDropTarget { get; set; }
[DispId(0x22a)]
bool TheaterMode { get; set; }
[DispId(0x22b)]
bool AddressBar { get; set; }
[DispId(0x22c)]
bool Resizable { get; set; }
}
}
If you have some .NET code that you want to share with VB6, COM has always been a nice option. You just add couple of ComVisible tags and that's all.
But...
Collections can be a little tricky.
This is a simple example of how to expose your Collections To VB6.
Here I create an ArrayList descendant that you can use to expose your collections.
Just create a new C# class library project and add the code below.
Remember to check the Register for ComInterop setting.
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
namespace CollectionsInterop
{
[Guid("0490E147-F2D2-4909-A4B8-3533D2F264D0")]
[ComVisible(true)]
public interface IMyCollectionInterface
{
int Add(object value);
void Clear();
bool Contains(object value);
int IndexOf(object value);
void Insert(int index, object value);
void Remove(object value);
void RemoveAt(int index);
[DispId(-4)]
System.Collections.IEnumerator GetEnumerator();
[DispId(0)]
[System.Runtime.CompilerServices.IndexerName("_Default")]
object this[int index]
{
get;
}
}
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
[ComDefaultInterface(typeof(IMyCollectionInterface))]
[ProgId("CollectionsInterop.VB6InteropArrayList")]
public class VB6InteropArrayList : System.Collections.ArrayList, IMyCollectionInterface
{
#region IMyCollectionInterface Members
// COM friendly strong typed GetEnumerator
[DispId(-4)]
public System.Collections.IEnumerator GetEnumerator()
{
return base.GetEnumerator();
}
#endregion
}
/// <summary>
/// Simple object for example
/// </summary>
[ComVisible(true)]
[ClassInterface(ClassInterfaceType.AutoDual)]
[ProgId("CollectionsInterop.MyObject")]
public class MyObject
{
String value1 = "nulo";
public String Value1
{
get { return value1; }
set { value1 = value; }
}
String value2 = "nulo";
public String Value2
{
get { return value2; }
set { value2 = value; }
}
}
}
To test this code you can use this VB6 code. Remember to add a reference to this class library.
Private Sub Form_Load()
Dim simpleCollection As New CollectionsInterop.VB6InteropArrayList
Dim value As New CollectionsInterop.MyObject
value.Value1 = "Mi valor1"
value.Value2 = "Autre valeur"
simpleCollection.Add value
For Each c In simpleCollection
MsgBox value.Value1
Next
End Sub
I am a firm believer in program understanding and in that our computer skills will allow us to develop programs that will understand programs and maybe in the future even write some of them :).
I also belive that natural languages ans programming languages are two things with a lot in common.
These are just some ideas about this subject.
"A language convertion translates one languate to another language, while a language-level upgrade moves an application from an older version of a language to a modern or more standardized version of that same language. In both cases, the goal is to improve portability and understanbility of an application and position that application for subsequent transformation", Legacy Systems, Transformation Strategies by William M. Ulrich.
An natural language convertion is exactly that. Translating one language to another language.
Natural language processing and transformation have a lot in common with automated source code migration. There is a lot of grammar studies on both areas, and a lot of common algorithms.
I keep quoting:
"Comparing artificial language and natural language it is very helpful to our understanding of semantics of programming languages since programming languages are artificial. We can see much similarity between these two kinds of languages:
Both of them must explain "given'" languages.
The goal of research on semantics of programming languages is the same as that of natural language: explanation of the meanings of given language. This is unavoidable for natural language but undesirable for programming language. The latter one has often led to post-design analysis of the semantics of programming languages wherein the syntax and informal meaning of the language is treated as given( such as PL/I, Fortran and C ). Then the research on the semantics is to understand the semantics of the language in another way or to sort out anomalies, ommisions, or defects in the given semantics-which hasn't had much impact on the language design. We have another kind of programming languages that have formal definitions, such as Pascal, Ada, SML. The given semantics allow this kind of programming language to be more robust than the previous ones.
Both of them separate "syntax'" and "semantics'".
Despite these similarities, the difference between the studies of natural and artificial language is profound. First of all, natural language existed for thousands of years, nobody knows who designed the language; but artificial languages are synthesized by logicians and computer scientists to meet some specific design criteria. Thus, `` the most basic characteritic of the distinction is the fact that an artificial language can be fully circumscribed and studied in its entirety.''
We already have developed a mature system for SYNTAX. In 1950's, linguist Chomsky first proposed formal language theory for English, thus came up with Formal Language Theory, Grammar, Regular Grammar, CFG etc. The ``first'' application of this theory was to define syntax for Algol and to build parser for it. The landmarks in the development of formal language theory are: Knuth's parser, and YACC-which is a successful and ``final''application of formal language theory.
"
from Cornell university http://www.cs.cornell.edu/info/projects/nuprl/cs611/fall94notes/cn2/cn2.html
Jing Huang
I also will like to add a reference from an interesting work related to pattern recognition a technique used both in natural language processing (see for example http://prhlt.iti.es/) and reverse engineering.
This work is from Francesca Arcelli and Claudia Raibulet from Italy and they are working with the NASA Automated Software EngineeringResearch Center
http://smallwiki.unibe.ch/woor2006/woor2006paper3/?action=MimeView
In VB6 it was very simple to add scripting capabilities to your application.
Just by using the Microsoft Script Control Library
You can still use this library in .NET just as Roy Osherove' Bloc show in
http://weblogs.asp.net/rosherove/articles/dotnetscripting.aspx
However there are some minor details that must be taken care of:
* Objects must be exposed thru COM (Add the [ComVisible(true)] attribute to the class
* Add the ComVisible(true) attribute to the AssemblyInfo file
* Make these objects public
* Recommended (put your calls to Eval or ExecuteStatement inside try-catch blocks).
And here's an example:
using System;
using System.Windows.Forms;
namespace ScriptingDotNetTest
{
[System.Runtime.InteropServices.ComVisible(true)]
public partial class frmTestVBScript : Form
{
public int MyBackColor
{
get { return System.Drawing.ColorTranslator.ToOle(this.BackColor); }
set { this.BackColor = System.Drawing.ColorTranslator.FromOle(value); }
}
MSScriptControl.ScriptControl sc = new MSScriptControl.ScriptControl();
private void RunScript(Object eventSender, EventArgs eventArgs)
{
try
{
sc.Language = "VbScript";
sc.Reset();
sc.AddObject("myform", this, true);
sc.ExecuteStatement("myform.MyBackColor = vbRed");
}
catch
{
MSScriptControl.IScriptControl iscriptControl = sc as MSScriptControl.IScriptControl;
lblError.Text = "ERROR" + iscriptControl.Error.Description + " | Line of error: " + iscriptControl.Error.Line + " | Code error: " + iscriptControl.Error.Text;
}
}
[STAThread]
static void Main()
{
Application.Run(new frmTestVBScript());
}
}
}
TIP: If you don find the reference in the COM tab, just browse to c:\windows\system32\msscript.ocx
When people decide to migrate their VB6 applications they eventually end up questioning where they should go. Is VB.NET or C# a good choice?
I have my personal preference, but my emphasis is in developing the technology to take where YOU want to go.
VB.NET is a VB dialect very similar to VB6. It supports several constructs and it makes the changes easier.
C# has several differences from VB6, but it has it a growing language with lots of enthusiasts in its community.
Obviously migrating VB6 to VB dialect is a task far more easier than migrating to a different language.
However we are a research company with years of work in this area and challenges is just what we love.
Let's use a methaphor here.
My beautiful wife, was born in Moscow, Russia. Like her, I really enjoy reading a good book. Some of my favorite authors are
russian authors like Dostoievsky, Tolstoi and Chejov. However I still do not speak russian. I have tried, and I will keep trying but
I still don't know russian. I have read only translations of their books, and I really enjoy them.
As a native speaker my wife always tells me, that it is not the same to read those books in another language besides russian.
And they are phrases (specially in Chejov books that I might not completely understand) but I really got the author
message and enjoyed it.
Translating a book from russian to a more similar language like Ucranian is easier than translating it to English or Spanish.
But I think everybody agrees that is a task than can be done.
You can use terrible works case scenarios, but these scenarios must be analized.
Let see (I took these example from the link in that Francesco put in my previous post http://blogs.artinsoft.net/mrojas/archive/2008/08/07/vb-migration-not-for-the-weak-of-mind.aspx)
If you have code like this:
Sub CopyFiles(ByVal throwIfError As Boolean)
If Not throwIfError Then On Error Resume Next
Dim fso As New FileSystemObject
fso.CopyFile "sourcefile1", "destfile1"
fso.CopyFile "sourcefile2", "destfile2"
fso.CopyFile "sourcefile3", "destfile3"
' seven more CopyFile method calls …
End Sub
and you translate it to:
void CopyFiles(bool throwIfError)
{
Scripting.FileSystemObject fso = new Scripting.FileSystemObjectClass();
try
{
fso.CopyFile("sourcefile1", "destfile1", true);
}
catch
{
if (throwIfError)
{
throw;
}
}
try
{
fso.CopyFile("sourcefile1", "destfile1", true);
}
catch
{
if (throwIfError)
{
throw;
}
}
try
{
fso.CopyFile("sourcefile1", "destfile1", true);
}
catch
{
if (throwIfError)
{
throw;
}
}
// seven more try-catch blocks
}
I think that the russian is really keep in this translation.
First of all. When you do a translation, you should try to make it as native as possible. So why will you keep using a COM function when there is an
equivalent in .NET. So why not use System.IO.File.CopyFile("sourcefile1", "destfile1", true); instead?
Second of all. The On Error Resume Next, I agree is a not a natural statement in C#. I really think that using it could provide results that are less predictable.
Why? Becuase after executing it, are you sure that all the CopyFile occurred successfully? I would prefer wrapping the whole code inside a try-catch instead of trying
to provide an implementation that is not natural in C#, will Aspect Oriented programming provide a clean solution for this cases. Maybe?
RPG and COBOL to Object Oriented Programming, PowerBuilder to C#, Hierarquical Databases to Relational Databases are just the kind of challenges we have faced in our research project.
Not everything is easy, and we might not be able to automate all the tasks (commonly due to the cost of implementing the automation not becuase of feasability).
But at the end Could you understand the whole novel?, even if you didn't understand the joke in the one of the paragraphs in the page?
My years of reading make be belive that you can.
Console applications are still very useful for me.
I write like 125 console applications in the morning and like 4 or 5 in the afternoon.
In one of these applications that was running a long process I just started wandering:
what will happen with Lost? Will ABC ever finish this series?
And If someone presses Ctrl-C will I be able to catch it?
And indeed, the greate C# provides a very easi way to do it:
static void Main(string[] args)
{
Console.CancelKeyPress +=
delegate(object sender, ConsoleCancelEventArgs e)
{
Artinsoft.VBUMKernel.Implementations.UpgradeCommand.StopAllUpgradeProcess(true);
Console.WriteLine("Process aborted by user!");
};
//Long running process
}
Motivation:
I hate to be disappointed. Specially if it is by a person you had respect for. And that's exactly what Francisco Balena from VB Migration Partner, has done. I have respected him for his books and all his VB6 experience. In terms of legacy VB6 code he is a monster. He is the man.
But in terms of code migration...
I'm not saying this because I work on code migration or maybe I'm biased a little by the fact that I work almost 10 years with a company that has done source code migration research on a big number of legacy languages such as COBOL, RPG, PL\1, Algol, Progress, PowerBuilder and also VB6.
I can tell the difference between a "compiler" and a system that rewrites a expression to the closest equivalent in the target language. We are aware of limitations. We are aware of paradigm differences and functional equivalence, but we talk from experience. We talk about our results. And we have proven those things we talk about.
Let's says you create a Cobol Library with a "MOVE" function, and a COBOLPicture Type and add minus, divide, and add operators. And I write something like:
CobolPicture x = new CobolPicture("XXXX");
x.move(10);
x.add(10);
We have things like that, and it works. It's feasible and maybe there are cases where that is a solution. But we are also proud of have researchers that have been able to detect pattern to rewrite something like that like:
int x = 0;
x = 10;
x+=10;
And saying, that something is not possible just because you can't or you dont like it, just seem uneducated to me.
All of this has motivated me to start a series of chapters I for a small blog book I will call VB Migration (not for the weak of mind).
For those of you, who really are tecnology savvy and are in the process of a VB Migration, this is YOUR book.
This is way a discused with a friend for migrating a VB6 RDS CreateRecordset
Private Function Foo(rs As ADOR.Recordset) As Boolean
On Error GoTo Failed
Dim ColumnInfo(0 To 1), c0(0 To 3), c1(0 To 3)
Dim auxVar As RDS.DataControl
Set auxVar = New RDS.DataControl
ColInfo(0) = Array("Value", CInt(201), CInt(1024), True)
ColInfo(1) = Array("Name", CInt(129), CInt(255), True)
Set rs = auxVar.CreateRecordSet(ColumnInfo)
Foo = True
Exit Function
Failed:
Foo = False
Exit Function
End Function
According to MSDN the CreateRecordset function takes a Varriant array with definitions for the columns. This definitions are made up of four parts
Attribute |
Description |
Name |
Name of the column header. |
Type |
Integer of the data type. |
Size |
Integer of the width in characters, regardless of data type. |
Nullability |
Boolean value. |
Scale (Optional) |
This optional attribute defines the scale for numeric fields. If this value is not specified, numeric values will be truncated to a scale of three. Precision is not affected, but the number of digits following the decimal point will be truncated to three. |
So if we are going to migrate to System.Data.DataColumn we will used a type translation like the following (for now I’m just putting some simple cases)
Length |
Constant |
Number |
DataColumn Type |
Fixed |
adTinyInt |
16 |
typeof(byte) |
Fixed |
adSmallInt |
2 |
typeof(short) |
Fixed |
adInteger |
3 |
typeof(int) |
Fixed |
adBigInt |
20 |
|
Fixed |
adUnsignedTinyInt |
17 |
|
Fixed |
adUnsignedSmallInt |
18 |
|
Fixed |
adUnsignedInt |
19 |
|
Fixed |
adUnsignedBigInt |
21 |
|
Fixed |
adSingle |
4 |
|
Fixed |
adDouble |
5 |
|
Fixed |
adCurrency |
6 |
|
Fixed |
adDecimal |
14 |
|
Fixed |
adNumeric |
131 |
|
Fixed |
adBoolean |
11 |
|
Fixed |
adError |
10 |
|
Fixed |
adGuid |
72 |
typeof(System.Guid) |
Fixed |
adDate |
7 |
Typeof(System.DateTime) |
Fixed |
adDBDate |
133 |
|
Fixed |
adDBTime |
134 |
|
Fixed |
adDBTimestamp |
135 |
|
Variable |
adBSTR |
8 |
|
Variable |
adChar |
129 |
typeof(string) |
Variable |
adVarChar |
200 |
typeof(string) |
Variable |
adLongVarChar |
201 |
typeof(string) |
Variable |
adWChar |
130 |
|
Variable |
adVarWChar |
202 |
|
Variable |
adLongVarWChar |
203 |
|
Variable |
adBinary |
128 |
|
Variable |
adVarBinary |
204 |
|
Variable |
adLongVarBinary |
205 |
|
So the final code can be something like this: private bool Foo(DataSet rs)
{
try
{
DataColumn dtCol1 = new DataColumn("Value",typeof(string));
dtCol1.AllowDBNull = true;
dtCol1.MaxLength = 1024;
DataColumn dtCol2 = new DataColumn("Name",typeof(string));dtCol2.AllowDBNull = true;
dtCol2.MaxLength = 255;
DataTable dt = rs.Tables.Add();
dt.Columns.Add(dtCol1);
dt.Columns.Add(dtCol2);
return true;
}
catch
{
return false;
}
}
NOTES:
My friend Esteban also told my that I can use C# 3 syntax and write something even cooler like:
DataColumn dtCol1 = new DataColumn()
{
ColumnName = "Value",
DataType = typeof (string),
AllowDBNull = true,
MaxLength = 1024
};
Recently my friend Yoel had just a wonderful idea. We have an old Win32 C++ application, and we wanted to add a serious logging infraestructure so we can provide better support in case the application crashes.
So Yoel came with the idea of using an existing framework for logging: LOG4NET
The only problem was, how can we integrate these two together. One way was problably exporting a .NET object as COM. But Yoel had a better idea.
Create a C++ Managed application that will comunicate with the LOG4NET assemblies, and export functions so the native applications can use that. How great is that.
Well he finally made it, and this is the code of how he did it.
First he created a C++ CLR Empty project and set its output type to Library. In the references we add a refrence to the Log4Net Library. We add a .cpp code file and we call it Bridge.cpp. Here is the code for it:
#include
<atlstr.h>
using
namespace System;
///
<summary>
/// Example of how to simply configure and use log4net
/// </summary>
ref class LoggingExample
{
private:
// Create a logger for use in this class
static log4net::ILog^ log = log4net::LogManager::GetLogger("LoggingExample");static LoggingExample()
{
log4net::Config::BasicConfigurator::Configure();
}public:static void ReportMessageWarning(char* msg)
{
String^ data = gcnew String(msg);
log->Warn(data);
}
static void ReportMessageError(char* msg)
{
String^ data = gcnew String(msg);
log->Error(data);
}static void ReportMessageInfo(char* msg)
{
String^ data = gcnew String(msg);
log->Info(data);
}static void ReportMessageDebug(char* msg)
{
String^ data = gcnew String(msg);
log->Debug(data);
}
};
extern "C"
{_declspec(dllexport) void ReportMessageWarning(char* msg)
{
LoggingExample::ReportMessageWarning(msg);
}
_declspec(dllexport) void ReportMessageError(char* msg)
{
LoggingExample::ReportMessageError(msg);
}
_declspec(dllexport) void ReportMessageInfo(char* msg)
{
LoggingExample::ReportMessageInfo(msg);
}
_declspec(dllexport) void ReportMessageDebug(char* msg)
{
LoggingExample::ReportMessageDebug(msg);
}
}
Ok. That's all. Now we have a managed C++ DLL that exposes some functions as an standard C++ DLL and we can use it with native win32 applications.
Let's do a test.
Lets create a Win32 Console application. And add this code:
// Log4NetForC++.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <atlstr.h>
extern "C"
{_declspec(dllimport) void ReportMessageWarning(char* msg);
_declspec(dllimport) void ReportMessageError(char* msg);_declspec(dllimport) void ReportMessageInfo(char* msg); _declspec(dllimport) void ReportMessageDebug(char* msg);
}
int _tmain(int argc, _TCHAR* argv[])
{
ReportMessageWarning("hello for Log4NET");
ReportMessageError("hello for Log4NET");
ReportMessageInfo("hello for Log4NET");
ReportMessageDebug("hello for Log4NET");
return 0;
}
Ok. Now we just test it and we get something like:
Cool ins't it :)
Ok Ok. I must admitted I have a weird taste to configure my gui. But recently I took it to a the extreme as I (don't know how) delete my File menu.
I managed to get around this thing for a few weeks but finally I fed up. So this gentleman gave me a solution (reset my settings) http://weblogs.asp.net/hosamkamel/archive/2007/10/03/reset-visual-studio-2005-settings.aspx
This code is so handy that I'm posting it just to remember. I preffer to serialize my datasets as attributes instead of elements. And its just a matter of using a setting. See:
Dim cnPubs As New SqlConnection("Data Source=<servername>;user id=<username>;" & _
"password=<password>;Initial Catalog=Pubs;")
Dim daAuthors As New SqlDataAdapter("Select * from Authors", cnPubs)
Dim ds As New DataSet()
cnPubs.Open()
daAuthors.Fill(ds, "Authors")
Dim dc As DataColumn
For Each dc In ds.Tables("Authors").Columns
dc.ColumnMapping = MappingType.Attribute
Next
ds.WriteXml("c:\Authors.xml")
Console.WriteLine("Completed writing XML file, using a DataSet")
Console.Read()
The find in files options of the IDE is part of my daily bread tasks. I use it all day long to get to the darkest corners of my code and kill some horrible bugs.
But from time to time it happens that the find in files functionality stops working. It just starts as always but shows and anoying "No files found..." and i really irritated me because the files where there!!!! !@#$!@#$!@#$
Well finally a fix for this annoyance is (seriously is not a joke, don't question the dark forces):
1. Spin your chair 3 times for Visual Studio 2003 and 4 times for Visual Studio 2005
2. In Visual Studio 2003 press CTRL SCROLL-LOCK and in Visual Studion 2005 press CTRL and BREAK.
3. Dont laugh, this is serious! It really works.
We found and interesting bug during a migration. The issue was that when there was an iteration through the controls in the forms, and you set the Enabled property, the property didn't get set.
After some research my friend Olman found this workaroung
foreach(Control c in Controls)
{
ctrl.Enabled = true;
if (ctrl is AxHost) ((AxHost)ctrl).Enabled = true;
}
Do you want to create a program to install your assembly in the GAC using C#. Well if you had that requirement or you are just curious, here is how.
I read these three articles:
Demystifying the .NET Global Assembly Cache
GAC API Interface
Undocumented Fusion
What I wanted just a straight answer of how to do it. Well here is how:
using System;
using System.Collections.Generic;
using System.Text;
using System.GAC;
//// Artinsoft
//// Author: Mauricio Rojas orellabac@gmail.com mrojas@artinsoft.com
//// This program uses the undocumented GAC API to perform a simple install of an assembly in the GAC
namespace AddAssemblyToGAC
{
class Program
{
static void Main(string[] args)
{
// Create an FUSION_INSTALL_REFERENCE struct and fill it with data
FUSION_INSTALL_REFERENCE[] installReference = new FUSION_INSTALL_REFERENCE[1];
installReference[0].dwFlags = 0;
// Using opaque scheme here
installReference[0].guidScheme = System.GAC.AssemblyCache.FUSION_REFCOUNT_OPAQUE_STRING_GUID;
installReference[0].szIdentifier = "My Pretty Aplication Identifier";
installReference[0].szNonCannonicalData= "My other info";
// Get an IAssemblyCache interface
IAssemblyCache pCache = AssemblyCache.CreateAssemblyCache();
String AssemblyFilePath = args[0];
if (!System.IO.File.Exists(AssemblyFilePath))
{
Console.WriteLine("Hey! Please use a valid path to an assembly, assembly was not found!");
}
int result = pCache.InstallAssembly(0, AssemblyFilePath,installReference);
//NOTE recently someone reported a problem with this code and I tried this:
// int result = pCache.InstallAssembly(0, AssemblyFilePath,null); and it worked. I think is a marshalling issue I will probably review it later
Console.WriteLine("Process returned " + result);
Console.WriteLine("Done!");
}
}
}
And here's the complete source code for this application: DOWNLOAD SOURCE CODE AND BINARIES
I present here the implementation of some useful tasks
In Artinsoft we perform massive migrations of VB6 code to VB.Net
and C#.
And sometimes after migration there are customizations to be
performed on the code, to add new functionality or to set certain new
properties.
The idea was to provide a couple of very simple and puntual MSBuildTask
to illustrate how easy it is to create custom tasks and to provide a starting
point to create new one.
You can freely use this code, just keep this comments and remember this is just
a sample code. There are not warranties. ;) And i made it a rush I know it could have
been written better
Artinsoft
mrojas@artinsoft.com
The implemented tasks are:
RemoveCOMReference |
Removes COMReferences from your project. COM references are for when you are using things thru Interop |
FixOutputPath |
Resets the output paths to bin\Release and bin\Debug |
AddProjectReference |
Add a reference to another project. A nice feature is that it generates RelativePaths the way Visual Studio does |
AddSimpleReference |
Add a reference to a very simple references like the ones you add when you click Add Reference and add System.EnterpriseServices |
ChangeCurrentBuildSetting |
This can be used for a lot of things.
For example to turn on or off the RegisterForComInterop setting
To set conditional compilation variables
To set debug info to pdbonly
The sky is the limit jeje |
The following is a sample project file
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<!-- make sure that the Assembly is in a place where msbuild can find it, a simple way is just to put it
in the same directory of your .proj file -->
<UsingTask TaskName="SomeUsefulTasks.MSBuild.RemoveCOMReference"
AssemblyFile="SomeUsefulTasks.dll"/>
<UsingTask TaskName="SomeUsefulTasks.MSBuild.FixOutputPath"
AssemblyFile="SomeUsefulTasks.dll"/>
<UsingTask TaskName="SomeUsefulTasks.MSBuild.AddProjectReference"
AssemblyFile="SomeUsefulTasks.dll"/>
<UsingTask TaskName="SomeUsefulTasks.MSBuild.AddSimpleReference"
AssemblyFile="SomeUsefulTasks.dll"/>
<UsingTask TaskName="SomeUsefulTasks.MSBuild.ChangeProjectBuildSetting"
AssemblyFile="SomeUsefulTasks.dll"/>
<ItemGroup>
<VSProjects Include="$(Start)\**\*.*proj" />
</ItemGroup>
<!--
Run with
MSBUILD SampleProject.proj /target:COMReference /p:Start="C:\MyCode"
-->
<Target Name="COMReference">
<RemoveCOMReference SourceFiles="@(VSProjects)" ComReferenceName="MSXML2" />
</Target>
<!--
Adds a project reference
Run with
MSBUILD SampleProject.proj /target:AddProjectReference /p:Start="C:\MyCode" /p:ProjectPath="C:\MyCode\MyNewSuperProject\Project1.csproj"
-->
<Target Name="AddProjectReference">
<AddProjectReference SourceFiles="@(VSProjects)" AbsolutePathToProject="$(ProjectPath)"/>
</Target>
<!--
Adds a reference to a standard assembly
Run with
MSBUILD SampleProject.proj /target:AddSimpleReference /p:Start="C:\MyCode" /p:Reference="System.EnterpriseServices"
-->
<Target Name="AddSimpleReference">
<AddSimpleReference SourceFiles="@(VSProjects)" Reference="$(Reference)" />
</Target>
<!--
Resets the OutputPaths to .\bin\Debug and .\bin\Release
Run with
MSBUILD SampleProject.proj /target:FixOutput /p:Start="C:\MyCode" /p:Reference="System.EnterpriseServices"
-->
<Target Name="FixOutput">
<FixOutputPath SourceFiles="@(VSProjects)" />
</Target>
<!--
Adds a reference to a standard assembly
There are several options here for example to set the project debug info to pdb-only do this:
Run with
MSBUILD SampleProject.proj /target:ChangeSettingToPDBOnly /p:Start="C:\MyCode"
Or run with
MSBUILD SampleProject.proj /target:ChangeSettingAddAConstant /p:Start="C:\MyCode"
Or run with
MSBUILD SampleProject.proj /target:SettingComInterop /p:Start="C:\MyCode"
-->
<Target Name="ChangeSettingToPDBOnly">
<ChangeProjectBuildSetting
SourceFiles="@(VSProjects)"
ConfigurationType="All"
Setting="DebugType"
NewValue="pdbonly" />
</Target>
<Target Name="ChangeSettingAddAConstant">
<ChangeProjectBuildSetting
SourceFiles="@(VSProjects)"
ConfigurationType="All"
Setting="DefineConstants"
NewValue="MYNEWVAL"
Add="True"/>
</Target>
<Target Name="SettingComInterop">
<ChangeProjectBuildSetting
SourceFiles="@(VSProjects)"
ConfigurationType="All"
Setting="RegisterForComInterop"
NewValue="true" />
</Target>
</Project>
DOWNLOAD CODE AND BINARIES
I had the requirement of creating a MSBuild custom task that opens a .csproj
adds a reference to another project.
The problem I faced is that references in VisualStudio are generated as relative paths,
so I needed something to help me generate relative paths.
After some Googleing I finally found this code. It was in a long forum discussion
and was posted by a guy named something like Marcin Grzabski. And here it is for posterity.
private static string EvaluateRelativePath(string mainDirPath, string absoluteFilePath)
{
string[]
firstPathParts =
mainDirPath.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);
string[]
secondPathParts =
absoluteFilePath.Trim(Path.DirectorySeparatorChar).Split(Path.DirectorySeparatorChar);
int sameCounter = 0;
for (int i = 0; i < Math.Min(firstPathParts.Length,secondPathParts.Length); i++)
{
if (
!firstPathParts[i].ToLower().Equals(secondPathParts[i].ToLower()))
{
break;
}
sameCounter++;
}
if (sameCounter == 0)
{
return absoluteFilePath;
}
string newPath = String.Empty;
for (int i = sameCounter; i < firstPathParts.Length; i++)
{
if (i > sameCounter)
{
newPath += Path.DirectorySeparatorChar;
}
newPath += "..";
}
if (newPath.Length == 0)
{
newPath = ".";
}
for (int i = sameCounter; i < secondPathParts.Length; i++)
{
newPath += Path.DirectorySeparatorChar;
newPath += secondPathParts[i];
}
return newPath;
}
And to use is just do somelines like:
String test = EvaluateRelativePath(@"E:\Source_Code\Code\ProjectsGroup1\Project1", @"E:\Source_Code\Code\ProjecstGroup2\Project2");
//This will genearate something like ..\..\ProjectGroup2\Project2
In my past life I spent a few eons writing Java code. And it wasn't bad. We had nice tools like Jalopy! that allowed us to have
code in a very standard way.
And I missed that. I've been looking around for something similar but I havent found anything like that :(
Until I found a great post from Chris Eargle, he improved the original solution from Kelvinpinch
Well here's the code.
Public Sub FormatSolution()
Dim sol As Solution = DTE.Solution
For i As Integer = 1 To sol.Projects.Count
FormatProject(sol.Projects.Item(i))
Next
End Sub
Private Sub FormatProject(ByVal proj as Project)
For i As Integer = 1 To proj.ProjectItems.Count
FormatProjectItem(proj.ProjectItems.Item(i))
Next
End Sub
Private Sub FormatProjectItem(ByVal projectItem As ProjectItem)
If projectItem.Kind = Constants.vsProjectItemKindPhysicalFile Then
If projectItem.Name.LastIndexOf(".cs") = projectItem.Name.Length - 3 Then
Dim window As Window = projectItem.Open(Constants.vsViewKindCode)
window.Activate()
projectItem.Document.DTE.ExecuteCommand("Edit.FormatDocument")
window.Close(vsSaveChanges.vsSaveChangesYes)
End If
End If
'Be sure to format all of the ProjectItems.
If Not projectItem.ProjectItems Is Nothing Then
For i As Integer = 1 To projectItem.ProjectItems.Count
FormatProjectItem(projectItem.ProjectItems.Item(i))
Next
End If
'Format the SubProject if it exists.
If Not projectItem.SubProject Is Nothing Then
FormatProject(projectItem.SubProject)
End If
End Sub
To use it perform the following steps:
- Go to the VS IDE Tools Option
- Then Select the Macros option and select Macros IDE...
- This will open the macros IDE
- In the Macros IDE navigate to the Module1, and Insert the code
To run the Macro go to Tools\Macros\Macro Explorer
And select FormatAll :)
And last but not least if you want to runit from the command line just do:
devenv /command "Macros.MyMacros.Module1.FormalAll" MyProject.csproj or
devenv /command "Macros.MyMacros.Module1.FormalAll" MySol.sln or
During migration to C# or .NET it is easier to keep the same ActiveX.
The VBCompanion does a great work in migrating the ActiveX control using the .NET ActiveX wrappings and fixing all method calls.
Sadly sometimes those ActiveX do not work properly in .NET.
Well we have good news.
Recently my friend Jose David (who we keep bothering because he is now
a Project Manager and now he only programs in MS Excel and MS Project, I added the MS by his request :P) fixed a curious bug
we had with an aplication we migrated from VB6 to C#.
The thing is that the aplication had an ActiveX control with a strange runtime behaviour.
We migrated the application keeping the ActiveX control and in most ocasions it worked ok.
But randomly it started throwing exceptions.
During the testing he discovered that if he repeated the steps slowly the bug did not reproduced.
So his idea was that it was due a garbage collection issue. And SURPRINSINLY he was right :P
He added this:
System.GC.Collect();
System.
GC.WaitForPendingFinalizers();
And the application started to work.
It seems like some of the COM objects needed a little more time for releasing all references :)
Recently we added some support for migrating the IsMissing function to VB.NEt or C#
The thing is. In VB6 the IsMissing Function is TRUE only if you have something like:
Public Sub Foo(Optional str)
Where you dont specify the variable type, or if you have
Public Sub Foo(Optional str as Variant)
And is IsMissing is FALSE for any other case. Including Optional variables whose definition type is not Variant.
So let's see some examples to illustrate the idea:
Example 1:
Public Sub Foo(str, a As Integer, b As Integer, Optional c As Integer)
MsgBox (str & "Foo Is missing a " & IsMissing(a))
MsgBox (str & "Foo Is missing b " & IsMissing(b))
MsgBox (str & "Foo Is missing c " & IsMissing(c))
End Sub
It occurs that IsMissing is really FALSE in all cases. So it is equivalent to:
Public Sub Foo(str, a As Integer, b As Integer, Optional c As Integer)
MsgBox (str & "Foo Is missing a " & false)
MsgBox (str & "Foo Is missing b " & false)
MsgBox (str & "Foo Is missing c " & false)
End Sub
Example 2:
Public Sub Goo(str, a As Integer, b As Integer, Optional c As Object, Optional d As Byte, Optional e)
MsgBox (str & "Goo Is missing a" & IsMissing(a))
MsgBox (str & "Goo Is missing b" & IsMissing(b))
MsgBox (str & "Goo Is missing c" & IsMissing(c))
MsgBox (str & "Goo Is missing d" & IsMissing(d))
MsgBox (str & "Goo Is missing e" & IsMissing(e))
End Sub
All cases EXCEPT "e" are equivalent to FALSE
Public Sub Goo(str, a As Integer, b As Integer, Optional c As Object, Optional d As Byte, Optional e)
MsgBox (str & "Goo Is missing a" & false)
MsgBox (str & "Goo Is missing b" & false)
MsgBox (str & "Goo Is missing c" &false)
MsgBox (str & "Goo Is missing d" & false)
MsgBox (str & "Goo Is missing e" & IsMissing(e))
End Sub
So if you are migrating your VB6 Code to C# put attention to these little details it can save you a lot of time.And remember that this is just one feature of VBCompanion tool ;)