For those of you interessted in seismic activity in and around Norway feel free to download the source or binaries here.

Binaries:
http://www.labraaten.com/wpblog/wp-content/2008/06/EarthQuake.jad

Source:
EarthQuake.java
EarthQuakeCanvas.java

-petter

This post is password protected. To view it please enter your password below:

Password:

A typical example ias converting a string of comma seperated numbers into an array of integers. Here’s how to do it in one statement, without any loop:

Dim str As String = "1,2,3,4,5"
Dim ints As Integer() = Array.ConvertAll(Of String, Integer)(str.Split(","), _
    AddressOf Convert.ToInt32)

Compiler Error CS1540: Cannot access protected member 'member' via a qualifier
of type 'type1'; the qualifier must be of type 'type2' (or derived from it).

Then I encountered Eric Lipperts explanation of Why Can’t I Access A Protected Member From A Derived Class?

Then I got angry. And then, after working my emotions I had to figure out a solution.

Lets start with the example provided by Mr. Lippert:

class Ungulate {
  protected void Eat() { /* whatever */ }
}

class Giraffe : Ungulate {
  public static void FeedThem() {
    Giraffe g1 = new Giraffe();
    Ungulate g2 = new Giraffe();
    g1.Eat(); // fine
    g2.Eat(); // compile-time error “Cannot access protected member”
  }
}

The problem here is that the compiler won’t let you touch g2.Eat() from within the context of Giraffe, simply because all that the compiler knows is that g2 is (or is derived from) an Ungulate. The compiler couldn’t care less whether or not Giraffe is derived from Ungilate itself. That is protection and - according to the responsible ones - by design.

Anyway, I had to figure a way around. My goal was to ensure future access to the protected method from any derived class. And what was my solution? To add a protected dispatch wrapper (in this case static) around my protected method:

class Ungulate {
  protected void Eat() { /* whatever */ }
  protected static void Eat(Ungulate instance) {
    instance.Eat();
  }
}

class Giraffe : Ungulate {
  public static void FeedThem() {
    Giraffe g1 = new Giraffe();
    Ungulate g2 = new Giraffe();
    g1.Eat(); // fine
    Ungulate.Eat(g2);  // fine aswell
  }
}

Breaking some principles of encapsulation? Maybe, but it works like a charm

-petter

http://news.bbc.co.uk/1/hi/northern_ireland/7275060.stm

- petter

Where you pre 3.0 would initialize a list of integers like this:

List<int> list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);

You now can do this:

List<int> list = new List<int>() {1, 2, 3};

Now, this is somewhat beautified, but it does exactly the same as in the first example. The compiler parses the code and calls the Add method, implemented by List<int>, once for every integer in the initialization list.

Now, wouldn’t this be nice to do on your own proprietary collections? Ofcourse. All that’s needed is for your collection to implement the IEnumerable inteface (for uncertain reasons) and add your own Add function:

public class Person
{
    public string Name;
}

public class Family : System.Collections.IEnumerable
{
    List<Person> members;

    public Family()
    {
        this.members = new List<Person>();
    }

    public void Add(Person member)
    {
        members.Add(member);
    }

    // IEnumerable Members
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        { throw new NotImplementedException(); }
}

Then you can initialize a family instance like this:

Family family = new Family()
{
    new Person() { Name = "Petter" }
    new Person() { Name = "Kristine" }
};

It’s that simple. Anyway, in my opinion there is just one problem. You don’t always want to garble your collection with additional interfaces and/or methods just to achieve custom collection initialization. Or maybe you cannot change your collection.


So what is the solution?
Well, one solution is to use the adaptor pattern (or maybe it’s actually the factory pattern) and implement the necessary logic in a seperate adaptor class, then use implicit casting to turn this adaptor class into your target collection. Something like this:

abstract class CollectionInitializationAdapter<F,T>
    : System.Collections.IEnumerable where F:new()
{
    protected F collection;

    // Default constructor
    public CollectionInitializationAdapter()
    {
        // Create new instance of target collection
        this.collection = new F();
    }

    // Abstract and implemented by user to fit the target collection
    abstract public void Add(T item);

    // Allows implicit cast to type F (target collection)
    public static implicit operator F(CollectionInitializationAdapter<F, T> f)
    {
        return f.collection;
    }

    // IEnumerable Members
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }
}

Now, to use this abstract generic adaptor class you need to implement it to fit your proprietary collection. That is, implement the Add function:

class FamilyInitializator : CollectionInitializationAdapter<Family, Person>
{
    public override void Add(Person item)
    {
        // add the item (person) to the target collections (family) members list
        collection.Member.Add(item);
    }
}

And then put it to use:

Family family = new FamilyInitializator ()
{
    new Person() { Name = "Petter" },
    new Person() { Name = "Kristine" }
};

Wee! Now you got collection initialization for the Family class (or any collection) without adding any interface or changing any code in the collection itself.

- petter ]]> http://www.labraaten.com/wpblog/2008/02/29/a-generic-c-30-collection-initialization-adapter/feed/ http://www.labraaten.com/wpblog/2008/02/29/in%c2%b7con%c2%b7sis%c2%b7tent-iiii/ http://www.labraaten.com/wpblog/2008/02/29/in%c2%b7con%c2%b7sis%c2%b7tent-iiii/#comments Fri, 29 Feb 2008 17:42:01 +0000 Petter Labråten http://www.labraaten.com/wpblog/2008/02/29/in%c2%b7con%c2%b7sis%c2%b7tent-iiii/ When it comes to Visual Studio installation folders, why is it that Microsoft don’t just settle for one naming convention?

Here it seems that thy’re not sure what their product is named. Sometimes is .NET, sometimes not. Sometimes by year, sometimes by version (with or without the decimal):

Microsoft Visual Studio .NET 2003
Microsoft Visual Studio 8
Microsoft Visual Studio 9.0

At times they find capitalized words totally unnecessary:

microsoft frontpage

And sometimes a space, sometimes not:

Microsoft ASP.NET
Microsoft.NET

- petter