After adjusting the designs we finally settled with this spectacular, showing how perfectly fits which varied radically from the previously presented two designs, so we can see that were finally raised the ways in which we can see the logo, the titles of the Masters and settings for reports. 
PropertyGrid control (sheet or property) is a component that we include in our projects, as editor of properties of controls or objects contained therein. Its use allows us to modify the value of a property at run time, the same way as the Properties window of Visual Studio IDE allows us to do at design time.
Its structure consists of two columns and many rows, as properties in control or the associated object. The first column contains the name of the property and the actual value thereof. These values \u200b\u200bcan be entered directly or through the appropriate editor who vary depending on the type of value.
PropertyGrid control allows us to provide greater functionality to our applications, is an interesting way to mechanize the handling properties, and offers users the ability to customize those aspects for which had been scheduled.
PropertyGrid ADDING OUR CONTROL PROJECT
First we add to our project a PropertyGrid control . This we can do with the following line of code. PropertyGrid
HojaPropiedades = new PropertyGrid ();
As mentioned above, a PropertyGrid control is typically associated with a control (instance of a class belonging to Visual Studio or other third-suite), or an object (instance of a class created by us). The associated control or object is selected using the property SelectedObject, and how value is entered the name of the elected body.
HojaPropiedades.SelectedObject = Label1; / / Set the properties of Label1 control
HojaPropiedades.SelectedObject = Button1; / / Set the Button1 control's properties
HojaPropiedades.SelectedObject = Entidad3D ; / / Set the object properties Entidad3D
In first two cases, control HojaPropiedades show the properties of each of the associated controls. In the third case, the properties would be shown that the derived class Entidad3D instance, had declared.
To set a property within a class using the following syntax:
[ Property Attributes] TipoPropiedad propertyName {{ September for writing code values \u200b\u200b } { get code to read values}} So in this way, the class definition Entidad3D , would be as follows.
1: public class Entidad3D
2: { 3: / / / The following fields are private fields properties
4: / / / visible in the property sheet.
5: / / / General category
6: private string _Name;
7: private string _Clase;
8 : private Color _ColorLineas = SystemColors.ControlLight;
9: private Color _ColorFondo = SystemColors.ControlDarkDark;
10: private string _Group;
11: / / / category XYZ coordinates
12: private XYZ = _Coordenadas new XYZ ();
13: private XYZ = _CoordenadasEjes new XYZ ();
14: /// categoría Modificadores 3D
15: private float _EscalaX;
16: private float _EscalaY;
17: private float _EscalaZ;
18: private float _RotacionX;
19: private float _RotacionY;
20: private float _RotacionZ;
21: / / / Categoria United
22: private bool _Activada;
23: private bool _Visible;
24: private Font _Fuente = new Font ( "Arial" , 8, FontStyle.Regular);
25: 26: / / / Definition of the code for properties
27: [CategoryAttribute ( "General" )
28: DescriptionAttribute ( "Set the name for the instance of the class." )
29: DefaultValueAttribute ( "Entity" )]
30: public string Name
31: {32: get { _Name return;}
33: _Name set {value = ;}
34 :} 35: [CategoryAttribute ( "General" )
36: DescriptionAttribute ( "Shows the name of the source class." )
37: ReadOnlyAttribute( true )]
38: public string Clase
39: { 40: get{ return _Clase;}
41: set { _Clase = value ; }
42: } 43: [CategoryAttribute( "General" )
44: DescriptionAttribute ( "Set the color of the lines in the wireframe." )]
45: Color public ColorLines
46: { 47: get { _ColorLineas return;}
48: _ColorLineas set {value = ;}
49:} 50: [CategoryAttribute ( "General" )
51: DescriptionAttribute ( "Set the background color in wireframe." )]
52: Color ColorFondopublic
53: { 54: get { _ColorFondo return;}
55: _ColorFondo set {value = ;}
56:} 57: [CategoryAttribute ( "General" )
58: DescriptionAttribute ( "shows the group to which the entity." ) ,
59: DefaultValueAttribute ( "None" )
60: ReadOnlyAttribute ( true)]
61: public string
Group 62: {63: get { _Grupo return;}
64: _Grupo set {value = ;}
65: } 66: [CategoryAttribute ( "XYZ" )
67: DescriptionAttribute ( "Deploy to establish the coordinates of the entity." )
68: DefaultValueAttribute ( "0, 0, 0" )]
69: public XYZ coordinates
70: { 71: get {return _Coordenadas;}
72: _Coordenadas set {value = ;}
73:} 74: [CategoryAttribute ( "Coordenadas XYZ" )]
75: public XYZ CoordenadasEjes
76: { 77: get { _CoordenadasEjes return;}
78: _CoordenadasEjes set {value = ;}
79:} 80: [category attribute ( "Modificadores 3D" )]
81: public float EscalaX
82: { 83: get{ return _EscalaX;}
84: set{_EscalaX = value ;}
85: } 86: [CategoryAttribute( "Modificadores 3D" )]
87: public float EscalaY
88: { 89: get{ return _EscalaY;}
90: set{_EscalaY = value ;}
91: } 92: [CategoryAttribute( "Modificadores 3D" )]
93: public float EscalaZ
94: { 95: get{ return _EscalaZ;}
96: set{_EscalaZ = value ;}
97: } 98: [CategoryAttribute( "Modificadores 3D" )]
99: public float RotacionX
100: { 101: get{ return _RotacionX;}
102: set{_RotacionX = value ;}
103: } 104: [CategoryAttribute( "Modificadores 3D" )]
105: public float RotacionY
106: { 107: get{ return _RotacionY;}
108: set{_RotacionY = value ;}
109: } 110: [CategoryAttribute( "Modificadores 3D" )]
111: public float RotacionZ
112: { 113: get{ return _RotacionZ;}
114: set{_RotacionZ = value ;}
115: } 116: [category attribute ( "Estados" )]
117: public bool Activada
118: { 119: get { _Activada return;}
120: _Activada set {value = ;}
121:} 122: [category attribute ( "Estados" )]
123: public bool Visible
124: { 125: get { _visible return;}
126 : _visible set {value = ;}
127:} 128: public Font Fuente
129: { 130: get { _Fuente return;}
131: _Fuente set {value = ;}
132: } 133:} The definition of class properties Entidad3D , have used some special attributes. This is due, that we may set certain characteristics of properties of the classes whose objects associated with a PropertyGrid control by optional attributes included in the System.ComponentModel space. These attributes are as follows.
CategoryAttribute (String) classifies properties into groups.
DescriptionAttribute (String) descriptive text that appears in the bottom of the PropertyGrid when you select the property.
BrowsableAttribute (Boolean) Determines if the property is or is not in control. The default value is True (True).
ReadOnlyAttribute (Boolean) allows or prohibits the user to edit the property to enter values. The default value is False (false).
DefaultValueAttribute (Object) Sets the default value of the property.
DefaultPropertyAttribute (String) This attribute does not apply to a property but to the class. Sets the property that is selected when the object is given control.
FINAL RESULT The result of the foregoing in the above lines would be a property sheet object Entidad3D , as we see in the image on the right.
I hope you liked it.
A greeting and to another.
Public Sub New ()
MyBase . New ()
'Windows Form Designer requires the following line of code.
InitializeComponent ()
' The stylization of the application begins when the library of styles
' is loaded by calling the Load method of StyleManager. This
'normally occurs during the startup of the application.
Infragistics.Win.AppStyling.StyleManager.Load ( "MiEstilo.isl" )
'Inside the library there will be a marked style style
' defect. In addition there may be other styles marked by default for
'specific types of components such as ultragrid, Ultracomb, etc.
'In the following example, we do not use the default style for
' UltraToolbarsManager component, but specific one, for what that
'change the value of the property StyleSetName, name
' desired style.
I . UltraToolbarsManager1.StyleSetName = "EstiloDeComponente"
'In the event that no any style we wanted to assign a component
'deactivate your ability to stylization.
I . UltraButton1.UseAppStyling = False
End Sub
[Example in C #]
public MainForm () {
/ / Windows Form Designer requires the following line code.
InitializeComponent ();
/ / The stylization of the application begins when the library
/ / style is loaded by calling the Load method of l
/ / StyleManager. This typically occurs during the startup of the
/ / application.
Infragistics.Win.AppStyling.StyleManager.Load ( "MiEstilo.isl" )
/ / Inside the library there will be a marked style style
/ / default. addition there may be other styles marked by default for
/ / specific types of components such as ultragrid, Ultracomb, etc.
/ / In the following example, we do not use the default style for
/ / component UltraToolbarsManager, but other specific so
/ / change the value of the property StyleSetName, name
/ / the desired style.
this . UltraToolbarsManager1.StyleSetName = "EstiloDeComponente" ;
/ / If we do not want to assign any style
/ / component, d esactivaríamos styling ability.
this . UltraButton1.UseAppStyling = false;}
/ * \u0026lt;text> * /These comments can span as many lines as necessary. For example:
/ * This is a comment that illustrates how to write Comments that span multiple lines * /But be careful with the fact that you can not nest comments of this kind. That is, it does not write comments like the following:
/ * Comment container / * comment string * / * /This is because as the compiler ignores all the text in a comment and just looking for the sequence * / that marks its end, ignore the second / * and when you reach the first * / deemed to have finished with the first open comment / * (not open to the second) and will search code. As * / only supported if detected before any comments yet open and closed (while not looking code), when you reach the second * / deemed to have been a mistake and you will find the * / where he hoped to find code .
/ / \u0026lt;text>And an example of its use is:
/ / This comment illustrates how to write comments shortcutsThese single-line single-line comments themselves can be nested without any problem. For example, the comment is perfectly valid:
/ / Comment wrapper / / Commentcontent Continue Reading ...
\\ u \u0026lt;dígito> \u0026lt;dígito> \u0026lt;dígito> \u0026lt;dígito> or \\ U \u0026lt;dígito> \u0026lt;dígito> \u0026lt;dígito> ; \u0026lt;dígito> \u0026lt;dígito> \u0026lt;dígito> \u0026lt;dígito> \u0026lt;dígito>These digits indicate the Unicode character you want to include as part of the identifier, and each of them has to be a digit valid hexadecimal. (0-9, af or AF) should be noted that the character has or write in lowercase when Unicode characters are indicated with 4 digits and uppercase characters when they are shown with eight. Examples of valid identifiers are C \\ u0064 (equivalent to C #, since 64 is the code # in Unicode) or a \\ U00000033b (equal aa! B>)
Apart from these reserved words, if in future implementations of the language is decided to include new keywords, Microsoft said that those words would have to include at least two consecutive underscore symbols ( __>) Therefore, to avoid possible future conflicts is not recommended to give our identifier names containing the sequence of symbols.abstract, as, base, bool, break, byte, case, catch, char, checked, class,
const, continue, decimal, default, delegate, do, double, else, enum, event,
explicit, extern, false, finally, fixed, float, for, foreach, goto, if,
implicit, in, int, interface, internal, lock, is, long, namespace, new,
null, object, operator, out, override, params, private, protected, public,
readonly, ref, return, sbyte, sealed, short, sizeof, stackalloc, static,
string, struct, switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, virtual, void, while
class @ class {static void @ static (bool @ bool) {if (@ bool) Console.WriteLine ("true") else Console.WriteLine ("false");}} What has been done in the previous code has been used @ to declare a class named class name with a static method that takes a bool parameter name, even if all these names are reserved words in C #. class A {int a; / / ( 1) int @ a / / (2)
public static void Main () {}} If we try to compile this code will fail to inform us that the name field has been declared many times in class A . This is because as @ actually not part of the identifier name to the above, the statements marked with comments like (1) and (2) are equivalent. | Character | Unicode escape code | Code special exhaust |
| Single quote | \\ u0027 | \\ ' |
| double Comilla | \\ u0022 | \\ " |
| null
| \\ u0000 | \\ 0 |
| Alarm
| \\ u0007 | \\ a |
| Reverse | \\ u0008 | \\ b |
| Page Break | \\ u000C | \\ f |
| New Line
| \\ u000A | \\ n |
| Carriage return | \\ u000D | \\ r |
| Horizontal tab | \\ u0009 | \\ t |
| Vertical tab | \\ u000B | \\ v |
| Backslash | \\ u005C | \\ \\ |
Table 4.1: special escape codes
| String Literal | Interpreted as ... |
| "Hello \\ tMundo" Hello | World |
| @ "Hello \\ tMundo" | Hello \\ tMundo |
| @ " Hello World" Hello |
World |
| @ "" Hello World " | " Hello World " |
Table 4.2: Examples flat string literals
checked ( \u0026lt;expresiónAritmética> ) unchecked ( \u0026lt;expresiónAritmética> )Both operators \u0026lt;expresiónAritmética> calculate the result and return it if during the calculation does not occur no overflow. However, in case of overflow each works in a different way: checked causes a compilation error \u0026lt;expresiónAritmética> is a constant expression and an exception System.OverflowException if not, while unchecked returns the result of arithmetic expression truncated to fit the expected size.
access operations tables: Table
\u0026lt;expresión2>The significance of the operation is as follows: Evaluate \u0026lt;condition> If true returns the result of evaluating \u0026lt;expresión1>, and if false returns the result \u0026lt;condición2> evaluate. An example of its use is: b = (a> 0)? a: 0; / / Assume a and b integer types In this example, if the value of the variable is greater than 0 is assigned to ab value, while otherwise the value assigned is 0. Keep in mind that this operator is right associative, so an expression like? B: c? D: e is equivalent to a? B: (c? D: e)
should not be confused this operator with the conditional statement if to be treated in the Item 8: Instructions , because although its usefulness is similar to it,
object access operations: To access the members of an object is used
Operationspointers: pointer
. As discussed in the Item 5: Classes, this operator is often used in polymorphic methods.
Finally, C # incorporates a third operator that allows information about a data type:
\u0026lt;nombreTipo> ( \u0026lt;parameters>)
Airplane a1 = new Airplane () / / constructor is called Airplane parameters a2 = new Airplane ( "Hunting"); / / Constructor is called Airplane taking ; ; ; / / As a string parameter If the type has been called for the creation of the object is a class, it will be created on the heap, and what new
\u0026lt;nElementos> ] This operator it does is create a table cell so many elements of type \u0026lt;nombreTipo> \u0026lt;nElementos> as directed and return the memory address it has been created. For example: int * p = stackalloc [100] / / p points to a table of 100 integers.stackalloc only be used to initialize pointers to objects of value types declared as local variables.
i = (int) l / / assign i the result of converting the value of type int int types and long >int is 32 bits, while the long is 64 bits. Therefore, unless we use the conversion operator, the compiler will not let us do the assignment as being more the capacity of longare predefined in C # and can store integer values.
capacity
Not every value that can be stored in a long is why being able to store an int . That is, not true: i = l, / / \u200b\u200bERROR: The value of l does not have to fit in i This restriction is imposed on the allocation because the compiler could occur without it very difficult to detect errors before truncation unexpected because the value of the variable source is beyond the capacity of the target variable. There is another operator which perform conversion very similar to that already seen. This is the operator
\u0026lt;tipoDestino> What it does is return the result of converting the result of evaluating the rate indicated in \u0026lt;expression> \u0026lt;tipoDestino> For example, to store in a variable p the result of converting an object type t Person you would type: Person as p = t; The only differences between using one or another conversion operator are:
asonly applies to reference types and only those cases where there are predefined conversions language. As discussed below, this only includes conversions between a guy and his parents and between types a type and types his children. One consequence of this is that the programmer can define how to do type conversions defined by him and others through operator () , but not by as
addthis_url = ''; addthis_title = ''; addthis_pub = 'igner';