Chris on Computers

Encrypt local mail folders and the desktop search index

Christoph Rüegg — Sat, 25 Aug 2007 18:10:00 GMT

I'm using TrueCrypt to encrypt all kind of files on my computer (and on all external harddrives and most USB thumbdrives) for quite some time now and I really like it. On the PC I have a set of data I want to have encrypted but that I always need, so I've configured it to automatically mount it as X:\ after login (that is, I just have to enter my password, hit enter and forget about it). One of this kind of data is the web browser bookmarks, history and cache. Luckily the Firefox browser allows you to store the profile wherever you want, so I simply store it on that virtual drive X mentioned before.

Desktop Search is very useful (be it Google Desktop or Microsoft Desktop Search or whatever). However, what's the point of encrypting files when they're full-text indexed to some unencrypted location anyway. Hence I want this index to be stored on that encrypted drive X too.

Issue: The Windows Desktop Search service starts before I can enter the password and mount X. If it can't access the index, it automatically starts generating a new index at the default (and unencrypted) location. So I need some way of delaying the service start.

In addition I also want my local mail folder encrypted on X. Similar to Firefox, the Mozilla email client Thunderbird allows my to store the profile wherever I want, so I chose to store it directly on X. However, I also use Outlook 2007, and there it's not that simple:

Issue: While Outlook 2007 allows you to store the main post folder wherever you want, for some yet unknown reason you can't move IMAP or Exchange data folders.

Luckily there is a workaround for both issues, although it's not trivial and involves some coding. Here's what I did, let me know if you have a better solution (the NTFS built-in encryption is no option for me), or if you're interested in the code:

Change the Search Index Service to start manually (instead of automatically)
Write a small windows service that starts automatically and checks all few seconds whether X is mounted. If it is, it stops further checking and starts the Search Index Service.
Move all files from the outlook data folder (something like Documents and Settings\..\Local Settings\Application Data\Microsoft\Office) to a new folder in X and delete this Outlook folder
Have the small windows service (from point 2) create an NTFS Junction (aka symlink) in place of the just deleted Outlook folder, and point it to the new directory in X, as soon as X is mounted; and remove this junction again once the service stops. This makes Outlook 2007 think the files are still where it expects it, but in reality they're on X instead.

Capture Keyboard Input in WPF

Christoph Rüegg — Tue, 08 May 2007 11:17:00 GMT

In case you every need to capture some keyboard input similar to a TextBox but without a TextBox (hence you also want to capture input that - on some keyboard layouts - need a secondary key to type (like % on my layout = Shift+5), but don't care whether the user presses special keys like Shift or Ctrl, or whether the num block was used to enter a number): Don't try to start with KeyDown or KeyUp, they won't help much. Instead, register a text input handler on the TextCompositonManager:

TextCompositionManager.AddTextInputHandler(this,
new TextCompositionEventHandler(OnTextComposition));

...and then simply use the event handler argument's Text property:

private void OnTextComposition(object sender,
TextCompositionEventArgs e) 
{
    string key = e.Text;
    ...
}

And you get the keyboard layout and system key tracking for free.

How to get listed on the great chinese firewall?

Christoph Rüegg — Thu, 08 Mar 2007 00:06:19 GMT

My server is currently being "attacked" by a chinese computer at 220.173.30.198, what resolves to - you guessed right - China Telecom:

netname:      CHINANET-GX
descr:        CHINANET guangxi province network
descr:        China Telecom
descr:        No.31,jingrong street
descr:        Beijing 100032

It simply ~~downloads~~ tried to download (until I blocked it on IP protocol level) some of my open source packages multiple times per second, more than 100'000 times up to now. It's only from one single IP and therefore easy to block, and it generated only about 3 GB extra traffic so far, so it's not really a problem. Most likely a horribly badly written bot ...

Nevertheless: How to easily get onto the great chinese firewall? What do you have to publish on your server? Would easily prevent both spam and such annoyance... ;)

Why exactly these files?

I already observed something like this maybe a year ago, but expected a download manager then, that was in some way incompatible with the way CommunityServer handles downloads (other than when I'd simply put them directly into an IIS folder).

What caught my eye was the HTTP Range attribute (is this correct HTTP with the trailing dash?), and the (clearly faked) User-Agent of course. And why does it disallow caches?

GET /cs/files/folders/670/download.aspx HTTP/1.1
...
User-Agent: Mozilla/4.0 (compatible; MSIE 5.00; Windows 98)
Range: bytes=148681-
Pragma: no-cache
Cache-Control: no-cache
Connection: close

Does CommunityServer maybe have a problem with ranges and download resumes? Is this just a badly written spider/grabber that just hangs there because of some incompatibility? Well, I guess not ...

Lock down your own .NET Library Assemblies

Christoph Rüegg — Mon, 05 Mar 2007 10:35:00 GMT

Because information about this is actually hard to find (there are loads of samples around about how to demand several rights, but hardly any about locking down your own frameworks & assemblies):

I recommend for most cases to start from no rights at all (except execution and some identity permissions) and then whitelist whatever you need.

[assembly: PermissionSet(SecurityAction.RequestOptional, Name="Execution")]

Note that you have to use RequestOptional, not RequestMinimum (that wouldn't have any effect! see here), because the effective permissions are calculated as follows

Effective = (RequestMinimum union RequestOptional) - RequestRefuse

where by default RequestOptional is FullTrust, Hence you'll always get FullTrust if you only use RequestMinimum.

Note also that we rely here upon what the user/administrator specified in the "Execution" Permission Set - by default it's just the SecurityPermission's Execute Permission and nothing else.

After that just request any additional permissions you may need (RequestOptional) or you need in any case to make sense (RequestMinimum), as usual. For example use a FileIOPermission if you need to read some file, or a SocketPermission for network access, with the appropriate SecurityAttribute and parameters:

[assembly: FileIOPermission(SecurityAction.RequestMinimum, ...)]
[assembly: System.Net.SocketPermission(SecurityAction.RequestOptional, ...)]
...

Earlier I simply used to add "[assembly: SecurityPermission(SecurityAction.RequestRefuse)]" to any of my framework assemblies and thought that's it, but that was rubbish and didn't even have any effect. Don't do it. (Unless I'm very mistaken, please correct me if I am!)

C++/CLI: Explicitly Implement Interface Properties

Christoph Rüegg — Tue, 09 Jan 2007 20:37:00 GMT

In case you ever wondered how to explicitly implement interface properties in C++/CLI that collide with an already existing better typed property: It's quite easy, but I didn't find a sample in neither the language specification nor the web.

Imagine you have some already existing generic ItemBuilder class:

ref class Item;

generic<class T>
where T : Item
public ref class ItemBuilder
{
public:
    property T Prototype { T get(); };
}; 

But now you want to generalize it, to be able to access the prototype property as Item, independent of the actual generic class type. So you define an interface IItemBuilder:

public interface class IItemBuilder
{
    property Item^ Prototype { Item^ get(); };
}; 

How to explicitly implement this interface in ItemBuilder in C++/CLI?

generic<class T>
where T : Item
public ref class ItemBuilder : public IPacketBuilder
{
private:
    virtual property Item^ PrototypeUntyped
        { Item^ get() sealed = IItemBuilder::Prototype::get; };
public:
    property T Prototype { T get(); };
};  

Let me know if you know a better approach ...

Strange PowerShell Bug?

Christoph Rüegg — Sun, 24 Sep 2006 19:19:00 GMT

I'm fighting with a strange behavior of the MS PowerShell RC1, that might be a bug. It's about moving and renaming items with "[" or "]" in the name. Strangely they're simply ignored, sometimes I also get a message that the file does not exist (although I just gathered it using Get-ChildItem!?)

How to reproduce:

Open PowerShell and create an empty directory:

> mkdir pstest
> cd pstest

Create a file without [ and ] and rename/move it around.

> New-Item abc.txt -type file
> gci *.txt | mi -Destination test.txt // works
> ri test.txt

Now try it with a file containing [ and ] in its name.

> New-Item abc.[def].txt -type file
> gci *.txt | mi -Destination test.txt // does NOT work

In the second case the file is not renamed. Did I misunderstand something? Can you reproduce it? It is an old well known bug?

Email Address Format Myths

Christoph Rüegg — Sat, 16 Sep 2006 14:58:00 GMT

I'm used to enter a unique email address whenever I really have to provide one. Up to some weeks ago I used the "reg.{0}@mydomain.com" pattern, where I replaced "{0}" with a name I associate with the site, often the second level domain part (e.g. "amazon"). I applied a set of server side processing rules to move some of them to special folders, and automatically delete mails to blacklisted names. This worked very well for the last, say, 7-8 years. More than once I observed that a name I used to register for a once free service was obviously sold to spammers some months after the service was discontinued, so I just blacklisted this name.

I can do this because I have my own domain and mail server, and I've set a catch-all alias. Unfortunately I receive a lot of spam to obviously random generated email aliases (like "abnd798as8fihkasd89@..."), so I finally decided to upgrade my mail server to SmarterMail 3, which not only provides a much better spam filter system, but also allows the so called plus-addressing, allowing the same thing (the format is now "reg+{0}@mydomain.com", and it automatically moves mails to a {0}-folder (optional: always, only if folder already exists, never)) but without the hassle of a catch-all alias.

At the beginning this worked very well. But soon I got problems because some web apps don't allow the "+"-character in email addresses. This is strange, since a "+" in the local part (that is the part before the "@") perfectly legal.

Obviously there exists some strange myths about what characters are allowed in an email address or not. I suspect the reason for some of this myths is that the rules for domain names are very restrictive - domain names indeed don't allow "+"-characters. But the local-part does, and much more. I've also heard myth saying that everything after a "+" is considered as a comment. Or that "+" is considered equal to "@" in case you can't enter a real "@" for whatever reason. Btw, GMail supports Plus-Addressing (no, they did not invent it!), but the part after the "+" is apparently limited to six characters (I haven't tested that).

According to RFC2821 (SMTP) and RFC2822 (Internet Message Format), a mailbox address is constructed as follows:

Mailbox = Local-part "@" Domain
Local-part = Dot-string / Quoted-string
Dot-string = Atom *("." Atom)
Atom = 1*atext
atext = ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"

To summarize, the local part (before @) allows the following characters:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
0123456789
.!#$%&"*+-/=?^_`{|}~

While the domain part (after @) only allows the following characters (except IDN, but that's another topic):

ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
0123456789
.-

Note that domain names are never case-sensitive, but the local-part might be (allowed, but optional).

Beside of the next best web-app I've also heard of some MTAs making problems with local-parts that aren't valid domain names. Why on earth do developers still validate the whole email address with the domain name rules? Just for simplicity? Please, don't do that, or I'll have to put your name to the "plus-haters list of shame" ;)

Agile Hardware Design?

Christoph Rüegg — Fri, 25 Aug 2006 20:43:00 GMT

Looking back at my first semester thesis at ETH, where I designed a full-custom ASIC, I realize something odd:

In VLSI design, especially when designing ASICs or ASIPs (not so much on FPGAs), people make a real fuss about testing. For a good reason, since A) the fabrication setup is expensive and really slow (you speak in terms of months), and even more important, since B) the fabrication is error-prone. As a side note, in practice it is not economic to fabricate error-free, as such a process would be clearly far from the density limit. Hence you usually accept a yield of, say, Y=95%. Having a fault coverage T leads to a defect level of DF = 1-Y^(1-T). To minimize this you want a high fault coverage (e.g. T > 99.9%).

Part A) is about functional tests to ensure the IC does what you intend, while B) is about testing whether the chip fabric actually produced error-free what you told them to - you examine every single IC with this test, often directly on the waver.

Interestingly there is a very nice tool support for B). A common practice are scan chains, a simple technique where you insert additional logic to systematically set the values of every single register on the chip with only few additional I/O pads (actually, a tool inserts this automatically). Using such chains and a given fault model, another tool then automatically generates a huge set of test vectors, trying to reach 100% fault coverage with as few vectors as possible.

Now the odd part, when we come to A): No one seems to apply Unit Testing, or has ever heard of anything like "agile" methodologies. Ok, they do functional testing, but only the on whole chip (and to be fair, also on IP blocks - usually this means generating an input vector sequence and compare the simulated outputs with the expectations); and it probably depends on the environment. But I think there doesn't even exist a tool like NUnit/JUnit for VHDL, let alone a continuous integration server (although you could theoretically write some NAnt task adapters and use a common CI server). Looks like there's not that much communication between the hardware and the software world, or at least not on methodological aspects?

Btw, there is a ruby based hardware description language called RHDL, trying to unify object oriented and agile concepts with VHDL. Might be interesting!

Kakuro Combinations

Christoph Rüegg — Wed, 23 Aug 2006 19:26:00 GMT

Enough Sudoku for a while? Try Kakuro!

I've created a small helper table lately, listing what numbers are possible in what condition (dependent on the required sum and the number of fields). You may download it as a PDF (see attachment):

I could have evaluated the allowed numbers by hand, but decided to write a small console code snippet in C# instead. It's neither optimized nor well designed, but it works... *note to myself: use a functional language next time*

Call the method Kakuro(s,f) with the required sum in s and the number of fields in f, and it returns all possible combinations (only the ascending permutation for each) and the union set of numbers appearing in at least one combination (that's the numbers in the helper table above)

The recursive backtracking method (with inline console output for simplicity):

static BitArray AppendSummand(int summandsLeft, int targetSum, BitArray used, int sum, int nextSummand)
{
   if(summandsLeft == 0)
   {
      if(targetSum == sum)
      {   // found valid solution
         PrintUsed(used, false);
         return used;
      }
      else // invalid solution A
         return new BitArray(9);
   }
   if(nextSummand >= 10) // invalid solution B
       return new BitArray(9);
       
   BitArray usedWith = new BitArray(used);
   usedWith[nextSummand-1] = true; // try with this number
   BitArray resultWithout = AppendSummand(summandsLeft, targetSum, used, sum, nextSummand+1);
   BitArray resultWith = AppendSummand(summandsLeft-1, targetSum, usedWith, sum+nextSummand, nextSummand+1);
   // combine results for the summary
   return resultWithout.Or(resultWith);
}

And the method to run it:

static void Kakuro(int sum, int fields)
{
   Console.WriteLine("==================================");
   Console.WriteLine("** Sum {0} in {1} cells",sum,fields);
   BitArray used = new BitArray(9);
   BitArray res = AppendSummand(fields,sum,used,0,1);
   Console.Write("** Superset: ");
   PrintUsed(res, true);
   Console.WriteLine();
}

Finally the print method used to print the numbers to the console:

static void PrintUsed(BitArray used, bool all)
{
   Console.ForegroundColor = ConsoleColor.Green;
   if(all)
      for(int i=0;i<used.Length;i++)
      {
         Console.ForegroundColor = used[ i ] ? ConsoleColor.Green : ConsoleColor.Red;
         Console.Write((i+1).ToString() + " ");
      }
   else
      for(int i=0;i<used.Length;i++)
         if(used[ i ])
            Console.Write((i+1).ToString() + " ");
   Console.ResetColor();
   Console.WriteLine();
}

My first ASIC

Christoph Rüegg — Thu, 04 May 2006 16:05:00 GMT

The last term I designed my first ASIC with a colleague, as part of a semester thesis. It realizes a new algorithm and datastructure for on-chip IP address lookup for classless interdomain routing. The algorithm only needs about 6 memory access to per lookup, in order find the right of about 1500 ranges, stored in 4.5 KB on-chip SRAM.

We were constrained to a chip size of 5.93 mm^2 and a core size of only 3.56 mm^2 (1.887 mm side length). It was manufactured in a 0.250 um process and runs at 166 MHz, processing about 10-15 million lookups per second.

Our final backend design:

The "lookup table" is stored in the two SRAM microcells in the top left corner. The additional cell in the right is needed for the tree construction algorithm for building the table internally.

I tried to scan the chip on my flatbed scanner, but of course without much luck. ;)
Remember, the chip has a side length of only 2.5 mm. Here is the result:

Luckily the microscope helps out. Here a better shot. Unfortunately you don't really see much of it, because the design center guys decided it would be better to fill the topmost metal 5 layer completely:

Nevertheless, it was a very interesting project. Let me know if you need a chip designer ;).

Next step is testing ...

English Blog from now on

Christoph Rüegg — Sun, 23 Apr 2006 00:41:00 GMT

This blog used to be german, but I'll write in english from now on. Drop me a line if you think my english is too bad and I'd better switch back to german immediately ... ;)

Beside of the language, I'll also shift the topic slightly. I'll write about computers and software in general, but also about other topics from "college" (ETHz), thesis and the like.

Equidistant Letter Sequences und Regular Expressions

Christoph Rüegg — Thu, 30 Dec 2004 01:56:00 GMT

Heute hat mich per WebForm Jemand gefragt ob Wörter aus äquidistante Buchstabensequenzen (ELS) mit regulären Ausdrücken erkannt werden können. Beispielsweise soll geprüft werden, ob das Wort "foo" als ELS im Text "abf1 2o 3bor z32" vorkommt (tut es, mit Intervalllänge 4 (f suchen, dann jeweils 3 Zeichen überspringen)).

Eine äquidistande Buchstabensequenz mit unbekannter und beliebig grosser Intervalllänge n ist keine reguläre Sprache und kann folglich nicht mit einem regulären Ausdruck beschrieben werden. Dies kann einfach mit dem Pumping Lemma bewiesen werden.

Falls allerdings das gesuchte Wort bekannt und die Intervalllänge mit einem Maxima m eingegrenz werden kann (n<=m) ist die Sprache regulär und kann mit einem regulären Ausdruck beschrieben werden - wenn auch mit einem hässlichen: "(f.{0}o.{0}o|f.{1}o.{1}o|f.{2}o.{2}o|...|f.{m}o.{m}o)" (Das Pattern muss m mal wiederholt werden, mit jeweils inkrementierter Zahl zwischen den geschweiften Klammern).

Falls ELS im grösseren Rahmen erkannt werden sollten, lohnt es sich wohl einen kleinen eigenen Parser zu schreiben statt die Regex zu verwenden - mit einem solchen einfachen spezialisierten Parser ergibt sich die Intervalllängenbeschränkung, und das ganze wird wahrscheinlich wesentlich performanter ablaufen...

A C# Framework for Interprocess Synchronization and Communication

Christoph Rüegg — Thu, 30 Sep 2004 20:23:00 GMT

Mit ThreadMessaging.NET habe ich diesen Herbst eine weitere kleine Bibliothek in C# geschrieben (opensource, BSD Lizenz), ein Framework für fortgeschrittene transparente Synchronisation und Kommunikation zwischen verschiedenen Threads und Prozessen (auch über Rechnergrenzen hinweg) in der .NET Welt, die sichere Implementationen verschiedener Nachrichtenübermittlungs- und Datenflusssteuerungsstrukturen bereitstellt.

Begleitend dazu habe ich einen Artikel bei CodeProject verfasst, der nun offenbar sogar die monthly competition (august 04) gewann. Vielen Dank für die interessanten Preise :)

Bitwise: Bin&#228;re Spielchen

Christoph Rüegg — Fri, 03 Oct 2003 22:09:00 GMT

Ich bin hin und wieder erstaunt, wie unbekannt die bitwise Operatoren bei vielen Programmierern doch sind. Gehört hat man davon, vielleicht schon mal einige Beispiele gesehen, doch so richtig verstanden hat man sie doch nicht, selber angewendet sowieso nicht. Desshalb habe ich mich entschieden, diesen kleinen Artikel zu schreiben und hier zu publizieren...

Einführung

Bei modernen Sprachen wie C# merkt man nicht mehr viel von der Hardware, auf dem die Anwendungen schlussendlich ablaufen soll. Konzepte wie das der Objektorientierung abstrahieren von der Architektur des Mikroprozessors besonders stark. Trotzdem stehen auch in C# nützliche Werkzeuge aus der Digitaltechnik zur Verfügung: Bitwise Operatoren. Diese Operatoren sind in CMOS sehr einfach zu implementieren und haben eine konstante Laufzeit da vollständig parallelisierbar. Dafür sind sie umso mächtiger, ist doch ein Mikroprozessor ansich auch nicht viel mehr als eine sinnvolle Verschaltung einzelner CMOS Gatter wie NANDs (negiertes Und), NORs (negiertes Oder), XORs (negierte Gleichheit) oder NOTs (Inversion). Wendet man diese Gatter parallel auf jedes Bit eines ganzen Buses an (der zb, falls 32 Bit breit, gerade eine C# Integer-Zahl repräsentiert), so erhält man die erwähnten bitwise Operatoren. (Einfachheitshalber arbeite ich in diesem Artikel nur mit 8 Bits = 1 Byte).

Binärzahlen

Um bitwise Operatoren zu verstehen ist es unumgänglich, zu Verstehen wie eine Ganzzahl (Integer) als Binärzahl dargestellt wird.

Ein Bit ("eine Datenleitung") kann genau 2 Zustände annehmen: 1 und 0 (vgl. Boolean: 1=true, 2=false). Gruppiert man nun 8 Bits zusammen, so erhält man einen 8 Bit breiten Bus, der 2^8 = 256 verschiedene Zustände, und somit 256 Zahlen darstellen kann. Damit diese Zustände eindeutig Zahlen zugeordnet werden können hat sich eine Konvention (=Code) bewährt, die am einfachsten mit ein par Beispielen gezeigt werden kann:

00000000 = 0
00000001 = 1
00000010 = 2
00000011 = 3
00000100 = 4
00000101 = 5
...
11111111 = 255

Dabei stellt jede Ziffer ein Bit dar; die Ziffer ganz links heist MSB (Most Significant Bit), die ganz rechts LSB (Least Significant Bit).

Das 2er Komplement

Ein C# Integer kann auch negative Zahlen darstellen. Dazu verwendet man das Bit ganz links für das Vorzeichen. Dadurch stehen dann allerdings pro Vorzeichen nur noch 2^7 = 128 verschiedene Zustände zur Verfügung. Mit 8 bits kann man daher, alternativ zum oben vorgestellten (unsigned) Code mit dem Bereich 0..255, auch den (signed) Bereich -128..127 darstellen (0 zählt als positive Zahl, daher ist die grösste positive Zahl 127, nicht 128!). Dazu wieder einige Beispiele:

10000000 = -128
10000001 = -127
...
11111110 = -2
11111111 = -1
00000000 = 0
00000001 = 1
...
01111110 = 126
01111111 = 127

Die positiven Zahlen funktionieren also abgesehen vom ersten Bit genau wie zuvor. Bemerkenswert ist hier vielleicht, dass (-1) + 1 0 ergiebt, 127 plus 1 jedoch (-128)! Doch wie negiert man eine Zahl, zB. '5'? Dazu braucht man erst die Zahl in Binärform. Dann dreht man jedes Bit um (1->0, 0->1) und addiert eine 1:

00000101 = 5
11111010 = -6
11111011 = -5

00000100 = 4
11111011 = -5
11111100 = -4 (beachte hier den Übertrag: 10 + 01 = 11, 101 + 001 = 110, 011 + 001 = 100, 11 + 01 = 00)

00000000 = 0
11111111 = -1
00000000 = 0

Das letzte Beispiel zeigt einen klassischen Überlauf: 011 + 001 = 100. Das führende 1 wird hier jedoch abgeschnitten, da ja kein Platz für eine weitere Stelle vorhanden ist!

Das praktische am 2er Kompelement ist u.a., dass auch die Addition von negativen und gemischten Zahlen genau gleich funktioniert wie bisher, und die Subtraktion sehr einfach auf die Addition mit einem negierten Summanden zurückgeführt werden kann. So lassen sich mit einem simplen Ripple-Carry-Addierer sehr einfach Addier-Subtrahier-Werke mit bereits sehr interessanten Funktionen konstruieren. Damit hat man dann schon fast eine einfache ALU (Arithmetisch Logische Einheit, der Kern jedes Mikroprozessors).

Bitwise Operatoren

In C# stehen folgende bitwise Operatoren zur Verfügung:

AND/und (a&b): für jedes Bit: 1 wenn a und b beide 1 sind.
OR/oder (a|b): für jedes Bit: 1, wenn a oder b oder beide 1 sind.
XOR/exklusives oder (a^b): für jedes Bit: 1, wenn a oder b (aber nicht beide gleichzeitig!) 1 ist.
INV/komplement (~a): für jedes Bit: 1 wenn a 0 ist, 0 wenn a 1 ist
SHIFT (a<<n,a>>n): Verschiebt alle Bits um n Stellen nach links bzw. rechts und füll mit 0 auf.

Bitwise Operatoren sind besonders interessant, wenn man in den einzelnen Bits gezielt Informationen hinterlegen will.

Was haben die einzelnen Operatoren nun für Auswirkungen auf den Bus als ganzes, bzw. für was kann man sie in der Praxis gebrauchen?

Der UND Operator '&'

Dieser Operator ist besonders praktisch um einen Bus mit einer Maske zu filtern. Wenn uns zb. nur das 2., 3. und 5. Bit (von rechts) interessiert können wir ihn mit der Maske '00010110' filtern. Alle anderen Bits werden dabei auf 0 gesetzt:

01010101 & 00010110 = 00010100
10101010 & 00010110 = 00000010
00010110 & 00010110 = 00010110
11101001 & 00010110 = 00000000

So kann man z.B. prüfen ob in a=7 das 3. bit gesetzt ist (was hier atsächlich der Fall ist):

int a = 7; //7 = 00000111
if((a & 4) == 4) {//4 = 00000100 Achtung: der linke Teil mus geklammert werden!
//...
}

Der OR Operator '|'

Mit OR kann man beispielsweise ein Bit oder eine ganze Folge von Bits auf 1 setzen.

Sollen beispielsweise in a=12 das 2. und 3. Bit auf 1 gesetzt werden, so geht das mit folgendem Code:

int a = 12; //12 = 00001100
a = a|6; //6 = 00000110

a hat danach den Wert 14 = 00001110

Der XOR Operator '^'

Damit kann man ein einzelnes Bit oder eine ganze Folge von Bits invertieren.

Sollen beispielsweise das 2. und 3. Bit invertiert werden, so geht das wie folgt:

int b = 6; //6 = 00000110
12^b = 10 //12 = 00001100, 10 = 00001010
14^b = 8 //14 = 00001110, 8 = 00001000
0^b = 6
b^b = 0

Der Komplement Operator '~'

.. ist beispielsweise hilfreich, um ein Bit oder eine Folge von Bits auf 0 zu setzen:

Sollen beispielsweise bei a=12 das 2. und 3. Bit auf 0 gesetzt werden, so geht das wie folgt:

int b = 6; //6 = 00000110 -> ~6 = 11111001
12&(~b) = 8 //12 = 00001100, 8 = 00001000
14&(~b) = 8 //14 = 00001110
0&(~b) = 0
b&(~b) = 0

Was passiert dabei genau? ~b dreht jedes Bit von b um. Somit haben wir genau die inverse Maske. Wir filtern die Eingabe also mit dieser inversen Maske, womit alle Bits, die in b 1 waren, nun im Ergebnis 0 sind.

Hinweis: ~6 = -7. Siehe oben "2er Komplement". -6 ist somit ~6+1!

Die SHIFT Operatoren '<<' und '>>'

Das Shiften ist die schnellste Methode, um eine Zahl n mal mit 2 zu multiplizieren bzw. zu dividieren.:

1<<1 = 2 //00000010
1<<2 = 4 //00000100
3<<2 = 12 //000001100
12>>2 = 3 //00000011

Die Shift Operatoren sind daher auch praktisch um all die oben verwendeten Masken zu generieren. Eine Maske für das 2. und 5. Bit kann beispielsweise wie folgt generiert werden:

(1<<1)|(1<<4) äquivalent mit (00000010)|(00010000) äquivalent mit 00010010, der gesuchten Maske.

Eine klassische Anwendung solcher Masken ist das Subnetting im IP Netzwerkprotokoll ("Subnetmask")

Eine praktische Anwendung der genannten Operatoren: Flags

Enumerationen sind eine praktische Sache. Manchmal wäre es aber besonders praktisch, wenn man auch mehrere Einträge der Enumeration gleichzeitig gewählt werden können. Dazu "dekoriert" man die Enumeration mit dem [Flags] Attribut und weist den Elementen Potenzen von 2 zu (0,1,2,4,8,..,256,..):

[Flags]
public enum AssemblyNameFlags: int
{
    None = 0,
    PublicKey = 1,
    Retargetable = 256
}

Nun kann man man auch durch den OR Operator gemischte Werte zuweisen (a hat danach den Wert 257):

AssemblyNameFlags a = AssemblyNameFlags.PublicKey | AssemblyNameFlags.Retargetable;

Abfragen, ob PublicKey definiert ist:

if((a & AssemblyNameFlags.PublicKey) == AssemblyNameFlags.PublicKey) { code..; }

Das PublicKey Flag nachträglich setzen (falls bereits definiert ändert sich nichts):

a |= AssemblyNameFlags.PublicKey;

Das PublicKey Flag nachträglich entfernen (falls es nicht gesetzt ist ändert sich nichts):

a &= ~AssemblyNameFlags.PublicKey;

Zum Schluss noch ein kleines Code Beispiel

[Flags]
public enum MySuperFlag: int
{
   blue = 1,
   round = 2,
   warm = 4,
   blueAndWarm = 5 // = blue | warm
   ... = 8
   ... = ...
}

MySuperFlag msf = MySuperFlag.blue;
public MySuperFlag SuperFlag //direkter Zugriff auf die Enumeration
{
   set {msf = value;}
   get {return msf;}
}
public bool IsRoundObject //direkter Zugriff auf ein einzelnes Flag der Enumeration
{
   get {return (msf & MySuperFlag.round) == MySuperFlag.round;}
   set
   {
       if(value)
          msf |= MySuperFlag.round;
       else
          msf &= ~MySuperFlag.round;
   }
}