Content by Category
.NET 1.x
.NET 2.0
.NET 3.0
.NET 3.5
.NET 4.0
.NET 4.5
.NET Assemblies
.NET Framework
.NET Getting Started
Accessibility
ADO.NET
Advertorials
Agile Development
AJAX
Amazon Web Services
Analysis Services
Android
Architecture
Arduino
ASP .NET Web API
ASP.NET
ASP.NET MVC
ASP.NET WebForms
Azure
B2B (Business Integration)
BDD
Big Data
Bing
BizTalk
Book Excerpts
Build and Deploy
Business Intelligence
C#
C++
ClickOnce
Cloud Computing
Code Contracts
CODE Framework Info - non Technical
CODE on the Road!
COM+
Community
Conferences
Continuous Integration
Crystal Reports
CSLA.NET
CSS
Data
Debugger
Design Patterns
Development Process
Display Technologies
Distributed Computing
Document Database
DotNetNuke
DSL
Dynamic Languages
Dynamic Programming
Editorials
Enterprise Services ("COM+")
Entity Framework
Events
Expression Blend
F#
Fox to Fox
Frameworks
Functional Programming
Git
Graphics
HTML 5
Internet Explorer 8.0
Interviews
IOS
iPhone
Iron Ruby
Java
Java Script
JavaScript
jQuery
JSON
Lightswitch
LINQ
Linux
LUA
Mac OS X
MDX
Messaging
Metro
Microsoft Application Blocks
Microsoft Business Rules Framework
Microsoft Dynamics
Microsoft Expression
Microsoft Office
Mobile Development
Mobile PC
Mono
MsBuild
MVVM
MySQL
Network
NHibernate
node.js
NOSQL
Nuget
Object Oriented Development
Objective C
Odata
OLAP
Open Source
Opinion
Opinions
Oracle
ORM
Other Languages
Parallel Programming
Patterns
PHP
Podcasts
Post Mortem
PowerPoint
Print/Output
Prism
Product News
Product Reviews
Project Management
Prolog
Python
Q&A
Rails
Rake
Razor
Reporting Services
REST
RIA Services
Ruby
Ruby on Rails
Scheme
Search
Security
Services
SharePoint
SignalR
Silverlight
SOA
Social Networks
Software & Law
Software Business
Source Control
Speech-Enabled Applications
SQL Server
SQL Server 2000
SQL Server 2005
SQL Server 2008
SQL Server 2012
SQL Server CE/AnyWhere/Mobile/Compact
SSIS
Subversion
Sync Framework
Tablet PC
TDD
Team System
Techniques
Testing and Quality Control
TFS
Tips
TypeScript
UI Design
UML
User Groups
VB Script
VB.NET
Version Control
VFP and .NET
VFP and SQL Server
Virtual Earth
Vista
Visual Basic
Visual Basic 6 (and older)
Visual FoxPro
Visual Studio .NET
Visual Studio 11
Visual Studio 2005
Visual Studio 2008
Visual Studio 2010
Visual Studio 2011
Visual Studio 2012
Visual Studio Tools for Office
VSX
WCF
Web Development (general)
Web Services
WebMatrix
WF
Whitepapers
Windows 7
Windows 8
Windows Azure
Windows Live
Windows Phone 7
Windows Phone SDK
Windows Server
Windows Vista
WinForms
WinRT
Workflow
WPF
XAML
Xiine Documentation
XML
XNA
XSLT



LearnNow


XAMALOT
 


LearnNow

Category: .NET Assemblies


22 Articles
found and displayed in this view.

  • Reengineering .NET: Injecting Quality, Testability, and Architecture into Existing Systems - Chapter 3: Unit Testing

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Monday, November 19, 2012
    Quick ID: 1211073
    This excerpt is from Reengineering .NET: Injecting Quality, Testability, and Architecture into Existing Systems, by Bradley Irby, Published Oct 24, 2012 by Addison-Wesley Professional. Part of the Microsoft Windows Development Series series. Copyright 2013, ISBN-10: 0-321-82145-9. To Purchase this book go to: http://www.informit.com/store/reengineering-.net-injecting-quality-testability-and-9780321821454 .

  • Tasks and Parallelism: The New Wave of Multithreading

    Magazine/Issue: CoDe Magazine, 2012 Nov/Dec
    Release Date: Thursday, October 04, 2012
    Quick ID: 1211071
    Since the beginning of .NET, developers have been able to take advantage of multithreading when developing applications. In fact we’ve been given more than one programming model to accommodate just about any requirement that might come across. There’s the Thread class, the Thread Pool, the Async Pattern, and the Background Worker. Well, as if that isn’t enough, we now have a couple of more patterns that bring with them another genre - parallel programming.

  • Inside Visual Studio LightSwitch

    Magazine/Issue: CoDe Magazine, 2011 Mar/Apr
    Release Date: Friday, February 11, 2011
    Quick ID: 1103051
    Microsoft Visual Studio LightSwitch uses a model-centric architecture for defining, building, and executing a 3-tier LightSwitch application.

  • Chapter 2: Creating Versatile Types

    Magazine/Issue: Online CoDe Magazine, Book Excerpts
    Release Date: Sunday, March 21, 2010
    Quick ID: 100083
    Whenever you create your own classes, you need to consider the circumstances under which they could be used. For example, will two instances of your Item struct ever be compared for equality? Will your Person class need to be serializable, or sortable?

  • How Many Threads Do You Need?

    Magazine/Issue: Online CoDe Magazine, Publisher's Point
    Release Date: Monday, May 29, 2006
    Quick ID: 060033
    Markus Egger discusses the need to create multi-threaded applications.

  • LINQx

    Magazine/Issue: CoDe Magazine, 2005 - Nov/Dec
    Release Date: Friday, October 28, 2005
    Quick ID: 0511121
    Microsoft demonstrated a new technology at PDC called LINQ (Language Integrated Query). The following note from Alan Griver, a member of the LINQ team at Microsoft, offers some details related to the LINQ project. In future issues of CoDe Magazine we will have more details on LINQ.Microsoft demonstrated a new technology at PDC called LINQ (Language Integrated Query). The following note from Alan Griver, a member of the LINQ team at Microsoft, offers some details related to the LINQ project. In future issues of CoDe Magazine we will have more details on LINQ.

  • What's New in .NET 2.0 for Assemblies and Versioning?

    Magazine/Issue: CoDe Magazine, 2005 - Jul/Aug
    Release Date: Monday, June 20, 2005
    Quick ID: 0507041
    The third release of the .NET Framework (version 2.0) introduces many changes and innovations not just in the application frameworks, but also in the essential mechanics of assemblies themselves.Microsoft strived to improve on a few limitations of the original assemblies model, as well as provide new features and capabilities in assemblies and in the tools used to build and manage them, predominantly Visual Studio 2005. These include application assembly reference, reference aliasing, friend assembly, better strong name protection, specific versioning, and targeting specific CPU architectures, and more. This article describes each such new feature, and when applicable, recommends best practices and guidelines.

  • Pest Control

    Magazine/Issue: Online CoDe Magazine, Publisher's Point
    Release Date: Monday, February 07, 2005
    Quick ID: 050033
    Brian Kernighan [1] once said, "Debugging is twice as hard as writing code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it." This quote gets a little giggle out of most developers, but on the serious side, there is a lot of truth in it. Writing code that does cool or useful things certainly is much easier than writing code that does cool or useful things reliably.

  • The Importance of the Managed Platform

    Magazine/Issue: Online CoDe Magazine, Publisher's Point
    Release Date: Tuesday, August 31, 2004
    Quick ID: 040073
    .Net is a maturing platform. The first .NET alphas and betas went to a selected group of people years and years ago. At this point, we are approaching the third major installment of Visual Studio .NET (now called "Visual Studio 2005"). Surely at this point, nobody has to explain what .NET and the Managed Platform is. Or do we?

  • Managing Processes in .NET

    Magazine/Issue: CoDe Magazine, 2004 - March/April
    Release Date: Friday, February 20, 2004
    Quick ID: 0403051
    The Process class allows you to gain full control over system processes.You can start and stop processes and retrieve information about running processes such as the list of loaded modules and the characteristics of the memory occupied. The class also features handy methods to know whether a process is responding or has just exited and with which return code. Programmers also have full control over the style of the window the process runs in. After an overview of the capabilities of the Process class, this article demonstrates how to hide running console processes, monitor their execution, and capture any output. I'll use this strategy to create a sample Compression class to use with WinZip and gzip (popular tools for compressing data).

  • An Introduction to Visual Studio .NET Whidbey

    Magazine/Issue: CoDe Magazine, 2004 - January/February
    Release Date: Monday, January 05, 2004
    Quick ID: 0303022
    When I was asked to write a few pages on what's coming in the next version of Microsoft Visual Studio .NET (code named Whidbey), the biggest issue I had was how to limit this article to a few pages.I opted to list a few categories and drill down into each. I'm not going to cover everything, just some key items in each area. Please note that not all of these changes are implemented in the PDC build that attendees are receiving, and that some of these features are still in the planning stages. That said, here are the categories that I'd like to discuss:

  • Touring Base Class Library Enhancements

    Magazine/Issue: CoDe Magazine, 2004 - January/February
    Release Date: Monday, January 05, 2004
    Quick ID: 0303042
    As the core API set underpinning managed application development in .NET, the Base Class Libraries, receive several long-awaited and notable additions in the Whidbey release.The Base Class Libraries (BCL) provide a standardized set of managed APIs to accomplish all of the common and most widely executed application tasks. BCL enhancements surface in as performance-based improvements, class-oriented feature additions, and the introduction of previously missing functionality through entirely new classes.

  • Defining and Using Custom Attribute Classes in C#

    Magazine/Issue: CoDe Magazine, 2003 - July/August
    Release Date: Sunday, June 15, 2003
    Quick ID: 0307041
    The complex, component-style development that businesses expect out of modern software developers requires greater design flexibility than the design methodologies of the past. Microsoft's .NET Framework makes extensive use of attributes to provide added functionality through what is known as "declarative" programming. Attributes enhance flexibility in software systems because they promote loose coupling of functionality. Because you can create your own custom attribute classes and then act upon them, you can leverage the loose coupling power of attributes for your own purposes.

  • Auto-Deploying Windows Forms .NET Applications: The Revenge of the Fat Client

    Magazine/Issue: CoDe Magazine, 2003 - July/August
    Release Date: Sunday, June 15, 2003
    Quick ID: 0307061
    .NET provides new tools to make deployment of fat client .NET applications easier.This article describes the basics of .NET Auto-Deployment technology and the security mechanism that prevents users from inadvertently running code distributed by hackers and virus writers.

  • Working with Extender Classes

    Magazine/Issue: CoDe Magazine, 2003 - Jan/Feb
    Release Date: Sunday, December 15, 2002
    Quick ID: 0301041
    Extender classes do just that; they allow you to extend the functionality of a .NET control class. The Error Provider and Tooltip classes are two examples of extender classes in the .NET Framework. The Tooltip class represents a significant departure from how tooltips were implemented in earlier versions of Visual Studio. The Error Provider class provides a new way to inform users about invalid input. Although each class serves a different purpose, their implementation is quite similar. This article introduces these two classes and gives a brief, yet comprehensive primer on how to use them

  • Reflection Part 2: Emit

    Magazine/Issue: CoDe Magazine, 2003 - Jan/Feb
    Release Date: Sunday, December 15, 2002
    Quick ID: 0301051
    In our previous article, Reflection Part 1: Discovery and Execution, we introduced the System.Reflection namespace and its classes which allow developers to view assembly metadata, query for and discover types, and invoke code?all at run-time. In this article we will examine reflection emit?the ability to dynamically generate code at run-time.

  • Threading Support in the .NET Framework

    Magazine/Issue: CoDe Magazine, 2002 - Nov/Dec
    Release Date: Friday, November 01, 2002
    Quick ID: 0211141
    This article explains in depth how to implement multi-threading in your .NET applications.

  • Dynamically Executing Code in .NET

    Magazine/Issue: CoDe Magazine, 2002 - Nov/Dec
    Release Date: Tuesday, October 15, 2002
    Quick ID: 0211081
    This article demonstrates the techniques for compiling dynamic code in your .NET applications.

  • Stateful Network-Deployable .NET Components Use Isolated Storage

    Magazine/Issue: CoDe Magazine, 2002 - Nov/Dec
    Release Date: Tuesday, October 15, 2002
    Quick ID: 0211111
    Sometimes an application needs to keep its data in its own secure "sandbox". This article demonstrates creating these isolated applications in .NET.

  • Microsoft Exception Management Application Blocks

    Magazine/Issue: CoDe Magazine, 2002 - Nov/Dec
    Release Date: Tuesday, October 15, 2002
    Quick ID: 0211131
    A new feature of .NET is its ability to handle exceptions. This article demonstrates implementing Microsoft's Exception Management Application Blocks.

  • Reflection Part 1: Discovery and Execution

    Magazine/Issue: CoDe Magazine, 2002 - Nov/Dec
    Release Date: Tuesday, October 15, 2002
    Quick ID: 0211161
    One feature of the .NET environment is the ability to read meta-data from classes and namespaces created in .NET. This article demonstrates accessing this data.

  • End DLL Hell with .NET Version Control and Code Sharing

    Magazine/Issue: CoDe Magazine, 2002 - July/Aug
    Release Date: Saturday, June 15, 2002
    Quick ID: 0207071
    Component-oriented programming must allow for clients and components to evolve separately.Component developers should be able to deploy new versions (or just defect fixes) of existing components without affecting existing client applications. Client developers should be able to deploy new versions of the client application and expect it to work with older component versions. As a component technology, .NET must enforce version control, allowing for separate evolution paths and for side-by-side deployment of different versions of the same component. .NET should also detect incompatibility as soon as possible and alert the client.


 

TOWER 48

  AppsWorld Europe


SSWUG