blog.ahzf.de » Software Development

Is my code compiled on Mono (or Microsoft .NET)?

ahzf — Tue, 22 Dec 2009 18:11:29 +0000

If you want to distinguish between your .NET program compiled on Mono and your program compiled on Microsoft Windows you can use the “__MonoCS_” pre-processor flag!

using System;
using System.IO;

public class AmIMono
{

public static void Main()
{
#if __MonoCS__
Console.WriteLine("Hello Mono! ");
#else
Console.WriteLine("No Mono! ");
#endif
}

}

mcs test.cs
./test.exe

via btk

Definition of C#

ahzf — Sat, 17 Oct 2009 22:00:31 +0000

C#.NET: A hybrid of C and Java that attempted to lure defectors from the Java camp to the .NET platform. It also provides an easy transition for C++ refugees who are sick of the annoyances of manual memory management and having 9 incompatible ways to implement a simple string. (via Software++)

Google Wave – A Revolution done wrong!

ahzf — Wed, 07 Oct 2009 23:06:53 +0000

What might E-Mail look like if it were invented by… Linus Torvalds… the OSS-Community… the XMPP-Guys… or any company without central servers within their buisness plan? To me Google Wave is not much more than an IMAP-Server with integrated CSV-Log and a nice GUI. If you remember Linux Torvalds talk on the GIT at Google Talk (or better its rant against Google sourcecode management) you will be sure, that E-Mail invented by Linux would at least be as decentralized like the GIT or XMPP. Therefore Google Wave might be a very big hype but neither a technological break-through nor a great vision on the future of communicatiuon and collaboration.

C# and implicit conversions

ahzf — Sun, 04 Oct 2009 21:29:31 +0000

Sometime you decide to create a small datastructure – let’s call it Trinary – which will mostly behave like some standard datastructure – let’s think of Boolean – but with some different behavior from time to time. TO avoid a lot of noisy changes to your codebase it might be better to define an implicit conversation from your new datastructure to the standard datastructure (and vice versa). Fortunately this is very easy within C# as all you have to do is to implement appropriate “public static implicit operator $DestType($SourceType myParam)” methods for the conversion:

public static implicit operator Trinary(Boolean myBoolean)
{
if (myBoolean) return Trinary.TRUE;
return Trinary.FALSE;
}

public static implicit operator Boolean(Trinary myTrinary)
{
if (myTrinary == Trinary.FALSE) return false;
if (myTrinary == Trinary.DELETED) return false;
return true;
}

The complete class might look like the following:

public sealed class Trinary
{

#region Data

public readonly String Name;
public readonly Byte Value;

#endregion

#region Init default values

public static readonly Trinary FALSE = new Trinary(0, "FALSE");
public static readonly Trinary TRUE = new Trinary(1, "TRUE");
public static readonly Trinary DELETED = new Trinary(2, "DELETED");

#endregion

#region (private) Constructor

private Trinary(Byte myValue, String myName)
{
this.Name = myName;
this.Value = myValue;
}

#endregion

#region Implicit conversion to/from Boolean

public static implicit operator Trinary(Boolean myBoolean)
{

if (myBoolean)
return Trinary.TRUE;

return Trinary.FALSE;

}

public static implicit operator Boolean(Trinary myTrinary)
{

if (myTrinary == Trinary.FALSE)
return false;

if (myTrinary == Trinary.DELETED)
return false;

//if (myTrinary == Trinary.TRUE)
return true;

}

#endregion

public int CompareTo(Boolean myBoolean)
{

if (Value == 0 && myBoolean == false)
return 0;

if (Value == 2 && myBoolean == false)
return 0;

if (Value == 1 && myBoolean == true)
return 0;

return 1;

}

public int CompareTo(Trinary myTrinary)
{

if (this.Equals(myTrinary))
return 0;

return 1;

}

#region Operator overloading

#region Equals(myObject)

public override Boolean Equals(Object myObject)
{

// Check if myObject is null
if (myObject == null)
return false;

// If parameter cannot be cast to Point return false.
Trinary _Trinary = myObject as Trinary;
if ((Object)_Trinary == null)
return false;

return Equals(_Trinary);

}

#endregion

#region Equals(myRevisionID)

public Boolean Equals(Trinary myTrinary)
{

// If parameter is null return false:
if ((Object)myTrinary == null)
return false;

// Check if the inner fields have the same values
if (Value != myTrinary.Value)
return false;

if (Name != myTrinary.Name)
return false;

return true;

}

#endregion

#region Operator == (myTrinary1, myTrinary2)

public static Boolean operator == (Trinary myTrinary1, Trinary myTrinary2)
{

// If both are null, or both are same instance, return true.
if (System.Object.ReferenceEquals(myTrinary1, myTrinary2))
return true;

// If one is null, but not both, return false.
if (((Object)myTrinary1 == null) || ((Object)myTrinary2 == null))
return false;

return myTrinary1.Equals(myTrinary2);

}

#endregion

#region Operator != (myTrinary1, myTrinary2)

public static Boolean operator !=(Trinary myTrinary1, Trinary myTrinary2)
{
return !(myTrinary1 == myTrinary2);
}

#endregion

#region GetHashCode()

public override int GetHashCode()
{
return Value.GetHashCode() ^ Name.GetHashCode();
}

#endregion

#region ToString

public override String ToString()
{
return Name;
}

#endregion

}

Additionally it might be usefull to define an extension method to compare the standard Boolean to your new datastructure:

public static class TrinaryExtensionMethods
{

public static int CompareTo(this Boolean myBoolean, Trinary myTrinary)
{

if (myTrinary == Trinary.FALSE && myBoolean == false)
return 0;

if (myTrinary == Trinary.DELETED && myBoolean == false)
return 0;

if (myTrinary == Trinary.TRUE && myBoolean == true)
return 0;

return 1;

}

Architectural Principles…

ahzf — Sat, 02 May 2009 21:08:11 +0000

Principles that seemed inviolable a few years ago are deprecated today. Principles that seem sacred today will be deprecated tomorrow. The principle of constant change is perhaps the only principle of the Internet that should survive indefinitely.

RFC1958

s/the Internet/any IT technology/

OpenSSL default on Windows?!

ahzf — Mon, 02 Feb 2009 13:13:28 +0000

There’s a bug in “the matrix ™”…?!?

(Note: WE did NOT install OpenSSL on our development systems… It seems to be there at default )

.NETzzzzz

ahzf — Tue, 30 Dec 2008 23:17:40 +0000

F: Was ist ein echte Ritterschlag einer Programmiersprachen / Laufzeitumgebung?
A: Wenn Hacker anfangen ihre Toolzzzzz Analysesoftware darinzu programmieren

Datatypes: To be “0″ or not to be “0″…

ahzf — Sun, 23 Nov 2008 22:27:37 +0000

Argh… how much time (and money) is wasted every year by bugfixing problems caused when a variable becomes zero although there is not much sense for the variable to become zero within the actual context of the program and therefore the programmer missed to add a line for checking this unexpected behavior.

The most common example for this might be if a for-loop will start at zero or one.

I really ask myself if it would be worth creating a new datatype “unsignedNotZero” which can not be set to zero and letting the compiler do most of the checking for me?! Suggestions?

The History of .NET

ahzf — Fri, 03 Oct 2008 14:10:03 +0000

Slashdot posted an interessting interview with Anders Hejlsberg, Microsoft’s leader of C# development, writer of the Turbo Pascal system, and lead architect on the Delphi language. He reveals the history behind C# and what the future holds for C# 4.0.

There is also a podcast interview from May 2008 with Anders Hejlsberg by Software Engineering Radio.

How to Design a Good API and Why it Matters

ahzf — Sat, 23 Aug 2008 12:50:43 +0000

There is a very nice but older Google Tech Talk by Joshua Bloch on “How to Design a Good API and Why it Matters” (local copy) which was also the keynote on the Library-Centric Software Design (LCSD’05). The talk is also available as video. From the conference announcements:

“Every day around the world, software developers spend much of their time working with a variety of Application Programming Interfaces (APIs). Some are integral to the core platform, some provide access to widely distributed frameworks, and some are written in-house for use by a few developers. Nearly all programmers occasionally function as API designers, whether they know it or not. A well-designed API can be a great asset to the organization that wrote it and to all who use it. Good APIs increase the pleasure and productivity of the developers who use them, the quality of the software they produce, and ultimately, the corporate bottom line. Conversely, poorly written APIs are a constant thorn in the developer’s side, and have been known to harm the bottom line to the point of bankruptcy. Given the importance of good API design, surprisingly little has been written on the subject. In this talk, I’ll attempt to help you recognize good and bad APIs and I’ll offer specific suggestions for writing good APIs and coping with bad ones.”