Rick Minerich's Development Wonderland : asp.net

F# Discoveries This Week 10/18/2010

RickM — Mon, 18 Oct 2010 17:46:44 GMT

I’ve been very busy lately what with getting ready for the move to Hoboken, trying to put together an online version of my F# Ant AI Contest, and working on my talk for the F# in Education Workshop. Nonetheless, I’ve set some time aside to bring you the F# links you crave. Cheers!

News

October 2010 Community 4 F# Meeting - Trees, Language Oriented Programming and F# with Robert Pickering on 10/19

In this presentation Robert Pickering will take a look at the concept of the tree data structure, and we’ll see how trees are everywhere we look in programing — from XML to lisp, and passing by indexes in RMDS.

Daniel Mohl’s Speaking at the October Nashville Web Dev User Group Meeting on 10/12

“In this talk, we will quickly go over some of the basics of the F# language, then dive into four quick ways to get started developing web application in F#.”

Skills Matter : Functional Programming eXchange 2011 18-03-1

“Following on from the success of the last Functional Programming eXchange in December 2009, Skills”

Tools

Microsoft Solver Foundation

“Solver Foundation Services (SFS) can automatically analyze models and determine which solver is most appropriate.”

Funtastic

“A simple tool for working with F# interactive.”

General

Luke Hoban's Benoit Mandelbrot

“In honor of Mandelbrot, here are two very simple takes on the Mandelbrot fractal that I’ve written in the last couple years.”

Scott Philip Brown's Turtle Graphics and L-systems with F# and WPF

“This article will explain how to use the turtle graphics program, and show the F# and WPF code which was used to implement it, and provide some example code for generating fractal shapes using L-system grammars.”

Tomas Petricek's Formatting F# source code for the Web

“In this article, I presented a tool for generating nice HTML snippets from F# source code called F# Web Snippets. The most interesting thing about the tool is that it also generates tool tips with type information for F# identifiers.”

Satnam Singh's F# Black-Scholes running on GPUs and SSE3 Multicore Processors using Accelerator

“The objective of this blog is to give you a feel for what data-parallel programming looks like with the Accelerator system.”

Kean Walmsley's SortOnVersion in F#

“I had a very nice surprise in my inbox, this morning. Thorsten Meinecke, from GTB in Berlin, decided to convert the VB.NET code contained in the last post into an F# script and to share it with this blog’s readership.”

Robert Pickering's TwitMemento a twitter client in F#

“It’s written in F# (as you might have guessed if you follow this blog regularly). It's based on Twitter’s new HTTP streaming API's so tweets come in as they happen, no need to refresh, and uses OAuth so your password is never seen by the app.”

Ade Miller's Gotchas: Assembly Level Attributes in F#

“It turns out that the module needs an empty do() statement at the end of it. So your assemblyInfo.fs file might look something like this.”

Mauricio Scheffer's A functional wrapper over ADO.NET

“ADO.NET is the de-facto basic library for data access in .NET, and as everything in the BCL, it's object oriented. Which forces you to write object-oriented code when you use ADO.NET in F#.”

Mauricio Scheffer's A functional wrapper over ADO.NET (part 2)

“FsSql aims to wrap ADO.NET to make it more idiomatic for F# consumers, providing several fine-grained functions meant to be reused or combined as necessary, as is usual in functional programming.”

Rey Dacoco's Mouse Trails using Basic shapes

“Obsessed with mouse trails? Try the following sample applications:”

Luis Diego Fallas' Using C#'s implicit type conversions from other .NET languages

“One interesting C# feature is the ability to define a method that implements implicit conversion from one type to another. In this post I'm going to show how to use this feature from IronPython, F#, VB.NET and IronRuby.”

ASP.NET with F# and Mono

“ASP.NET is the implementation of server-side code based on .NET to create dynamic web pages. Mono does support ASP.NET with some additional configuration F# can also be used to create dynamic web content.”

F# to Canvas

“A rudimentary library of functions that enable F# algorithms to turn their output into visual representations using the HTML5 canvas by outputting javascript”

Teaching and Basics

Ivan Towlson's F# and first-class functions, parts one, two, three and four

“In previous instalments of this series, I’ve described F#’s support for first-class functions in terms of relatively simple, isolated examples. In this final part, I want to draw on a real-world example to show how F# has made it easy for me to use higher-order functions to address a genuine business requirement.”

Richard Minerich's A CUFP Tutorial, F# Day at the … Oh God, Ants!

“Everyone was ready for a nice relaxing day at the beach when they showed up for my CUFP tutorial…”

Community

Matthew Podwysocki's Continuation Monad with Error Handling

Fredrik Holmström's A few custom F# operators I use

F# Discoveries This Week 05/14/2010

RickM — Fri, 14 May 2010 21:06:49 GMT

Today, I’d like to thank all of the F# users on twitter.

Twitter’s a great place to stay up to date on the latest F# happenings and many of the posts you see here are either written by or passed on from members of this community. So, if you are interested in becoming part of the F# Twitter Community, I suggest starting with these frequent F# tweeters: @dmohl, @TigerHasse, @robertpi, @sforkmann, and @ptrelford.

I’ve also been known to occasionally tweet on F# and other programming topics. Now, on to the links.

Brian McNamara’s More F# Screencasts

My previous two screencasts (‘Getting started with F# in VS2010’ and ‘Editing F# source code in VS2010’) have been moved to MSDN, which means they’re now available in a variety of video formats. A new screencast (‘Managing F# projects in VS2010’) has also been added, so check it out!

Robert Pickering’s F# Talks in London

I’ve been in London for the past few days. I arrived Tuesday afternoon and gave at talk at “The F#unctional Londoners Meetup Group” on the Tuesday evening.

James McCaffrey’s Combinations and Permutations with F#

Understanding combinations and permutations is a fundamental skill in software testing. In this month’s Test Run column I show you how to work with combinations and permutations using code written in the new F# language.

Amanda Laucher and Josh Graham’s Pragmatic F# in Action (video)

Amanda Laucher and Josh Graham introduce the audience to F# basics showing some of its main features, emphasizing what makes it better than imperative languages.

Tomas Petricek’s ASP.NET and F# Part 1 – Creating MVC Web Applications in F#

If you want to use F# for creating an MVC application, you have a few options. It should be possible to create the web application solely as an F# project. However, we'll use a more convenient approach. We'll create a standard C# MVC project and move all the actual implementation to an F# library.

Steffen Forkmann’s FAKE – F# Make 1.20.0 Released and
Using a MailboxProcessor to speedup “FAKE – F# MAKE”

Today I released a new bugfix release for “FAKE – F# Make”. We fixed some path and logging issues and as a new feature we introduced the @@ operator which allows to combine paths.

Phillip Trelford’s Trading on IM with F#

The slides from my Trading on IM talk will be attached to this post, and the video/podcast should be appear on the Skills Matter website. I’ll also attach the 100 lines of code for shopping checkout sample, that works with a barcode scanner, I showed at the start of my presentation.

Daniel Mohl’s Integrating F# and Erlang Using OTP.NET

Recently, I ran across a post that talked about a .NET library named OTP.NET. OTP.NET is a port of a Java library named JInterface that allows a .NET application to act as an Erlang node. OTP.NET hasn't been updated in a while and the API is a bit clunky, but the provided functionality is very cool.

Nick Grattan’s Creating Web Parts with F# and
An EDSL for Emitting HTML Tables in Web Parts using F#

When writing web parts in C# for SharePoint the System.Web “table” class or “table” HTML elements are most often used for controlling layout (“div” aficionados keep your ears covered…). The code quickly gets ugly and difficult to manage – there’s no direct control to ensure correct matching of opening and closing of tags. So how about writing an EDSL that provides a syntax and constructs for doing this?

Neil Carrier’s Tiny Expert System using Monads

Below is a tiny expert system implemented using computation expressions. I managed to find a way to use the following computation expression methods: Bind, Delay, and Return.

Neil Carrier’s A Simple DSL: Tokenization to Evaluation,
S-Expressions for Semantic Networks and
A Half-Baked Scheme

This post presents a small example of the above process. It implements a small interpreter which analyzes and evaluates LISP-like prefix expressions involving integers, multiplication, and division. For example: (+ (* 1 2) (* 3 4) evaluates to a data element containing the number 14. To make clear what is happening, be sure and examine the value of tokenList before it is evaluated.

Julien Ortin’s Technical analysis indicators in F# – Bands, Signal and Ehlers

This is part of a series on technical analysis indicators in F#, based on the multi-language TA-Lib. Quick disclaimer : some of these indicators are not verified.

Yin Zhu’s F# for Project Euler Problems

Some problems have two versions of solutions, the version I first learned F# and the version based on my current knowledge of F#. The first version is usually quite easy to understand even if the reader does not know F#, while the second uses some nice F# feature or good functional programming practice in general.

Jon Harrop’s Java vs. F#

What Cliff forgot to mention is that .NET also provides value types and a far more compelling example than complex numbers is the humble hash table.

Tim Ng’s F# + WPF + Events

I recently had to do some travelling for the VS launch event in Las Vegas and QCON event in Beijing. One of the things thats nice about travelling is that it gives you time to do some things you may not otherwise do - in my case, I had a chance to try to (re) learn WPF and see how I can use F# with WPF.

Mark Needham’s Tacit Programming

I realised that this approach quite closely describes what I've been trying to drive towards in my most recent playing around with F# and it's actually quite fun trying to drive any intermediate state or storing of data in variables out of a program and just relying completely on function composition and higher order functions.

Mark Needham’s F#: My current coding approach

I spent a bit of time over the weekend coding a simple generic builder for test objects in F# and I noticed that although there were similarity with the ways I drive code in C# or Java my approach didn't seem to be exactly the same.

Ebru Cucen’s F# vs C# Samples

After my talk at ldnUG yesterday, I got nice suggestions from Zi Makki, and here is the first one: comparison between F# and C#, especially using LINQ. This subject had been quite popular once in a while, now it is probably my time to focus on this subject.

Bjorn Rochel’s Kata StringCalculator in F#

Two meetings ago we decided to do some coding on every meeting. The previous meeting we solved Kata FizzBuzz and on yesterday’s meeting we tried to dance with Roy Osheroves Kata StringCalculator.

Gunnar Peipman’s F# in ASP.NET, mathematics and testing

Starting from Visual Studio 2010 F# is full member of .NET Framework languages family. It is functional language with syntax specific to functional languages but I think it is time for us also notice and study functional languages. In this posting I will show you some examples about cool things other people have done using F#.

Luis Diego Fallas’s Defining mutually recursive classes in F#

As explained in Adventures in F#--Corecursion defining mutually recursive functions requires the use of the and keyword between function definitions. As briefly mentioned in the Type Definitions section of the manual, the and keyword can also be used in types.

Nancy Strickland’s New Features in F# 2.0 Training Video

Describes the new features in F# version 2.0, which comes included in Visual Studio 2010.

DotNetRocks in Boston (with F# Panel)

The panel suggested we add F# to our repertoire and understand its strengths, and use it where it's beneficial. I'm going to take that advice. Bottom line is if I can replace 50 lines of confusing C# code with 10 lines of elegant F#, I've done myself a service.

F# Discoveries This Week 04/09/2010

RickM — Fri, 09 Apr 2010 17:28:16 GMT

With the Visual Studio 2010 launch just days away, the F# community is exploding with fury and excitement. Come inside and find links to topics ranging from general programming patterns to specific algorithm implementations.

Don Syme on the Passing of Robin Milner

It is with sadness that I mention the death of Professor Robin Milner, the great British computer scientist, who passed away 11 days ago.

Talbott Crowell’s FSUG Talk – F# and Silverlight

This talk describes building Silverlight 3 applications using F#. Both Visual Studio 2008 and 2010 RC are demonstrated.

CodeCast Episode 73: F# with Michael Hale

F# with Michael HaleIn this episode of CodeCast, Ken Levy interviews Michael Hale, a program manager on the F# team at Microsoft. Michael discusses what’s new in F# for both Visual Studio 2008 and Visual Studio 2010, various scenarios for functional programming with F#.

IronJS is a Javascript implementation for the DLR written in F# (source)

I just wanted to give a quick notice that I got the new compiler for IronJS to run on both .NET 2.0 and Mono 2.6 today, the goal is for IronJS to be able to run on .NET 2.0, 3.x and 4.x plus Mono 2.6

Brian McNamara’s F# async on the client side

Though the killer app for F# async is non-blocking I/O on the server side, F# asyncs are also useful and fun to use for client-side programming on the UI thread. I’ll show two small examples of F# async lets you do non-blocking loops on the UI thread.

Brian McNamara’s F# async on the server side

Last time I talked about cool ways to use F# asyncs to help write client GUIs. Today I’ll talk about the killer app for F# asyncs, namely, non-blocking I/O on the server side. Once again, this is material I lifted from a recent talk that Matthew Podwysocki and I gave at TechReady.

Brian McNamara’s Nine reasons to use F#

The list is not necessarily distinct (some elements overlap) or complete (this is just a list I came up with today), and not every reason in the list will resonate with every reader. But they are all ‘real’ reasons, in the sense that they’re representative of individuals or teams out in the world who are already using F# today.

Matthew Podwysocki’s Time Flies Like An Arrow in F# and the Reactive Extensions for .NET

Let’s take a look at what would be required for us to make the Time Flies Like an Arrow example work in F# using first class events and the Reactive Extensions for .NET on top of WPF. I’ll write it in a pseudo-code to give you an idea of how it should be done.

Aaron Erickson’s F# Based Discriminated Union/Structural Similarity

Imagine you have a need to take one type, which may or may not be a discriminated union, and see if it “fits” inside of another type. A typical case might be whether one discriminated union case would be a possible case for a different discriminated union. That is, could the structure of type A fit into the structure of type B. For lack of a better word, I am calling this “structural similarity”.

Mike Hadlow’s Functional Dependency Injection == Currying

In a functional language like F# we can do the same thing without the overhead of having to declare classes and interfaces. We can also do the same thing in C#, but it requires some jiggery-pokery, so I’m going to show you it in F#.

Neil Carrier’s A 32-Bit Computer in One Page of Code,
F# Implementation of Bit-Based Computer,
Bit Computer Addition and Bit Operations from TAoCP in F#,

I want to depart from the lofty world of semantic networks for a few posts, in order to investigate the world of bit-based computers. By bit-based computer, I mean one in which the entire state of the computer is based on an ordered set of bits. The computer I describe below was suggested by Digi-Comp I, a classic bit-based computer made almost entirely of plastic, but mine is based on a somewhat different design.

Neil Carrier’s The Estimable Item 175 and Item 175 At Large

This example illustrates a famous “Gosper hack.” There is apparently some controversy over which Gosper hack merits the title THE Gosper hack. Often that title goes to MIT A.I. Laboratory HAKMEM Item 145. The code below is based on Gosper hack 175 from the same document, which is the one Knuth mentions.

Neil Carrier’s Easter (Practical Astronomy With Your Calculator)

In honor of the day, I present the following short program for calculating the date of Easter. The method is from Butcher's Ecclesiastical Calendar (1876). I present it in the form given in Peter Duffett-Smith's Practical Astronomy With Your Calculator (Cambridge 1981, the 1988 version is still available from Amazon, et al).

Neil Carrier’s Search Routines, Continued and Improved Canonical Search

In the meantime, here is a first try at general purpose depth/breadth-first search routine. It's not really generic yet, being based on a specific data structure. However, my goal is, over the next few days, to turn it into a nice generic search routine that I can use in a number of applications.

Julien Ortin’s Technical analysis indicators in F# – Oscillators

The articles of this series are being updated as the series expand. In particular : corrections were made to errors in the algorithms (an example use sample will be published to show what has been checked against either a spreadsheet application or TA-Lib) and modification of the meta information.

Julien Ortin’s Technical analysis indicators in F# – Moving Averages

This is part of a series on technical analysis indicators in F#, based on the multi-language TA-Lib. Quick disclaimer : some of these indicators are not verified.

Daniel Mohl’s .NET Remoting in F#: A Start to Distributed a Hash Table (DHT) and A Distributed Hash Table (DHT) in F#: Moving from .NET Remoting to WCF

In my last post I provided a start to a distributed hash table (DHT) using F#, the Chord protocol, and .NET remoting. In this post, I'll show how that code has changed due to a migration from .NET remoting to WCF.

Roger Alsing’s F# + Gold Parser = true

First of all, I have to confess that I’ve started to see the light of F# and AST manipulation. Anyway, I’ve created a F# skeleton template for Gold Parser and the Calitha .NET engine.

Can Erten’s Random number Generation with RNG

I would like to mention a question that posed on stackoverflow a year back, with a slight change: Given a function which produces a random integer in the range 0 to 4, write a function which produces a random integer in the range 0 to 6.

Vladimir Matveev’s F# and handling ASP.NET requests

Objective was the following: implement simple socket based application that will listen specified port, parse incoming HTTP requests (extract uri from request treating it as file) and return content of specified file. Roughly speaking it should be primitive http server.

Vladimir Matveev’s Evoked by "Patterns of Parallel Programming" (part 1) and Evoking by "Patterns of Parallel Programming" 1.1

One section in excellent article "Patterns of Parallel Programming" is dedicated to idiom "Speculative processing". In brief we can start multiple computation in parallel (utilizing advantages of multiple cores), take first result and ignore others. Unfortunatly F# library doesn't provide builtin primitive for this strategy.

From the CCNET Blog: CruiseControl.NET and F#

I’ve been writing some documentation on building plug-ins and recently I expanded it to include some Visual Basic examples. That got me thinking, what other languages can we build plug-ins in? So I thought I’d give it a quick try in one of the new fangled languages that people are raving about – F#.

Chris Marinos’ An Introduction to Functional Programming for .NET Developers

But in order for you to take advantage of all of these fantastic features of F#, you need to understand the basics. In this article, I’ll explain these concepts using vocabulary that you are already familiar with as a .NET developer. I will also show you some functional programming techniques that you can apply to your existing code and some ways in which you are already programming functionally.

Imperative Programming in F# (From F# in Action)

This article is taken from the book F# in Action. The authors discuss basics of imperative programming in F# and develop a simple application to show how this type of programming works. They also feature some of the interoperability among languages on .NET platform.

Wayne Delport’s Introducing F#

The purpose of this article is to introduce you to the F# language - what it is, it's origins, and how it fits into Visual Studio 2010 RC.

Anders Hejlsberg on functional programming, programming futures

I will not try and summarise [sic] the whole talk here; but will bring out its unifying thought, which is that programming is moving towards a style that emphasises [sic] the “what” rather than the “how” of the tasks it encodes.

Mike Roberts’ F# Simple Twitter Update

A short while ago I posted some code for a C# twitter update. I decided to move the same functionality / logic to F#. Here is what I came up with.

Enes Bajramovic’s Yet another page provider but in F#

Since the best way to learn programming language is to use it, I tought I could port the EPiServer XmlPageProvider to F#. FSharpPageProvider is my first attempt to accomplish that.

From The “F# Code” Blog: Generic Monadic Map and Join using statically resolved type variables

A demonstration of how the inline keyword and statically resolved type variables allow for much more robust type inference.

Discoveries This Week 05/24/2009

RickM — Mon, 25 May 2009 02:24:00 GMT

An exciting week with the release of Visual Studio 2010 Beta 1 and F# 1.9.6.16. This week we have John Backus’s classic FP manifesto, Luke Hoban speaks on F# in VS2010 beta 1, Django for ASP.NET, and an article on breaking changes in the latest F# release.

John Backus – Can Programming Be Liberated from the von Neumann Style?

Functional programs deal with structured data, are often nonrepetitive and nonrecursive, are hierarchically constructed, do not name their arguments, and do not require the complex machinery of procedure declarations to become generally applicable.

The functional programming manifesto. Well worth the time to read for anyone serious about functional programming.

Luke Hoban on Channel9 – What’s the Story? What’s Next?

Here, F# Program Manager Luke Hoban talks with me about F#, generally and what people have been doing with it, the current state of the technology, what F# enables

The most interesting thing I gleamed from the talk is that F# Powerpack will not be included with Visual Studio 2010. Luke hopes that this will allow faster development cycles.

Alex Pedenko’s Project, NDjango - Django templates in .NET

The current version is being released as a beta. It has full django tag support, and most of the default filters.

I’ve heard many great things about Django from my web developer friends. I’m sure many will be happy to see ASP.NET support. It can be used stand-alone or in conjunction with the Bistro Framework. Best of all, NDjango is built on F# and Bistro has full F# support.

Abel Avram on InfoQ - Latest F# Breaks Binary Compatibility

Microsoft has included F# in VS 2010 Beta 1 and has released a corresponding CTP update for VS 2008. The latest binaries, version 1.9.6.16, are not compatible with previous ones, v. 1.9.6.2, meaning all previous code needs to be recompiled.

Also important to note, the #light syntax is now on by default.

I understand it is exceedingly painful to sign up for an account to leave a comment. That given, I am still trying to figure out a solution to my spam problem. For now, if you would like to comment and don’t wish to set up an account, please email me your comment and I will manually post it.

Changing Your Garbage Collector Settings on the Fly (.NET Memory Management: Part 5)

RickM — Wed, 20 Aug 2008 20:39:00 GMT

It has come to my attention via a recent DZone article that .NET 3.5 and 2.0 SP1 jointly included a new feature which lets you manipulate the way your garbage collector acts programmatically. This can be done through changing the value of a new property of the System.Runtime.GCSettings class named LatencyMode. In this article I will walk you through this new property and the different effects of each of it's possible settings.

Other Articles in This Series

Part 1 – Basic Housekeeping
Part 2 – Improving Performance Through Stack Allocation
Part 3 – Increasing the Size of your Stack
Part 4 – Choosing the Right Garbage Collector Settings
Part 5 – Changing Your Garbage Collector Settings on the Fly

LatencyMode

The new LatencyMode property accepts three different enumerated values. The first two of which are Batch and Interactive which correspond to turning <gcConcurrent> on and off inside of your application configuration. However, the effects of the third value, which is named LowLatency, were previously unavailable by any means. By setting this the LatencyMode to LowLatency you can now put the Garbage Collector in an ultra-conservative mode which will insure the application will be interrupted as infrequently as possible.

There are a couple of things you should take note of before changing your Garbage Collector's LatencyMode:

LatencyMode settings are process-wide and so all of the threads in your application will be effected.
Changing LatencyMode will have no effect if your application has <gcServer> mode set in its configuration file.

Now, let’s explore each of the possible values of LatencyMode in detail:

Batch

When it’s useful:
It’s useful in applications without a UI and in Server Based Software. It may also be useful to switch your garbage collector into Batch latency mode if your application has a data crunching mode which occurs after a user interface.

What it does:
This is the most intrusive setting. Garbage Collection is done non-concurrently in one big batch call. Your program will be suspended while garbage collection takes place.

Defaults:
This is the default value when <gcConcurrent> is disabled.

Notes:
Even though this will be the enumeration which will be set if <gcServer> is enabled, the garbage collector will act as described in my previous article. In fact, if you have your application defined to be in <gcServer> mode the LatencyMode property cannot be changed from its default of “Batch”.

Interactive

When it’s useful:
It’s the best mode for most any UI-based application.

What it does:
This is the most balanced setting. Garbage Collection happens concurrently with your application. Most of the work is done in a separate thread and although your application will be suspended it will not happen very often and for only very short periods of time.

Defaults:
This is the default value for garbage collection on workstations. If <gcConcurrent> is left at its default value, this is the type of garbage collection that will occur.

LowLatency

When it’s useful:
It’s useful for time sensitive applications such as 3d rendering or data acquisition.

What it does:
This is the least intrusive mode the Garbage Collector can be set to. As in Interactive, garbage collections happen concurrently with your application. However, collection of older objects will only happen when memory pressure becomes high. Collection of generation 2 objects is kept to a bare minimum.

Defaults:
This is never the default setting.

Notes:
LowLatency mode was designed for short time use only during time-critical sections of your application. Leaving an application in LowLatency mode for an extended period of time will cause unused objects accumulate. Before using low latency mode, you should take a look at the guidelines laid out at the bottom of the MSDN Latency Modes page.

References
MSDN Visual Studio 2008 Developer Center – Latency Modes
MSDN .NET Framework Developer Center – GCLatencyMode Enumeration
DZone - Low-Latency GC in .NET 3.5

The Cursed History of Smalltalk in .NET

RickM — Wed, 18 Jun 2008 20:44:00 GMT

After my last blog post, due to some of the responses, I decided to spend some time with Smalltalk. As a DotNET developer by trade, I wanted to see what kinds of options were available for use on the CLR. Unfortunately, out of the five different DotNET...(read more)

Choosing the Right Garbage Collector Settings for Your Application (.NET Memory Management: Part 4)

RickM — Wed, 14 May 2008 18:11:00 GMT

Tuning the garbage collector to the specific context of the particular application can significantly improve the performance of both non-threaded and multi-threaded applications. In this post I discuss the gcConcurrent and gcServer settings which allow...(read more)

Increasing the Size of your Stack (.NET Memory Management: Part 3)

RickM — Tue, 22 Apr 2008 17:45:00 GMT

In the previous article I discussed a few of the benefits of stack allocation as well as a couple of C# keywords which help you to leverage those benefits. However, the one megabyte default stack size is too small for stack allocation to be used with...(read more)