digitalnetbizz's WebLog : C#

.NET Book Zero

digitalnetbizz — Sun, 28 Jan 2007 10:16:00 GMT

A free book from Petzold.

What the C or C++ Programmer Needs to Know About C# and the .NET Framework

Available in XPS and PDF. http://www.charlespetzold.com/dotnet/index.html

Anonymous Methods ...

digitalnetbizz — Sat, 07 Feb 2004 08:08:00 GMT

I read Anonymous Methods support in Whidbey (CLR) last week and decided to play with it. This looks a lot like how Javascript (in IE) handles event -

In general Anonymous Methods allows code block in place of delegate. For example,

public class TestApp: Windows.Application
{
protected override void
   OnStartingUp(Windows.StartingUpCancelEventArgs e)
{
  Window win = new Window();
  win.Text = "My Avalon Window";
  win.SizeChanged += delegate { win.Text = "My Avalon Window changed"; };
...
}

My first impressions are "how can I debug this in my IDE?" and "isn't this going to make my code messy?".

I did a test with my VS Whidbey PDC and to my suprise, it actually work with the debugging. The following line actually being called twice when my loading my Window.

win.SizeChanged += delegate { win.Text = "My Avalon Window changed"; };

The first time to setup the SizeChanged event-handling and second (and subsequent) time when my Window's size changed.

This solves my first concern, what about the second one? I thought about it for a while, it's up to you to decide to use it or not. I think Anonymous Method is suitable for a small anonymous method (like setting 1 or 2 properties). Using Anonymous Methods will help me reduce the number of lines in code due to less Event Handlers. For event handlers that do a bunch of things, you can always use stick to using an event handler.

This posting is provided "AS IS" with no warranties, and confers no rights.

Create Assembly in-memory and run it...

digitalnetbizz — Sat, 31 Jan 2004 21:20:00 GMT

This has to do with CodeDom and Microsoft.CSharp namespace. The following code will let you compile and run code in memory, IMHO - perfect for scripting engine needs:

using System;
using Specialized = System.Collections.Specialized;
using Reflection = System.Reflection;
using CSharp = Microsoft.CSharp;
using CodeDom = System.CodeDom.Compiler;

public sealed class TestCompile
{

static string ScriptCodeToCompileInMem = "public class Script {public void ScriptExecute(){System.Console.WriteLine(123);} }";
public static void Main()
{
TestCompile tc = new TestCompile();
tc.Execute(TestCompile.ScriptCodeToCompileInMem);
}

public void Execute(string scriptCode)
{
string [] source = new string[1];
source[0] = scriptCode;
CSharp.CSharpCodeProvider cscp = new CSharp.CSharpCodeProvider();
this.Compile(cscp, source[0]);
}

private void Compile(CodeDom.CodeDomProvider provider, string source)
{
CodeDom.CompilerParameters param = new CodeDom.CompilerParameters();
param.GenerateExecutable = false;
param.IncludeDebugInformation = false;
param.GenerateInMemory = true;
CodeDom.ICodeCompiler cc = provider.CreateCompiler();
CodeDom.CompilerResults cr = cc.CompileAssemblyFromSource(param, source);
Specialized.StringCollection output = cr.Output;
if(cr.Errors.Count !=0)
{
    System.Console.WriteLine("Error invoking scripts.");
    CodeDom.CompilerErrorCollection es = cr.Errors;
    foreach(CodeDom.CompilerError s in es)
      System.Console.WriteLine(s.ErrorText);
}
else
{
    object o = cr.CompiledAssembly.CreateInstance("Script");
    System.Type type = o.GetType();
    type.InvokeMember ("ScriptExecute",
            Reflection.BindingFlags.InvokeMethod |
            Reflection.BindingFlags.Default, null, o, null);
}
}
}

This posting is provided "AS IS" with no warranties, and confers no rights.

System.Collections.Generics

digitalnetbizz — Sat, 31 Jan 2004 07:46:00 GMT

I have been starting to use CLR Generics. Absolutely useful for day to day software design and implementation.

using Generics = System.Collections.Generics;
...
private Generics.IList<int> myList = new Generics.List<int>(capacity);

myList.Add(100);
myList.Add(201);
myList.Add(303);

The sample above might look very much like ArrayList and it's being use all over the place. If you compare ArrayList to Generic List, generic list is much much better because no casting to object and back (or boxing/unboxing) which will result in better performance.

This is not all the benefits, you can use other generic class like a Queue or a stack (pretty much reminds me of STL) and of course you can write your own generic class or inherit from existing ones.