Shulou(Shulou.com)06/02 Report--

This article is about how C # uses custom controls. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Platform: VS 2005 WINFORM

Language: C #

The final effect of the C# custom control:

Just looking at the picture doesn't seem to mean anything, so let's move on.

To edit the C# custom control in VS 2005 winform, the steps are as follows:

1. Click File-> New Project-> Select Windows Control Library

two。 Edit control

3. Click generate-> generate the project name, and after completing this step, you will see the "project name .dll" file in the bin or debug directory. This is your control library.

4. Click tools-> Select tool items-> Browse-> Select the .dll file in the program that needs to use the control, so that you will find your control in your toolbox.

What we are going to write today is mainly the second step, and everyone else will master it by themselves.

When you create a new project, you will get the interface shown in the figure:

First, let's give this custom control a name: ColorHatch

Next, we modify the layout of the interface to an interface similar to the effect picture.

Then I started editing the code.

Analysis 1: we need a panel1 to display the color of our choice; at the same time, we want to be able to set its initial color directly in the program that calls the control

So now let's implement the requirements in Analysis 1: the main problem here is how to define an external property for our control so that we can set it in the property design view.

The way to define attributes is to first declare a private variable private Color hatchColor;, and then we write set and get methods, that is, the corresponding attribute assignment and value methods.

[Description ("set current color")] / / description shown in the property design view [DefaultValue (typeof (Color), "Black") / / give the initial value public Color HatchColor {get {return hatchColor;} set {hatchColor = value; panel1.BackColor = value;}}

In this way, our external property is done. this effect can only be seen in the form that calls this control.

Analysis 2: when the form that calls the control is running, we want to have a way to pass the selected color to the called form; we can associate how other controls transmit information with the main form (either through properties or events), we are sure to pass the color to the main form after selecting a certain color, so we have to use events to deal with it.

Because the control itself does not provide this event, we naturally want to define an event ourselves.

With regard to the "event", we can almost write a special piece about it in detail. here we are just a brief introduction to how to define events ourselves. You can check the information online, as mentioned in Chen Guang's c# language reference video.

The main steps for writing events for a C# custom control are as follows:

1. Create a delegate (not introduced here) 2. Declare an event 3. Define a method that triggers an event

Now let's write about this event:

Public delegate void ColorChangedEventHandler (object sender, ColorChangedEventArgs e); / / delegation required by the event / / trigger the event public event ColorChangedEventHandler ColorChanged when the color changes / / define a ColorChanged event protected virtual void OnColorChanged (ColorChangedEventArgs e) {/ / event trigger method if (ColorChanged! = null) {/ / determine whether the event is empty ColorChanged (this, e); / / trigger event}}

ColorChanged (this,e) actually uses a delegate to call an event handling method, which is a method that is automatically generated when we double-click an event. It's like when we double-click click, we automatically generate a private panel1_click (object sender,EventArgs e).

But after writing this, we can't find this event on the caller, because we have just completed an event and have not associated it with our control. We must add the event trigger method where the control needs to call this event. We need to know that the premise for using this event is that the color in the panel1 is changed, that is, when we select a new color, this method is triggered as follows:

Private void panel_Click (object sender, EventArgs e) {Panel p = sender as Panel; if (p! = null) {hatchColor = p.BackColor; panel1.BackColor = hatchColor; OnColorChanged (new ColorChangedEventArgs (hatchColor)); / / trigger event} because of color change

After adding this step, we can find this custom event in the event of the form that called the control. in this way, we can double-click to write event handling methods just like normal events.

At this point, some friends may ask what ColorChangedEventArgs is. Does this thing look familiar? Is it very similar to EventArgs? We often encounter .EventArgs in the click event. Our ColorChangedEventArgs is a class inherited from this EventArgs and is used to pass our selected color to the caller.

Let's take a look at this ColorChangedEventArgs class.

Public class ColorChangedEventArgs: EventArgs {private Color color; / * * / Color change event data / changed color public ColorChangedEventArgs (Color c) {color = c } / * * / get the color / public Color GetColor {get {return color;}

The main problem of such a C # custom control has been solved, and some friends may be dizzy, so it is recommended to learn about the events in .NET first.

* Let's take a look at the effect in the form that calls this C# custom control:

Thank you for reading! This is the end of this article on "how to use Custom controls in C#". I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.