 ;; Statement keywords followed directly by a substatement.
 ;; catch is not one of them, because catch has a paren (typically).
 (c-lang-defconst c-block-stmt-1-kwds
-  csharp '("do" "try" "finally" "unsafe"))
+  csharp '("do" "else" "try" "finally" "unsafe"))
 
 
 ;; Statement keywords followed by a paren sexp and then by a substatement.

           ;; Fontify all keywords except the primitive types.
           ,`(,(concat "\\<" (c-lang-const c-regular-keywords-regexp))
              1 font-lock-keyword-face)


           ;; Fontify leading identifiers as a reference? in fully
           ;; qualified names like "Foo.Bar".
           ,@(when (c-lang-const c-opt-identifier-concat-key)
               `((,(byte-compile
                    `(lambda (limit)
                       (csharp-log 3 "bmb reference? p(%d) L(%d)" (point) limit)
                       (while (re-search-forward
                               ,(concat "\\(\\<" ;; 1
                                        "\\("  ;; 2
                                        ;;"[A-Z]";; uppercase - assume upper = classname
                                        "[A-Za-z_]"  ;; any old
                                        "[A-Za-z0-9_]*" ;; old: (c-lang-const c-symbol-key)
                                        "\\)"
                                        "[ \t\n\r\f\v]*"
                                        "\\."   ;;(c-lang-const c-opt-identifier-concat-key)
                                        "[ \t\n\r\f\v]*"
                                        "\\)" ;; 1 ends
                                        "\\("
                                        "[[:alpha:]_][A-Za-z0-9_]*" ;; start of another symbolname
                                        "\\)"  ;; 3 ends
                                        )
                               limit t)
                         (csharp-log 3 "bmb ref? B(%d)" (match-beginning 0))
                         (unless (progn
                                   (goto-char (match-beginning 0))
                                   (c-skip-comments-and-strings limit))
                           (let* ((prefix  (match-string 2))
                                  (me1 (match-end 1))
                                  (first-char (string-to-char prefix))
                                  (is-upper (and (>= first-char 65)
                                                 (<= first-char 90))))
                             (csharp-log 3 "  - class/intf ref (%s)" prefix)
                             ;; only put face if not there already
                             (or (get-text-property (match-beginning 2) 'face)
                                 (c-put-font-lock-face (match-beginning 2)
                                                       (match-end 2)
                                                       (if is-upper
                                                           font-lock-type-face ;; it's a type!
                                                         font-lock-variable-name-face)))

                             (goto-char (match-end 3))
                             (c-forward-syntactic-ws limit)

                             ;; now, maybe fontify the thing afterwards, too
                             (let ((c (char-after)))
                               (csharp-log 3 "  - now lkg at c(%c)" c)

                               (cond

                                ((= c 40) ;; open paren
                                 (or (get-text-property (match-beginning 3) 'face)
                                     (c-put-font-lock-face (match-beginning 3)
                                                           (match-end 3)
                                                           font-lock-function-name-face))
                                 (goto-char (match-end 3)))

                                ;;  these all look like variables or properties
                                ((or (= c 59)  ;; semicolon
                                     (= c 91)  ;; open sq brack
                                     (= c 41)  ;; close paren
                                     (= c 44)  ;; ,
                                     (= c 33)  ;; !
                                     (= c 124) ;; |
                                     (= c 61)  ;; =
                                     (= c 43)  ;; +
                                     (= c 45)  ;; -
                                     (= c 42)  ;; *
                                     (= c 47)) ;; /
                                 (or (get-text-property (match-beginning 3) 'face)
                                     (c-put-font-lock-face (match-beginning 3)
                                                           (match-end 3)
                                                           font-lock-variable-name-face))
                                 (goto-char (match-end 3)))

                                (t
                                 (goto-char (match-end 1)))))))))))))

           ))



                       nil))
                  )))

           ;; Case 4: using clause. Without this, using (..) gets fontified as a fn.
           ,@(when t
               `((,(byte-compile
