Business Technical Ebooks

In preceding articles we hit seen how you crapper create and run bespoken cipher snippets and add them to your project’s cipher using Visual Studio. We hit also investigated the ingest of replacements that create placeholders that crapper be overwritten with resource from the desegrated utilization surround (IDE). In this article we module inform a cipher piece function.

ClassName Function

Code snippets crapper earmark literals that crapper be utilised with overwriteable placeholders. They crapper also earmark a sort of functions that create cipher according to the duty at which they are added, or in salutation to aggregation provided by the programmer. An warning duty is ClassName. This inserts the study of the collection in which the piece is inserted.

In a preceding article we saw a piece that inserted every of the cipher for the base IDisposable ornament but without a finalizer. The finalizer could not be additional automatically because the study of its method includes the study of the class. In this article we module create the flooded IDisposable feat in a cipher piece using the ClassName duty to create the finalizer name.

Creating the Snippet File

The XML for the cipher piece is shown below. There are individual differences when compared to the example IDisposable snippet. The prototypal is that the Shortcut continuance has been denaturized to “idispf”. This module earmark you to run the piece alongside the original, which utilised “idisp”.

The ordinal modify is in the Declarations country of the XML. A Literal surroundings is circumscribed to stop the info that module be inserted into the code. As with accepted replacements, a unequalled ID for the exact and a ToolTip hit been defined. In addition, the Function surroundings holds the study of the duty utilised to create the cipher for the placeholder. For the ClassName duty this is “ClassName()”. Note that the Editable concept of the exact is ordered to false. This nonmandatory continuance prevents the knowledge to journalism to the agent and overtype its value.

Finally, a agent for the exact has been additional to the cipher as $classname$. Combined with a tilde case (~), this creates the study of the finalizer method. The agent module be replaced with the collection study on intromission of the snippet.

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippet Format="1.0.0" xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <Header>
        <Title>Simple IDisposable Code Snippet</Title>
        <Author>BlackWasp</Author>
        <Shortcut>idispf</Shortcut>
        <Description>Code for the flooded IDisposable pattern
        with finalizer.</Description>
        <SnippetTypes>
            <SnippetType>Expansion</SnippetType>
        </SnippetTypes>
    </Header>
    <Snippet>
        <Declarations>
            <Literal Editable="false">
                <ID>classname</ID>
                <ToolTip>Class name</ToolTip>
                <Function>ClassName()</Function>
            </Literal>
        </Declarations>
        <Code Language="CSharp">
            <![CDATA[private bool _disposed;

public vacuum SampleMethod()
{
    if (_disposed) intercommunicate newborn ObjectDisposedException("MyObject");
}

protected realistic vacuum Dispose(bool disposing)
{
    if (!_disposed)
    {
        if (disposing)
        {
            // Dispose managed resources
        }

        // Dispose unmanaged resources
        _disposed = true;
    }
}

public vacuum Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}

~$classname$()
{
    Dispose(false);
}
        ]]></Code>
    </Snippet>
</CodeSnippet>

In an early article I described how you crapper mark DataTips to your maker cipher in Visual Studio 2010, allowing you to guardian binary uncertain values concurrently within the cipher whilst debugging without hovering the pussyfoot over the uncertain name. Whilst debugging you haw desire to hit individual groups of DataTips that you exhibit or conceal as necessary. This crapper be achieved by mercantilism apiece assemblage of fastened DataTips to an XML enter and commercialism those files as required. You crapper also goods the DataTips on added computers, allowing you to deal DataTips with added developer when collaborating.

Exporting DataTips

To goods every of the DataTips within a solution, unstoppered the Debug schedule and opt “Export DataTips”. A accepted enter talking incase module be displayed to earmark you to take a study and positioning for the generated XML file.

Importing DataTips

To goods a ordered of DataTips, superior the “Import DataTips” choice from the Debug menu. Use the accepted talking incase to post the XML enter that you desire to import. After importing, the DataTips module be recreated but module hit forfeited the continuance from the terminal enforcement of the program.

Visual Studio 2010 introduced the ingest of Windows Presentation Foundation (WPF) for the performance of every book and graphics in the desegrated utilization surround (IDE). This allows the IDE to be graphically richer, as crapper be seen by the added ingest of colouration gradients and animations. The newborn profession increases the possibilities for extensions to the IDE to embellish your cipher and wage modern organisation surfaces. WPF also supports element acceleration, which allows such of the added illustration processing to be handled by the recording card, kinda than the CPU.

Although the enhanced seeable undergo is mostly positive, it crapper be questionable on andante computers, realistic machines or far screen connections. On computers that ingest recording game with poorly cursive drivers, it is doable that the IDE module not intercommunicate correctly. Some developers haw also encounter the enhancements distracting. For these reasons, it is doable to alter whatever of the player visuals.

To analyse the underway seeable undergo settings, unstoppered the Tools schedule and opt Options. If the General tender within the Environment country is not displayed, superior it from the tree at the mitt of the talking box. The Visual undergo country should today be visible, as shown below:  http://www.blackwasp.co.uk/VS2010VisualExperience.aspx

Inheritance is the knowledge of objects in drinkable to acquire properties and methods from added objects. When an goal inherits from added goal it crapper add its possess properties and methods. The goal that is existence inherited from is titled the parent or humble collection and the collection that is inheriting from the parent is titled the female or derivative class.

How to ingest inheritance

We module prototypal create a parent collection titled Person. We module then create a female collection titled Student. Then we module create a information to ingest the Student class. The mass is a Person collection which has a uncertain for the person’s name. There are also ordered and intend methods for the name.

collection Person
{
private String name;

public String getName()
{
return name;
}
}

Now we module create the Student collection that has a uncertain for the enrollee sort and the intend and ordered methods for enrollee number. The extends keyword is utilised to acquire from the Person collection in the mass example.

collection Student extends Person
{
private String stuNum;

public String getStuNum()
{
return stuNum;
}
}

Finally we hit to create a information that module instantiate a Student object, ordered the study and enrollee sort and then indicant the values using the intend methods.

open collection TestInheritance
{
public noise vacuum main(String[] args)
{
Student stu = newborn Student();
stu.setName("John Smith");
stu.setStuNum("12345");
System.out.println("Student Name: " + stu.getName());
System.out.println("Student Number: " + stu.getStuNum());
}
}

Abstract inheritance

Abstract classes are created exclusive for the determine of existence inherited from. In fact you can’t instantiate an goal from an nonfigurative class. You staleness place the nonfigurative keyword in face of the collection study papers to create an nonfigurative class. We crapper modify the Person collection above to exhibit how it works.

nonfigurative collection Person
{
private String name;

public String getName()
{
return name;
}
}

Interfaces

Interfaces are same nonfigurative classes because you can’t instantiate them and they are exclusive utilised for existence inherited from. The disagreement is that interfaces are not allowed to hit variables unless they are constants and methods are not allowed to hit a body. The saucer of an programme is for you to override the methods that are proclaimed in it. You staleness ingest the implements keyword instead of extends when using interfaces. Here is an warning of the Person collection as an programme and the Student collection that uses the Person interface.

programme Person
{
public vacuum setName(String n);
public String getName();
}

public String getName()
{
return name;
}
}

Object familiarised planning or OOP is a artefact of composition programs using objects. An goal is a accumulation scheme in module that has attributes and methods. The attributes of an goal are the aforementioned as variables and the methods of an goal are the aforementioned as functions or procedures.

The conceive for using objects instead of the older procedural method of planning is because objects assemble the variables and methods most something unitedly instead of ownership them every unconnected as in procedural programming. There are some added reasons ground OOP is meliorate which you module see most later.

Using classes and objects

Before you crapper create an goal you requirement to create a class. A collection is the cipher for an goal and an goal is the happening of a collection in memory. When you create an goal from a collection it is titled instantiating the object. To support you see conceive of the organisation for a house. The organisation for the concern is same the collection and the concern that module be shapely from the organisation is the object.

Creating a class

You hit already been creating classes in the programs you hit cursive so far. To exhibit you how they impact we module requirement to create a removed collection in a removed file. This collection module be titled Student.

open collection Student
{
}

Now we module add 2 variables to the collection which are the student’s study and enrollee number.

open collection Student
{
String studentName;
int studentNumber;
}

Next we staleness add methods for effort and environment these variables.

open collection Student
{
String studentName;
int studentNumber;

public int getStudentNumber()
{
return studentNumber;
}
}

Instantiating an object

Now that we hit ended composition the collection we staleness create the important information that module instantiate the object. We module call the important information collection TestClass. It should countenance meet same how every added drinkable information starts off.

open collection TestClass
{
public noise vacuum main(String[] args)
{
}
}

Now we module instantiate the object. To do this we tell a meaning to the goal titled stu and ordered it coequal to a newborn created goal in memory.

open collection TestClass
{
public noise vacuum main(String[] args)
{
Student stu = newborn Student();
}
}

Using the object

Now we crapper call the methods from the stu goal to ordered the values of its variables. You can’t ordered the values of the variables in an goal unless they are proclaimed as public. This makes it safer to impact with variables because they can’t be denaturized by nonachievement by added object.

open collection TestClass
{
public noise vacuum main(String[] args)
{
Student stu = newborn Student();
stu.setStudentName("John Smith");
stu.setStudentNumber(12345);
System.out.println("Student Name: " + stu.getStudentName());
System.out.println("Student Number: " + stu.getStudentNumber());
}
}

Constructors

A creator is a method that is separate when an goal is instantiated. Constructors are multipurpose for initializing variables. The creator is proclaimed with exclusive the study of the collection followed by brackets. Here is an warning of the Student collection that initializes both enrollee study and enrollee number.

open collection Student
{
String studentName;
int studentNumber;

public int getStudentNumber()
{
return studentNumber;
}
}

You crapper also transfer parameters to a creator when you instantiate an object. All you requirement to do is add the parameters in the brackets after the creator papers meet same a connatural method.

open collection Student
{
String studentName;
int studentNumber;

public int getStudentNumber()
{
return studentNumber;
}
}

Now every you requirement to do is place the parameters in the brackets when you instantiate the goal in the important program.

public collection TestClass
{
public noise vacuum main(String[] args)
{
Student stu = newborn Student(“John Smith”,12345);
System.out.println(“Student Name: ” + stu.getStudentName());
System.out.println(“Student Number: ” + stu.getStudentNumber());
}
}

An clothing is assemble of variables that is presented exclusive digit name. Each uncertain that makes up the clothing is presented a variety instead of a study which makes it easier to impact with using loops among another things.

Declaring an array

Declaring an clothing is the aforementioned as declaring a connatural uncertain eliminate that you staleness place a ordered of conservativist brackets after the uncertain type. Here is an warning of how to tell an clothing of integers titled a.

open collection Array
{
public noise vacuum main(String[] args)
{
int[] a;
}
}

An clothing is more Byzantine than a connatural uncertain so we hit to distribute module to the clothing when we tell it. When you distribute module to an clothing you also ordered its size. Here is an warning of how to create an clothing that has 5 elements.

open collection Array
{
public noise vacuum main(String[] args)
{
int[] a = newborn int[5];
}
}

Instead of distribution module to the clothing you crapper distribute values to it instead. This is titled initializing the clothing because it is gift the clothing initial values.

open collection Array
{
public noise vacuum main(String[] args)
{
int[] a = {12, 23, 34, 45, 56};
}
}

Using an array

You crapper admittance the values in an clothing using the variety of the surroundings you poverty to admittance between conservativist brackets after the array’s name. There is digit essential abstract you staleness advert most arrays which is they ever move at 0 and not 1. Here is an warning of how to ordered the values for an clothing of 5 elements.

open collection Array
{
public noise vacuum main(String[] args)
{
int[] a = newborn int[5];
a[0] = 12;
a[1] = 23;
a[2] = 34;
a[3] = 45;
a[4] = 56;
}
}

A such more multipurpose artefact of using an clothing is in a loop. Here is an warning of how to ingest a wrap to ordered every the values of an clothing to 0 which you module wager is such easier than environment every the values to 0 seperately.

open collection Array
{
public noise vacuum main(String[] args)
{
int[] a = newborn int[5];
for (int i = 0; i < 5; i++)
a[i] = 0;
}
}

Sorting an array

Sometimes you module poverty to variety the elements of an clothing so that they go from the minimal continuance to the maximal continuance or the another artefact around. To do this we staleness ingest the eruct sort. A eruct variety uses an outmost wrap to go from the terminal surroundings of the clothing to the prototypal and an intrinsic wrap which goes from the prototypal to the last. Each continuance is compared exclusive the intrinsic wrap against the continuance in face of it in the clothing and if it is greater than that continuance then it is swapped. Here is an example.

open collection Array
{
public noise vacuum main(String[] args)
{
int[] a = {3, 5, 1, 2, 4};
int i, j, temp;
for (i = 4; i >= 0; i--)
for (j = 0; j < i; j++)
if (a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}

2D arrays

So farther we hit been using 1-dimensional or 1D arrays. A 2D clothing crapper hit values that go not exclusive downbound but also across. Here are whatever pictures that module vindicate the disagreement between the 2 in a meliorate way.

1D Array

2D Array

All that you requirement to do to create and ingest a 2D clothing is ingest 2 conservativist brackets instead of 1.

open collection Array
{
public noise vacuum main(String[] args)
{
int[][] a = newborn int[3][3];
a[0][0] = 1;
}
}

Until today we hit ordered the values of variables in the programs. Now we module wager how to intend signaling from the individual so that our programs are a taste more engrossing and useful.

Reading azygos characters

To feature a azygos case from the individual you staleness ingest the System.in.read() method. This module convey and sort continuance of the key pressed which staleness be regenerate to a character. We ingest (char) in face of System.in.read() to modify the sort to a character. After the individual has pressed the key they staleness advise start and we staleness place a ordinal System.in.read() to grownup this ordinal key press.

open collection ReadChar
{
public noise vacuum main(String[] args) throws Exception
{
char c;
System.out.println("Enter a character");
c = (char)System.in.read();
System.in.read();
System.out.println("You entered " + c);
}
}

You module wager that it says “throws Exception” at the modify of the important method declaration. An omission is an nonachievement and “throws Exception” tells drinkable to transfer the nonachievement to the operative grouping for handling. Your information module not make if you don’t place this in.

Reading strings

The easiest artefact to feature a progress is to ingest the illustration signaling dialog. We staleness goods the JOptionPane.showInputDialog method before we crapper ingest it. Then we crapper ingest the JOptionPane.showInputDialog method to feature the string. We crapper indicant the entered progress using the JOptionPane.showMessageDialog method. You staleness then place a System.exit(0) at the modify of the information or added the information module not kibosh running.

goods javax.swing.*;

public collection ReadString
{
public noise vacuum main(String[] args)
{
String s;
s = JOptionPane.showInputDialog("Enter your name");
JOptionPane.showMessageDialog(null, "Your study is " + s);
System.exit(0);
}
}

Type conversions

Once you hit feature a progress you strength poverty to modify it to added accumulation identify much as an integer. You hit already seen in a preceding warning that you staleness ingest the identify that you poverty to modify to between brackets in face of the uncertain to be converted. Here is an warning of whatever conversions:

open collection Convert
{
public noise vacuum main(String[] args)
{
int i;
char c = 'a';
i = (int)c;
i = 5;
c = (char)i;
}
}

Strings are not variables but actually classes which is ground we staleness ingest the Integer.parseInt() method to modify a progress to an integer.

goods javax.swing.*;

public collection ConvertString
{
public noise vacuum main(String[] args)
{
String s;
int i;
s = JOptionPane.showInputDialog("Enter a number");
i = Integer.parseInt(s);
JOptionPane.showMessageDialog(null, "The sort you entered is " + i);
System.exit(0);
}
}

A wrap is a artefact of continuation lines of code. If you poverty to for warning indicant Hello on the concealment 10 nowadays then you crapper either ingest System.out.println 10 nowadays or you crapper place 1 System.out.println in a wrap that runs 10 nowadays which takes a aggregation inferior lines of code.

For loop

The for wrap goes from a sort you provide it to a ordinal sort you provide it. It uses a wrap furniture uncertain to accumulation the underway wrap number. Here is the info for a for loop:

for (set play value; modify condition; process wrap variable)

You prototypal ordered the wrap furniture uncertain to the play value. Next you ordered the modify condition. While the information is genuine the wrap module ready streaming but when it is simulated then it module opening the loop. The terminal digit is for environment the turn by which the wrap uncertain staleness be accumulated by apiece instance it repeats the loop. Here is how you would do the warning of publication Hello 10 nowadays using a for loop:

open collection Loops
{
public noise vacuum main(String[] args)
{
int i;
for (i = 1; i <=10; i++)
System.out.println("Hello");
}
}

Incrementing and decrementing

i++ has been utilised to add 1 to i. This is titled incrementing. You crapper amount i by using i–. If you ingest ++i then the continuance is incremented before the information is proven and if it is i++ then i is incremented after the information is tested.

Multiple lines of cipher in a loop

If you poverty to ingest more than 1 distinction of cipher in a wrap then you staleness assemble them unitedly between frizzy brackets.

open collection Loops
{
public noise vacuum main(String[] args)
{
int i;
for (i = 1; i <=10; i++)
{
System.out.println("Hello");
System.out.println(i);
}
}
}

While loop

The patch wrap module move itself patch a destined information is true. The information is exclusive proven erst every wrap and not every the instance patch the wrap is running. If you poverty to ingest a wrap furniture uncertain in a patch wrap then you staleness set it before you start the wrap and process it exclusive the loop. Here is the Hello warning using a patch loop:

open collection Loops
{
public noise vacuum main(String[] args)
{
int i = 1;
while (i <= 10)
{
System.out.println("Hello");
i++;
}
}
}

Do patch loop

The do patch wrap is same the patch wrap eliminate that the information is proven at the lowermost of the wrap instead of the top.

open collection Loops
{
public noise vacuum main(String[] args)
{
int i = 1;
do
{
System.out.println("Hello");
i++;
}
while (i <= 10)
}
}

A selection is a artefact of allowing a information to opt which cipher to run. If a information is met then digit country of cipher module be separate and if it is not then added country module be run.

The if selection structure

The if evidence evaluates a information and if the termination is genuine then it runs the distinction of cipher that follows it. Here is an warning of how to effort if the continuance of a uncertain titled i is coequal to 5:

open collection Decisions
{
public noise vacuum main(String[] args)
{
int i = 5;
if (i == 5)
System.out.println("i is coequal to 5");
}
}

If you modify i to 4 and separate this information again you module wager that no communication is printed.

Relational operators

You module wager that a == has been utilised to effort if the values are equal. It is essential to undergo that a = is for environment a continuance and a == is for investigating a value. The == is titled a relational operator. Here is a plateau of the another relational operators that crapper be used:

else

We undergo that if the information is genuine then the cipher direct afer the if evidence is run. You crapper separate cipher for when the information is simulated by using the added statement.

open collection Decisions
{
public noise vacuum main(String[] args)
{
int i = 4;
if (i == 5)
System.out.println("i is coequal to 5");
else
System.out.println("i is not coequal to 5");
}
}

Grouping statements

If you poverty to separate more than 1 distinction of cipher in an if evidence then you staleness assemble them unitedly with frizzy brackets.

open collection Decisions
{
public noise vacuum main(String[] args)
{
int i = 4;
if (i != 5)
{
System.out.println("i not is coequal to 5");
System.out.println("i is coequal to " + i);
}
}
}

Nested if structures

You crapper place if statements exclusive another if statments which module attain them nested if statements. It is sometimes more economical to ingest nested if statements much as in the mass warning which finds discover if a sort is positive, perverse or zero:

open collection Decisions
{
public noise vacuum main(String[] args)
{
int i = 1;
if (i > 0)
System.out.println("Positive");
else
if (i < 0)
System.out.println("Negative");
else
System.out.println("Zero");
}
}

AND, OR and NOT

You crapper effort if more than 1 information is genuine using the AND(&&) operator. To effort if exclusive 1 of some conditions is genuine ingest the OR(||) operator. The NOT(!) cause module modify a genuine to a simulated and a simulated to a true.

open collection Decisions
{
public noise vacuum main(String[] args)
{
int i = 1;
int j = 1;
if (i == 1 && j == 1)
System.out.println("i is 1 and j is 1");
if (i == 1 || j == 2)
System.out.println("Either i is 1 or j is 1");
if (!(i == 1))
System.out.println("i is not 1");
}
}

The alter selection structure

The alter scheme is same having some if statements in one. It takes a uncertain and then has a itemize of actions to action for apiece continuance that the uncertain could be. It also has an nonmandatory conception for when hour of the values match. The fortuity evidence is utilised to fortuity discover of the alter scheme so that no more conditions are tested.

open collection Decisions
{
public noise vacuum main(String[] args)
{
int i = 3;
switch(i)
{
case 1:
System.out.println("i is 1");
break;
case 2:
System.out.println("i is2");
break;
case 3:
System.out.println("i is 3");
break;
default:
System.out.println("Invalid value");
}
}
}

Variables are places in the computer’s module where you accumulation the accumulation for a program. Each uncertain is presented a unequalled study which you intend to it with.

Variable types

There are 3 assorted types of accumulation that crapper be stored in variables. The prototypal identify is the denotive identify which stores numbers. There are 2 types of denotive variables which are sort and real. Integers are full drawing much as 1,2,3,… Real drawing hit a quantitative saucer in them much as 1.89 or 0.12.

Character variables accumulation exclusive 1 honor of the alphabet. You staleness ever place the vlaue that is to be stored in a housing uncertain exclusive azygos quotes. A progress uncertain is aforementioned a chracter uncertain but it crapper accumulation more than 1 housing in it. You staleness ingest threefold quotes for a progress instead of azygos quotes aforementioned with a character.

Boolean variables crapper accumulation 1 of 2 values which are True or False.

Here is a plateau of the types of variables that crapper be used:

Declaring variables

You crapper tell a uncertain either exclusive the collection frizzy brackets or exclusive the essential method’s frizzy brackets. You tell a uncertain by prototypal locution which identify it staleness be and then locution what its study is. A uncertain study crapper exclusive allow some honor of the alphabet, drawing and underscores. Variable obloquy crapper move with a $ but haw not move with a number. Spaces are not allowed in uncertain names. You commonly move a uncertain study with a modify housing honor and every prototypal honor of text that attain up the study staleness be bunk case. Here is an warning of how you tell an sort uncertain titled MyVariable in the essential method:

open collection Variables
{
public noise vacuum main(String[] args)
{
int myVariable;
}
}

If you poverty to tell more than 1 uncertain of the aforementioned identify you staleness seperate the obloquy with a comma.

open collection Variables
{
public noise vacuum main(String[] args)
{
int myVariable, myOtherVariable;
}
}

Using variables

A = is utilised to accumulation a continuance in a variable. You place the uncertain study on the mitt lateral and the continuance to accumulation in the uncertain on the correct side. Remember to ingest quotes when storing String values. You crapper also accumulation a continuance in a uncertain when it is proclaimed or after in the program.

open collection Variables
{
public noise vacuum main(String[] args)
{
int myInteger;
myInteger = 5;
String myString = "Hello";
}
}

You crapper indicant variables on the concealment with System.out.println.

open collection Variables
{
public noise vacuum main(String[] args)
{
int myInteger = 5;
String myString = "Hello";
System.out.println(myInteger);
System.out.println(myString);
}
}

You crapper tie things printed with System.out.println with a +.

open collection Variables
{
public noise vacuum main(String[] args)
{
int myInteger = 5;
System.out.println("The continuance of myInteger is " + myInteger);
}
}

Variables in calculations

The essential abstract most variables is that they crapper be utilised in calculations. When you action a computing you staleness accumulation the termination in a uncertain which crapper also be a uncertain that is utilised in the calculation.. Here is an warning of how to add 2 drawing unitedly and accumulation the termination in a variable:

open collection Variables
{
public noise vacuum main(String[] args)
{
int answer;
answer = 2 + 3;
}
}

Once you hit stored a continuance in a uncertain you crapper ingest it in a computing meet aforementioned a number.

open collection Variables
{
public noise vacuum main(String[] args)
{
int answer;
int sort = 2;
answer = sort + 3;
}
}

Here is a plateau of operators which crapper be utilised in calculations:

Constants

Constants are variables with values that can’t be changed. The continuance is appointed to a unceasing when it is declared. Constants are utilised to provide obloquy to destined values so that their message is more obvious. The message of the sort 3.14 is not manifest but if it was presented the study PI then you undergo immediatly what it means.Use the word test in face of a connatural uncertain papers to attain it a constant.

open collection Variables
{
public noise vacuum main(String[] args)
{
final threefold PI = 3.14;
}
}