R – Sharing code between compact and full .NET Framework

compact-frameworknet

I have a whole bunch of projects which I want to reuse between the .net compact framework and the full framework. I have read Daniel Moth's incredibly informative article about this subject (http://msdn.microsoft.com/en-us/magazine/cc163387.aspx)

So the two main methods are:

1) Target the compact framework (ie. go for the lowest common denominator)

2) Have different projects, linking to this same source.

I would prefer to go with method 1 simply because I would like to write ONCE, build ONCE and deploy ONCE. Are there any performance/memory/stability issues by going with this approach?

Best Answer

The first option sounds great in theory, until you're working on one of your projects, and you'd really like to implement some feature for the full version, but you can't for the compact version because it doesn't support it.

I would suggest trying to separate out all the "lowest common denominator" code into separate assemblies from everything else. If you handle your separation of concerns correctly you can have a front end for your full and compact projects by tying together the appropriate assemblies into each respective front end.

However, I think it's probably good advice to start by targeting the compact framework. Employ separation of concerns where appropriate, and when you get to a point where you really want an extra feature on the full version, then it's time to branch into two front ends. Don't do it until you need it, though, otherwise YAGNI.

This is the style that Microsoft tends to use in their examples.

It appears that the guidance in this area may have changed, as StyleCop now enforces the use of the C# specific aliases.

.net – What’s the difference between struct and class in .NET

In .NET, there are two categories of types, reference types and value types.

Structs are value types and classes are reference types.

The general difference is that a reference type lives on the heap, and a value type lives inline, that is, wherever it is your variable or field is defined.

A variable containing a value type contains the entire value type value. For a struct, that means that the variable contains the entire struct, with all its fields.

A variable containing a reference type contains a pointer, or a reference to somewhere else in memory where the actual value resides.

This has one benefit, to begin with:

value types always contains a value
reference types can contain a null-reference, meaning that they don't refer to anything at all at the moment

Internally, reference types are implemented as pointers, and knowing that, and knowing how variable assignment works, there are other behavioral patterns:

copying the contents of a value type variable into another variable, copies the entire contents into the new variable, making the two distinct. In other words, after the copy, changes to one won't affect the other
copying the contents of a reference type variable into another variable, copies the reference, which means you now have two references to the same somewhere else storage of the actual data. In other words, after the copy, changing the data in one reference will appear to affect the other as well, but only because you're really just looking at the same data both places

When you declare variables or fields, here's how the two types differ:

variable: value type lives on the stack, reference type lives on the stack as a pointer to somewhere in heap memory where the actual memory lives (though note Eric Lipperts article series: The Stack Is An Implementation Detail.)
class/struct-field: value type lives completely inside the type, reference type lives inside the type as a pointer to somewhere in heap memory where the actual memory lives.

Best Answer

Related Solutions

C# – the difference between String and string in C#

This is the style that Microsoft tends to use in their examples.

.net – What’s the difference between struct and class in .NET

Related Topic