During compilation, PostSharp takes great care in making sure that everything works correctly. When something goes wrong, PostSharp will report it as an error or a warning. Until now, however, whenever an error or a warning occurred, the developer had to manually navigate to that place in code.

We are excited to announce that with PostSharp 2.1 we’ve enhanced the errors and warnings with the exact location information, allowing you to simply double-click on the message and you’ll be taken to the error line!

To enable this feature, go to Tools – Options – PostSharp, and under Experimental, set Resolve Message Location to True:

Then, simply rebuild your solution, and if there are any warnings or errors, you’ll be able to see exactly where they are:

This is accomplished by specifying the member (in this case, the method) that is responsible for the message, in the aspect’s CompieTimeValidate method:

// Validate the attribute usage.
public override bool CompileTimeValidate( MethodBase method )
{
    // Don't apply to constructors.
    if ( method is ConstructorInfo )
    {
        Message.Write( method, SeverityType.Error, "CX0001", 
                       "Cannot cache constructors." );
        return false;
    }

    MethodInfo methodInfo = (MethodInfo) method;

    // Don't apply to void methods.
    if ( methodInfo.ReturnType.Name == "Void" )
    {
        Message.Write( method, SeverityType.Error, "CX0002", 
                       "Cannot cache void methods." );
        return false;
    }

    // Does not support out parameters.
    ParameterInfo[] parameters = method.GetParameters();
    for ( int i = 0; i < parameters.Length; i++ )
    {
        if ( parameters[i].IsOut )
        {
            Message.Write( method, SeverityType.Error, "CX0003", 
                           "Cannot cache methods with return values." );
            return false;
        }
    }

    return true;
}

Aspect developers are encouraged to include the member in error/warning messages. For more information, please refer to the documentation on Working with Errors, Warnings and Messages.

Please note that this is not enabled by default as it is still experimental and might have an impact on performance. Please let us know how it works out for you!

Happy PostSharping!

-Igal

I’m thrilled to announce that our partner IdeaBlade has just released a new version of DevForce. This application framework already provided pretty much all of the wiring you need to develop rich line-of-business applications (Silverlight and WPF backed by WCF, Entity Framework, OData). The last release now supports  domain models written for Entity Framework in Code First style… and that still respect the spirit of Code First: nice, clean code, free from infrastructure boilerplate.

Guess who is writing that boilerplate for you? Right: PostSharp. What’s nice with DevForce is that you can start coding immediately and don’t have to understand anything about AOP and PostSharp since DevForce provides all the aspects you need. Even better: you don’t need to download PostSharp and you don’t have to check-out any license: all is included in the IdeaBlade package.

See! I managed to avoid the c*c*c word.

I’d like to thank Albert and his team for their efforts and feedback during the RC stage of PostSharp 2.1. I’m sure DevForce and PostSharp will benefit from each other and will make it even easier to develop strong LOB applications.

Happy PostSharping – now even to those who never heard of PostSharp.

-gael

We’re thrilled to finally announce the availability of PostSharp training, worldwide. We’ve assembled an experienced team of trainers and consultants to offer a comprehensive 2 day course that’s designed to bring you up to speed fast on aspect-oriented programming and PostSharp.

The course includes hands-on labs and discussion where you’ll learn how to:

• create PostSharp aspects; and
• successfully introduce PostSharp aspects into complex projects.

Upon completion, you’ll be able to apply what you’ve learned to your own applications, and produce cleaner, more efficient, higher quality code than ever before.

Meet our Training & Consulting Partners

Donald Belcham is a senior software developer, independent contractor, and agile development expert who is a strong supporter of fundamental OO patterns and practices. He is co-author of the book, Brownfield Application Development in .NET (Manning Press, 2008), and actively shares his expertise with other technical professionals at user groups, code camps and conferences held throughout the world. Past lectures have covered topics that encompass development practices, quality team leadership, and the intricacies of new and emerging technologies.

 

Golo Roden works as self-employed trainer and consultant for C#, JavaScript and web development – focusing on code quality and agile methods. In 2011 he launched the Agile Development Framework, a comprehensive approach which combines the successful elements of previous agile methods. He has written more than 100 articles for professional magazines, has given more than 50 talks at international conferences, and wrote a book on C# in 2008. Golo blogs regularly and writes a recurring column on C# specialties for dotnetpro magazine.

 

Endjin is a collaboration of like-minded people who are imbued with an infectious enthusiasm for solving business problems through the smart application of technology. Their endjin-eers are outstanding individuals who have come together from across the business, creative and technology community having demonstrated a mastery of their craft. Unconstrained by industry vertical, company size or budget; endjin is motivated by solving problems. Their goal is to energize your business whether it is through a 2 hour conversation or 2 years of team effort.

PostSharp Training Agenda

The standard public agenda is composed of the following modules (note: for private training other topics can be introduced after discussion with the trainer):

• Introduction to AOP
• Basic aspects
• Applying aspects to code
• Interception aspects
• Aspect composition
• Composite aspects
• Deployment and build process integration
• Targeting different platforms
• Best practices

We’ve got more exciting training news coming in the weeks ahead and, if you sign-up now to request more information about PostSharp training, we’ll let you in on the exciting news (including an exclusive offer) before we announce it publicly.

Happy PostSharping!

-Britt

I’m excited to announce the first release candidate of PostSharp 2.1, available for download from our website and from the NuGet official repository.

PostSharp 2.1 is a minor upgrade of PostSharp 2.0; the upgrade is free for everybody. The objective of this version is to fix several gray spots in the previous release.

This release candidate is ought to be of very high quality and free of known bugs, but needs to be tested by the community before it can be labeled stable. As required by the RC quality label, the online documentation has been updated to reflect the latest API.

PostSharp 2.1 has full backward binary compatibility with PostSharp 2.0.

What’s new in RC 1?

This release candidates contains the following additions to the previous CTP:

• The design of architecture validation (PostSharp.Constraints) has been finalized.
• Warnings can be disabled locally (for a specific element of code) using the IgnoreWarning custom attribute. See online documentation for details.
• The PostSharp project property page in Visual Studio now allows you to specify which warnings should be globally ignored or escalated into errors.
• Compatibility with Code Contracts 4.0
• As an experimental feature, warnings and errors now come with file/line information. The feature must be enabled manually from Visual Studio options. We’re eager to hear feedback about this feature from customers with larger projects.
• 17 bug fixes

What’s new in PostSharp 2.1?

If you missed the previous announcements, here’s a list of new features in PostSharp 2.1 compared to version 2.0:

• Improved build-time performance: up to 5x faster. Read more.
• Architecture validation: build-time validation of design rules. Read more.
• Extended reflection API: programmatically navigate code references. Read more and more.
• NuGet packaging and improved no-setup deployment experience. Read more.
• Support for obfuscators: we now support Dotfuscator. Read more.
• Support for Silverlight 5.
• Compatibility with Code Contracts 4.
• Improved messaging API.
• Tab page in Visual Studio project properties.
• Streamlined licensing experience.
• License server.
• Streamlined “getting started” experience.

Upgrade your Projects

To upgrade your projects from PostSharp 2.0 to PostSharp 2.1 easily you can use the conversion utility included in the PostSharp HQ application. Just open the app and click on “convert”, then select the folder containing your projects. References to libraries and MSBuild imports will be automatically fixed.

PostSharp 2.1 Roadmap

A release candidate means that we are confident in the code quality and is that all mandatory quality work, including documentation, has been done. PostSharp 2.1 is now the default version on our download page. We’ll wait a couple of weeks to allow the community to give this version a try, then publish the RTM or another RC, according to the feedback.

Note that the license agreement allows for production use.

It’s now time to download PostSharp 2.1 and upgrade your projects!

Happy PostSharping!

-gael

I'm pleased to announce that the third and final Community Technical Preview of PostSharp 2.1 is now available for download on our website and as a NuGet package.

The new CTP is principally a stabilization release, with a large number of bug fixes (including all hot fixes from the 2.0 branch) and some corrections in the new API design. This CTP is more stable than the latest builds on the 2.0 branch, but this has of course to be validated by the community.

What’s New in PostSharp 2.1 CTP 3

• A streamlined experience for first-time users, including a redesigned PostSharp HQ application and new Learn PostSharp tool window in Visual Studio.
• PostSharp does not enter the evaluation mode automatically. Instead, a dialog box will ask you to explicitly enter the evaluation mode. This adds a little friction for those evaluating PostSharp but should help to clarify any licensing questions.
• Complete class reference documentation (the conceptual documentation is still not updated).
• Support for Windows Phone 7.1 Beta.
• Support for Silverlight and Windows Phone in the NuGet package.

What’s New in PostSharp 2.1 CTP 2

• Architecture constraints.
• Extended build-time reflection API.
• Support for obfuscation.
• Support for Silverlight 5.
• License server.

What's New in PostSharp 2.1 CTP 1

• Improvements in build-time performance.

What’s Next?

Now that the design is nearly finalized, we should finally blog about and document new features. The release candidate will be published as soon as the documentation is complete (the current release has been tested to release candidate-level quality).

Update Today

If your application is not going to production in the next few months, now is a great time to download PostSharp 2.1 and to upgrade your current application in a feature branch. Doing so will help us to validate the new version and move the final release date forward. Please report all issues on the support forum. Thanks!

Happy PostSharping!

-gael

I’m excited to announce the release of PostSharp 2.1 CTP 2, available for download from our web site and from the NuGet gallery. This CTP is mostly feature complete and has zero known bugs. It includes all fixes from the 2.0 branch.

If you’re not on a tight go-to-production schedule, it’s pretty safe to give this version a try now. Unlike with the previous CTP, we will be in “continuous delivery” mode and will be able to release hot fixes very quickly.

So what’s new in PostSharp 2.1? I’ll be blogging about individual features the next days. Here is a short summary:

• Build-time performance improvement
• NuGet packaging and improved no-setup experience
• Extensions to the System.Reflection API
• Architecture validation (constraints)
• Support for obfuscation
• Support for Silverlight 5
• License management

Build-Time Performance Improvement

Most users will see some improvement in the build-time performance of PostSharp, but for some users it could even mean a 500% speed up. The main reason? We completely rewrote the last step of the PostSharp pipeline: writing the modified assembly back to disk. The previous implementation was based on ILASM, which scaled badly for very large assemblies. The new implementation is fully written in unsafe C# and is probably the fastest available. Other improvements are due to a better utilization of multiple cores, although PostSharp remains largely a single-threaded program. For details about this feature, see our CTP 1 announcement.

This feature is available on all editions of PostSharp.

NuGet Package and Improved No-Setup Experience

PostSharp 2.1 can now be added to your application directly from Visual Studio thanks to NuGet. No need to run a program with elevated privileges. No need to edit your project file if you want to put PostSharp in your source repository. Everything is done by the NuGet package installer.

You can now use the Visual Studio Extension (VSX) even if you don’t want to run the setup program. The first time you (or your colleague) will build a program using PostSharp, a dialog box will ask you whether you want to install the VSX. No elevated privileges needed. When you deploy a new version of PostSharp to the source control, all developers get the updated VSX.

Thanks to NuGet, it will become much easier for vendors and open-source projects to include a dependency to PostSharp. Our friends at Gibraltar Software already uploaded their application monitoring agent, and will soon update it to include the dependency to the PostSharp package.

This feature is available on all editions of PostSharp.

Extensions to the System.Reflection API

How many times did you want to get the list of all classes in your assembly deriving from System.Forms.Control? Sure, you can enumerate all types and build the index yourself, but it’s quite CPU expensive. Since PostSharp already computes this information internally, it seemed natural to expose it to the PostSharp.dll library. The PostSharp.Reflection.ReflectionSearch class offers methods that allow you to search for:

• All custom attributes of a given type (or derived type);
• All custom attributes on a given declaration (including those added through MulticastAttribute);
• All types derived from a given class or implementing a given interface;
• All methods, fields or types referenced in the body of a given method;
• All methods using a given method, field or type in their body;
• All types, methods, fields, properties, events or parameters referencing a given type.

Note that this functionality is only available at build time. This feature is available on the Professional Edition only.

Architecture Validation (Constraints)

Many people used “empty” aspects that just did one thing: validate the code. You now have a better way to validate your code: constraints (namespace PostSharp.Constraints). As aspects, constraints are custom attributes that you put on your code. They contain code that gets executed for every assembly referencing this code. The constraint logic typically queries the current assembly using reflection and the newly introduced reflection extensions, and emit errors or warnings to Visual Studio. Since your code can use LINQ, you have a very powerful toy to play with! PostSharp comes with off-the-self constraints:

• [Friend], applied to an internal declaration, will raise an error if the declaration is used in a different namespace than the current one. It can be used to enforce isolation of components, and gives a level of visibility that stands between private and internal.
• [InternalImplements], applied on public interfaces, will raise an error if the interface is implemented in a different assembly. Use this constraint when you need to expose an interface but don’t want the users of your API to implement it, because you want to reserve the right to add new methods to the interface. PostSharp SDK is full of such interfaces that can be consumed but not implemented.
• [Internal], applied on a public declaration, will raise an error if the declaration is used in a third assembly. It can be used when you don’t want users to reference a part of the API, but have to make it public for technical reasons.

Note that architecture validation is disabled by default. You need to enable it in your project properties (“PostSharp” property page). This feature is available on the Professional Edition only.

Support for Obfuscation

Let me start with a disambiguation: PostSharp does not become an obfuscator with this feature. It just became compatible with some obfuscators.

In previous versions, you could get into serious problems if you tried to use PostSharp and any obfuscator in the same project. PostSharp relied on some metadata references that were broken by the obfuscator because of renaming, so you got runtime exceptions. This is obvious if, for instance, you had a field of type MethodInfo in your aspect. The method name was stored in the serialization stream and the obfuscator did not know how to modify it. There were other less obvious cases with aspects on generic methods.

PostSharp 2.1 can be made aware of obfuscators and write metadata references in a way that obfuscators can understand and modify. But the obfuscator has also to be aware of PostSharp.

We implemented support for Dotfuscator because it is the market leader and has a free edition that ships with Visual Studio. According to the feedback we get from this CTP, we will publish our specification so that other vendors can implement it if they are interested.

This feature is available on the Professional Edition only.

Support for Silverlight 5 Beta

PostSharp 2.1 supports Silverlight 5 applications. What to add? This feature is available on all editions.

License Management

First of all, we chose to rename the community edition to Starter Edition. We got too many questions whether the community edition can be used for commercial project. We hope the new name makes the answer clear: yes, you can use the Starter Edition in commercial projects, you will just enjoy less features than with the Professional Edition.

At SharpCrafters, our license enforcement policy is to trust the customer to respect the license agreement. That’s why there was no license enforcement in version 2.0. It was not just a priority. But we may have been too liberal by letting people deploy the license key in the source control: for many companies, it meant that nobody knew how many developers were using the product. We strongly believe in trust, but we think that we should provide tools for proper license management. So we did a few changes.

We chose to deprecate deployment of license keys through source control because we want some mental process to take place when a developer first starts using the product: he also needs a license. We provide a license metering solution: we will monitor how many people install the license on their computer, but we will never block them. If we that believe a license key is being used too many times, we will simply contact the one who purchased the license key and discuss a solution. But we trust you in first place. By requesting license installation by each user, we are just asking that every company maintains a record of who is using the software.

What if manual license bookkeeping is impractical? For these situations, we provide a license server (technically: a simple ASP.NET application backed by an SQL database). The license server maintains the list of leases and ensures that the license agreement is respected. It will send emails to the license administrator (or team leader, or whomever else) when new licenses should be acquired – and you will get a 30-day grace period to purchase them. We tried to make the license server a valuable tool for the customer. You are free to modify the underlying database at will if it makes sense. You as the customer are responsible for respecting the legal agreement and we trust you.

The license server will be available with a new type of licenses called corporate licenses, that will be available for a premium (likely +30% compared to the normal commercial license).

Upgrade Today

The upgrade is free for anyone. I am pretty confident of the quality of this release so it’s a great time for you to download it. Submit all your changes to source control, do the upgrade, rebuild, and run your unit tests. If it fails, shelve the changes and report the issue. We do a lot of internal testing, but we need your feedback to move quality of this release forward.

In the next days, I’ll try to blog about individual features of this release.

Happy PostSharping!

Join us on April 28th as Gael Fraiteur and Kendall Miller (Gibraltar Software) speak with this month's LIVE Webinar guest Gary Short about overcoming the timeless challenges developers face in building fast and scalable systems.

Gary is a frameworks technical evangelist for DevExpress, C# MVP, and frequent speaker at user groups and conferences throughout the UK, Europe and the U.S. -- including the upcoming DDD Scotland and TechEd conferences.

With presentation titles including How to Eat an Elephant, Data Mining the Social Web, and Credit Crunch Code, it's clear that Gary enjoys speaking about technical architecture.

In this month's LIVE Webinar you'll get a sneak peek at Gary's latest presentation, titled:

Asymptotics and Algorithms – What You’ve Forgotten Since University

Join the LIVE Webinar and discover:

• The lost art of calculating which algorithm is more efficient than another, and...
• Why managed environments, like .NET, may not know best.

Given the "big picture" performance theme of this month's Live Webinar, co-host Kendall Miller, will debut his latest presentation, titled:

Natural Laws of Software Performance

 

Join the LIVE Webinar and discover:

• The natural laws that govern software performance
• How technology has changed the tactics of high performance but is still at the mercy of these natural laws
• How understanding these laws will help you create applications that scale without arcane tricks or endless hardware

Sign Up Now and Receive a Live Meeting URL Prior to Kickoff >>

Last week we announced that PostSharp 2.1 CTP was available under our Early Access Program (EAP, in short). So what is the SharpCrafters EAP? It’s very simple:

• Free and open to everyone. You register by selecting the right option in your user profile.
• Get access to pre-releases. One you registered, CTPs and hot fixes will be unlocked.
• Get notifications to your mailbox every time an important bug has been fixed. We do not send commercial emails, just technical ones.
• Unsubscribe at any time. If you don’t want to participate in our EAP, you can unregister at any time by editing your profile.

So why are we offering this EAP? It’s also simple: because we need your help. Although we test every change carefully and have lots of regression tests, we just can’t think of every possible combination. Development environments have very different configurations, and compiler sometimes emit non-standard assemblies or debugging symbols. Most of the time, when we can think of a situation, we have a test for it. Most bugs come from situations we did not imagine. So we need your help to test PostSharp with the largest set of scenarios possible.

Our way to say Thanks!

Since we appreciate the time you spend testing our software and reporting issues, we will offer one free license of PostSharp Professional Edition for every bug you report and reproduce. You qualify if:

• You help us reproduce the issue, i.e. you typically provide material (source code or DLL) that let us reproduce and fix the bug.
• You are the first to report and reproduce the bug.
• We acknowledge it as a bug of reasonable importance (not as a ‘feature’ or a minor defect without impact, for instance).
• You have to claim the free license by email. Don’t assume we remember everything :).

If you report more than one bug, you will receive several free licenses for you to give away (not for resale).

We need your help. To get started, download PostSharp 2.1 CTP and report issues in the support forum.

Happy PostSharping!

-gael

I’m pleased to announce that the first Community Technical Preview of PostSharp 2.1 is available for download.  Note that you have to register to the Early Access Program before you can access download. Registration to the EAP is free for anybody.

As any CTP, this release is meant for testing and not for production use.

PostSharp 2.1 is a minor upgrade to PostSharp 2.0, which means that your existing license key should just work.

What’s New in PostSharp 2.1 CTP 1?

This first CTP is all about improving build-time performance, i.e. making PostSharp compile faster.

Much faster.

Here are the results measured by Bartek Legiędź and Remigiusz Cieślak, software engineers at Comarch in Poland. Their setup consists of a small number of very large projects (assemblies of several megabytes). As you can see, PostSharp 2.1 is more than five times faster than 2.0.

The next table compares the time taken by PostSharp while building the solution in two configurations (debug and release). Of course PostSharp itself ran in release mode both times.

Build Configuration	2.0	2.1	Speedup
Debug Configuration	160,662 ms	21,293 ms	672%
Release Configuration	121,694 ms	23,897ms	571%

Thanks guys for your time doing this benchmark!

The performance improvement you will experience with your setup depends on several factors: size and number of projects, number of aspects, and hardware resources. Also, remember that PostSharp is only a part of the build process. After upgrading to PostSharp 2.1, the build time may be dominated by the C# compiler or by Code Contracts.

I would like to hear about your own experience of performance improvements.

Here is how to produce benchmark results:

1. Wait until the system load is stably low (TortoiseSVNCache.exe and similar processes may load your processor)
2. Execute: Msbuild /p:Configuration=Debug /clp:PerformanceSummary /t:rebuild > msbuild-2.0.log
3. Upgrade your project to PostSharp 2.1 (see below)
4. Execute: Msbuild /p:Configuration=Debug /clp:PerformanceSummary /t:rebuild > msbuild-2.1.log

The performance report lays near to the end of the log file, above the summary of warnings and errors. For greater accuracy, you should execute MSBuild three times with every version of PostSharp, and take the best results. Then you can send me both performance summaries by email (gael@sharpcrafters.com) so I can see how large are improvements with real-life projects. Frankly, I don’t expect 500% improvement for everybody.

What Changed in PostSharp 2.1 CTP

Most performance improvements were obtained by replacing the component that writes back the assembly to disk. Before version 2.1, PostSharp still used  our ol’ good text-based writer, backed by Microsoft’s ILASM. This required a lot of I/O just to create the text IL file (some customers reported files of several hundreds of megabytes), then ILASM required a lot of CPU and memory to process it. Fortunately, this was not that bad and there were excellent reasons to keep this writer. Now we have our own assembly writer, coded by your servant himself, and tuned with all the obsession and passion he is able of.

You should normally not observe any difference from PostSharp 2.0, except of compilation speed. Debugging support may be a little improved because I integrated some bits of the Microsoft CCI PDB reader/writer into PostSharp, but this debugging support is still to be fine-tuned.

So except this, there’s no change in this CTP, no addition of feature.

Redefinition of the Community Edition

The Community Edition is being renamed Starter Edition, because the former name did confuse many people.

We’re doing two little changes in the features available to the Starter Edition:

• The Aspect Dependency Framework (PostSharp.Aspects.Dependencies) will not be available any more in the Starter Edition. Frankly, this feature was present by mistake, since it clearly supports “pro” scenarios. To order aspects, Starter users will have to use the AspectPriority attributes, i.e. they will have to assign an integer to every aspect.
• The Starter Edition will not run from source control. It will have to be installed on the computer.
• Yes, the new build-time performance enhancements are available to the Starter Edition!

So we add a lot and we remove a little in order to position the Starter Edition as a light tool for individuals, and the Professional Edition as – well -- a professional tool for teams. We do not push anyone in the corner. You all have workarounds: installing the product or using AspectPriority. We are just getting clearer about the positioning of each edition. We think we’re adding more comfort to the Starter Edition than we actually remove.

And remember: PostSharp is cheap (usually less than one day of bill), and we give a lot of discounts to students, Microsoft BizSparks members, or influencers.

Upgrade to PostSharp 2.1 CTP

PostSharp 2.1 CTP can be installed side-by-side with PostSharp 2.0 on the same machine. At build time, the correct version of PostSharp should kick in, according to the version of PostSharp.dll your project is referencing.

There is one exception to this rule. The Visual Studio Extensions (VSX) cannot be installed side-by-side, so the setup program of PostSharp 2.1 will remove the VSX of PostSharp 2.0 and replace it by the new version. Since it’s backward compatible, the VSX 2.1 will work with projects using PostSharp 2.0.

Once you’ve installed PostSharp 2.1 (or copied it to your source control), you can run the PostSharp 2.1 Conversion Utility (PostSharp.Convert.exe), a simple application that let you update your references from previous versions to the current one. The utility is also able to prepare your project to run PostSharp from source control, if you prefer not to install it using the setup program. Note that all this utility does is to edit your csproj or vbproj files.

Gotcha: When a project references both PostSharp 2.0 and 2.1

What happens if you have a project that has been migrated to PostSharp 2.1, but uses a component (such as Gibraltar aspects) that has not been? The project would have a direct reference to PostSharp.dll version 2.1, and an indirect reference to PostSharp.dll version 2.0.

1. Make sure that the old PostSharp.dll dependency is not copied to your final bin directory. At run-time, you will need the version 2.1.
2. Install the last hot fix of PostSharp 2.0.
3. Add the following code to your application configuration file:

<configuration>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="PostSharp" publicKeyToken="b13fd38b8f9c99d7" 
                          culture="neutral"  />
        <bindingRedirect oldVersion="2.0.0.0" newVersion="2.1.0.0"  />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>

Therefore, our partners don’t need to recompile their product for every of our minor version, and you can always use the version of PostSharp you would like.

What’s Next?

We did our best to address the major painful point reported by users: building time. We tested the new PE writer on large and complex assemblies like those forming the .NET framework itself. Now we want to hear from you:

• Does it work for your projects?
• What are the performance gains?

In the mean time, we’ll be working on the next CTP, which should bring some minor new features. Then there’ll be the cycle of RC and finally the winner RC will be promoted RTM.

Happy PostSharping!

-gael

ATTENTION LONDON .NET COMMUNITY:
We’ll be in town next Thursday, December 2nd, for a full-day of PostSharp Training.

Here’s the agenda:

10:00 - 10:45	An introduction to PostSharp and Aspect-Oriented Programming
11:00 - 11:15	PostSharp customer presentation
11:15 - 12:00	Hands-on: developing simple aspects and applying them to code; understanding aspect lifetime; troubleshooting
Lunch!
13:00 - 14:15	Deep dive into aspect types, code generation, and other advanced features
14:30 - 15:45	Hands-on: developing complex aspects with advice and pointcuts; solving/preventing conflicts between multiple aspects on the same piece of code
16:00 - 17:15	What’s new in PostSharp 2.0; Comparison to other AOP frameworks; Licensing and pricing
17:30 - 18:00	Workshop: the value of aspect-oriented programming and what we can do to make it popular in .Net.

Here’s the best part—it’s free!

If you’re in the London area, and would like to learn more about how PostSharp helps teams produce cleaner code, please contact me via email (britt@sharpcrafters.com) and I'll add you to the attendee list plus send you the location details.

-Britt