All About Interop : emacs

Enable .NET 3.5 goodies in IIS vdir

DotNetInterop — Fri, 05 Dec 2008 20:29:00 GMT

Some of you may be oddballs like me: you like .NET, you program in .NET, but you don't always use Visual Studio. You hand-code everything for some applications. You often open up a text editor and just start writing a source module, with no wizards, no project templates, etc. You hand-code your MSbuild files. You hand-code your web.config files.

Oddballs like us cannot rely on the code-generation that comes with Visual Studio. So when we write a new ASP.NET application, and we want to use the .NET 3.5 goodies in that app - things like var types, and LINQ - we need to explicitly specify that we want .NET 3.5 compilation. Same is true if you are writing a WCF service and want to use REST or any of the var types or LINQ.

I've done this twice now and had to search for the way to do it both times. I'm putting here as a "note to self" and also as a reference for anyone else. These are the custom magic incantations for web.config, if you want to enable .NET 3.5 in your ASP.NET app, or in your WCF Service - eg, the cool REST stuff from .NET 3.5.

<?xml version="1.0" encoding="utf-8"?>
<configuration>

  <system.web>
    <compilation debug="false">  
      <assemblies>  
        <add assembly="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>  
        <add assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>  
        <add assembly="System.Xml.Linq, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>  
        <add assembly="System.Data.DataSetExtensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089"/>  
      </assemblies>  
    </compilation>  
  </system.web>


  <system.codedom>  
    <compilers>  
      <compiler language="c#;cs;csharp" extension=".cs"   
                type="Microsoft.CSharp.CSharpCodeProvider,System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"   
                warningLevel="4">  
        <providerOption name="CompilerVersion" value="v3.5"/>  
        <providerOption name="WarnAsError" value="false"/>  
      </compiler>  
      <compiler language="vb;vbs;visualbasic;vbscript" extension=".vb"   
                type="Microsoft.VisualBasic.VBCodeProvider, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"   
                warningLevel="4">  
        <providerOption name="CompilerVersion" value="v3.5"/>  
        <providerOption name="OptionInfer" value="true"/>  
        <providerOption name="WarnAsError" value="false"/>  
      </compiler>  
    </compilers>  
  </system.codedom> 

</configuration>

Editing XAML in Emacs

DotNetInterop — Thu, 21 Aug 2008 19:11:00 GMT

Luis Diego Fallas provides some hints. He uses a RELAX NG based parser called nXML mode for emacs.

http://langexplr.blogspot.com/2008/08/using-emacs-and-nxml-to-edit-xaml-files.html

Emacs regex to grok csc compilation errors

DotNetInterop — Thu, 22 May 2008 19:47:00 GMT

People have asked about this. This is the regular expression I use to allow emacs' next-error function to handle csc error messages. It is included in the emacs.el that I published previously. Here it is excerpted for convenience.

;; to allow next-error to work with csc.exe: 
(setq compilation-scroll-output t)
(setq-default compilation-error-regexp-alist
;       (append 
 '(
 ; Microsoft VJC:
 ;sample.java(6,1) : error J0020: Expected 'class' or 'interface'
 ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)[,]\\([0-9]+\\)): \\(error\\|warning\\) VJS[0-9]+:" 1 3 4)

 ;; dinoch - Wed, 04 Aug 2004  09:29
 ;; handle whitespace at beginning of line (for nant output)
 ;; 
 ;C# Compiler
 ;t.cs(6,18): error SC1006: Name of constructor must match name of class
 ;
 ("[ \t]*\\(\\([_a-zA-Z:\]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)[,]\\([0-9]+\\)): \\(error\\|warning\\) CS[0-9]+:" 1 3 4)

 ; Microsoft C/C++:
 ;  keyboard.c(537) : warning C4005: 'min' : macro redefinition
 ;  d:\tmp\test.c(23) : error C2143: syntax error : missing ';' before 'if'
 ;VC EEi
 ;e:\projects\myce40\tok.h(85) : error C2236: unexpected 'class' '$S1'
 ;myc.cpp(14) : error C3149: 'class System::String' : illegal use of managed type 'String'; did you forget a '*'?
    ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)) \
: \\(error\\|warning\\) C[0-9]+:" 1 3)
 )
;;  compilation-error-regexp-alist)
)

C# Code Completion in emacs - CSDE now has a CsdeShell

DotNetInterop — Tue, 22 Apr 2008 21:44:00 GMT

I've been fiddling some more with C# code completion in emacs. I wrote a csde-shell.el that is the CSDE equivalent to JDE's beanshell.el . It runs as an inferior shell in emacs. The csde code-completion logic calls out to this shell to inquire about types by name. The shell then returns type information as lisp s-expressions, which can then be parsed and manipulated by csde-complete.el . Actually, the shell is nothing more than Powershell, with a particular assembly of mine loaded into it. The assembly exposes a couple static methods that return information about .NET types.

For example, if invoke this method within PowerShell:

[Ionic.Csde.Utilities]::GetTypeInfo("System.IO.DriveInfo","mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");

Then I get back something like this:

(list "System.IO.DriveInfo" 'type
            (list
             (list "Name" 'property "System.String" (cons 'typemodifiers (list "readonly" "public" )))
             (list "DriveType" 'property "System.IO.DriveType" (cons 'typemodifiers (list "readonly" "public" )))
             (list "DriveFormat" 'property "System.String" (cons 'typemodifiers (list "readonly" "public" )))
             (list "IsReady" 'property "System.Boolean" (cons 'typemodifiers (list "readonly" "public" )))
             (list "AvailableFreeSpace" 'property "System.Int64" (cons 'typemodifiers (list "readonly" "public" )))
             (list "TotalFreeSpace" 'property "System.Int64" (cons 'typemodifiers (list "readonly" "public" )))
             (list "TotalSize" 'property "System.Int64" (cons 'typemodifiers (list "readonly" "public" )))
             (list "RootDirectory" 'property "System.IO.DirectoryInfo" (cons 'typemodifiers (list "readonly" "public" )))
             (list "VolumeLabel" 'property "System.String" (cons 'typemodifiers (list "public" ))))
            (list
             (list "Equals" 'function "System.Boolean" (list "System.Object" )
                   (cons 'typemodifiers (list "public" )))
             (list "GetDrives" 'function "System.IO.DriveInfo[]" nil (cons 'typemodifiers (list "public" "static" )))
             (list "GetHashCode" 'function "System.Int32" nil (cons 'typemodifiers (list "public" )))
             (list "GetType" 'function "System.Type" nil (cons 'typemodifiers (list "public" )))
             (list "ToString" 'function "System.String" nil (cons 'typemodifiers (list "public" )))))

This is basically the same way JDEE works. It wasn't too difficult to set up the shell, because I already had a shell (Powershell). The trickiest part was formatting and parsing the s-expressions, on both the C# side and the elisp side.

With this, if you install into your emacs CSDE (remember CSDE is abandonware, stuck at version 0.1 since 2002), and then try a csde-complete-at-point, you will get context-sensitive code completion. Yow! The first time I saw it, I had to rub my eyes! Yes, I said C# code completion in emacs. And this is not dabbrev.

Ok, settle down. This is really just a proof-of-concept at this point. There are tons of limitations, just oodles of them. The code completion is not very robust. It does not do Constructors, or public fields. It is not savvy to public/private/internal etc modifiers. It does not do parameter lists on methods - so once you select a method you have to key in all the parameters with no assistance. (Really in its current state it is nothing more than a smart property and method browser.) The C# parser in Semantic apparently does not know about the var keyword (anonymous types) introduced in C# 3.0. So if you use var, then you don't get code completion. It only works, for now, on the classes in the .NET Framework base class library. It would have to be generalized to support other class libraries. Also, to be usable, all the pieces would have to be packaged together - CSDE, the CEDET and Semantic pieces, the Powershell piece. [ Update: I've attached to this post the elisp for csde and the C# code for the CsdeShell. But that is partial, not enough to get you started. more later on other posts. ]

Like I said, tons of limitations. But it is a start. Yinz guys should ring me up if you have an interest in developing this further. Or, better, vote if you want me to make this a codeplex project, sort of CSDE-limited redux. (Remember the goal here was just code completion, much more limited that the broader goals of CSDE.)

C# Code Completion in emacs - getting beanshell equivalent in CSDE

DotNetInterop — Mon, 21 Apr 2008 19:56:00 GMT

The beanshell is something that, I think, was specially engineered to support the JDE, and particularly the code completion stuff. In JDEE, emacs starts up a Java VM and runs the beanshell class, in comint (command interpreter) mode. Then emacs can send commands to this beanshell thing, commands like "Tell me what you know about the class named 'foo'". And the beanshell reflects on foo and returns the result, which would include public methods and properties, and so on.

In my last post i said that the CSDE basically copied all this stuff over and did a search-and-replace (s/java/csharp). That's obviously not gonna work in general, and in particular with the beanshell. But we do have this Powershell thing in .NET land, don't we? Maybe you've heard of it. And I already put together a working powershell comint mode for emacs.

Just now I wrote a little TypeInfo class that exposes a single public static method, GetTypeInfo(). It uses reflection to list the members of a named class. I can load that TypeInfo() class into Powershell and interrogate types like this:

  [System.Reflection.Assembly]::LoadFrom("c:\\dinoch\\dev\\dotnet\\TypeInfo.dll");

  [Ionic.Reflection.Utilities.TypeInfo]::GetTypeInfo("System.Data.SqlClient.SqlCommand",
                                  "System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");

  [Ionic.Reflection.Utilities.TypeInfo]::GetTypeInfo("System.Xml.XmlReader",
                                  "System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");

  [Ionic.Reflection.Utilities.TypeInfo]::GetTypeInfo("System.DateTime",
                                  "mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");

This is pretty much what beanshell does for JDE. Now to figure out how to return the information in the way that CSDE can use it.

I know, I know. I said I didn't want to write a code completion thing for C# in emacs. But the various building blocks are all just sitting there, ready to be stitched together. It's not far off.

[ Update: for the next installment in this drama, see the next post.]

C# Code Completion in emacs - a look at Cedet, semantic, and CSDE

DotNetInterop — Mon, 21 Apr 2008 18:15:00 GMT

In my prior post I wrote that I have a dream of getting c# code completion in emacs. Jason Rumney wrote to me:

I think everything you want is here: http://cedet.sourceforge.net/semantic.shtml Semantic is what JDEE uses to provide code completion, and the page above claims grammars are already available for C# .

Well, I checked it out. Did a little reconnoitering. Here's what I found.

Cedet (Semantic)

Cedet is an interesting batch of tools, some of which are interesting to me, and some of which are not. Like, I don't want a Connected Graph Editor. "Cogre". I don't even want to know what such a thing is. But it's in Cedet. Also, Cedet has something called eieio. It's a very cute name, and I'm sure a very clever reference to something. But I don't get the joke, and don't care to. Senator (After some stumbling around I discovered that "Senator" is a part of cedet that does the navigation, informed by the code analysis. (like, jump forward one class, one method, whatever)) Bovine, another oblique reference to yacc and bison I guess. Whatthehell is "bovinate"? Do I want to do that or not? Will I be arrested if I try it?

Look, all I want is code completion. I am vaguely aware that various impressive magic has to happen in order to get code completion. There is some parsing magic, some context-analysis magic, and so on. I don't want to write a compiler and a parser though, although I am happy to use someone else's. I also don't want to admire the beauty of someone else's compiler, parser, or analyzer. Nor do I want to learn 8 new brand names for different magic technology (eieio, semantic, bovine, cogre, cedet, ede, speedbar, senator, etc etc etc) and how they all integrate and work together. I just want code completion. I'm sure your compiler is beautiful. I'm sure your parser is pure elegance. Your branding is very clever. It's all very nice. I just want code completion.

Ok, let me stop whining and start over. CEDET seems to have a whole bunch of infrastructure for doing analysis of source code in emacs, and then doing things with the analysis. Like, navigation. Code highlighting. And, in theory, code completion. There is a csharp parser contribution to semantic, and this means that csharp source code is correctly parsed when you load it into an emacs buffer. Installing it is pretty simple, you have to download cedet, then fiddle your emacs to add the cedet directories to your load-path, then load up semantic, and so on. Ok, it's not just a matter of running an msi file. It's a little more complicated than that. But you can handle it, you run emacs.

Once you get it installed, semantic gives you highlights on namespaces, classes, methods, and so on. It looks like this:

So this is hard evidence that semantic has successfully parsed the Csharp code. Keep in mind that there is another engine parsing the csharp code – it is called csharp-mode, and it has provided the pretty colors on the text (what emacs calls "font-lock"). But cedet seems to be a much deeper analysis of the code based on a formal parser. So, it's "better". Ok, we have blue lines calling my attention to the classes and methods. What else? In particular, DO WE GET CODE COMPLETION?

Hmm, well, see… (Reminds me of an episode of "The Office" where Michael asks about a potential dating partner. He asks, "Would this woman fit in a standard-sized rowboat, without causing the boat to capsize?" And there's no answer. And Michael says, "your delay in answering causes some concern…" Same thing here). Ah, so where were we? Code completion. Well, see, the code completion done by semantic depends on a tags database, I think, which does not exist for the .NET Framework class library. Semantic automagically generates suggested completions for classes in your source code. It looks like this:

As you can see, Semantic has put some stuff in the minibuffer to tell us how much it knows about the current context. It knows my incomplete line of code is referencing the Secant type, and it is looking for static members on that type. That alone is pretty impressive. But not so impressive is the crappy popup. Half of the text is cut off and unreadable. If I then type an 'S' and then just a few seconds, Semantic suggests the SolveViaSecant() method, and if I TAB through, Semantic will autocomplete that method. Yeehaw! The delay is not up to Visual Studio snappiness standards, but it did work.

(NB: the rose-colored highlighted lines come from flymake.el, which I wrote about previously).

As I said Semantic can do this with the classes defined in code in the buffer. And maybe even with classes defined in other source code in the same directory, although I could not get that to work. Also, sometimes the suggested completions were wrong. AND More importantly!! Semantic does not know about any of the 5000+ classes that are defined in the .NET Framework base class library. (that reminds me, I should count the classes in .NET 3.5 sometime soon).

In other words, if I declare a variable of type, let's say, System.Data.SqlClient and then try to get code completion, semantic knows I want to get a member on an instance of type SqlClient, but semantic doesn't know what SqlClient looks like. It lacks the knowledge of SqlClient and it lacks the ability to go find out.

In theory I could build a "system database" of tags that could be used by semantic to inform the code completion. BUT, I could not find any tools that would enable me to build such a database, nor could I find examples of such a database. I couldn't figure out how to teach Semantic about libraries other than those defined in active source code.

I imagine that Cedet and its semantic sub-technology works really well with C and C++. Not so much with C#, not yet anyway. And, I found it impenetrable.

CSDE

CSDE is an abandonware clone of the JDEE. The JDEE is a bunch of add-ons to emacs that make developing in Java much easier. One of the things you get is… code completion! Zowie! Since C# is so similar to Java, the guy who started with CSDE figured the JDEE would be a great leg up. Basically he copied all the elisp and just did a global search-and-replace, swapping out "java" and inserting "csharp".

The statement by Jason was that JDEE uses Semantic to power its code completion, but this is not exactly what I found. I didn't do a teardown of JDEE, but the snapshot of JDEE that CSDE is based upon, uses the beanshell in order to get class information. Here's the thing, code completion magic all works mostly the same. Some analysis has to happen to figure out what you're doing in the code. Then there's got to be an information database about the type or identifier you are fiddling with – this is the source of context-sensitive suggestions. JDEE gets the class information by doing reflection on a named class, in the beanshell. The beanshell is a name foe a JVM that runs as an inferior process inside emacs, and just waits for commands to run. Emacs sends it a "tell me about class java.lang.Integer" command, and the beanshell returns what it knows about that class- all its members and so on.

The CSDE still has all the beanshell crapola in it, all the –classpath nonsense and jar files and so on. The same idea for getting class information could work in .NET, but certainly not with a JVM. We're gonna need more than that.

So CSDE looks like a non-starter.

Csense

Finally there is CSense. As I commented elsewhere, it looks like the Csense project was thrown together in a couple afternoons by a passionate developer, then abandoned just as quickly. Csense actually has tools that go and build a database of information about classes from the various assemblies. This is really cool. But I could not get csense to apply that information to a code-completion request.

The Bottom Line

So the end result is that I cannot find code completion in emacs for C#. We have some tantalizing building blocks, but no real joy. The best results I have got so far is using dabbrev, which works on a text analysis of the buffer. Cedet looks good, but I cannot figure out how to build the database for system or third party assemblies. Csense builds a database for system assemblies, but I cannot figure out how to get it to use that data. CSDE seems to be a nice idea that was never really developed.

The right answer I think would require combining some magic from these various projects and developing them further. Combining the csense database-generation magic with the code-completion stuff in either CSDE or Semantic would do the trick. Or possibly just developing the CSDE a little further to have its own inferior process. Figuring out which of those paths to take? I will leave that for another day.

[ Update: I have continued to explore this, and actually produced a CsdeShell. For more on this, see my other posts on C# and emacs with this link. ]

I have a dream! C# Code Completion in Emacs (csense, dabbrev, etc)

DotNetInterop — Tue, 15 Apr 2008 23:39:00 GMT

No good options here.

I know, dabbrev does some neat things. But it pales in comparison to real code completion as you get in Visual Studio, or, I think, even SharpDevelop.

I checked out a module called csense that a lone developer hacked together last year. The goal of the project looked simple, focused, valuable: real code completion in Emacs for C# !!! Whoohoo!!!!! but

The implementation looks incomplete
There are no docs
I couldn't even figure out how to initially install it
nobody is using it; there were 33 downloads and I think I was about 8 of them.
I couldn't figure out how to configure it or what the various vars did, without wading in knee deep into elisp code.
after bumping around in the dark, I did get a popup to show a class definnition when I hovered on XmlReader, for example
But when I tried to get the code-completion to work, I consistently got the result that my editing buffer would just silently close. (I guess I didn't want to edit that file anyway.)
It appears to be, as someone else said, "abandonware"

So the search continues. Real code completion looks to be pretty hard to get, and not easy to implement.

I think the next thing I may do is check out CSDE.

Jeez I hope I don't start considering implementing this meself. That would be a disaster. Somebody stop me.

C# snippets for yasnippet.el (Emacs snippets)

DotNetInterop — Tue, 15 Apr 2008 20:00:00 GMT

Some nice person built yasnippet.el, a snippet package for emacs. You type 2 or 3 letters, then hit TAB, and it expands into a snippet. Like dabbrev, but with forms-based fill-in fields. It's quickie code generation. Sadly, no C# snippets are included.

Here's my contribution (attached). There's one for try..catch, foreach, for, using, while, class definition, property definition, singleton, and a couple others.

yasnippet worked like a charm for me. I did have to make a change in yasnippet.el:

(defvar yas/known-modes
 ; added csharp so it will show up in the menu!! 
  '(ruby-mode rst-mode csharp-mode)
  "A list of mode which is well known but not part of emacs.")

Also I built a tool to generate the snippet bundle:

;; CreateSnippetBundle.el
;;
;; Useful utility for creating / updating / maintaining snippets ..
;; Complements the yasnippet package. 
;;
;; Run this once, and it creates the bundle.el file. 
;; do not delete this file!
;;
;; Time-stamp: <Friday, April 11, 2008  19:04:17  (by dinoch)>
;;


(require 'yasnippet)
(yas/compile-bundle 
 ; the starting point
 "c:/users/dinoch/elisp/yasnippet.el"

 ; the bundle file to generate
 "c:/users/dinoch/elisp/yasnippet-bundle.el" 

 ; the snippet dir from which to generate the bundle
 "c:/users/dinoch/elisp/snippets")

Getting emacs flymake.el to work with C# modules

DotNetInterop — Tue, 15 Apr 2008 00:28:00 GMT

[I'm going to try to keep this up to date, because I periodically change tweak and improve flymake setup... Latest is 23 April 2008]

I Loooooooove Flymake. Emacs, since a while back, ships with a package called flymake.el, that defines a minor mode. When you enable this mode, flymake more-or-less continuously compiles the module you're working on, checking for syntax errors, and highlighting any that are found in your buffer. Pretty cool!

Bad news: Out of the box, flymake does not work with C# compiles on Windows. But, it's possible to get it to work. Here's what I added to my .emacs file to make it work for me.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; flymake minor mode - tweaks for csharp
;
; Flymake is built-in to emacs.  It  more-or-less continually compiles an
; active buffer when the minor mode is enabled. It also flags broken lines
; in the compile as you type.
;
; This is a set of tweaks of flymake for C# on Windows.
;
; last saved Time-stamp: <Wednesday, April 23, 2008  13:44:26  (by dinoch)>
;

(require 'flymake) 

(setq flymake-log-level 0)  ;; insure flymake errors get plopped into the *Messages* buffer

;; There are 2 common ways to build C# files: nmake or msbuild.
;; Here are examples for either. 
;;
;; For makefile, use nmake.  Configure this stanza to specify where your
;; nmake is.  Usually it is in the .NET 2.0 SDK directory, or the platform SDK
;; directory.
;;
;; If you use nmake, then you need a make target like this in your makefile:
;;
;; check-syntax:
;;      $(_CSC) /t:module $(CHK_SOURCES)
;;
;; (You could also put this in an alternatively named makefile,
;; like makefile.flymake. In this case you would also need to modify
;; the nmake command line (See below))
;;
;; If you use msbuild, and you are compiling projects that consist of a single
;; source file, you can use a standard (boilerplate) build project
;; file.  Call it msbuild.flymake.xml, and define it like this:
;;
;; <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"
;;         DefaultTargets="CompileAll"
;;         ToolsVersion="3.5"
;;       >
;;
;;  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
;;
;;  <!-- specify reference assemblies for all builds in this project -->
;;  <ItemGroup>
;;    <Reference Include="mscorlib" />
;;    <Reference Include="System" />
;;    <Reference Include="System.Core" />
;;    <Reference Include="System.Data" />
;;    <Reference Include="System.Data.Linq" />                   <!-- LINQ -->
;;    <!--Reference Include="System.ServiceModel" /-->           <!-- WCF -->
;;    <!--Reference Include="System.ServiceModel.Web" /-->       <!-- WCF -->
;;    <!--Reference Include="System.Runtime.Serialization" /-->  <!-- WCF -->
;;  </ItemGroup>
;;
;;  <Target Name="CheckSyntax"
;;          DependsOnTargets="ResolveAssemblyReferences"
;;        >
;;    <CSC 
;;       Sources="$(SourceFileToCheck)"
;;       References="@(ReferencePath)"
;;       TargetType="module"
;;       Toolpath="$(MSBuildToolsPath)"
;;       Nologo="true"
;;       />
;;  </Target>
;;
;; </Project>
;;
;; -ends-
;;
;; (This msbuild file works only with .NET 3.5.)
;;

;; If your projects consist of multiple source files, then you need to get fancier.
;; You need to compile all files, *except* for the original source file, the one
;; being edited currently. In this case, your msbuild.flymake.xml file should look
;; something like this: 

;; <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"
;;          DefaultTargets="CompileAll"
;;          ToolsVersion="3.5"
;;          >
;; 
;;   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
;; 
;;    <PropertyGroup>
;;       <Optimize>false</Optimize>
;;       <DebugSymbols>true</DebugSymbols>
;;       <!-- <OutputPath>.\bin\</OutputPath>  -->
;;       <OutputPath>.\</OutputPath>
;;       <OutDir>.\</OutDir>
;;       <IntermediateOutputPath>.\obj\</IntermediateOutputPath>
;;    </PropertyGroup>
;; 
;;   <!-- specify reference assemblies for all builds in this project -->
;;   <ItemGroup>
;;     <Reference Include="mscorlib" />
;;     <Reference Include="System" />
;;     <Reference Include="System.Core" />
;;     <Reference Include="System.Data" />
;;     <Reference Include="System.Data.Linq" />                   <!-- LINQ -->
;;     <!--Reference Include="System.ServiceModel" /-->           <!-- WCF -->
;;     <!--Reference Include="System.ServiceModel.Web" /-->       <!-- WCF -->
;;     <!--Reference Include="System.Runtime.Serialization" /-->  <!-- WCF -->
;;   </ItemGroup>
;; 
;;   <!-- This ItemGroup includes every .cs source file in the directory,           -->
;;   <!-- except for the one indicated by OriginalSourceFile.  In flymake, that     -->
;;   <!-- property indicates the currently edited file. So the result is that the   -->
;;   <!-- ItemGroup CSFile will include all files, including the _flymake.cs clone, -->
;;   <!-- but not including the original file.  Which is what we want.              -->
;;   <ItemGroup>
;;     <CSFile Include="*.cs" Exclude="$(OriginalSourceFile)" />
;;   </ItemGroup>
;; 
;;   <!-- Stuff the OriginalSourceFile property into an ItemGroup.                  -->
;;   <!-- We do this so we can get at the metadata, which I Think is available only -->
;;   <!-- through an item within an ItemGroup.  We want the root filename, which    -->
;;   <!-- we use to name the output netmodule.                                      -->
;;   <ItemGroup>
;;     <ExcludedCSFile Include="$(OriginalSourceFile)" />
;;   </ItemGroup>
;; 
;;   <Target Name="CheckSyntax"
;;           DependsOnTargets="ResolveAssemblyReferences"
;;           >
;;     <!-- Run the Visual C# compilation on the specified set of .cs files. -->
;;     <CSC 
;;        Sources="@(CSFile)"
;;        References="@(ReferencePath)"
;;        TargetType="module"
;;        Toolpath="$(MSBuildToolsPath)"
;;        OutputAssembly="%(ExcludedCSFile.Filename)_flymake.netmodule"
;;        Nologo="true"
;;        />
;;   </Target>
;; 
;; </Project>
;; 


;; These variables are ones I made up for help with C#:
(defvar dino-flymake-netsdk-location "c:\\netsdk2.0"
  "Location of .NET SDK, for finding nmake.exe.  The nmake is found in the bin subdir.  Example value is: c:\\Program Files\\Microsoft Visual Studio 8\\SDK\\v2.0 .")

(defvar dino-flymake-msbuild-location "c:\\.net3.5"
  "Directory containing MSBuild.exe.  Typically, c:\\windows\\Microsoft.NET\\Framework\\v3.5 .")

(defvar dino-flymake-csharp-msbuild-buildfile "msbuild.flymake.xml"
  "Build file if using MSBuild.exe.")

(defvar dino-flymake-csharp-nmake-buildfile "makefile"
  "Build file if using nmake.exe.")

(defvar dino-flymake-csharp-use-msbuild t
  "If t, then flymake uses msbuild.exe and the msbuild.flymake.xml
file.  If nil, then flymake uses nmake and the makefile with a
check-status target. Keep in mind the buildfile for either msbuild or nmake
is customizable.  See the vars dino-flymake-csharp-{nmake,msbuild}-buildfile .")

(defun dino-flymake-csharp-cleanup ()
  "Delete the temporary .netmodule file created in syntax checking,
then call through to flymake-simple-cleanup."
  (if flymake-temp-source-file-name
  (let* ((netmodule-name
          (concat (file-name-sans-extension flymake-temp-source-file-name)
                              ".netmodule"))
         (expanded-netmodule-name (expand-file-name netmodule-name "."))
         )
    (if (file-exists-p expanded-netmodule-name)
        (flymake-safe-delete-file expanded-netmodule-name)
      )
    )
  )
    (flymake-simple-cleanup)
    
  )



(defun dino-flymake-csharp-buildfile ()
  (if dino-flymake-csharp-use-msbuild
      dino-flymake-csharp-msbuild-buildfile
    dino-flymake-csharp-nmake-buildfile
    )
  )


(defun dino-flymake-find-csharp-buildfile (source-file-name)
  (let ((actual-build-file-name (dino-flymake-csharp-buildfile)))
    (if (file-exists-p (expand-file-name actual-build-file-name "."))
        "."
      (flymake-log 1 "no buildfile (%s) for %s" actual-build-file-name source-file-name)
      (flymake-report-fatal-status
       "NOMK" (format "No buildfile (%s) found for %s"
                      actual-build-file-name source-file-name))
      nil
      )

  )
  )


;(debug-on-entry 'flymake-create-temp-inplace)

(defun dino-flymake-csharp-init ()
  (dino-flymake-csharp-init-impl 'flymake-create-temp-inplace t t  'flymake-get-make-cmdline))


(defun dino-flymake-csharp-init-impl (create-temp-f use-relative-base-dir use-relative-source get-cmdline-f)
  "Create syntax check command line for a directly checked source file.
Use CREATE-TEMP-F for creating temp copy."
  (let* ((args nil)
         (source-file-name   buffer-file-name)
         (buildfile-dir      (dino-flymake-find-csharp-buildfile source-file-name)))
    (if buildfile-dir
        (let* ((temp-source-file-name  (flymake-init-create-temp-buffer-copy create-temp-f)))
          (setq args (flymake-get-syntax-check-program-args temp-source-file-name buildfile-dir
                                                            use-relative-base-dir use-relative-source
                                                            get-cmdline-f))))
    args))

;(debug-on-entry 'dino-flymake-csharp-init)



; This fixup sets flymake to use a different cleanup routine for c# compiles
(defun dino-fixup-flymake-for-csharp ()
  (let (elt 
        (csharp-entry nil)
        (masks flymake-allowed-file-name-masks)
        )

    ;; The "flymake-allowed-file-name-masks" variable stores a filename pattern as
    ;; well as the make-init function, and a cleanup function.  In the case of csharp,
    ;; the setting in flymake.el has the cleanup fn as nil, which means it gets the
    ;; standard cleanup : the *_flymake.cs cloned source file gets deleted.  But the
    ;; way I have done the syntax checking, I compile the .cs file into a module,
    ;; which needs to be deleted afterwards.
    ;;
    
    ;; Here, we remove the C# entry in the "flymake-allowed-file-name-masks"
    ;; variable, and replace it with an entry that includes a custom csharp cleanup
    ;; routine.  In that cleanup routine, I delete the .netmodule file.

    ;; I could just setq the "flymake-allowed-file-name-masks" var to the C# thing I
    ;; want, but that would obliterate all the masks for all other languages, which
    ;; would be bad manners.

    ;; You know, come to think of it, I could just delete the generated .netmodule
    ;; file in the msbuild or makefile.  That might be simpler.

    ;; But the main point is this ought to be more easily configurable or customizable
    ;; in flymake.el.  And also, flymake ought to do something reasonable for csharp builds,
    ;; rather than completely punt.
    
    ;; This fixup is really hacky, relying on the string that is used for csharp in
    ;; flymake.el.  But it will do for now...

    ;; Find the entry
    (while (consp masks)
      (setq elt (car masks))
      (if (string= "\\.cs\\'" (car elt))
          (setq csharp-entry elt)
        )
      (setq masks (cdr masks))
      )
    
    ;;  remove the original one ...
    (if csharp-entry
        (setq flymake-allowed-file-name-masks
              (delete csharp-entry flymake-allowed-file-name-masks)))

    ;; Now add a new one, with the custom cleanup method.
    (setq flymake-allowed-file-name-masks
          (cons 
           '("\\.cs\\'" dino-flymake-csharp-init dino-flymake-csharp-cleanup)
           flymake-allowed-file-name-masks))
    )
  )

; need to do this only once, not every time csharp-mode is invoked
(dino-fixup-flymake-for-csharp) 


; This method re-defines the defun shipped in flymake, for csharp.  Re-defining
; this function *will* definitely break flymake for all other languages.  One
; way to fix that problem is to make the "get-make-cmdline" function a
; configurable hook within flymake!  

(defun flymake-get-make-cmdline (source base-dir)
  (if dino-flymake-csharp-use-msbuild
      (list (concat  dino-flymake-msbuild-location "\\msbuild.exe")
            (list (concat base-dir "/" (dino-flymake-csharp-buildfile))
                  "/nologo"
                  "/t:CheckSyntax"
                  "/v:quiet"  ;; normal
                  ;; use file-relative-name to remove the fully-qualified directory name 
                  (concat "/property:SourceFileToCheck=" (file-relative-name source))
                  (concat "/property:OriginalSourceFile=" (file-relative-name buffer-file-name))
                  ))
    
    (list (concat  dino-flymake-netsdk-location "\\bin\\nmake.exe")
        (list "/f"
              (concat base-dir "/" (dino-flymake-csharp-buildfile))
              (concat "CHK_SOURCES=" source)
              "SYNTAX_CHECK_MODE=1"
              "check-syntax"))

    )
  )

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(provide 'flymake-for-csharp)

;;; end of flymake-for-csharp.el

I think there are probably still some problems with this. For example, there's no direct support for projects, so for a module that refers to a class in another source file, you're gonna have to fiddle with the msbuild file to get the references right. But as a first attempt, it's basically working.

I do love flymake, it is very handy. But just to repeat my previous statement about it:

Flymake is at least 5 years old, but it still seems to be a bit rough. There's no doc in the el file. It doesn't respect the "compile-command" variable of compile.el, instead hard-coding make. There are a bunch of other missed opportunities for customization in flymake, too. There's no doc for how to specify a different check-syntax build. There's no doc for how to do a better cleanup - so I have temporary output files hanging around. Why isn't flymake-allowed-file-name-masks an alist? Basically flymake is bad manners all around. But it's mostly working now, and it seems very handy.

Dino's .emacs file

DotNetInterop — Mon, 14 Apr 2008 21:13:00 GMT

[I'm going to try to keep this up to date, because I periodically change tweak and improve flymake setup... Latest is 15 April 2008]

This includes all my setup for C# development, including yasnippet, hideshow, flymake, htmlize, defaultcontent, timestamp, csharp-mode, and so on. The flymake is pulled out, you can find it here.

;; 
;; Dino's .emacs setup file.  
;; Time-stamp: <Tuesday, April 15, 2008  17:59:13  (by dinoch)>
;;
;; Works with v22.2 of emacs. 
;;
;; total re-organization April 2008.
;; use byte-compile-file to compile this file into emacs.elc.
;;


;;
(message "Running emacs.el...")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; directory to load additional libraries from :
; This dir contains:
;  yasnippet.el defaultcontent.el, csharp-mode.el,
;  powershell-mode.el, powershell.el, htmlize.el
;  javascript.el 

(setq load-path
      (append '("c:/users/dinoch/elisp")  load-path ))

; csense is junk
;(setq load-path
;      (append '("c:/users/dinoch/elisp/csense")  load-path ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Global settings
;
(global-set-key "\C-xw" 'dino-fixup-linefeeds)
(global-set-key "\C-c1" 'just-one-space)
(global-set-key "\C-cw" 'where-is)
(global-set-key "\M-\C-^"   'describe-variable)
(global-set-key "\C-^"      'describe-key-briefly)
(global-set-key "\C-xd"     'delete-window)
(global-set-key "\C-x\C-d"  'delete-window)
(global-set-key "\C-x\C-r"  'dino-resize-big)
(global-set-key "\C-xx"     'copy-to-register)
(global-set-key "\C-xg"     'insert-register)
(global-set-key "\C-xp"     'previous-window)
(global-set-key "\C-x\C-p"  'previous-window)
(global-set-key "\C-xn"     'other-window)
(global-set-key "\C-x\C-e"  'compile)
(global-set-key "\C-x\C-g"  'auto-fill-mode)
(global-set-key "\C-x\C-n"  'next-error)
(global-set-key "\C-xt"     'toggle-truncation)
(global-set-key "\M-\C-y"   'yank-pop)
(global-set-key "\M-g"      'goto-line)
(global-set-key "\M- "      'set-mark-command)
(global-set-key "\M-\C-h"   'backward-kill-word)
(global-set-key "\C-c\C-c"  'center-paragraph)  ; good for text mode
(global-set-key "\C-ck"     'global-set-key)
(global-set-key "\C-cs"     'search-forward-regexp)

(global-set-key "\C-cq"     'query-replace)
(global-set-key "\C-cc"     'goto-char)
(global-set-key "\C-cr"     'replace-regexp)
(global-set-key "\C-ct"     'dino-insert-timeofday)
(global-set-key "\C-c\C-t"  'dino-insert-timestamp)
(global-set-key "\C-cw"     'where-is)
(global-set-key "\C-c\C-w"  'compare-windows)
(global-set-key "\C-c!"     'revert-buffer-unconditionally)


;;the help key is assigned to Ctrl-\, or Esc-Ctrl-\
(global-set-key "\M-\C-\\"   'help-for-help)
(global-set-key "\C-\\"      'help-for-help)


; handle text end-of-line conventions the way it oughta be: 
(setq inhibit-eol-conversion nil)

; turn on font-lock globally
(global-font-lock-mode 1  'ON)

(setq-default fill-column 72)
(setq auto-save-interval 500)
(setq case-fold-search nil)

; helpful for debugging lisp code:
(setq messages-buffer-max-lines 2500)

;; for fontification in emacs progmodes:
(load "font-lock")
(setq font-lock-maximum-decoration t)

(setq completion-auto-help nil)

(put 'eval-expression 'disabled nil)

; set truncation on side-by-side windows to nil.
(setq truncate-partial-width-windows nil)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

                

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Frames preferences: initial and default frames
;; see http://www.gnu.org/software/emacs/windows/big.html#windows-frames
(setq default-frame-alist
      '(
        (top . 10) (left . 860)
        (width . 100) (height . 28)
        (cursor-color . "Blue")
        (cursor-type . box)
                (foreground-color . "Black")
        (background-color . "White")
                (mouse-color . "sienna3")
        (font . "-*-Lucida Console-normal-r-*-*-11-82-96-96-c-*-iso8859-1")
        )
      )

; initial frame is 128 wide x 72 high
(setq initial-frame-alist '(
                            (top . 40) (left . 10)
                            (width . 128) (height . 68)
                            )
      )



;; what should a frame look like
(setq frame-title-format '("%f [mode: %m]" )    ; "filename [mode]" in title bar
      icon-title-format '("emacs: %b"))   ; "emacs: buffername" in icon

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; adjustment to mode mappings
;
; In the regexp's, the trailing \\' represents "end of string".
; The $ represents the zero-width place before newline.
; They are equivalent unless there is a filename with a new line in it.
; 
(setq auto-mode-alist
      (append '(
                ("\\.\\(war\\|ear\\|WAR\\|EAR\\)\\'" . archive-mode)        ; java archives
                ("\\.s?html?\\'"                     . html-helper-mode)
                ("\\.asp$"                           . html-helper-mode)
                ("\\.aspx$"                          . html-helper-mode)
                ("\\.html$"                          . html-helper-mode)
                ("\\.htm$"                           . html-helper-mode)
                ("\\.md$"                            . emacs-lisp-mode)     ; what the hell is an .md file?
                ("\\.el$"                            . emacs-lisp-mode)
                ("\\.js\\'"                          . javascript-mode)
                ("\\.txt$"                           . text-mode)
                ("\\.asmx$"                          . csharp-mode)          ; maybe, could be any language tho
                ) auto-mode-alist ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; htmlize

(require 'htmlize)
(setq htmlize-output-type 'inline-css)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; yasnippet

;; grabbed 2008 april 11
;; see http://code.google.com/p/yasnippet/downloads/list

; you need to create a new yasnippet-bundle.el each time you add
; new snippets! see yasnippet-CreateBundle.el for the tool.

(require 'yasnippet-bundle)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; defaultcontent
;;
;; This package inserts "default content" into a new  file of a given
;; type, when it is first edited in emacs.
;; See the elisp/defaultcontent directory for templates.
;;

(require 'defaultcontent)

;; specify the directory to look in for templates
(setq dc-auto-insert-directory "c:/users/dinoch/elisp/defaultcontent/")
(setq dc-fast-variable-handling t)

;; specify the template to use for .cs files:
(add-to-list 'dc-auto-insert-alist '("\\.cs$" . "template.cs" ))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; configure external utilities

(setq archive-zip-use-pkzip nil)   ;i.e. use unzip instead
(setq archive-zip-extract '("unzip" "-"))

(setq-default compile-command "nmake")

(setq-default grep-command "grep -i ")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; timestamp 
;
; put this in a file in the first N lines to get an auto-updated timestamp: 
;  Time-stamp: <>
;

(setq 
  time-stamp-active t          ; do enable time-stamps
  time-stamp-line-limit 24     ; check first N buffer lines for Time-stamp: <>
  time-stamp-format "%:a, %:b %02d, %04y  %02H:%02M:%02S %Z (by %u)") ; date format

(add-hook 'before-save-hook 'time-stamp)  ; update time stamps when saving

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Text mode

(add-hook 'text-mode-hook '(lambda () (auto-fill-mode 1)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; flymake-for-csharp
;
; tweaks to flymake.el for csharp.
;

(require 'flymake-for-csharp)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;; (require 'csense-cs-frontend)
;; (setq csense-cs-source-files (csense-get-files-recursive "." ".+\\.cs$"))
;; (setq csense-cs-assembly-parser-program "c:\\users\\dinoch\\elisp\\csense\\netsense.exe")

;; (setq csense-cs-assemblies '("c:\\.net2.0\\System.dll" "c:\\.net2.0\\System.XML.dll" "c:\\.net2.0\\System.Data.dll"))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; csharp mode 
;

;; csharp mode was originally from Brad Merrill, bmerrill@microsoft.com
;; but then Dennis Haney (I think) <davh@davh.dk> updated it. 
;; http://davh.dk/script/ 
;;
;; I then found what I think is a later version? better integrated with cc-modes.?
;; maintained by Dylan Moonfire. Most recently updated September 2007.
;; http://mfgames.com/linux/csharp-mode
;;

(require 'csharp-mode)

(require 'hideshow)  ; builtin to emacs


;(autoload 'csharp-mode "csharp-mode" "Major mode for editing C# code." t)
(c-add-style "C#"
 '("Java"
   (c-basic-offset . 2)
   (c-comment-only-line-offset . (0 . 0))
   (c-offsets-alist 
    . (
       (access-label . -)
       (arglist-close . c-lineup-arglist)
       (arglist-cont . 0)
       (arglist-cont-nonempty . c-lineup-arglist)
       (arglist-intro . c-lineup-arglist-intro-after-paren)
       (block-close . 0)
       (block-open . 0)
       (brace-entry-open . 0)
       (brace-list-close . 0)
       (brace-list-entry . 0)
       (brace-list-intro . +)
       (brace-list-open . +)
       (c . c-lineup-C-comments)
       (case-label . 0)
       (catch-clause . 0)
       (class-close . 0)
       (class-open . 0)
       (comment-intro . c-lineup-comment)
       (cpp-macro . 0)
       (cpp-macro-cont . c-lineup-dont-change)
       (defun-block-intro . +)
       (defun-close . 0)
       (defun-open . 0)
       (do-while-closure . 0)
       (else-clause . 0)
       (extern-lang-close . 0)
       (extern-lang-open . 0)
       (friend . 0)
       (func-decl-cont . +)
       (inclass . +)
       (inexpr-class . +)
       (inexpr-statement . 0)
       (inextern-lang . +)
       (inher-cont . c-lineup-multi-inher)
       (inher-intro . +)
       (inlambda . c-lineup-inexpr-block)
       (inline-close . 0)
       (inline-open . 0)
       (innamespace . +)
       (knr-argdecl . 0)
       (knr-argdecl-intro . 5)
       (label . 0)
       (lambda-intro-cont . +)
       (member-init-cont . c-lineup-multi-inher)
       (member-init-intro . +)
       (namespace-close . 0)
       (namespace-open . 0)
       (objc-method-args-cont . c-lineup-ObjC-method-args)
       (objc-method-call-cont . c-lineup-ObjC-method-call)
       (objc-method-intro . [0])
       (statement . 0)
       (statement-block-intro . +)
       (statement-case-intro . +)
       (statement-case-open . +)
       (statement-cont . +)
       (stream-op . c-lineup-streamop)
       (string . c-lineup-dont-change)
       (substatement . +)
       (substatement-open . 0)
       (template-args-cont c-lineup-template-args +)
       (topmost-intro . 0)
       (topmost-intro-cont . 0)
       ))
   ))


(c-add-style "myC#Style"
  '("C#"  ; this must be defined elsewhere 
  (c-basic-offset . 2)
  (c-echo-syntactic-information-p . t)
  (c-comment-only-line-offset . (0 . 0))
  (c-offsets-alist . (
    (c                     . c-lineup-C-comments)
    (namespace-open        . 0)
    (namespace-close       . 0)
    (innamespace           . +)
    (class-open            . 0)
    (class-close           . 0)
    (inclass               . +)
    (block-open            . -)    ; eg, open a block under a function name or if stmt;
                                   ; want this to be flush with prev line. 
    (arglist-cont          . +)
    (substatement-open     . 0)  ; I think this is for a try {} or if{} or etc. why this is not block open, I don't know!
    (defun-open            . 0)  ; method defn? (but no!)
    (defun-block-intro     . +)  ;0 ; block within a function????
    (inline-open           . 0)  ; eg, opening a function? ??
    (statement-block-intro . +)  ; unknown what this is
    (brace-list-open       . 0)  ; list open (like an enum, array initializer)
    (brace-list-intro      . +)  ; first item in the list 
    (brace-list-entry      . 0)  ; subsequent items in the list 
    (brace-list-close      . 0)  ; list close
    (statement-cont        . (dinoch-csharp-lineup-string-cont +))  ; align long strings
    ))
  ))



; this aligns long strings broken across multiple lines.
; need   (statement-cont . (dinoch-csharp-lineup-string-cont +)) in the styles list
(defun dinoch-csharp-lineup-string-cont (langelem)
  "Like `c-lineup-string-cont' but works with csharp string continuations."
  (save-excursion
    (back-to-indentation)
    (and (looking-at "@?\\s\"")
         (let ((quote (if (equal (char-after) ?@)
                          (char-after (1+ (point)))
                        (char-after)))
               pos)
           (while (and (progn (c-backward-syntactic-ws)
                              (when (eq (char-before) ?+)
                                (backward-char)
                                (c-backward-syntactic-ws))
                              (eq (char-before) quote))
                       (c-safe (c-backward-sexp) t)
                       ;; uncomment this to lineup under the @
                       ;;(progn (if (eq (char-before) ?@) (backward-char)) t)
                       (/= (setq pos (point)) (c-point 'boi))))
           (when pos
             (goto-char pos)
             (vector (current-column)))))))



;(debug-on-entry 'hs-hide-level-recursive)


;; for hideshow.el
(defun csharp-hs-forward-sexp (&optional arg)

"I set hs-forward-sexp-func to this function.

I found this customization necessary to do the hide/show magic in C#
code, when dealing with region/endregion. This routine
goes forward one s-expression, whether it is defined by curly braces
or region/endregion. It handles nesting, too.

The forward-sexp method takes an arg which can be negative, which
indicates the move should be backward.  Therefore, to be fully
correct this function should also handle a negative arg. However,
the hideshow.el package never uses negative args to its
hs-forward-sexp-func, so it doesn't matter that this function does not
do negative numbers.

The arg can also be greater than 1, which means go forward
multiple times. This function doesn't handle that EITHER.  But
again, I haven't see that as a problem."

  (let ((nestlevel 0)
        (mark1 (point))
        (done nil)
        )

    ;(show-match-data)
    
    (if (and arg (< arg 0))
        ;; a negative argument; we want to back up!
        (message "negative arg (%d) is not supported..." arg)

      ;; else, we have a positive argument, hence move forward.
      ;; simple case is just move forward one brace
      (if (looking-at "{")
          (and
           (forward-sexp arg)
           )
        
        ; The more complex case is dealing with a "region/endregion" block.
        ; We have to deal with nested regions!
        (and
         (while (not done)
           (re-search-forward "^[ \\t]*#[ \\t]*\\(region\\|endregion\\)\\b"
                              (point-max) 'move)
           (cond
            
            ((eobp))                            ; do nothing if at end of buffer
            
            ((and
              (match-beginning 1)

              ;; if the match is longer than 6 chars, we know it is "endregion"
              (if (> (- (match-end 1) (match-beginning 1)) 6)
                   (setq nestlevel (1- nestlevel))
                 (setq nestlevel (1+ nestlevel))
                )
              )))

           (setq done (not (and (> nestlevel 0) (not (eobp)))))
           
           ) ; while
                        
         (if (= nest 0)
             (goto-char (match-end 2)))

         )
        )
      )
    )
  )

;; more for hideshow.el
(unless (assoc 'csharp-mode hs-special-modes-alist)
          (push '(csharp-mode
                  ; "\\(^\\s*#\\s*region\\b\\)\\|{"      ; regexp for start block
                  "\\(^[ \\t]*#[ \\t]*region\\b\\)\\|{"  ; regexp for start block
                  
                  ; "\\(^\\s*#\\s*endregion\\b\\)\\|}"   ; regexp for end block
                  "\\(^[ \\t]*#[ \\t]*endregion\\b\\)\\|}"   ; regexp for end block
                  
                  "/[*/]"                                ; regexp for comment start
                  
                  csharp-hs-forward-sexp                 ; hs-forward-sexp-func
                  hs-c-like-adjust-block-beginning       ;c-like adjust (1 char)
                  ;csharp-hs-adjust-block-beginning      ;csharp adjust ?
                  )
                hs-special-modes-alist))



(defun dino-csharp-mode-fn ()
  (cond (window-system
         (turn-on-font-lock)
         (c-set-style "myC#Style")
         (local-set-key "\M-\C-R"  'indent-region)
         (local-set-key "\M-#"     'dino-indent-buffer)
         (local-set-key "\M-s"     'dino-insert-csharp-gettersetter)
         (local-set-key "\C-cp"    'dino-convert-csharp-field-to-property)
         (local-set-key "\C-c\C-p" 'dino-convert-csharp-field-to-property)

         ; for skeleton stuff?  do I need this now?
         ;(make-local-variable skeleton-pair)
         (setq skeleton-pair t)
         (local-set-key (kbd "(") 'skeleton-pair-insert-maybe)
         (local-set-key (kbd "[") 'skeleton-pair-insert-maybe)
         (local-set-key (kbd "{") 'skeleton-pair-insert-maybe)
         (local-set-key (kbd "\"") 'skeleton-pair-insert-maybe)
         
         ;; for snippets support:
         (yas/minor-mode-on)
         
         ;; for flymake support:
         (flymake-mode)
         
         ; for hide/show support
         (hs-minor-mode 1)
         (setq hs-isearch-open t)

         ; with point inside the block, use these keys to hide/show
         (local-set-key "\C-c>"  'hs-hide-block)
         (local-set-key "\C-c<"  'hs-show-block)

         ; autorevert.el is built-in to emacs; if files
         ; are changed outside of emacs, the buffer auto-reverts.
         (turn-on-auto-revert-mode)
         
         )))

(add-hook 'csharp-mode-hook 'dino-csharp-mode-fn)


;; to allow next-error to work with csc.exe: 
(setq compilation-scroll-output t)
(setq-default compilation-error-regexp-alist
;       (append 
 '(
 ; Microsoft VJC??:
 ;sample.java(6,1) : error J0020: Expected 'class' or 'interface'
 ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)[,]\\([0-9]+\\)): \\(error\\|warning\\) VJS[0-9]+:" 1 3 4)

 ;; dinoch - Wed, 04 Aug 2004  09:29
 ;; handle whitespace at beginning of line (for nant output)
 ;; 
 ;C# Compiler
 ;t.cs(6,18): error SC1006: Name of constructor must match name of class
 ;
 ("[ \t]*\\(\\([_a-zA-Z:\]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)[,]\\([0-9]+\\)): \\(error\\|warning\\) CS[0-9]+:" 1 3 4)

 ; Microsoft C/C++:
 ;  keyboard.c(537) : warning C4005: 'min' : macro redefinition
 ;  d:\tmp\test.c(23) : error C2143: syntax error : missing ';' before 'if'
 ;VC EEi
 ;e:\projects\myce40\tok.h(85) : error C2236: unexpected 'class' '$S1'
 ;myc.cpp(14) : error C3149: 'class System::String' : illegal use of managed type 'String'; did you forget a '*'?
    ("\\(\\([a-zA-Z]:\\)?[^:(\t\n]+\\)(\\([0-9]+\\)) \
: \\(error\\|warning\\) C[0-9]+:" 1 3)
 )
;  compilation-error-regexp-alist)
)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; XML mode
;;

(add-hook 'sgml-mode-hook (lambda () (turn-on-auto-revert-mode)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; elisp mode
;;

(defun dino-elisp-mode-fn ()
  (local-set-key "\r"        'newline-and-indent)
  (local-set-key "\C-c\C-c"  'comment-region)
  (local-set-key "\M-\C-R"   'indent-region)
  (local-set-key "\C-ce"     'eval-buffer)
  (local-set-key "\C-c\C-e"  'eval-region)
  (local-set-key "\C-x\C-e"  'byte-compile-file)
  )
(add-hook 'emacs-lisp-mode-hook 'dino-elisp-mode-fn)

; This is for scratch buffer
(add-hook 'lisp-interaction-mode-hook 'dino-elisp-mode-fn)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; JavaScript

(autoload 'javascript-mode "javascript" nil t)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


   


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Java

(defun dino-java-mode-hook ()
  (c-set-style "myJavaStyle")
  (font-lock-mode)
  (local-set-key "\M-\C-R" 'indent-region)
)
(setq java-mode-hook 'dino-java-mode-hook)


(c-add-style "myJavaStyle"
  '("Java"  ; this must be defined elsewhere - it is in cc-modes.el
  (c-basic-offset . 2)
  (c-echo-syntactic-information-p . t)
  (c-comment-only-line-offset . (0 . 0))
  (c-offsets-alist . (
    (c                     . c-lineup-C-comments)
    (statement-case-open   . 0)
    (case-label            . +)
    (substatement-open     . 0)  
    ))
  ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; C Programming language
(defun dino-c-mode-hook ()
  (c-set-style "myCStyle")
  ;for re-tabbing an entire region of code: 
  (local-set-key "\M-\C-R" 'indent-region)

  ; don't think I still need this!
  ;(set-backspace-keys-conditionally)

  ; turn off the c-indent-region thing; I don't like the indents it gives me! 
  ; by using nil here, I get indent-according-to-mode, which is what works for me. 
  (setq indent-region-function nil)

  (setq c-auto-newline nil)

  ;two comment procedures (see above)
;  (local-set-key "\M-/" 'dino-start-c-comment)
;  (local-set-key "\M-?" 'dino-end-c-comment)  
)
(setq c-mode-hook 'dino-c-mode-hook)


(c-add-style "myCStyle"
  '("bsd"  ; this must be defined elsewhere - it is in cc-modes.el
  (c-basic-offset . 2)
  (c-echo-syntactic-information-p . t)
  (c-comment-only-line-offset . (0 . 0))
  (c-offsets-alist . (
    (c                     . c-lineup-C-comments)
    (statement-case-open   . 0)
    (case-label            . +)
    (substatement-open     . 0)  
    ))
  ))


(fset 'dino-start-c-comment   "/* ")

(fset 'dino-end-c-comment   " */")

(fset 'dino-end-block-comment
   [escape ?\C-b escape ?  ?\C-a ?\C-w ?\C-y escape ?\C-f ?  ?/ ?/ ?  ?\C-y ?\C-x ?\C-x ?\C-c ?1])

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; perl mode
;
(defalias 'perl-mode 'cperl-mode)
(autoload 'perl-mode "c:/emacs/lisp/progmodes/cperl-mode" "" t)
;(autoload 'perl-mode "c:/emacs/lisp/progmodes/perl-mode" "" t)



;(setq                                       
; cperl-comment-column   44)                 ; must these be set globally?

(defconst my-cperl-style
  '( ("MyPerl"
     (cperl-indent-level               .  0)
     (cperl-brace-offset               .  2)
     (cperl-continued-statement-offset .  2)
     (cperl-continued-brace-offset     . -2)
     (cperl-label-offset               . -2)
     (cperl-close-paren-offset         . -1))))



(defun cperl-mode-hook-fn ()
  "My hook for perl"
  (set-variable 'c-indent-level 0)      ; required for c-outline
  (turn-on-font-lock)
  )

(add-hook 'cperl-mode-hook 'cperl-mode-hook-fn) 

(make-local-variable 'cperl-style-alist)
(setq cperl-style-alist 'my-cperl-style)

(add-to-list 'auto-mode-alist '("\\.\\([pP][Llm]\\|al\\)\\'" . cperl-mode))
(add-to-list 'interpreter-mode-alist '("perl" . cperl-mode))
(add-to-list 'interpreter-mode-alist '("perl5" . cperl-mode))
(add-to-list 'interpreter-mode-alist '("miniperl" . cperl-mode))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Powershell

(autoload 'powershell-mode "powershell-mode"   
  "Major mode for editing powershell code." t)
(setq auto-mode-alist (cons '( "\\.ps1\\'" . powershell-mode ) auto-mode-alist ))

(autoload 'powershell "powershell"   
  "Run powershell as a shell within emacs." t)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;








;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; handy utility functions for various purposes
;

; when copying binary files into a clipboard buffer
(fset 'dinoch-b64-copy
   [escape ?  escape ?> escape ?x ?b ?a ?s ?e ?6 ?4 ?- ?e ?n ?c tab return ?\C-w ?\C-y])

; when pasting the base64 stuff from binary files 
(fset 'dinoch-b64-paste
   [escape ?x ?r backspace ?e ?r ?a ?s ?e ?- ?b ?u tab return ?\C-y escape ?x ?b ?a ?s ?e ?6 ?4 ?- ?d ?e ?c ?o tab return ?\C-x ?\C-s])


(defun dino-fixup-linefeeds ()
  "Dino's function to replace the CR-LF of a DOS ASCII file to a LF for Unix." 
  (interactive)
  (save-excursion
  (while (search-forward "

" nil t)
    (replace-match "
" nil t))
  )
)


(defun dino-indent-buffer ()
  "Dino's function to re-indent an entire buffer; helpful in progmodes like XML mode or csharp mode."
  (interactive)
  (indent-region (point-min) (point-max))
)


; put an href around the url at point. 
(fset 'dino-href-url
   [?< ?  backspace ?a ?  ?h ?r ?e ?f ?= ?\" ?\C-s ?  ?\C-b ?\" ?> ?\C-r ?/ ?\C-f escape ?  ?\C-s ?\" ?\C-b ?\C-w ?\C-y ?\C-f ?\C-f ?\C-y ?< ?/ ?a ?> ?< ?b ?r ?> return])


(defun revert-buffer-unconditionally ()
  "revert the current buffer unconditionally,"
  (interactive)
  (revert-buffer t t)
  )

(defun dino-resize-big ()
  "quick resize to 128x72"
  (interactive)
  (set-frame-height (selected-frame) 72)
  (set-frame-width (selected-frame) 128)
)

(defun dino-toggle-truncation ()
  "Joe's function to toggle the state of the truncate-lines variable"
  (interactive)
  (setq truncate-lines (not truncate-lines))
  (redraw-display)
  )

(defun dino-remove-trailing-whitespace () 
"For each line in region, Convert multiple spaces at end of line to just one." 
  (interactive)
  (let ((beg (point-min))
        (end (point-max)))
  (save-excursion
    (goto-char beg)
    (while (and (< (point) end)
                (re-search-forward " +$" end t))
      (just-one-space)
      (backward-delete-char-untabify 1)
      )
)))


(defun dino-insert-timestamp ()
  "function to insert timestamp at point. format: DayOfWeek, Date Month Year   24hrTime"
  (interactive)
  (let (localstring mytime)
    (setq localstring (current-time-string))
    (setq mytime (concat "....dinoch...."
                         (substring localstring 0 3)  ;day-of-week
                         ", " 
                         (substring localstring 8 10) ;day number
                         " "
                         (substring localstring 4 7)  ;month 
                         " "
                         (substring localstring 20 24 ) ;4-digit year
                         "...."
                         (substring localstring 11 16 ) ;24-hr time
                         "....\n"
                         ))
    (insert mytime))
) 



(defun dino-insert-timeofday ()
  "function to insert time of day at point . format: DayOfWeek, Date Month Year   24hrTime"
  (interactive)
  (let (localstring mytime)
    (setq localstring (current-time-string))
; example:
; Mon, 17 Jun 96  12:52
    (setq mytime (concat (substring localstring 0 3)  ;day-of-week
                         ", " 
                         (substring localstring 8 10) ;day number
                         " "
                         (substring localstring 4 7)  ;month 
                         " "
                         (substring localstring 20 24 ) ;4-digit year
                         "  "
                         (substring localstring 11 16 ) ;24-hr time
                         "\n"
                         ))
    (insert mytime))
) 


; The following function (scarfed off an emacs bboard) will allow you to
; see what emacs is seeing when you press any key.  
(defun dino-see-chars ()
  "Displays characters typed, terminated by a 3-second timeout."
  (interactive)
  (let ((chars "")
        (inhibit-quit t))
    (message "Enter characters, terminated by 3-second timeout.")
    (while (not (sit-for 3))
      (setq chars (concat chars (list (read-char)))
            quit-flag nil))         ; quit-flag maybe set by C-g
    (message "Characters entered: %s" (key-description chars))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(message "Done with emacs.el...")

Making Hideshow.el work with Csharp-mode.el and region/endregion

DotNetInterop — Mon, 14 Apr 2008 20:27:00 GMT

The default hideshow.el stuff in emacs doesn't "do" region/endregion, which is commonly seen in C# modules. Thankfully, the hideshow people thought of this, and made available a customization hook, where you can specify how to navigate blocks within the buffer. It is hs-forward-sexp-func, and you can customize it for any mode. I wrote one to deal with C#.

(defun csharp-hs-forward-sexp (&optional arg)

  "I set hs-forward-sexp-func to this function.

I found this customization necessary to do the hide/show magic in C#
code, when dealing with region/endregion. This routine
goes forward one s-expression, whether it is defined by curly braces
or region/endregion. It handles nesting, too.

The forward-sexp method takes an arg which can be negative, which
indicates the move should be backward.  Therefore, to be fully
correct this function should also handle a negative arg. However,
the hideshow.el package never uses negative args to its
hs-forward-sexp-func, so it doesn't matter that this function does not
do negative numbers.

The arg can also be greater than 1, which means go forward
multiple times. This function doesn't handle that EITHER.  But
again, I haven't see that as a problem."

  (message "csharp-hs-forward-sexp, (arg %d) (point %d)..."
           (if (numberp arg) arg -1)
           (point))
  
  (let ((nestlevel 0)
        (mark1 (point))
        (done nil)
        )
    
    (if (and arg (< arg 0))
        (message "negative arg (%d) is not supported..." arg)

      ;; else, we have a positive argument, hence move forward.
      ;; simple case is just move forward one brace
      (if (looking-at "{")
          (forward-sexp arg)
        
        ; The more complex case is dealing with a "region/endregion" block.
        ; We have to deal with nested regions!
        (and
         (while (not done)
           (re-search-forward "^[ \\t]*#[ \\t]*\\(region\\|endregion\\)\\b"
                              (point-max) 'move)
           (cond
            
            ((eobp))                    ; do nothing if at end of buffer
            
            ((and
              (match-beginning 1)
              ;; if the match is longer than 6 chars, we know it is "endregion"
              (if (> (- (match-end 1) (match-beginning 1)) 6)
                  (setq nestlevel (1- nestlevel))
                (setq nestlevel (1+ nestlevel))
                )
              )))

           (setq done (not (and (> nestlevel 0) (not (eobp)))))
           
           )                            ; while
                        
         (if (= nest 0)
             (goto-char (match-end 2)))

         )
        )
      )
    )
  )


(unless (assoc 'csharp-mode hs-special-modes-alist)
          (push '(csharp-mode
                  ; "\\(^\\s*#\\s*region\\b\\)\\|{"      ; regexp for start block DID NOT WORK
                  "\\(^[ \\t]*#[ \\t]*region\\b\\)\\|{"  ; regexp for start block
                  
                  ; "\\(^\\s*#\\s*endregion\\b\\)\\|}"   ; regexp for end block NO WORKY!
                  "\\(^[ \\t]*#[ \\t]*endregion\\b\\)\\|}"   ; regexp for end block
                  
                  "/[*/]"                                ; regexp for comment start
                  
                  csharp-hs-forward-sexp                 ; hs-forward-sexp-func
                  hs-c-like-adjust-block-beginning       ;c-like adjust (1 char)
                  ;csharp-hs-adjust-block-beginning      ;csharp adjust ?
                  )
                hs-special-modes-alist))


;;
;; To use this, put this into your csharp-mode-hook:
;;
;;       ; for hide/show support
;;       (hs-minor-mode 1)
;;       (setq hs-isearch-open t)
;; 
;;       ; with point inside the block, use these keys to hide/show
;;       (local-set-key "\C-c>"  'hs-hide-block)
;;       (local-set-key "\C-c<"  'hs-show-block)

If you use emacs to code C#, maybe this is useful to you. It is attached here, too.

Emacs is better than Visual Studio as a C# Development Tool?!!

DotNetInterop — Sun, 13 Apr 2008 07:15:00 GMT

I recently spent some time fiddling with my setup of emacs on Windows. I use emacs for lots of stuff; just now I optimized my setup for development of C# apps.

I knew of the JDEE, which has been around for a long time. JDEE is the Java Development Environment for Emacs; it used to go by the moniker of JDE. It has code completion (aka "intellisense"), compiling tools (ant I think), syntax highlighting, an "immediate window" (BeanShell) for evaluating Java expressions right now, that kind of thing. There was a copycat project launched in 2001 called CSDE (C# Dev Env for Emacs). It sounded like a great idea, but it is now stale as 3-day old doughnuts, not having been updated since early 2005. With just one contributor, it never reached critical mass. And no update since before the launch of .NET 2.0 means no support for generics, I suppose, no support for msbuild, nothing for the yield keyword, and other goodies like that. Certainly nothing for LINQ syntax or anonymous methods. I didn't even have the courage to take it for a test drive.

So lacking an integrated set of add-ons, what would be the best Emacs setup, for C# development? Here's what I put together.

First, emacs v22.2. This was released last week. I upgraded from v21.3. It was painless.
csharp-mode.el from Dylan Moonfire of Moonfire games. Latest is v0.7.0, Sept 2007.
The main thing in this "mode" is C# syntax highlighting (using emacs' "font locking" capability) and auto-indenting.
A template library – I used yasnippet.el. This allows me to type "fore<TAB> and get a template of a foreach loop. Or I could type try<TAB> and get the boilerplate for a try…catch…finally. Yasnippet ships with templates for C, C++, Java, Ruby, Python, HTML, CSS, and even Fortran (??). But no csharp. I created a set: new class, foreach, arg parsing in a console app, xml serialization, if-then-else, while, using, and singleton among others.
hideshow.el, which is included in emacs v22.2. Hideshow can collapse or expand regions of text bounded by three-curly-braces . I almost never do that in my C# codeJ , so I had to write an extension to hideshow.el to allow it to recognize the region/endregion syntax supported in C#. There were some suggestions on the csharp page on the emacs wiki, that I only needed to set a regular expression up. But, 2 things: the regexp didn't work, and when I modified it to work, hideshow.el still did not behave as I wanted it to. So I had to write the extension. (I'll post that separately)
defaultcontent.el – fills empty (new) files with some default content. Every time I create a new .cs file from within emacs, I can fill it with a header, some copyright info, and even some boilerplate code, like using statements and a class skeleton. This is not part of emacs, it is a separate add-on. Setting up the new-file template was pretty easy.
skeleton.el – this does auto-insert of matching characters, so for example when I type an open-curly I get a close-curly automatically. This is included in emacs, all I needed to do was set it up.
htmlize.el – which is a bit of magic that generates html for the syntax-highlighted c# code. I wrote about this a few days ago. This is the moral equivalent of CopySourceAsHtml, from Steven Coller.
Customization of the existing, built-in emacs stuff – like
- timestamp. Timestamp is I can insert a field into the source file that emacs automagically updates every time I save the file. The default is that emacs looks only in the first 8 lines for the timestamp. But for C# code, that was not sufficient, so I needed to bump it out a bit. I can even stuff the timestamp into a const string within the class. Nice.
- Properly configuring the next-error function in emacs to be able to see the error messages generated by csc.exe.
- To properly use csharp-mode, I needed to define a C# Style, which defines my indentation preferences and so on. This is about 20 lines of elisp.
- I wrote some elisp functions to do common refactoring tasks, like convert a field to a property with a getter and setter, stuff like that.
Setting up a default msbuild file. For quick little projects I'd like to build a single .cs file into an exe. But I don't want to change the msbuild file every time I create a new .cs file. So it's gotta be general.
Stitching together all the pieces in my .emacs file. I need to load htmlize, hideshow, yasnippet, defaultcontent, and csharp-mode. Also need to set a bunch of key bindings and a style for csharp-mode and set up some hooks for hideshow.

There were some places where I came up short. Intellisense is something I really wanted, and I know it has been done within Emacs for Java. The CSDE though, was just too stale. I found a smaller package, dedicated more narrowly to just .NET intellisense, called csense. Bummer though; this thing did not work for me at all. It was a non-starter. I invested quite a bit of time but no joy. Couldn't find any doc. It seems like it was one of those things that someone built, and it worked for him, and that was it. I think it had something like 13 downloads.

I also checked out a package called folding.el. But it seemed heavier than hideshow.el, and unnecessarily so. Also, not sure if folding.el is still being maintained. I can't even find the URL now, where I downloaded it from, though I know I downloaded it. The emacs wiki says that the author appears to have vaporized. Anyway, I punted on folding.el.

I don't have integrated debugging, but I can separately start up the clrdbg.exe which is included in the .NET SDK.

I didn't bother with setting up unit testing. I can run nunit, from outside of emacs. So it's really independent.

The upshot is, I have a pretty good development environment for C# now, in Emacs. And, it's free. (no license charge) It uses emacs and a bunch of free add-ons, and the .NET SDK, which is a no-cost addition to Windows.

How does Emacs compare to Visual Studio?

Comparing Emacs to Visual Studio… hmmm…. Let me start by asking you a question: what is your time worth? I like what I have set up here, but I have to say, I don't think what I have done is accessible to, or feasible for, most people. I have used emacs for 20 years, the keybindings are in my nerve cells, it would be like major surgery for me to stop using it. But for most people, I imagine emacs itself would be hard to approach. Beyond that is the C# support, which is all add-on. The sheer number of pieces I had to seek out and install, configure, understand – that alone is daunting for most people I would guess. Couple that with the fact that I had to wade through and even write elisp code, which is yes, something I can do, though not very well. (I took a couple lisp courses in college 22 yrs ago) The other black magic is regular expressions, which are tricky and for some people, a complete puzzle. I had to use a ton of regexp's in the setup, for everything from hideshow (to find region/endregion) and the compile error messages. I have regexp knowledge from way back, too. All of this took lots of time to do, as well as some esoteric skills.

So for me, the emacs setup will continue to be useful. But for most devs, I'd guess it would be a tough sell.

In contrast, Visual Studio is just an install. Most things I want are set up already – I don't have to write a regular expression, for example, to find the compiler error message. I don't have to write an msbuild file to compile. The refactoring tasks are already built-in – you don't have to write code to describe what refactoring you want. Debugging is built in. Intellisense. Unit testing. Snippets. Collapsing regions of code. All of it is just soooo much more accessible for mere mortals, or for anyone, really who values their time realistically. And that doesn't even mention the graphical designers, the database designers (eg linq support), or the team-development capabilities of Visual Studio.

The Bottom Line

My effort at setting up emacs was a labor of love – it is not the kind of thing I would recommend to anyone who wants to actually make money at writing code. I did it because I wanted to see if it could be done. If time is money, I spent myself into the poorhouse setting up emacs for C# work. I spent a bunch of time evaluating options, exploring dead-ends. (I was just thinking – g*d help me if I lose my laptop, because my setup is totally unique and not reproducible.)

The bottom line is that it is possible to set up emacs as a dev environment for C#. What I got for myself – I will actually use it extensively, for quick jobs and small projects, as well as larger single-person efforts. For me, it will be better than VS, for those kinds of projects. But in the end, Visual Studio is still sooo much better in terms of overall cost/benefit.

On the other hand, all of the emacs stuff I did works on any platform. I benefited from emacs packages that were developed for and by devs using mono on non-Windows platforms. So I can see that for some people, emacs could make sense. The way I got into emacs, by the way, was in school. There was a critical mass of people using emacs as an editor, and so I was able to pick it up easily. Then I worked at a company where emacs was standard issue, and that is when emacs became part of my DNA. I had no choice in the matter. The emacs setup was all prearranged, set up and shaken down for me. I can see that continuing as a common scenario for new developers picking up emacs – when they join a team of experts who have done all the setup for them, and who can transfer the lore to them. The body of experts can make emacs accessible to the new guy. But without that, IDE's like Visual Studio just seem sooo much more broadly applicable.

Hey, last thing - If I've missed any gems for working with c# within emacs, please let me know! Especially intellisense!

CopySourceAsHTML in Emacs? Htmlize.el

DotNetInterop — Fri, 11 Apr 2008 09:26:00 GMT

There's a nice add-in for Visual Studio called CopySourceAsHTML (for VS2005, VS2008), which I have been using for a while now. Turns out there was an earlier progenitor in htmlize.el for emacs.

Here's the result:

PowerShell in Emacs, proof!

DotNetInterop — Fri, 11 Apr 2008 07:51:00 GMT

Here's the proof that you can run powershell as a shell in Emacs.

Grab the download from yesterday to get this awesome power yourself!

Run PowerShell as a shell within Emacs

DotNetInterop — Thu, 10 Apr 2008 22:46:00 GMT

I saw a couple people asking about running powershell as an inferior shell within emacs. Here's what I do.

For the tragically unhip, some background: PowerShell is a nifty shell, it ships as an add-on to Windows. Currently at v1.0, but the v2.0 is available as a CTP. Emacs is the venerable supereditor that does 1001 things - one of those things is the ability to run a shell within a buffer. Emacs runs on Unix and Windows, and the shell stuff is configurable across a wide variety of shells and operating systems. As I was saying, some people have expressed interest in running PowerShell as an inferior shell within Emacs.

We're not talking about a powershell script editing mode. That problem has been solved. Instead, we're talking about running a powershell interactively within emacs.

There are a couple challenges with doing this. First, emacs is complex, and it is hard for people to figure out to do what they want. Even the doc is impenetrable. Basically you just have to KNOW how to do something, or someone else shows you. Getting back to our situation, to explicitly specify the shell to run, in emacs you set a variable called explicit-shell-file-name. Great, so we set this to c:\\windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe. There's an example for starting shells that says "to set the arguments to the shell, set the explicit-sh-args variable. People were setting this variable and trying to run PowerShell but getting an error. That's because the variable name for arguments is different for each shell. For bash, sh is the image and the variable is explicit-sh-args. For powershell, the variable to set is explicit-powershell.exe-args . Of course! This isn't explicitly documented anywhere (that I could see), but if you read the source code for shell.el you will see it. And, to further complicate things, if you don't explicitly set anything in that args variable, shell.el implicitly includes -i as an argument, which makes powershell barf. -i is a valid powershell argument, but it needs another param. Hence the barf. Anyway, to avoid all this, set explicit-powershell.exe-args . Example:

  (setq explicit-shell-file-name "c:\\windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe")
  (setq explicit-powershell.exe-args '("-Command" "-" )) ; interactive, but no command prompt

After setting these variables, to launch powershell from within emacs, just use M-x shell. This gets you to the second problem: powershell goes into "noninteractive mode". It emits no prompts, although it reads from the stdin and puts output on stdout. So you can see the input and output, but no prompts at all. Needless to say, it's a bit unfriendly to do this.

To fix this up we have to ask powershell to give us prompts. A simple thing to do would be to launch powershell in interactive mode, despite the fact that stdin and stdout have been redirected. There's an option on powershell.exe to launch it in "noninteractive mode" which means no prompts, and which is already what we have. We want the converse. I couldn't figure a way to do the "force interactive mode", so I used some emacs lisp to sort of fake it.

Within shell mode, there are "hooks" that emacs will call, on certain events, and overrides that you can set. (Sort of like the channel stack in WCF.) One possible override is the "send command to shell" method. You can write some custom code that runs, every time the user types in a command to the shell, in order to send the command to the shell. You can filter it, modify it, log it, suppress it, whatever. I wrote a simple wrapper in elisp that sends the original command, and then ALSO sends the "prompt" command. This causes powershell to emit the prompt, after the first, explicit command is run. Cool. That's what we want.

Then there are some rough edges. For example, powershell assumes an 80-character width for a terminal in non-interactive mode. You can set this by tickling the RawUI object within powershell itself. This is made possible with another hook. Also, I need to resize the powershell terminal whenever the emacs window changes. So I need to hook the window-size-change event within emacs.

One last thing is that the powershell prompt comes out with a trailing newline. So I need to trim that off as well, so that the next command you type in the powershell inferior shell, is just to the right of the powershell prompt.

Anyway, the result is the brief bit of elisp attached here. It's pretty bare-bones, but it's a start. And it lets you do what you want - run powershell as an inferior shell within emacs.

;; powershell.el, version 0.1
;;
;; Author: Dino Chiesa
;; Thu, 10 Apr 2008  11:10
;;
;; Run Windows PowerShell v1.0 as an inferior shell within emacs. Tested with emacs v22.2.
;;
;; TODO:
;;  test what happens when you expand the window size beyond the maxWindowWidth for the RawUI
;;  make everything configurable (Powershell exe, initial args, powershell prompt regexp)
;;  implement powershell launch hooks
;;  prevent backspace from deleting the powershell prompt? (do other shells do this?)
;;

(require 'shell)


(defun powershell-gen-window-width-string ()
  (concat  "$a = (Get-Host).UI.RawUI\n" 
            "$b = $a.WindowSize\n"
            "$b.Width = " (number-to-string  (window-width)) "\n"
            "$a.BufferSize = $b\n"
            "$a.WindowSize = $b")
  )
  

(defvar powershell-prompt-pattern  "PS [^#$%>]+>" 
  "Regexp for powershell prompt.  This isn't really used, because I couldn't figure out how to get it to work."
  )

(defgroup powershell nil
  "Running shell from within Emacs buffers."
  :group 'processes
  )


(defcustom powershell-need-rawui-resize t
  "set when powershell needs to be resized"
  :group 'powershell
)

;;;###autoload
(defun powershell (&optional buffer)
  "Run an inferior powershell, by invoking the shell function. See the help for shell for more details.
\(Type \\[describe-mode] in the shell buffer for a list of commands.)"
  (interactive
   (list
    (and current-prefix-arg
         (read-buffer "Shell buffer: "
                      (generate-new-buffer-name "*PowerShell*")))))
  ; get a name for the buffer
  (setq buffer (get-buffer-create (or buffer "*PowerShell*")))

  (let (
        (tmp-shellfile explicit-shell-file-name)
        )
                                        ; set arguments for the powershell exe.
                                        ; This needs to be tunable.
    (setq explicit-shell-file-name "c:\\windows\\system32\\WindowsPowerShell\\v1.0\\powershell.exe")  
    (setq explicit-powershell.exe-args '("-Command" "-" )) ; interactive, but no command prompt
  
                                        ; launch the shell
    (shell buffer)

    ; restore the original shell
    (if explicit-shell-file-name
        (setq explicit-shell-file-name tmp-shellfile)
      )
    )
  
  (let (
        (proc (get-buffer-process buffer))
        )
    
    ; This sets up the powershell RawUI screen width. By default,
    ; the powershell v1.0 assumes terminal width of 80 chars.
    ;This means input gets wrapped at the 80th column.  We reset the
    ; width of the PS terminal to the window width. 
    (add-hook 'window-size-change-functions 'powershell-window-size-changed)

    (powershell-window-size-changed)
    
    ; ask for initial prompt
    (comint-simple-send proc "prompt")
    )

  ; hook the kill-buffer action so we can kill the inferior process?
  (add-hook 'kill-buffer-hook 'powershell-delete-process)

  ; wrap the comint-input-sender with a PS version
  ; must do this after launching the shell! 
  (make-local-variable 'comint-input-sender)
  (setq comint-input-sender 'powershell-simple-send)

  ; set a preoutput filter for powershell.  This will trim newlines after the prompt.
  (add-hook 'comint-preoutput-filter-functions 'powershell-preoutput-filter-for-prompt)

  ;(run-hooks 'powershell-launch-hook)

  ; return the buffer created
  buffer
)


(defun powershell-window-size-changed (&optional frame)
  ; do not actually resize here. instead just set a flag.
  (setq powershell-need-rawui-resize t)
)



(defun powershell-delete-process (&optional proc)
  (or proc
      (setq proc (get-buffer-process (current-buffer))))
  (and (processp proc)
       (delete-process proc))
  )



;; This function trims the newline from the prompt that we
;; get back from powershell.  It is set into the preoutput
;; filters, so the newline is trimmed before being put into
;; the output buffer.
(defun powershell-preoutput-filter-for-prompt (string)
   (if
       ; not sure why, but I have not succeeded in using a variable here???  
       ;(string-match  powershell-prompt-pattern  string)

       (string-match  "PS [^#$%>]+>" string)
       (substring string 0 -1)
     
     string

     )
   )



(defun powershell-simple-send (proc string)
  "Override of the comint-simple-send function, specific for powershell.
This just sends STRING, plus the prompt command. Normally powershell is in
noninteractive model when run as an inferior shell with stdin/stdout
redirected, which is the case when running as a shell within emacs.
This function insures we get and display the prompt. "
  ; resize if necessary. We do this by sending a resize string to the shell,
  ; before sending the actual command to the shell. 
  (if powershell-need-rawui-resize
      (and
       (comint-simple-send proc (powershell-gen-window-width-string))
       (setq powershell-need-rawui-resize nil)
       )
    )
  (comint-simple-send proc string)
  (comint-simple-send proc "prompt")
)

To use it, you need to add in this text in your .emacs file:

(autoload 'powershell "powershell" "Run powershell as a shell within emacs." t)

Start powershell within emacs with M-x powershell. You can continue to use the regular Windows shell within emacs via M-x shell.

Cheers!