We can disable the close button of a Windows Form in three ways
- Set controlbox property to false – It is most easy way to do this. But it also hides the Minimize and Maximize buttons.
- Using WIN32 API – Using Win32 API, we are getting the system menu and removes the close menu item using Remove menu item.
Here is the Code.
const int MF_BYPOSITION = 0x400;
[DllImport("User32")]
private static extern int RemoveMenu(IntPtr hMenu, int nPosition, int wFlags);
[DllImport("User32")]
private static extern IntPtr GetSystemMenu(IntPtr hWnd, bool bRevert);
[DllImport("User32")]
private static extern int GetMenuItemCount(IntPtr hWnd);
//In the Form load event
IntPtr hMenu = GetSystemMenu(this.Handle, false);
int menuItemCount = GetMenuItemCount(hMenu);
RemoveMenu(hMenu, menuItemCount - 1, MF_BYPOSITION);
And here is the screenshot
Using WIN32 API
- By Overriding the CreateParams property – The CreateParams property gets the required creation parameters when the control handle is created. By overriding the property we are removing the close button. You can get more information about CreateParams in MSDN
Here is the code.
private const int CS_CLOSE = 0x200;
protected override CreateParams CreateParams
{
get
{
CreateParams parms = base.CreateParams;
parms.ClassStyle |= CS_CLOSE; //
return parms;
}
}
And here is the screenshot
By Overriding CreateParams property
All of above three methods will work fine. But if you are using Windows 7 none of the above will work or OS will override all these.
Windows 7 - Close Window
Another new feature in the .NET 4 Framework is support for tuple,which are similar to anonymous classes that you can create on the fly. A tuple is a data structure used in many functional and dynamic languages, such as F# and Iron Python. By providing common tuple types in the BCL, we are helping to better facilitate language interoperability. Many programmers find tuple to be convenient, particularly for returning multiple values from methods.
Here is a code which uses a function that returns two values.
class Program
{
static void Main(string[] args)
{
//Getting the values from the Tuple Function
Tuple<string, string> details = GetDetails();
Console.WriteLine("FirstName : {0}, LastName :{1}", details.Item1, details.Item2);
Console.Read();
}
//Tuple function, which reads two values from
//user and returns to the main
static Tuple<string, string> GetDetails()
{
Console.Write("Enter First Name:");
string _firstName = Console.ReadLine();
Console.Write("Enter Last Name:");
string _lastName = Console.ReadLine();
return new Tuple<string, string>(_firstName, _lastName);
}
}
You can find more details about Tuples in MSDN : Tuple Class
Most of the forums, it’s a common question that how can we create PDF files from C#. Few days back I got a chance to work with iTextSharp library which helps to create PDF files from .Net. You can download the iTextSharp from sourceforge.net. It also supports HTML Parsing too.
Here is the code which converts and HTML File into PDF using iTextSharp libraries.
using System.Collections.Generic;
using System.IO;
using iTextSharp.text;
using iTextSharp.text.html.simpleparser;
using iTextSharp.text.pdf;
class Program
{
static void Main(string[] args)
{
//Creating the instance of the document object.
Document doc = new Document();
//Creating the PDF File
StreamWriter streamWriter = new StreamWriter(@"C:\Sample.pdf");
PdfWriter.GetInstance(doc, streamWriter.BaseStream);
doc.Open();
IEnumerable<IElement> elements;
//Reading the HTML Contents
using (StreamReader streamReader = new StreamReader(@"C:\SamplePage.htm"))
{
//Parsing HTML Contents.
elements = HTMLWorker.ParseToList(streamReader, new StyleSheet());
}
foreach (IElement item in elements)
{
doc.Add(item);
}
//Custom Text which will be appended using Paragraph class.
string paragraph = "This is custom text which will be appended";
doc.Add(new Paragraph(paragraph));
//Closing the document.
doc.Close();
}
}
Thanks to Rahul for providing initial inputs on iTextSharp library.
Last day I got an assignment to explore new features of .Net Framework 4.0. So I thought about writing a few posts with the new features. The first feature I explored was Optional Parameters and Named Parameters, as I am coming from VB background, I missed this feature in C# and yes we can resolve this using Overloading still we missed that feature. In .Net 4.0 Microsoft introduced Optional Parameters and Named Parameters in C#.
Both of these features are almost similar like in VB 6 or in VB.Net, unlike we don’t need an optional keyword.
class Program
{
static void Main(string[] args)
{
//Optional Parameters
ShowMessage("Hello World");
//Named parameters
ShowMessage("HelloWorld", backColor: ConsoleColor.Blue);
//Normal Function call
ShowMessage("Hello World", ConsoleColor.Red, ConsoleColor.Blue);
Console.Read();
}
//In .Net 4.0
static void ShowMessage(string message,
ConsoleColor foreColor = ConsoleColor.Black,
ConsoleColor backColor = ConsoleColor.White)
{
Console.ForegroundColor = foreColor;
Console.BackgroundColor = backColor;
Console.WriteLine(message);
//Resetting Console colors to default.
Console.ResetColor();
}
}
Long back one of my cousins Rajesh gives me an introduction to Operator overloading in C++, but at that time I was VB 6.0 guy and I didn’t give much importance to it. But yesterday I got a chance to work on some sample applications where I tried operator overloading on C#.
I overloaded the + operator for adding two persons objects, and here is the code.
//Person class.
public class Person
{
//Name of the Person
public string Name
{
get;
set;
}
//Operator overloading.
public static Person operator +(Person first, Person second)
{
//Returning person, by adding the Names.
return new Person()
{
Name = first.Name + " " + second.Name
};
}
}
And here is the void Main()
static void Main(string[] args)
{
Person firstPerson = new Person()
{
Name = "Person 1"
};
Person secondPerson = new Person()
{
Name = "Person 2"
};
//Adding Person objects
Person resultPerson = firstPerson + secondPerson;
//It will return Person 1 Person 2
Console.WriteLine(resultPerson.Name);
}
You can find Operator Overloading Tutorial in MSDN
In my first WinForms application, I have to create various wizard screens, I couldn’t find any ready made Controls for it from Microsoft. Then one of my colleague suggested a way to tweak it, like Add a Tab Control, Set the Alignment property to bottom and add a panel on top of the Tab Control, which contains Next / Previous / Cancel buttons. It was working fine. Few days back again I got the same situation for one of my personal project, and I thought about writing a control for the same. After doing some research I found a simple code snippet, which helps to hide the Tab Pages title in Runtime.
Here is the code, in this I am extending the Tab control and overriding the WndProc event.
protected override void WndProc(ref Message m)
{
// Hide tabs by trapping the TCM_ADJUSTRECT message
if (m.Msg == 0x1328 && !DesignMode)
{
m.Result = (IntPtr)1;
}
else
{
base.WndProc(ref m);
}
}
You can find more details about TCM_ADJUSTRECT Message on MSDN.
