PainlessSVN provides you with the ability to completely manage your Subversion Repositories & Server conviently and effectively without the using of command line interface.
PainlessSVN Features
.NET Framework version 3.0 is Microsoft’s managed-code programming model for developing software on the Windows platform. .NET Framework 3.0 includes Windows Presentation Foundation, Windows Communication Foundation, Windows Workflow Foundation, and Windows CardSpace technologies.Today you can learn these new technologies through a series of guided, hands-on labs which can be completed in 90 minutes or less.
Windows CardSpace Virtual Labs
Core Features of Windows CardSpace
Windows Presentation Foundation Virtual Labs
Building Windows Presentation Foundation Applications C# Part 1
Building Windows Presentation Foundation Applications C# Part 2
Building Windows Presentation Foundation Applications VB Part 1
Building Windows Presentation Foundation Applications VB Part 2
Windows Communication Foundation Virtual Labs
A Server Scenario Lab with Windows Communication Foundation
Understanding Windows Communication Foundation
The Fundamentals of Programming the Windows Communication Foundation
Reliable and Transacted Messaging with the Windows Communication Foundation
Windows Workflow Foundation Virtual Labs
A Server Scenario Lab with Windows Workflow Foundation
Getting Started with Windows Workflow Foundation
You get a downloadable manual and a 90-minute block of time for each module. You can sign up for additional 90-minute blocks at any time.
Scott used a few slides to explain each programming model concept in Silverlight, and then showed a very base sample for each concept that helped present concretely how it worked.
In the talk Scott covered fallowing Silverlight concepts:
You can download the slides + demos of this talk below:
Included in the .zip download are readme instructions on how to run all of the samples on your own machine.
Updated utilities are ZoomIt, Streams, String, PsExec, SigCheck and DiskExt.
List of changes:
ZoomIt - you can type text while zoomed and you can also create scratch pad by clearing screen.
Streams - Streams now supports printing and deleting streams on volume root directories. There is also new -accepteula switch - hope so it will be included with every single utility :(
String - improving performance by limiting no. of bytes that it is reading
PsExec - Officially this release to PsExec, a utility for running programs on remote systems, corrects a buffer overflow bug caused by long command line arguments. Unofficially as I found out - it also fixes bug with running PsExec against local computer (PsExec \\%ComputerName% cmd is giving you error regarding user name or password). Finally :) This is quite pain when you got automated processing.
SigCheck - new switches -a and -m (more version data and manifests)
DiskExt - now reports the mappings for volume that have not been mounted by a file system.
[Via MartinZugec's blog ]
In this 2-hour clinic you will learn about the rich functionality that ASP.NET AJAX Extensions provides for building highly responsive and enhanced web applications. In addition to learning about the different server and client components of ASP.NET AJAX, you will also learn how to build new ASP.NET AJAX applications and how to upgrade existing ASP.NET applications to take advantage of ASP.NET AJAX.
Clinic Content
Clinic Overview
Navigation Overview
Overview of ASP.NET AJAX
Introduction to AJAX and ASP.NET AJAX
Introduction to the Architecture of ASP.NET AJAX
Programming with ASP.NET AJAX
Building a Simple ASP.NET AJAX Application
Using the AJAX Library to Enhance Web User Interfaces
Calling Web Services and Web Methods from the Client
Additional Information
This collection of 3 2-hour premium clinics teaches about the new capabilities provided by the .NET Framework 3.0. These clinics are for experienced(2 years) Developers and SW Architects who are looking to integrate Microsoft's next generation technology within their projects.
Topics covered within the offer include:
Clinic 5136: Introduction to Developing with Windows® Workflow Foundation and Visual Studio® 2005
With DataBatcher you can perform the following tasks in a batch-processed manner:
Features
The DataGridView control in .NET 2.0 is an incredible data representation control, and contains many features that you could benefit from. The only thing that is not supported by this control is the printing feature.Salan Al-Ani created the class for this feature and share it with others.
PowerShell Analyzer is a rich interactive environment for Windows PowerShell. Its goal is to be the PowerShell host of choice for IT professionals and system administrators. It has all the typical editor and IDE functionality that you would expect when working on a modern language, but it focuses on the real time interactive experience as if you were at the console, helping you compose the commands you want to use, and also giving you rich graphical visualization of the results. PowerShell may seem to just return text like the average Unix shell, but in reality, it is returning rich self describing Dotnet objects. PowerShell Analyzer not only helps you with the INPUT, but also with the output. It shows you the properties of the rich objects that the commands return, as well as specific visualizers to help you interact with output such as XML, HTML, charts, tables, and hierarchical data structures.
The way to change font for a single cell in an unbound datagridview.
int columnIndex = 1;
int rowIndex = 2;
// create bold font based on the default font
Font newFont = new Font(dataGridView1.Font, FontStyle.Bold);
dataGridView1[columnIndex, rowIndex].Style.Font = newFont;
Using this simple technique you can change foreground or background color ( and many more style related properties ) for specific cell .
Sometimes we need to edit aggregated property - I mean the property that represents object with few properties .The simple way to do this - we can use TypeConverter with ExpandableObjectConverter as shown in the example
[TypeConverter(typeof(ExpandableObjectConverter))]
public class FullName
{
private string _FirstName;
private string _LastName;
public FullName(string _FirstName, string _LastName)
{
this._FirstName = _FirstName;
this._LastName = _LastName;
}
[DisplayName("First Name")]
[Description("First name of the person")]
public string FirstName
{
get
{
return _FirstName;
}
set
{
_FirstName = value;
}
}
[DisplayName("Last Name")]
[Description("Last name of the person")]
public string LastName
{
get
{
return _LastName;
}
set
{
_LastName = value;
}
}
///<summary>
///Returns a <see cref="T:System.String"></see>
/// that represents the current <see cref="T:System.Object"></see>.
///</summary>
///
///<returns>
///A <see cref="T:System.String"></see>
/// that represents the current <see cref="T:System.Object"></see>.
///</returns>
///<filterpriority>2</filterpriority>
public override string ToString()
{
return _FirstName + " " + _LastName;
}
}
[DisplayName("Full Name")]
[Description("Full name of the person")]
public FullName FullName
{
get
{
return _FullName;
}
set
{
_FullName = value;
}
}
Result - the editor for aggregated object
We need to cretate new type inhereted from UITypeEditor with custom painting( in our case the images located in resource file - where each image name equals to memeber of the enum ) as shown below
public class CountryEditor : UITypeEditor
{
///<summary>
///Indicates whether the specified context supports
/// painting a representation of an object's value within the specified context.
///</summary>
///
///<returns>
///true if
/// <see cref="M:System.Drawing.Design.UITypeEditor.PaintValue(System.Object,System.Drawing.Graphics,System.Drawing.Rectangle)">
/// </see> is implemented; otherwise, false.
///</returns>
///
///<param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext">
/// </see> that can be used to gain additional context information. </param>
public override bool GetPaintValueSupported(ITypeDescriptorContext context)
{
return true;
}
///<summary>
///Paints a representation of the value of an
/// object using the specified <see cref="T:System.Drawing.Design.PaintValueEventArgs"></see>.
///</summary>
///
///<param name="e">A <see cref="T:System.Drawing.Design.PaintValueEventArgs">
/// </see> that indicates what to paint and where to paint it. </param>
public override void PaintValue(PaintValueEventArgs e)
{
string resourcename = Enum.GetName(typeof (Country), e.Value);
// retrive image from resource file
Bitmap countryImage =
(Bitmap)Resources.ResourceManager.GetObject(resourcename);
Rectangle destRect = e.Bounds;
countryImage.MakeTransparent();
// paint
e.Graphics.DrawImage(countryImage, destRect);
}
}
Create new EnumTypeConverter
public class EnumTypeConverter : EnumConverter
{
private Type _enumType;
public EnumTypeConverter(Type type)
: base(type)
{
_enumType = type;
}
public override bool CanConvertTo(ITypeDescriptorContext context,
Type destType)
{
return destType == typeof(string);
}
public override object ConvertTo(ITypeDescriptorContext context,
CultureInfo culture,
object value, Type destType)
{
FieldInfo fi = _enumType.GetField(Enum.GetName(_enumType, value));
DescriptionAttribute dna =
(DescriptionAttribute)Attribute.GetCustomAttribute(
fi, typeof(DescriptionAttribute));
if (dna != null)
return dna.Description;
else
return value.ToString();
}
public override bool CanConvertFrom(ITypeDescriptorContext context,
Type srcType)
{
return srcType == typeof(string);
}
public override object ConvertFrom(ITypeDescriptorContext context,
CultureInfo culture,
object value)
{
foreach (FieldInfo fi in _enumType.GetFields())
{
DescriptionAttribute dna =
(DescriptionAttribute)Attribute.GetCustomAttribute(
fi, typeof(DescriptionAttribute));
if ((dna != null) && ((string)value == dna.Description))
return Enum.Parse(_enumType, fi.Name);
}
return Enum.Parse(_enumType, (string)value);
}
}
Then use attribute Editor
[DisplayName("Country")]
[Description("Country")]
[TypeConverter(typeof(EnumTypeConverter))]
[Editor(typeof(CountryEditor), typeof(UITypeEditor))]
public Country Country
{
get
{
return _Country;
}
set
{
_Country = value;
}
}
Now we can see the combo box as editor for our Enum type
SharpForge supports collaborative development and management of multiple software projects. Similar to SourceForge or CodePlex but for your own team or organisation. The software is written in C# for .NET 2.0 is integrates with Subversion for source control and is released under the New BSD License.
Features
[Via Larkware News]
/// <summary>
/// Calculates the opposite color
/// </summary>
/// <param name="clr">Given color</param>
/// <returns></returns>
public static Color CalculateOppositeColor(Color clr)
{
return Color.FromArgb(255 - clr.R, 255 - clr.G, 255 - clr.B);
}
This is an agile HTML parser that builds a read/write DOM and supports plain XPATH or XSLT (you actually don't HAVE to understand XPATH nor XSLT to use it, don't worry...). It is a .NET code library that allows you to parse "out of the web" HTML files. The parser is very tolerant with "real world" malformed HTML. The object model is very similar to what proposes System.Xml, but for HTML documents (or streams).
Sample applications:
- Page fixing or generation. You can fix a page the way you want, modify the DOM, add nodes, copy nodes, well... you name it.
- Web scanners. You can easily get to img/src or a/hrefs with a bunch XPATH queries.
- Web scrapers. You can easily scrap any existing web page into an RSS feed for example, with just an XSLT file serving as the binding. An example of this is provided.
[Via Roy Osherove's Blog]
