To add to the author's list:<p>* I seem to install Json.net in every .NET project I create (json serializer - thanks James Newton-King!)<p>* NLog for logging. It's fantastic.<p>* Dapper is also excellent (Micro ORM) (and anything written by Marc Gravell is generally top-notch - see protobuf-net, miniprofiler, StackExchange.Redis)<p>* Automapper, to avoid writing boilerplate code to convert between similarly shaped types (E.G. DTOs to DB models).<p>* RestSharp makes talking to RESTful apis easier.<p>* Microsoft's Unity is a great IOC framework, although most people seem to use NInject.
Some that I build (and use):<p>* albacore for cross platform builds with ruby <a href="https://github.com/Albacore/albacore/" rel="nofollow">https://github.com/Albacore/albacore/</a> C++.Net, VB, C#, F#<p>* suave.io <a href="http://suave.io" rel="nofollow">http://suave.io</a> F#<p>* logary for structured logging and metrics and health-checks <a href="http://logary.github.io/" rel="nofollow">http://logary.github.io/</a> C# and F#<p>* Chiron for F# JSON parsing<p>* logibit.hawk for F# API Hawk verification <a href="https://github.com/logibit/logibit.hawk/" rel="nofollow">https://github.com/logibit/logibit.hawk/</a><p>* Http.fs instead of RestSharp for F#<p>* FsSql for ADO.Net interaction
Some additional ones I haven't seen mentioned so far:<p>* FluentValidation: excellent validation library, keeps validation rules grouped together and easy to keep track of - <a href="https://github.com/JeremySkinner/FluentValidation" rel="nofollow">https://github.com/JeremySkinner/FluentValidation</a><p>* AutoFixture: great for the "Arrange" phase of unit tests. Populates object graphs with test data, highly customizable. There's a bit of a learning curve. Pairs nicely with xUnit but can be used with any TDD library - <a href="https://github.com/AutoFixture/AutoFixture" rel="nofollow">https://github.com/AutoFixture/AutoFixture</a><p>* Shouldly: a different approach to unit test assertions using "Should" that I find more readable. Also had friendlier error messages when assertions failed - <a href="https://github.com/shouldly/shouldly" rel="nofollow">https://github.com/shouldly/shouldly</a><p>Shameless plug of my own library:<p>* Regextra: aims to solve some common regex related scenarios. Features a Passphrase Regex Builder to generate a pattern for passphrase criteria, and also supports named templates and a few utility methods - <a href="https://github.com/amageed/Regextra" rel="nofollow">https://github.com/amageed/Regextra</a>
In addition to the great ones already listed on the link and in the comments here, I'd like to list 2 of my favorites:<p>* Simple.Data: <a href="https://github.com/markrendle/Simple.Data" rel="nofollow">https://github.com/markrendle/Simple.Data</a> , the smallest and simplest ORM you'll ever use.<p>* Hyperletter: <a href="https://github.com/Jiddler/Hyperletter" rel="nofollow">https://github.com/Jiddler/Hyperletter</a> , a very easy way to do inter-process communication. Great for writing distributed software over http, but can be just as useful locally.
Check out Akka.Net - <a href="http://getakka.net/" rel="nofollow">http://getakka.net/</a><p>This is a port of the Akka framework from Java to the .Net platform. It's an actor model framework which works incredibly well for building highly concurrent and distributed applications. They just hit version 1.0 and are out of beta and are backed by a commercial company Petabridge.<p>Highly recommended.
I used to use NLog for logging until I've discovered Serilog ( <a href="http://serilog.net/" rel="nofollow">http://serilog.net/</a> ) - simple .NET logging with fully-structured events.
Humanizer
Fantastic string, number, and datetime manipulation library
<a href="http://www.nuget.org/packages/Humanizer/" rel="nofollow">http://www.nuget.org/packages/Humanizer/</a><p>Units.Net
I love this for measurement and weight conversions
<a href="http://www.nuget.org/packages/UnitsNet/" rel="nofollow">http://www.nuget.org/packages/UnitsNet/</a><p>And, of course, a shameless plug of my own library
Fibber
An indiscriminate data generator that will generate random data for all properties in a given class based on the property's type vs. its name
<a href="https://github.com/Schandlich/Fibber" rel="nofollow">https://github.com/Schandlich/Fibber</a>
<a href="http://www.nuget.org/packages/Fibber/" rel="nofollow">http://www.nuget.org/packages/Fibber/</a>
Surprised no one has mentioned Nancy:
<a href="https://github.com/NancyFx/Nancy" rel="nofollow">https://github.com/NancyFx/Nancy</a>
I can't imagine building APIs without it now.
Here's another one that will make your life easier: <a href="https://github.com/adamcaudill/libsodium-net" rel="nofollow">https://github.com/adamcaudill/libsodium-net</a><p>Now you have no excuses for rolling your own broken crypto.
This (article + HN comments) will be extremely handy for me in the future (I'm a .NET dev).<p>Knowing that'll need some of those libraries later I decided to compile into a list here: <a href="https://github.com/tallesl/.NET-libraries" rel="nofollow">https://github.com/tallesl/.NET-libraries</a>
With .NET going open source, I'd like to see what is out there for web services. Are there any linux-compatible .NET web servers/routers that I can use that have a similar feature set and performance to the Spray/Scala stack? C# or F#, but preferably F#. I've tried a couple (suave, nancy), but some simple benchmarks showed they were about half as scalable as spray.
I've recently discovered Linq2Db. Works great for CRUD in conjunction with Dapper. <a href="https://github.com/linq2db/linq2db" rel="nofollow">https://github.com/linq2db/linq2db</a>
It also comes with handy T4 templates to generate models.
For those interested, here are the licenses each project is available under: (courtesy Evairfairy)<p>Hangfire
--------<p>LGPL3 <a href="https://tldrlegal.com/license/gnu-lesser-general-public-license-v3-(lgpl-3)" rel="nofollow">https://tldrlegal.com/license/gnu-lesser-general-public-lice...</a><p>Postal
------<p>MIT <a href="https://tldrlegal.com/license/mit-license#summary" rel="nofollow">https://tldrlegal.com/license/mit-license#summary</a><p>Formo
-----<p>MIT <a href="https://tldrlegal.com/license/mit-license#summary" rel="nofollow">https://tldrlegal.com/license/mit-license#summary</a><p>CsvHelper
---------<p>MS-PL <a href="https://tldrlegal.com/license/microsoft-public-license-(ms-pl)" rel="nofollow">https://tldrlegal.com/license/microsoft-public-license-(ms-p...</a>
Apache <a href="https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)" rel="nofollow">https://tldrlegal.com/license/apache-license-2.0-(apache-2.0...</a><p>Topshelf
--------<p>Apache <a href="https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)" rel="nofollow">https://tldrlegal.com/license/apache-license-2.0-(apache-2.0...</a>
See: <a href="https://github.com/Microsoft/dotnet" rel="nofollow">https://github.com/Microsoft/dotnet</a><p>This is an extensive list of (non-MS) OSS libs and tools for .NET , complete with descriptions. The URL might suggest this is the .NET source, it's a set of text documents with URLs to OSS libs/tools.
One of my recent favorite libraries lately is DynamicData [1] which is Rx for collections. It allows you to use LINQ operators to create lots of different collections from a single "observable cache". An example from the github page:<p><pre><code> var list = new ObservableCollectionExtended<TradeProxy>();
var myoperation = somedynamicdatasource
.Filter(trade=>trade.Status == TradeStatus.Live)
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp))
.ObserveOnDispatcher()
.Bind(list)
.DisposeMany()
.Subscribe()
</code></pre>
This takes the collection at <i>somedynamicdatasource</i>, transforms the contents to TradeProxy objects, sorts it, and binds it to <i>list</i>. Any time that an object is added or removed in <i>somedynamicdatasource</i>, <i>list</i> will be updated to match. This library has over 50 operators including dynamic filters (changing the filter causes the bound collection to be reevaluated), boolean operators (only update the resulting collection if the object is in both source collections or only one), etc.<p>[1] <a href="https://github.com/RolandPheasant/DynamicData" rel="nofollow">https://github.com/RolandPheasant/DynamicData</a>
I have to say that for someone starting to transition to .net, this is a great post. Posts like these are what I expect from the Ruby/Python/Node/PHP communities but the lack of them and lack of good learning opportunities had made me hesitant to use .net in the past.
Thanks a lot, you've just made me feel a whole lot better about the .net community as a whole.
Fasterflect, must-have reflection library <a href="https://fasterflect.codeplex.com" rel="nofollow">https://fasterflect.codeplex.com</a><p>Insight.Database, in my opinion much better than Dapper
<a href="https://github.com/jonwagner/Insight.Database" rel="nofollow">https://github.com/jonwagner/Insight.Database</a>
One of my must haves that I'd definitely recommend is T4MVC[0]<p><pre><code> T4MVC is a T4 template for ASP.NET MVC apps that creates strongly typed helpers that eliminate the use of literal strings in many places.
</code></pre>
[0]: <a href="https://github.com/T4MVC/T4MVC" rel="nofollow">https://github.com/T4MVC/T4MVC</a>
Does anyone have recommendations for frameworks or libraries for implementing CQRS and distributed processing of large sets of data through DDD?<p>I've found some different options including Lokad, NServiceBus, MassTransit, MPAPI, but would love to hear what, if any, tools HN users are utilizing.
One more I'll add to the mix that has come in handy several times: CsQuery jQuery port.
<a href="https://github.com/jamietre/CsQuery" rel="nofollow">https://github.com/jamietre/CsQuery</a>
Some that I've been enjoying lately:<p>- SpecsFor: Some nice BDD wrappers around NUnit and Moq <a href="http://specsfor.com/" rel="nofollow">http://specsfor.com/</a>
- Glimpse: A great diagnostic console tool for ASP.NET applications <a href="http://getglimpse.com/" rel="nofollow">http://getglimpse.com/</a>
- FluentMigrator: Awesome DB migration framework <a href="https://github.com/schambers/fluentmigrator" rel="nofollow">https://github.com/schambers/fluentmigrator</a>
re: Formo<p>Last summer and into the fall, I had plans for Formo 2.0, which included a lot more flexibility and customization capabilities (json config, http context config, environment variables, etc). When I learned about aspnet5's configuration I essentially stopped development on Formo. The big reason being that they're building in such a way that I imagined Formo would be used. (Which makes me quite happy)<p>For that reason, the project is largely "finished", but it's still stable and alive.
Great list. I found BizArk.Core powerful console application entry point library very useful. It provides command line arguments parsing based on class and properties atributes <a href="https://bizark.codeplex.com/wikipage?title=Console%20application%20with%20command-line%20parsing%20and%20validation&referringTitle=Documentation" rel="nofollow">https://bizark.codeplex.com/wikipage?title=Console%20applica...</a>
Great list, but could use more F# love!<p>Lots of cool/useful open source projects are always popping up in the F# community - <a href="http://fsharp.org/community/projects/" rel="nofollow">http://fsharp.org/community/projects/</a><p>Favs of mine from that list: Visual F# Power Tools, FSharp.Data.SqlClient, FsEye, Fantomas, R type provider
You guys should check these ones:<p>* Hangfire(<a href="http://hangfire.io/" rel="nofollow">http://hangfire.io/</a>): for background jobs.<p>* Polly(<a href="https://github.com/michael-wolfenden/Polly" rel="nofollow">https://github.com/michael-wolfenden/Polly</a>): For exception handling policies.<p>Edit: formatting.
As an alternative to CsvHelper I can recommend FileHelpers by Marcos Meli: <a href="http://filehelpers.sourceforge.net/" rel="nofollow">http://filehelpers.sourceforge.net/</a><p>Don't be put off by the dated SourceForge location. It is pure awesome for getting data in and out of CSV format.
About Object Mappers<p>* AutoMapper is a great mapper, but too slow <a href="http://automapper.org/" rel="nofollow">http://automapper.org/</a><p>* TinyMapper is extremely quick <a href="http://tinymapper.net/" rel="nofollow">http://tinymapper.net/</a>
A collection of awesome .NET libraries, tools, frameworks and software (curated by community)
<a href="https://github.com/quozd/awesome-dotnet" rel="nofollow">https://github.com/quozd/awesome-dotnet</a>
Hangfire looks great. I'm currently running all my jobs through Azure Scheduler. Would anyone know what the pros & cons are between these two job schedulers? Are there certain requirements or architectures that favor one or the other?